@bienui/core 0.1.13

package/dist/components/Display/Avatar.d.ts

@@ -0,0 +1,19 @@
+export interface AvatarProps {
+    src?: string;
+    alt?: string;
+    name?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    shape?: 'circle' | 'square';
+    status?: 'online' | 'offline' | 'away' | 'busy';
+    showStatus?: boolean;
+    icon?: React.ReactNode;
+    className?: string;
+}
+export interface AvatarGroupProps {
+    children: React.ReactNode;
+    max?: number;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    className?: string;
+}
+export declare function Avatar({ src, alt, name, size, shape, status, showStatus, icon, className, }: AvatarProps): import("react/jsx-runtime").JSX.Element;
+export declare function AvatarGroup({ children, max, size, className, }: AvatarGroupProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/Badge.d.ts

@@ -0,0 +1,10 @@
+export interface BadgeProps {
+    children: React.ReactNode;
+    variant?: 'success' | 'error' | 'warning' | 'info' | 'neutral' | 'primary' | 'ai';
+    size?: 'sm' | 'md' | 'lg';
+    icon?: React.ReactNode;
+    dot?: boolean;
+    outline?: boolean;
+    className?: string;
+}
+export declare const Badge: import("react").ForwardRefExoticComponent<BadgeProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/Display/Card.d.ts

@@ -0,0 +1,25 @@
+export interface CardProps {
+    children: React.ReactNode;
+    variant?: 'elevated' | 'outlined' | 'filled' | 'ghost' | 'ai' | 'glass-frost' | 'glass-tint';
+    color?: 'blue' | 'teal' | 'purple' | 'yellow';
+    padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    radius?: 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    shadow?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    gradient?: 'primary' | 'purple' | 'accent' | 'blue' | 'rainbow';
+    topGradient?: 'primary' | 'purple' | 'accent' | 'blue' | 'rainbow' | false;
+    hoverable?: boolean;
+    clickable?: boolean;
+    bordered?: boolean;
+    collapsible?: boolean;
+    defaultExpanded?: boolean;
+    expanded?: boolean;
+    onExpandChange?: (expanded: boolean) => void;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    title?: string;
+    subtitle?: string;
+    className?: string;
+    style?: React.CSSProperties;
+    onClick?: () => void;
+}
+export declare function Card({ children, variant, color, padding, radius, shadow, gradient, topGradient, hoverable, clickable, bordered, collapsible, defaultExpanded, expanded: controlledExpanded, onExpandChange, header, footer, title, subtitle, className, style, onClick, }: CardProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/ColorSwatch.d.ts

@@ -0,0 +1,8 @@
+export interface ColorSwatchProps {
+    name: string;
+    hex: string;
+    rgb?: string;
+    usage: string;
+    gradient?: string;
+}
+export declare function ColorSwatch({ name, hex, rgb, usage, gradient, }: ColorSwatchProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/List.d.ts

@@ -0,0 +1,62 @@
+import { ReactNode, HTMLAttributes } from 'react';
+export interface ListProps extends Omit<HTMLAttributes<HTMLUListElement | HTMLOListElement>, 'className'> {
+    /** List type */
+    type?: 'unordered' | 'ordered' | 'unstyled';
+    /** Visual style for list markers */
+    markerStyle?: 'default' | 'circle' | 'square' | 'disc' | 'decimal' | 'roman' | 'alpha' | 'none';
+    /** Size of the list items */
+    size?: 'sm' | 'md' | 'lg';
+    /** Spacing between items */
+    spacing?: 'none' | 'sm' | 'md' | 'lg';
+    /** Whether to show dividers between items */
+    dividers?: boolean;
+    /** Children list items */
+    children: ReactNode;
+    /** Additional CSS class */
+    className?: string;
+}
+export declare function List({ type, markerStyle, size, spacing, dividers, children, className, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
+export interface ListItemProps extends Omit<HTMLAttributes<HTMLLIElement>, 'className'> {
+    /** Icon to display before content */
+    icon?: ReactNode;
+    /** Avatar to display before content */
+    avatar?: ReactNode;
+    /** Whether item is interactive/clickable */
+    interactive?: boolean;
+    /** Whether item is active */
+    active?: boolean;
+    /** Whether item is disabled */
+    disabled?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Children content */
+    children: ReactNode;
+    /** Additional CSS class */
+    className?: string;
+}
+export declare function ListItem({ icon, avatar, interactive, active, disabled, onClick, children, className, ...props }: ListItemProps): import("react/jsx-runtime").JSX.Element;
+export interface DescriptionListProps extends Omit<HTMLAttributes<HTMLDListElement>, 'className'> {
+    /** Size of the list */
+    size?: 'sm' | 'md' | 'lg';
+    /** Layout orientation */
+    orientation?: 'vertical' | 'horizontal';
+    /** Spacing between items */
+    spacing?: 'none' | 'sm' | 'md' | 'lg';
+    /** Whether to show dividers */
+    dividers?: boolean;
+    /** Children content */
+    children: ReactNode;
+    /** Additional CSS class */
+    className?: string;
+}
+export declare function DescriptionList({ size, orientation, spacing, dividers, children, className, ...props }: DescriptionListProps): import("react/jsx-runtime").JSX.Element;
+export interface DescriptionTermProps extends Omit<HTMLAttributes<HTMLElement>, 'className'> {
+    children: ReactNode;
+    className?: string;
+}
+export declare function DescriptionTerm({ children, className, ...props }: DescriptionTermProps): import("react/jsx-runtime").JSX.Element;
+export interface DescriptionDetailsProps extends Omit<HTMLAttributes<HTMLElement>, 'className'> {
+    children: ReactNode;
+    className?: string;
+}
+export declare function DescriptionDetails({ children, className, ...props }: DescriptionDetailsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/Meter.d.ts

@@ -0,0 +1,59 @@
+import { CSSProperties } from 'react';
+export interface MeterProps {
+    /** Current value */
+    value: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Visual variant */
+    variant?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gradient-primary' | 'gradient-purple';
+    /** Size of the meter */
+    size?: 'sm' | 'md' | 'lg';
+    /** Label text */
+    label?: string;
+    /** Whether to show value */
+    showValue?: boolean;
+    /** Custom value formatter */
+    valueFormatter?: (value: number) => string;
+    /** Whether meter is optimum (positive) or suboptimum (negative) */
+    optimum?: 'low' | 'high';
+    /** Threshold values for status colors */
+    thresholds?: {
+        low?: number;
+        high?: number;
+        optimum?: number;
+    };
+    /** Whether to animate value changes */
+    animated?: boolean;
+    /** Additional CSS class */
+    className?: string;
+    /** Additional styles */
+    style?: CSSProperties;
+}
+export declare function Meter({ value, min, max, variant, size, label, showValue, valueFormatter, optimum, thresholds, animated, className, style, }: MeterProps): import("react/jsx-runtime").JSX.Element;
+export interface CircularMeterProps {
+    /** Current value */
+    value: number;
+    /** Minimum value */
+    min?: number;
+    /** Maximum value */
+    max?: number;
+    /** Visual variant */
+    variant?: 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'gradient-primary' | 'gradient-purple';
+    /** Size of the meter */
+    size?: number;
+    /** Stroke width */
+    strokeWidth?: number;
+    /** Label text */
+    label?: string;
+    /** Whether to show value in center */
+    showValue?: boolean;
+    /** Custom value formatter */
+    valueFormatter?: (value: number) => string;
+    /** Whether to animate value changes */
+    animated?: boolean;
+    /** Additional CSS class */
+    className?: string;
+}
+export declare function CircularMeter({ value, min, max, variant, size, strokeWidth, label, showValue, valueFormatter, animated, className, }: CircularMeterProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/ProfileAvatar.d.ts

@@ -0,0 +1,16 @@
+export interface ProfileAvatarProps {
+    src?: string;
+    alt?: string;
+    name?: string;
+    size?: 'md' | 'lg' | 'xl' | '2xl';
+    shape?: 'circle' | 'square';
+    status?: 'online' | 'offline' | 'away' | 'busy';
+    showStatus?: boolean;
+    editable?: boolean;
+    onEdit?: () => void;
+    badge?: React.ReactNode;
+    ring?: boolean;
+    ringColor?: 'brand' | 'success' | 'warning' | 'error';
+    className?: string;
+}
+export declare function ProfileAvatar({ src, alt, name, size, shape, status, showStatus, editable, onEdit, badge, ring, ringColor, className, }: ProfileAvatarProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,66 @@
+import { ReactNode, CSSProperties } from 'react';
+export interface TableColumn<T = Record<string, unknown>> {
+    /** Unique key for the column */
+    key: string;
+    /** Column header label */
+    label: string;
+    /** Width of the column */
+    width?: string | number;
+    /** Whether column is sortable */
+    sortable?: boolean;
+    /** Custom render function for cells */
+    render?: (value: unknown, row: T, index: number) => ReactNode;
+    /** Alignment of column content */
+    align?: 'left' | 'center' | 'right';
+}
+export interface TableProps<T = Record<string, unknown>> {
+    /** Column definitions */
+    columns: TableColumn<T>[];
+    /** Table data */
+    data: T[];
+    /** Visual variant */
+    variant?: 'default' | 'bordered' | 'striped' | 'minimal';
+    /** Header style variant */
+    headerVariant?: 'default' | 'glass-frost' | 'glass-tint';
+    /** Size of table cells */
+    size?: 'compact' | 'comfortable' | 'spacious';
+    /** Whether rows are hoverable */
+    hoverable?: boolean;
+    /** Whether rows are selectable */
+    selectable?: boolean;
+    /** Selected row keys */
+    selectedRows?: string[];
+    /** Callback when selection changes */
+    onSelectionChange?: (selectedKeys: string[]) => void;
+    /** Row key extractor */
+    rowKey?: (row: T) => string;
+    /** Custom row click handler */
+    onRowClick?: (row: T, index: number) => void;
+    /** Empty state content */
+    emptyState?: ReactNode;
+    /** Caption for the table */
+    caption?: string;
+    /** Whether table has sticky header */
+    stickyHeader?: boolean;
+    /** Max height for scrollable table */
+    maxHeight?: string | number;
+    /** Enable pagination */
+    pagination?: boolean;
+    /** Current page (1-indexed) */
+    page?: number;
+    /** Page size */
+    pageSize?: number;
+    /** Total number of items */
+    total?: number;
+    /** Callback when page changes */
+    onPageChange?: (page: number) => void;
+    /** Callback when page size changes */
+    onPageSizeChange?: (pageSize: number) => void;
+    /** Available page size options */
+    pageSizeOptions?: number[];
+    /** Additional CSS class */
+    className?: string;
+    /** Additional styles */
+    style?: CSSProperties;
+}
+export declare function Table<T = Record<string, unknown>>({ columns, data, variant, headerVariant, size, hoverable, selectable, selectedRows, onSelectionChange, rowKey, onRowClick, emptyState, caption, stickyHeader, maxHeight, pagination, page, pageSize, total, onPageChange, onPageSizeChange, pageSizeOptions, className, style, }: TableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/Tags.d.ts

@@ -0,0 +1,10 @@
+export interface TagsProps {
+    children: React.ReactNode;
+    variant?: 'success' | 'error' | 'warning' | 'info' | 'neutral' | 'primary' | 'accent' | 'purple' | 'gradient-primary' | 'gradient-purple' | 'gradient-accent' | 'gradient-rainbow' | 'gradient-blue' | 'gradient-teal';
+    size?: 'sm' | 'md' | 'lg';
+    onRemove?: () => void;
+    removable?: boolean;
+    disabled?: boolean;
+    className?: string;
+}
+export declare const Tags: import("react").ForwardRefExoticComponent<TagsProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/components/Display/Text.d.ts

@@ -0,0 +1,21 @@
+export interface TextProps {
+    children: React.ReactNode;
+    as?: 'p' | 'span' | 'div' | 'label' | 'strong' | 'em' | 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl';
+    weight?: 'light' | 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold';
+    tone?: 'primary' | 'secondary' | 'tertiary' | 'inverse' | 'brand' | 'success' | 'error' | 'warning' | 'accent' | 'purple' | 'blue';
+    align?: 'left' | 'center' | 'right' | 'justify';
+    truncate?: boolean;
+    maxLines?: number;
+    gradient?: 'primary' | 'purple' | 'accent' | 'blue' | 'rainbow';
+    highlight?: boolean;
+    highlightColor?: 'primary' | 'accent' | 'purple' | 'blue';
+    decoration?: 'underline' | 'line-through' | 'none';
+    transform?: 'uppercase' | 'lowercase' | 'capitalize' | 'none';
+    letterSpacing?: 'tight' | 'normal' | 'wide' | 'wider';
+    lineHeight?: 'tight' | 'normal' | 'relaxed' | 'loose';
+    italic?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Text({ children, as: Component, size, weight, tone, align, truncate, maxLines, gradient, highlight, highlightColor, decoration, transform, letterSpacing, lineHeight, italic, className, style, }: TextProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Display/Timeline.d.ts

@@ -0,0 +1,13 @@
+export interface TimelineItem {
+    id: string;
+    title: string;
+    description?: string;
+    time?: string;
+    content?: React.ReactNode;
+}
+export interface TimelineProps {
+    items: TimelineItem[];
+    orientation?: 'vertical' | 'horizontal';
+    className?: string;
+}
+export declare function Timeline({ items, orientation, className, }: TimelineProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,11 @@
+export { Text } from './Text';
+export { Card } from './Card';
+export { Badge } from './Badge';
+export { Tags } from './Tags';
+export { Avatar, AvatarGroup } from './Avatar';
+export { ProfileAvatar } from './ProfileAvatar';
+export { Timeline } from './Timeline';
+export { Meter, CircularMeter } from './Meter';
+export { Table } from './Table';
+export { List, ListItem, DescriptionList, DescriptionTerm, DescriptionDetails, } from './List';
+export { ColorSwatch } from './ColorSwatch';

package/dist/components/Feedback/Accordion.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+import { AccordionItem } from './AccordionItem';
+interface AccordionContextValue {
+    expandedItems: string[];
+    toggleItem: (value: string) => void;
+    variant: 'default' | 'bordered' | 'filled' | 'ai';
+    allowMultiple: boolean;
+}
+export declare const useAccordionContext: () => AccordionContextValue;
+/**
+ * Props for the Accordion component
+ */
+export interface AccordionProps {
+    /** The accordion items to render */
+    children: ReactNode;
+    /** Visual style variant of the accordion */
+    variant?: 'default' | 'bordered' | 'filled' | 'ai';
+    /** Allow multiple items to be expanded simultaneously */
+    allowMultiple?: boolean;
+    /** Default expanded item(s) */
+    defaultValue?: string | string[];
+    /** Controlled expanded item(s) */
+    value?: string | string[];
+    /** Callback when expanded items change */
+    onValueChange?: (value: string | string[]) => void;
+    /** Additional CSS class name */
+    className?: string;
+    /** Inline styles */
+    style?: React.CSSProperties;
+}
+/**
+ * Accordion component for creating collapsible content sections.
+ * Allows users to expand and collapse information panels. Perfect for FAQs,
+ * settings panels, and organizing content in a compact space.
+ */
+export declare function AccordionRoot({ children, variant, allowMultiple, defaultValue, value: controlledValue, onValueChange, className, style, }: AccordionProps): import("react/jsx-runtime").JSX.Element;
+export declare const Accordion: typeof AccordionRoot & {
+    Item: typeof AccordionItem;
+};
+export {};

package/dist/components/Feedback/AccordionItem.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+export interface AccordionItemProps {
+    value: string;
+    title: string;
+    subtitle?: string;
+    children: ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function AccordionItem({ value, title, subtitle, children, disabled, className, }: AccordionItemProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Feedback/Banner.d.ts

@@ -0,0 +1,20 @@
+export interface BannerAction {
+    label: string;
+    onClick: () => void;
+    variant?: 'primary' | 'secondary';
+}
+export interface BannerProps {
+    title?: string;
+    children: React.ReactNode;
+    variant?: 'info' | 'success' | 'warning' | 'error' | 'neutral' | 'ai';
+    icon?: React.ReactNode;
+    actions?: BannerAction[];
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    defaultVisible?: boolean;
+    visible?: boolean;
+    sticky?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Banner({ title, children, variant, icon, actions, dismissible, onDismiss, defaultVisible, visible: controlledVisible, sticky, className, style, }: BannerProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/Feedback/Callout.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+export interface CalloutAction {
+    label: string;
+    onClick: () => void;
+    variant?: 'primary' | 'secondary';
+}
+export interface CalloutProps {
+    children: ReactNode;
+    trigger: ReactNode;
+    title?: string;
+    description?: string;
+    actions?: CalloutAction[];
+    variant?: 'default' | 'glass-frost' | 'glass-tint';
+    position?: 'top' | 'bottom' | 'left' | 'right' | 'auto';
+    showArrow?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    closeOnClickOutside?: boolean;
+    className?: string;
+}
+export declare function Callout({ children, trigger, title, description, actions, variant, position, showArrow, open: controlledOpen, defaultOpen, onOpenChange, closeOnClickOutside, className, }: CalloutProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Feedback/EmptyState.d.ts

@@ -0,0 +1,42 @@
+import { ReactNode } from 'react';
+declare const illustrations: {
+    'no-data': import("react/jsx-runtime").JSX.Element;
+    'no-results': import("react/jsx-runtime").JSX.Element;
+    'no-notifications': import("react/jsx-runtime").JSX.Element;
+    error: import("react/jsx-runtime").JSX.Element;
+    'coming-soon': import("react/jsx-runtime").JSX.Element;
+    'folder-empty': import("react/jsx-runtime").JSX.Element;
+    'inbox-zero': import("react/jsx-runtime").JSX.Element;
+};
+export type EmptyStateIllustration = keyof typeof illustrations;
+/**
+ * Props for the EmptyState component
+ */
+export interface EmptyStateProps {
+    /**
+     * The illustration to display in the empty state. Can be a predefined illustration type or a custom React node.
+     */
+    illustration?: EmptyStateIllustration | ReactNode;
+    /**
+     * The main title text to display in the empty state.
+     */
+    title: string;
+    /**
+     * Optional description text to provide additional context about the empty state.
+     */
+    description?: string;
+    /**
+     * Optional action element (like a button) to help users resolve the empty state.
+     */
+    action?: ReactNode;
+    /**
+     * Optional CSS class name for custom styling.
+     */
+    className?: string;
+    /**
+     * Optional inline styles to apply to the component.
+     */
+    style?: React.CSSProperties;
+}
+export declare function EmptyState({ illustration, title, description, action, className, style, }: EmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Feedback/Loading.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Props for the Loading component
+ */
+export interface LoadingProps {
+    /** Size of the loading indicator. Defaults to 'md' if not specified */
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    /** Visual style variant of the loading indicator. Defaults to 'spinner' if not specified */
+    variant?: 'spinner' | 'dots' | 'pulse' | 'ring';
+    /** Optional message to display alongside the loading indicator */
+    message?: string;
+    /** Additional CSS class names to apply to the loading component */
+    className?: string;
+    /** Inline styles to apply to the loading component */
+    style?: React.CSSProperties;
+}
+export declare function Loading({ size, variant, message, className, style, }: LoadingProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Feedback/Modal.d.ts

@@ -0,0 +1,17 @@
+export interface ModalProps {
+    open: boolean;
+    onClose: () => void;
+    children: React.ReactNode;
+    title?: string;
+    subtitle?: string;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'fullscreen';
+    variant?: 'default' | 'centered';
+    headerVariant?: 'default' | 'glass-frost' | 'glass-tint';
+    gradient?: 'primary' | 'purple' | 'accent' | 'blue' | 'rainbow';
+    closeOnOverlayClick?: boolean;
+    showCloseButton?: boolean;
+    className?: string;
+}
+export declare function Modal({ open, onClose, children, title, subtitle, header, footer, size, variant, headerVariant, gradient, closeOnOverlayClick, showCloseButton, className, }: ModalProps): import("react").ReactPortal | null;

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

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+export interface Step {
+    label: string;
+    description?: string;
+    icon?: ReactNode;
+}
+export interface StepperProps {
+    steps: Step[];
+    currentStep: number;
+    orientation?: 'horizontal' | 'vertical';
+    variant?: 'default' | 'numbered' | 'dots';
+    size?: 'default' | 'compact';
+    clickable?: boolean;
+    onStepClick?: (step: number) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+export declare function Stepper({ steps, currentStep, orientation, variant, size, clickable, onStepClick, className, style, }: StepperProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,19 @@
+export interface Tab {
+    id: string;
+    label: string;
+    icon?: React.ReactNode;
+    content?: React.ReactNode;
+    disabled?: boolean;
+    badge?: string | number;
+}
+export interface TabsProps {
+    tabs: Tab[];
+    defaultTab?: string;
+    variant?: 'default' | 'underline' | 'pills' | 'filled';
+    size?: 'sm' | 'md' | 'lg';
+    fullWidth?: boolean;
+    vertical?: boolean;
+    onChange?: (tabId: string) => void;
+    className?: string;
+}
+export declare function Tabs({ tabs, defaultTab, variant, size, fullWidth, vertical, onChange, className, }: TabsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,8 @@
+export { Loading } from './Loading';
+export { EmptyState } from './EmptyState';
+export { Banner } from './Banner';
+export { Callout } from './Callout';
+export { Modal } from './Modal';
+export { Accordion } from './Accordion';
+export { Tabs } from './Tabs';
+export { Stepper } from './Stepper';

package/dist/components/Forms/Checkbox.d.ts

@@ -0,0 +1,7 @@
+export interface CheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    label?: string;
+    error?: string;
+    hint?: string;
+    indeterminate?: boolean;
+}
+export declare const Checkbox: import("react").ForwardRefExoticComponent<CheckboxProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/Forms/DatePicker.d.ts

@@ -0,0 +1,17 @@
+export interface DateRange {
+    start: Date | undefined;
+    end: Date | undefined;
+}
+export interface DatePickerProps {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    range?: boolean;
+    rangeValue?: DateRange;
+    onRangeChange?: (range: DateRange) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+export declare function DatePicker({ value, onChange, range, rangeValue, onRangeChange, minDate, maxDate, placeholder, disabled, className, }: DatePickerProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/Forms/Input.d.ts

@@ -0,0 +1,8 @@
+export interface InputProps extends React.InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+    hint?: string;
+    error?: string;
+    startElement?: React.ReactNode;
+    endElement?: React.ReactNode;
+}
+export declare const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/components/Forms/MarkdownTextarea.d.ts

@@ -0,0 +1,10 @@
+export interface MarkdownTextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'onChange'> {
+    label?: string;
+    error?: string;
+    hint?: string;
+    showCount?: boolean;
+    onChange?: (value: string) => void;
+    value?: string;
+    defaultValue?: string;
+}
+export declare const MarkdownTextarea: import("react").ForwardRefExoticComponent<MarkdownTextareaProps & import("react").RefAttributes<HTMLTextAreaElement>>;

package/dist/components/Forms/MultiSelect.d.ts

@@ -0,0 +1,21 @@
+export interface MultiSelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+export interface MultiSelectProps {
+    label?: string;
+    error?: string;
+    hint?: string;
+    options: MultiSelectOption[];
+    placeholder?: string;
+    value?: string[];
+    onChange?: (value: string[]) => void;
+    className?: string;
+    disabled?: boolean;
+    required?: boolean;
+    searchable?: boolean;
+    maxTags?: number;
+    variant?: 'primary' | 'accent' | 'purple' | 'neutral' | 'error' | 'warning' | 'info' | 'gradient-primary' | 'gradient-purple';
+}
+export declare const MultiSelect: import("react").ForwardRefExoticComponent<MultiSelectProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/components/Forms/Radio.d.ts

@@ -0,0 +1,12 @@
+export interface RadioProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    label?: string;
+}
+export declare const Radio: import("react").ForwardRefExoticComponent<RadioProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface RadioGroupProps {
+    label?: string;
+    error?: string;
+    hint?: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare function RadioGroup({ label, error, hint, children, className, }: RadioGroupProps): import("react/jsx-runtime").JSX.Element;