@hyddenlabs/hydn-ui 0.0.1-alpha.34

package/dist/index.d.cts

@@ -0,0 +1,1029 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React$1 from 'react';
+import React__default, { ReactNode, HTMLAttributes, MouseEvent } from 'react';
+
+type ButtonProps = {
+    children?: React__default.ReactNode;
+    onClick?: (e: React__default.MouseEvent<HTMLButtonElement>) => void;
+    ariaLabel?: string;
+    disabled?: boolean;
+    type?: 'button' | 'submit' | 'reset';
+    className?: string;
+    icon?: React__default.ReactNode;
+    iconPosition?: 'left' | 'right';
+    variant?: 'neutral' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error';
+    style?: 'solid' | 'outline' | 'ghost' | 'link' | 'soft';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    rounded?: 'default' | 'pill' | 'square' | 'circle';
+    loading?: boolean;
+    fullWidth?: boolean;
+    wide?: boolean;
+    active?: boolean;
+};
+declare function Button({ children, onClick, ariaLabel, disabled, type, className, icon, iconPosition, variant, style, size, rounded, loading, fullWidth, wide, active }: Readonly<ButtonProps>): react_jsx_runtime.JSX.Element;
+declare namespace Button {
+    var displayName: string;
+}
+
+type ValidationState$3 = 'default' | 'error' | 'success' | 'warning';
+type InputProps = {
+    value?: string;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    type?: 'text' | 'email' | 'password' | 'number' | 'tel' | 'url';
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+    required?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    validationState?: ValidationState$3;
+};
+declare function Input({ value, onChange, placeholder, disabled, type, className, ariaLabel, id, name, required, size, validationState }: Readonly<InputProps>): react_jsx_runtime.JSX.Element;
+declare namespace Input {
+    var displayName: string;
+}
+
+type CheckboxProps = {
+    checked?: boolean;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+};
+declare function Checkbox({ checked, onChange, disabled, className, ariaLabel, id, name }: Readonly<CheckboxProps>): react_jsx_runtime.JSX.Element;
+declare namespace Checkbox {
+    var displayName: string;
+}
+
+type RadioProps = {
+    checked?: boolean;
+    onChange?: (e: React__default.ChangeEvent<HTMLInputElement>) => void;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+    value?: string;
+};
+declare function Radio({ checked, onChange, disabled, className, ariaLabel, id, name, value }: Readonly<RadioProps>): react_jsx_runtime.JSX.Element;
+declare namespace Radio {
+    var displayName: string;
+}
+
+type ValidationState$2 = 'default' | 'error' | 'success' | 'warning';
+type SelectProps = {
+    value?: string;
+    onChange?: (e: React__default.ChangeEvent<HTMLSelectElement>) => void;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+    children: React__default.ReactNode;
+    required?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+    validationState?: ValidationState$2;
+};
+declare function Select({ value, onChange, disabled, className, ariaLabel, id, name, children, required, size, validationState }: Readonly<SelectProps>): react_jsx_runtime.JSX.Element;
+declare namespace Select {
+    var displayName: string;
+}
+
+type SelectItemProps = {
+    value?: string;
+    disabled?: boolean;
+    children: React__default.ReactNode;
+};
+declare function SelectItem({ value, disabled, children }: Readonly<SelectItemProps>): react_jsx_runtime.JSX.Element;
+declare namespace SelectItem {
+    var displayName: string;
+}
+
+type ValidationState$1 = 'default' | 'error' | 'success' | 'warning';
+type TextareaProps = {
+    value?: string;
+    onChange?: (e: React__default.ChangeEvent<HTMLTextAreaElement>) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+    rows?: number;
+    required?: boolean;
+    validationState?: ValidationState$1;
+};
+declare function Textarea({ value, onChange, placeholder, disabled, className, ariaLabel, id, name, rows, required, validationState }: Readonly<TextareaProps>): react_jsx_runtime.JSX.Element;
+declare namespace Textarea {
+    var displayName: string;
+}
+
+type SwitchProps = {
+    checked?: boolean;
+    onChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    variant?: 'primary' | 'secondary' | 'accent' | 'success' | 'warning' | 'info' | 'error' | 'neutral';
+};
+declare function Switch({ checked, onChange, disabled, className, ariaLabel, id, name, size, variant }: Readonly<SwitchProps>): react_jsx_runtime.JSX.Element;
+declare namespace Switch {
+    var displayName: string;
+}
+
+type SliderProps = {
+    value?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+    id?: string;
+    name?: string;
+};
+declare function Slider({ value, onChange, min, max, step, disabled, className, ariaLabel, id, name }: Readonly<SliderProps>): react_jsx_runtime.JSX.Element;
+declare namespace Slider {
+    var displayName: string;
+}
+
+type ButtonGroupProps = {
+    children: ReactNode;
+    className?: string;
+    variant?: 'default' | 'separated';
+    orientation?: 'horizontal' | 'vertical';
+};
+declare function ButtonGroup({ children, className, variant, orientation }: Readonly<ButtonGroupProps>): react_jsx_runtime.JSX.Element;
+declare namespace ButtonGroup {
+    var displayName: string;
+}
+
+type RadioGroupProps = {
+    children: ReactNode;
+    name: string;
+    label?: string;
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+};
+declare function RadioGroup({ children, name: _name, label, orientation, className }: Readonly<RadioGroupProps>): react_jsx_runtime.JSX.Element;
+declare namespace RadioGroup {
+    var displayName: string;
+}
+
+type ValidationState = 'default' | 'error' | 'success' | 'warning';
+type FormFieldProps = {
+    children: ReactNode;
+    label?: string;
+    htmlFor?: string;
+    error?: string;
+    helperText?: string;
+    required?: boolean;
+    className?: string;
+    validationState?: ValidationState;
+};
+declare function FormField({ children, label, htmlFor, error, helperText, required, className, validationState }: Readonly<FormFieldProps>): react_jsx_runtime.JSX.Element;
+declare namespace FormField {
+    var displayName: string;
+}
+
+type InputGroupProps = {
+    children: ReactNode;
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    className?: string;
+};
+declare function InputGroup({ children, prefix, suffix, className }: Readonly<InputGroupProps>): react_jsx_runtime.JSX.Element;
+declare namespace InputGroup {
+    var displayName: string;
+}
+
+type NavProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    ariaLabel?: string;
+};
+declare function Nav({ children, className, ariaLabel }: Readonly<NavProps>): react_jsx_runtime.JSX.Element;
+declare namespace Nav {
+    var displayName: string;
+}
+
+type NavbarProps = {
+    brand?: ReactNode;
+    children: ReactNode;
+    sticky?: boolean;
+    className?: string;
+    actions?: ReactNode;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    appearance?: 'solid' | 'blur' | 'transparent';
+    border?: 'none' | 'bottom' | 'top' | 'both';
+    disableMobileMenu?: boolean;
+};
+declare function Navbar({ brand, children, sticky, className, actions, size, appearance, border, disableMobileMenu }: Readonly<NavbarProps>): react_jsx_runtime.JSX.Element;
+declare namespace Navbar {
+    var displayName: string;
+}
+
+type NavbarBrandProps = {
+    children: ReactNode;
+    href?: string;
+    external?: boolean;
+    onClick?: () => void;
+    className?: string;
+};
+declare function NavbarBrand({ children, href, external, onClick, className }: Readonly<NavbarBrandProps>): react_jsx_runtime.JSX.Element;
+declare namespace NavbarBrand {
+    var displayName: string;
+}
+
+type NavbarLinkProps = {
+    href: string;
+    children: ReactNode;
+    external?: boolean;
+    className?: string;
+    end?: boolean;
+};
+declare function NavbarLink({ href, children, external, className, end }: Readonly<NavbarLinkProps>): react_jsx_runtime.JSX.Element;
+declare namespace NavbarLink {
+    var displayName: string;
+}
+
+type Tab = {
+    id: string;
+    label: string;
+    content: React__default.ReactNode;
+};
+type TabsProps = {
+    tabs: Tab[];
+    defaultTab?: string;
+    className?: string;
+    ariaLabel?: string;
+};
+declare function Tabs({ tabs, defaultTab, className, ariaLabel }: Readonly<TabsProps>): react_jsx_runtime.JSX.Element;
+declare namespace Tabs {
+    var displayName: string;
+}
+
+type DropdownProps = {
+    trigger: React__default.ReactNode;
+    children: React__default.ReactNode;
+    className?: string;
+};
+declare function Dropdown({ trigger, children, className }: Readonly<DropdownProps>): react_jsx_runtime.JSX.Element;
+declare namespace Dropdown {
+    var displayName: string;
+}
+
+type BreadcrumbItem = {
+    label: string;
+    href?: string;
+};
+type BreadcrumbsProps = {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+    className?: string;
+};
+declare function Breadcrumbs({ items, separator, className }: Readonly<BreadcrumbsProps>): react_jsx_runtime.JSX.Element;
+declare namespace Breadcrumbs {
+    var displayName: string;
+}
+
+type PaginationProps = {
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    className?: string;
+};
+declare function Pagination({ currentPage, totalPages, onPageChange, siblingCount, className }: Readonly<PaginationProps>): react_jsx_runtime.JSX.Element;
+declare namespace Pagination {
+    var displayName: string;
+}
+
+type SidebarProps = {
+    children: ReactNode;
+    className?: string;
+    width?: string;
+};
+declare function Sidebar({ children, className, width }: Readonly<SidebarProps>): react_jsx_runtime.JSX.Element;
+declare namespace Sidebar {
+    var displayName: string;
+}
+
+type StepProps = {
+    title: string;
+    description?: string;
+    icon?: ReactNode;
+    status?: 'pending' | 'current' | 'completed' | 'error';
+    optional?: boolean;
+};
+type StepperProps = {
+    steps: StepProps[];
+    currentStep: number;
+    className?: string;
+    orientation?: 'horizontal' | 'vertical';
+    onStepClick?: (step: number) => void;
+    clickable?: boolean;
+};
+declare function Stepper({ steps, currentStep, className, orientation, onStepClick, clickable }: Readonly<StepperProps>): react_jsx_runtime.JSX.Element;
+declare namespace Stepper {
+    var displayName: string;
+}
+
+type ToastProps = {
+    message?: string;
+    children?: React.ReactNode;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    onClose?: () => void;
+    className?: string;
+};
+declare function Toast({ message, children, type, onClose, className }: Readonly<ToastProps>): react_jsx_runtime.JSX.Element;
+declare namespace Toast {
+    var displayName: string;
+}
+
+type TooltipProps = {
+    children: ReactNode;
+    content: string | ReactNode;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    variant?: 'default' | 'primary' | 'secondary' | 'accent' | 'info' | 'success' | 'warning' | 'error' | 'neutral';
+    open?: boolean;
+    usePortal?: boolean;
+    className?: string;
+};
+declare function Tooltip({ children, content, position, variant, open, usePortal, className }: Readonly<TooltipProps>): react_jsx_runtime.JSX.Element;
+declare namespace Tooltip {
+    var displayName: string;
+}
+
+type ModalProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    children: React__default.ReactNode;
+    className?: string;
+    ariaLabel?: string;
+};
+declare function Modal({ isOpen, onClose, children, className, ariaLabel }: Readonly<ModalProps>): react_jsx_runtime.JSX.Element | null;
+declare namespace Modal {
+    var displayName: string;
+}
+
+type DialogProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    children: React__default.ReactNode;
+    actions?: React__default.ReactNode;
+    className?: string;
+};
+declare function Dialog({ isOpen, onClose, title, children, actions, className }: Readonly<DialogProps>): react_jsx_runtime.JSX.Element;
+declare namespace Dialog {
+    var displayName: string;
+}
+
+type DeleteDialogProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm: () => void;
+    title?: string;
+    description?: string;
+    itemName?: string;
+    isLoading?: boolean;
+    confirmText?: string;
+    cancelText?: string;
+    className?: string;
+};
+declare function DeleteDialog({ isOpen, onClose, onConfirm, title, description, itemName, isLoading, confirmText, cancelText, className }: Readonly<DeleteDialogProps>): react_jsx_runtime.JSX.Element;
+declare namespace DeleteDialog {
+    var displayName: string;
+}
+
+type PopoverProps = {
+    trigger?: React__default.ReactNode;
+    children?: React__default.ReactNode;
+    content: React__default.ReactNode;
+    position?: 'top' | 'bottom' | 'left' | 'right';
+    className?: string;
+};
+declare function Popover({ trigger, children, content, position, className }: Readonly<PopoverProps>): react_jsx_runtime.JSX.Element;
+declare namespace Popover {
+    var displayName: string;
+}
+
+type AlertProps = {
+    children: ReactNode;
+    type?: 'info' | 'success' | 'warning' | 'error';
+    dismissible?: boolean;
+    onClose?: () => void;
+    className?: string;
+};
+declare function Alert({ children, type, dismissible, onClose, className }: Readonly<AlertProps>): react_jsx_runtime.JSX.Element;
+declare namespace Alert {
+    var displayName: string;
+}
+
+type SpinnerProps = {
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'primary' | 'accent' | 'secondary' | 'neutral';
+    className?: string;
+    speed?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function Spinner({ size, variant, className, speed, ...props }: Readonly<SpinnerProps>): react_jsx_runtime.JSX.Element;
+declare namespace Spinner {
+    var displayName: string;
+}
+
+type ProgressBarProps = {
+    value: number;
+    max?: number;
+    showLabel?: boolean;
+    variant?: 'default' | 'success' | 'warning' | 'error';
+    className?: string;
+};
+declare function ProgressBar({ value, max, showLabel, variant, className }: Readonly<ProgressBarProps>): react_jsx_runtime.JSX.Element;
+declare namespace ProgressBar {
+    var displayName: string;
+}
+
+type SkeletonProps = {
+    variant?: 'text' | 'circular' | 'rectangular';
+    width?: string;
+    height?: string;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function Skeleton({ variant, width, height, className, ...props }: Readonly<SkeletonProps>): react_jsx_runtime.JSX.Element;
+declare namespace Skeleton {
+    var displayName: string;
+}
+
+type BadgeProps = {
+    children: ReactNode;
+    variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function Badge({ children, variant, size, className, ...props }: Readonly<BadgeProps>): react_jsx_runtime.JSX.Element;
+declare namespace Badge {
+    var displayName: string;
+}
+
+type StatusLabelProps = {
+    children: ReactNode;
+    status?: 'active' | 'inactive' | 'pending' | 'success' | 'error' | 'warning' | 'info';
+    size?: 'sm' | 'md' | 'lg';
+    variant?: 'filled' | 'outlined';
+    className?: string;
+};
+declare function StatusLabel({ children, status, size, variant, className }: Readonly<StatusLabelProps>): react_jsx_runtime.JSX.Element;
+declare namespace StatusLabel {
+    var displayName: string;
+}
+
+type AvatarProps = {
+    src?: string;
+    alt?: string;
+    fallback?: ReactNode;
+    size?: 'sm' | 'md' | 'lg' | 'xl';
+    className?: string;
+};
+declare function Avatar({ src, alt, fallback, size, className }: Readonly<AvatarProps>): react_jsx_runtime.JSX.Element;
+declare namespace Avatar {
+    var displayName: string;
+}
+
+type EmptyStateProps = {
+    title: string;
+    description?: string;
+    icon?: ReactNode;
+    action?: ReactNode;
+    className?: string;
+};
+declare function EmptyState({ title, description, icon, action, className }: Readonly<EmptyStateProps>): react_jsx_runtime.JSX.Element;
+declare namespace EmptyState {
+    var displayName: string;
+}
+
+type ListProps = {
+    children: ReactNode;
+    className?: string;
+    ordered?: boolean;
+};
+type ListItemProps = {
+    children: ReactNode;
+    className?: string;
+};
+declare function List({ children, className, ordered }: Readonly<ListProps>): react_jsx_runtime.JSX.Element;
+declare function ListItem({ children, className }: Readonly<ListItemProps>): react_jsx_runtime.JSX.Element;
+
+type TableProps = {
+    children: ReactNode;
+    className?: string;
+    striped?: boolean;
+    bordered?: boolean;
+    hoverable?: boolean;
+    compact?: boolean;
+    caption?: string;
+} & HTMLAttributes<HTMLTableElement>;
+type TableHeaderProps = {
+    children: ReactNode;
+    className?: string;
+} & HTMLAttributes<HTMLTableSectionElement>;
+type TableBodyProps = {
+    children: ReactNode;
+    className?: string;
+} & HTMLAttributes<HTMLTableSectionElement>;
+type TableFooterProps = {
+    children: ReactNode;
+    className?: string;
+} & HTMLAttributes<HTMLTableSectionElement>;
+type TableRowProps = {
+    children: ReactNode;
+    className?: string;
+    selected?: boolean;
+} & HTMLAttributes<HTMLTableRowElement>;
+type TableHeadCellProps = {
+    children: ReactNode;
+    className?: string;
+    align?: 'left' | 'center' | 'right';
+    scope?: 'col' | 'row';
+} & HTMLAttributes<HTMLTableCellElement>;
+type TableCellProps = {
+    children: ReactNode;
+    className?: string;
+    align?: 'left' | 'center' | 'right';
+} & HTMLAttributes<HTMLTableCellElement>;
+declare function Table({ children, className, striped, bordered, hoverable, compact, caption, ...props }: Readonly<TableProps>): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ children, className, ...props }: Readonly<TableHeaderProps>): react_jsx_runtime.JSX.Element;
+declare function TableBody({ children, className, ...props }: Readonly<TableBodyProps>): react_jsx_runtime.JSX.Element;
+declare function TableFooter({ children, className, ...props }: Readonly<TableFooterProps>): react_jsx_runtime.JSX.Element;
+declare function TableRow({ children, className, selected, ...props }: Readonly<TableRowProps>): react_jsx_runtime.JSX.Element;
+declare function TableHeadCell({ children, className, align, scope, ...props }: Readonly<TableHeadCellProps>): react_jsx_runtime.JSX.Element;
+declare function TableCell({ children, className, align, ...props }: Readonly<TableCellProps>): react_jsx_runtime.JSX.Element;
+
+type ColumnDef<T> = {
+    key: keyof T;
+    label: string;
+    sortable?: boolean;
+    width?: string;
+    align?: 'left' | 'center' | 'right';
+    render?: (value: T[keyof T], row: T, index: number) => ReactNode;
+};
+type DataTableProps<T> = {
+    data: T[];
+    columns: ColumnDef<T>[];
+    className?: string;
+    striped?: boolean;
+    bordered?: boolean;
+    hoverable?: boolean;
+    compact?: boolean;
+    stickyHeader?: boolean;
+    sortable?: boolean;
+    paginated?: boolean;
+    pageSize?: number;
+    selectable?: boolean;
+    onRowClick?: (row: T, index: number) => void;
+    onSelectionChange?: (selectedIndices: number[]) => void;
+    emptyMessage?: string;
+    emptyIcon?: ReactNode;
+    initialSort?: {
+        key: keyof T;
+        direction: 'asc' | 'desc';
+    };
+};
+declare function DataTable<T>({ data, columns, className, striped, bordered, hoverable, compact, stickyHeader, sortable, paginated, pageSize, selectable, onRowClick, onSelectionChange, emptyMessage, emptyIcon, initialSort }: DataTableProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace DataTable {
+    var displayName: string;
+}
+
+type SortDirection = 'asc' | 'desc' | null;
+type SortConfig<T> = {
+    key: keyof T;
+    direction: SortDirection;
+} | null;
+type UseTableOptions<T> = {
+    data: T[];
+    initialSort?: {
+        key: keyof T;
+        direction: 'asc' | 'desc';
+    };
+    pageSize?: number;
+};
+type UseTableReturn<T> = {
+    currentData: T[];
+    sortedData: T[];
+    sortConfig: SortConfig<T>;
+    handleSort: (key: keyof T) => void;
+    currentPage: number;
+    totalPages: number;
+    setCurrentPage: (page: number) => void;
+    nextPage: () => void;
+    prevPage: () => void;
+    canNextPage: boolean;
+    canPrevPage: boolean;
+    selectedRows: Set<number>;
+    toggleRow: (index: number) => void;
+    toggleAll: () => void;
+    isRowSelected: (index: number) => boolean;
+    isAllSelected: boolean;
+    clearSelection: () => void;
+};
+declare function useTable<T>({ data, initialSort, pageSize }: UseTableOptions<T>): UseTableReturn<T>;
+
+type ChipProps = {
+    children: ReactNode;
+    className?: string;
+    variant?: 'default' | 'primary' | 'success' | 'warning' | 'error';
+    size?: 'sm' | 'md' | 'lg';
+    onRemove?: (e: MouseEvent<HTMLButtonElement>) => void;
+    icon?: ReactNode;
+    disabled?: boolean;
+    clickable?: boolean;
+    onClick?: (e: MouseEvent<HTMLDivElement>) => void;
+};
+declare function Chip({ children, className, variant, size, onRemove, icon, disabled, clickable, onClick }: Readonly<ChipProps>): react_jsx_runtime.JSX.Element;
+declare namespace Chip {
+    var displayName: string;
+}
+
+type TimelineItemProps = {
+    children: ReactNode;
+    className?: string;
+    icon?: ReactNode;
+    iconColor?: 'default' | 'primary' | 'success' | 'warning' | 'error';
+    title?: string;
+    subtitle?: string;
+    timestamp?: string;
+    isLast?: boolean;
+};
+type TimelineProps = {
+    children: ReactNode;
+    className?: string;
+    position?: 'left' | 'center' | 'right';
+};
+declare function TimelineItem({ children, className, icon, iconColor, title, subtitle, timestamp, isLast }: Readonly<TimelineItemProps>): react_jsx_runtime.JSX.Element;
+declare function Timeline({ children, className, position }: Readonly<TimelineProps>): react_jsx_runtime.JSX.Element;
+declare namespace Timeline {
+    var displayName: string;
+}
+
+type PricingTableProps = {
+    title?: string;
+    description?: string;
+    children: ReactNode;
+    columns?: 2 | 3 | 4;
+    className?: string;
+};
+declare function PricingTable({ title, description, children, columns, className }: Readonly<PricingTableProps>): react_jsx_runtime.JSX.Element;
+declare namespace PricingTable {
+    var displayName: string;
+}
+
+type PricingFeature = {
+    label: string;
+    included: boolean;
+};
+type PricingTierProps = {
+    name: string;
+    price: string;
+    period?: string;
+    description?: string;
+    features: PricingFeature[];
+    ctaLabel: string;
+    ctaOnClick: () => void;
+    featured?: boolean;
+    badge?: string;
+    className?: string;
+};
+declare function PricingTier({ name, price, period, description, features, ctaLabel, ctaOnClick, featured, badge, className }: Readonly<PricingTierProps>): react_jsx_runtime.JSX.Element;
+declare namespace PricingTier {
+    var displayName: string;
+}
+
+type CodeBlockProps = {
+    code: string;
+    className?: string;
+    showCopy?: boolean;
+};
+declare function CodeBlock({ code, className, showCopy }: Readonly<CodeBlockProps>): react_jsx_runtime.JSX.Element;
+declare namespace CodeBlock {
+    var displayName: string;
+}
+
+type CardProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    variant?: 'default' | 'bordered' | 'ghost' | 'filled';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    hoverable?: boolean;
+    imagePosition?: 'top' | 'bottom' | 'side' | 'overlay';
+    centered?: boolean;
+    compact?: boolean;
+} & React__default.HTMLAttributes<HTMLDivElement>;
+declare function Card({ children, className, variant, size, hoverable, imagePosition, centered, compact, ...props }: Readonly<CardProps>): react_jsx_runtime.JSX.Element;
+declare namespace Card {
+    var displayName: string;
+}
+
+type CardHeaderProps = {
+    children: ReactNode;
+    className?: string;
+    bordered?: boolean;
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+};
+declare function CardHeader({ children, className, bordered, padding }: Readonly<CardHeaderProps>): react_jsx_runtime.JSX.Element;
+declare namespace CardHeader {
+    var displayName: string;
+}
+
+type CardFooterProps = {
+    children: ReactNode;
+    className?: string;
+    bordered?: boolean;
+    padding?: 'none' | 'sm' | 'md' | 'lg';
+    align?: 'start' | 'center' | 'end';
+};
+declare function CardFooter({ children, className, bordered, padding, align }: Readonly<CardFooterProps>): react_jsx_runtime.JSX.Element;
+declare namespace CardFooter {
+    var displayName: string;
+}
+
+type ContainerProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    size?: 'sm' | 'md' | 'lg' | 'xl' | 'full';
+    padding?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    align?: 'start' | 'center' | 'end';
+};
+declare function Container({ children, className, size, padding, align }: Readonly<ContainerProps>): react_jsx_runtime.JSX.Element;
+declare namespace Container {
+    var displayName: string;
+}
+
+type GridProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    itemSize?: 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    maxCols?: number;
+    gap?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+    responsive?: {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+    };
+    alignItems?: 'start' | 'center' | 'end' | 'stretch';
+    justifyItems?: 'start' | 'center' | 'end' | 'stretch';
+};
+declare function Grid({ children, className, itemSize, maxCols, gap, responsive, alignItems, justifyItems }: Readonly<GridProps>): react_jsx_runtime.JSX.Element;
+declare namespace Grid {
+    var displayName: string;
+}
+
+type StackProps = {
+    children: React__default.ReactNode;
+    className?: string;
+    direction?: 'horizontal' | 'vertical';
+    spacing?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'between' | 'around';
+};
+declare function Stack({ children, className, direction, spacing, align, justify }: Readonly<StackProps>): react_jsx_runtime.JSX.Element;
+declare namespace Stack {
+    var displayName: string;
+}
+
+type DividerProps = {
+    orientation?: 'horizontal' | 'vertical';
+    className?: string;
+} & React.HTMLAttributes<HTMLHRElement>;
+declare function Divider({ orientation, className, ...props }: Readonly<DividerProps>): react_jsx_runtime.JSX.Element;
+declare namespace Divider {
+    var displayName: string;
+}
+
+type DrawerProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    children: ReactNode;
+    position?: 'left' | 'right' | 'top' | 'bottom';
+    className?: string;
+};
+declare function Drawer({ isOpen, onClose, children, position, className }: Readonly<DrawerProps>): react_jsx_runtime.JSX.Element | null;
+declare namespace Drawer {
+    var displayName: string;
+}
+
+type PageProps = {
+    children: React__default.ReactNode;
+    className?: string;
+};
+declare function Page({ children, className }: Readonly<PageProps>): react_jsx_runtime.JSX.Element;
+declare namespace Page {
+    var displayName: string;
+}
+
+type AccordionItemProps = {
+    title: string;
+    children: ReactNode;
+    defaultOpen?: boolean;
+};
+type AccordionProps = {
+    children: ReactNode;
+    className?: string;
+    allowMultiple?: boolean;
+};
+declare function AccordionItem({ title, children, defaultOpen }: Readonly<AccordionItemProps>): react_jsx_runtime.JSX.Element;
+declare function Accordion({ children, className }: Readonly<AccordionProps>): react_jsx_runtime.JSX.Element;
+declare namespace Accordion {
+    var displayName: string;
+}
+
+type HeroAction = {
+    label: string;
+    onClick: () => void;
+    variant?: 'primary' | 'secondary' | 'neutral' | 'error';
+    style?: 'solid' | 'outline' | 'ghost' | 'link' | 'soft';
+    loading?: boolean;
+};
+type HeroProps = {
+    title: string;
+    description?: string;
+    primaryAction?: HeroAction;
+    secondaryAction?: HeroAction;
+    children?: ReactNode;
+    className?: string;
+    backgroundGradient?: boolean;
+    centered?: boolean;
+    size?: 'sm' | 'md' | 'lg';
+};
+declare function Hero({ title, description, primaryAction, secondaryAction, children, className, backgroundGradient, centered, size }: Readonly<HeroProps>): react_jsx_runtime.JSX.Element;
+declare namespace Hero {
+    var displayName: string;
+}
+
+type Feature = {
+    icon: ReactNode;
+    title: string;
+    description: string;
+};
+type FeatureSectionProps = {
+    title?: string;
+    description?: string;
+    features: Feature[];
+    columns?: 2 | 3 | 4;
+    centered?: boolean;
+    className?: string;
+};
+declare function FeatureSection({ title, description, features, columns, centered, className }: Readonly<FeatureSectionProps>): react_jsx_runtime.JSX.Element;
+declare namespace FeatureSection {
+    var displayName: string;
+}
+
+type FooterSection = {
+    title: string;
+    links: Array<{
+        label: string;
+        href: string;
+        external?: boolean;
+    }>;
+};
+type FooterProps = {
+    sections?: FooterSection[];
+    copyright?: string;
+    social?: ReactNode;
+    className?: string;
+};
+declare function Footer({ sections, copyright, social, className }: Readonly<FooterProps>): react_jsx_runtime.JSX.Element;
+declare namespace Footer {
+    var displayName: string;
+}
+
+type LeftNavLayoutProps = {
+    nav: ReactNode;
+    children: ReactNode;
+    collapsed?: boolean;
+    onCollapsedChange?: (collapsed: boolean) => void;
+    showToggle?: boolean;
+    className?: string;
+    navClassName?: string;
+    contentClassName?: string;
+    navWidth?: string;
+    navWidthCollapsed?: string;
+    mobileCollapsible?: boolean;
+    mobileMenuOpen?: boolean;
+    onMobileMenuOpenChange?: (open: boolean) => void;
+    embedded?: boolean;
+};
+declare function LeftNavLayout({ nav, children, collapsed: controlledCollapsed, onCollapsedChange, showToggle, className, navClassName, contentClassName, navWidth, navWidthCollapsed, mobileCollapsible, mobileMenuOpen: controlledMobileMenuOpen, onMobileMenuOpenChange, embedded }: Readonly<LeftNavLayoutProps>): react_jsx_runtime.JSX.Element;
+declare namespace LeftNavLayout {
+    var displayName: string;
+}
+
+type LeftNavItemProps = {
+    icon?: ReactNode;
+    children: ReactNode;
+    active?: boolean;
+    className?: string;
+    badge?: ReactNode;
+    href?: string;
+    title?: string;
+    preventNavigation?: boolean;
+};
+declare function LeftNavItem({ icon, children, active, className, badge, href, title, preventNavigation }: Readonly<LeftNavItemProps>): react_jsx_runtime.JSX.Element;
+declare namespace LeftNavItem {
+    var displayName: string;
+}
+
+type LeftNavSectionProps = {
+    children: ReactNode;
+    label?: string;
+    className?: string;
+};
+declare function LeftNavSection({ children, label, className }: Readonly<LeftNavSectionProps>): react_jsx_runtime.JSX.Element;
+declare namespace LeftNavSection {
+    var displayName: string;
+}
+
+type HeadingProps = {
+    children: ReactNode;
+    level?: 1 | 2 | 3 | 4 | 5 | 6;
+    className?: string;
+    noMargin?: boolean;
+};
+declare function Heading({ children, level, className, noMargin }: Readonly<HeadingProps>): React$1.DetailedReactHTMLElement<{
+    className: string;
+}, HTMLElement>;
+declare namespace Heading {
+    var displayName: string;
+}
+
+type TextProps = {
+    children: ReactNode;
+    variant?: 'body' | 'muted' | 'small';
+    size?: 'xs' | 'sm' | 'base' | 'lg' | 'xl';
+    weight?: 'normal' | 'medium' | 'semibold' | 'bold';
+    className?: string;
+    noMargin?: boolean;
+};
+declare function Text({ children, variant, size, weight, className, noMargin }: Readonly<TextProps>): react_jsx_runtime.JSX.Element;
+declare namespace Text {
+    var displayName: string;
+}
+
+type CodeProps = {
+    children: ReactNode;
+    block?: boolean;
+    variant?: 'default' | 'primary' | 'muted';
+    className?: string;
+};
+declare function Code({ children, block, variant, className }: Readonly<CodeProps>): react_jsx_runtime.JSX.Element;
+declare namespace Code {
+    var displayName: string;
+}
+
+type LinkProps = {
+    children: ReactNode;
+    href: string;
+    external?: boolean;
+    variant?: 'default' | 'muted' | 'secondary' | 'inherit';
+    underline?: 'hover' | 'always' | 'none';
+    size?: 'sm' | 'md' | 'lg';
+    display?: 'inline' | 'block';
+    className?: string;
+};
+declare function Link({ children, href, external, variant, underline, size, display, className }: Readonly<LinkProps>): react_jsx_runtime.JSX.Element;
+declare namespace Link {
+    var displayName: string;
+}
+
+type Theme = 'light' | 'dark';
+type ThemeContextType = {
+    theme: Theme;
+    setTheme: (theme: Theme) => void;
+    availableThemes: Theme[];
+};
+type ThemeProviderProps = {
+    children: ReactNode;
+    defaultTheme?: Theme;
+    storageKey?: string;
+    themes?: Theme[];
+};
+declare function ThemeProvider({ children, defaultTheme, storageKey, themes }: Readonly<ThemeProviderProps>): react_jsx_runtime.JSX.Element;
+declare function useTheme(): ThemeContextType;
+
+type ColorModeToggleProps = {
+    className?: string;
+};
+declare function ColorModeToggle({ className }: Readonly<ColorModeToggleProps>): react_jsx_runtime.JSX.Element;
+declare namespace ColorModeToggle {
+    var displayName: string;
+}
+
+export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, Alert, type AlertProps, Avatar, type AvatarProps, Badge, type BadgeProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, Card, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, Checkbox, type CheckboxProps, Chip, type ChipProps, Code, CodeBlock, type CodeBlockProps, type CodeProps, ColorModeToggle, type ColorModeToggleProps, type ColumnDef, Container, type ContainerProps, DataTable, type DataTableProps, DeleteDialog, Dialog, type DialogProps, Divider, type DividerProps, Drawer, type DrawerProps, Dropdown, type DropdownProps, EmptyState, type EmptyStateProps, type Feature, FeatureSection, type FeatureSectionProps, Footer, type FooterProps, type FooterSection, FormField, type FormFieldProps, Grid, type GridProps, Heading, type HeadingProps, Hero, type HeroAction, type HeroProps, Input, InputGroup, type InputGroupProps, type InputProps, LeftNavItem, type LeftNavItemProps, LeftNavLayout, type LeftNavLayoutProps, LeftNavSection, type LeftNavSectionProps, Link, type LinkProps, List, ListItem, type ListItemProps, type ListProps, Modal, type ModalProps, Nav, type NavProps, Navbar, NavbarBrand, type NavbarBrandProps, NavbarLink, type NavbarLinkProps, type NavbarProps, Page, type PageProps, Pagination, type PaginationProps, Popover, type PopoverProps, type PricingFeature, PricingTable, type PricingTableProps, PricingTier, type PricingTierProps, ProgressBar, type ProgressBarProps, Radio, RadioGroup, type RadioGroupProps, type RadioProps, Select, SelectItem, type SelectItemProps, type SelectProps, Sidebar, type SidebarProps, Skeleton, type SkeletonProps, Slider, type SliderProps, type SortConfig, type SortDirection, Spinner, type SpinnerProps, Stack, type StackProps, StatusLabel, type StepProps, Stepper, type StepperProps, Switch, type SwitchProps, type Tab, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHeadCell, type TableHeadCellProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, type TabsProps, Text, type TextProps, Textarea, type TextareaProps, type Theme, type ThemeContextType, ThemeProvider, type ThemeProviderProps, Timeline, TimelineItem, type TimelineItemProps, type TimelineProps, Toast, type ToastProps, Tooltip, type TooltipProps, type UseTableOptions, type UseTableReturn, useTable, useTheme };