@santi020k/lumen-react 0.1.0

package/dist/components.d.ts

@@ -0,0 +1,634 @@
+import { type LumenIconName } from '@santi020k/lumen-core';
+import type { ComponentPropsWithoutRef, ElementType, ReactNode } from 'react';
+import { type DialogOptions, type DropdownMenuOptions, type PopoverOptions, type ResizableDirection, type SelectOptions, type TabsOptions, type TooltipOptions } from './hooks.js';
+type AlertVariant = 'default' | 'destructive' | 'success' | 'warning';
+type BadgeVariant = AlertVariant | 'outline' | 'secondary';
+type ButtonSize = 'default' | 'icon' | 'lg' | 'sm';
+type ButtonVariant = 'default' | 'destructive' | 'ghost' | 'link' | 'outline' | 'secondary';
+type CardVariant = 'default' | 'glass' | 'interactive' | 'muted';
+type CodeTheme = 'auto' | 'lumen' | 'santi020k';
+type CodeVariant = 'block' | 'inline';
+type IconSize = 'default' | 'lg' | 'sm' | 'xl';
+export type DataTableCell = boolean | null | number | string | undefined | {
+    label?: boolean | null | number | string;
+    sortValue?: boolean | null | number | string;
+    value?: boolean | null | number | string;
+};
+export interface DataTableColumn {
+    header?: string;
+    key: string;
+    label?: string;
+    sort?: 'number' | 'string';
+    sortable?: boolean;
+}
+export type DataTableRow = Record<string, DataTableCell> & {
+    id?: number | string;
+    rowValue?: number | string;
+    value?: number | string;
+};
+type MessageFrom = 'assistant' | 'user';
+type MarkerVariant = 'danger' | 'default' | 'success' | 'warning';
+type Orientation = 'horizontal' | 'vertical';
+type SurfaceVariant = 'default' | 'glass';
+export type LumenGlassProp = boolean | 'subtle' | 'strong';
+interface SurfaceProps {
+    'data-surface'?: SurfaceVariant;
+    glass?: LumenGlassProp;
+    surface?: SurfaceVariant;
+}
+export interface Option {
+    disabled?: boolean;
+    label: string;
+    value: string;
+}
+type SelectOption = Option | string;
+type PrimitiveProps = ComponentPropsWithoutRef<'div'> & {
+    [key: string]: unknown;
+    as?: ElementType;
+};
+export type AccordionProps = ComponentPropsWithoutRef<'div'>;
+export declare const Accordion: ({ className, ...props }: AccordionProps) => import("react").JSX.Element;
+export interface AlertProps extends ComponentPropsWithoutRef<'aside'> {
+    glass?: LumenGlassProp;
+    variant?: AlertVariant;
+}
+export declare const Alert: ({ className, glass, variant, ...props }: AlertProps) => import("react").JSX.Element;
+export type AlertDialogProps = Omit<ComponentPropsWithoutRef<'dialog'>, 'open'> & SurfaceProps & Omit<DialogOptions, 'id'>;
+export declare const AlertDialog: ({ className, defaultOpen, glass, onClick, onClose, onOpenChange, open, surface, ...props }: AlertDialogProps) => import("react").JSX.Element;
+export interface AgendaProps extends ComponentPropsWithoutRef<'section'> {
+    glass?: LumenGlassProp;
+}
+export declare const Agenda: ({ className, glass, ...props }: AgendaProps) => import("react").JSX.Element;
+export interface AspectRatioProps extends ComponentPropsWithoutRef<'div'> {
+    ratio?: string;
+}
+export declare const AspectRatio: ({ className, ratio, style, ...props }: AspectRatioProps) => import("react").JSX.Element;
+export interface AttachmentProps extends ComponentPropsWithoutRef<'article'> {
+    glass?: LumenGlassProp;
+    href?: string;
+}
+export interface AutocompleteProps extends ComponentPropsWithoutRef<'input'> {
+    list: string;
+}
+export declare const Autocomplete: ({ className, type, ...props }: AutocompleteProps) => import("react").JSX.Element;
+export declare const Attachment: ({ className, glass, href, ...props }: AttachmentProps) => import("react").JSX.Element;
+export interface AvatarProps extends ComponentPropsWithoutRef<'span'> {
+    alt?: string;
+    fallback?: ReactNode;
+    src?: string;
+}
+export declare const Avatar: ({ alt, children, className, fallback, src, ...props }: AvatarProps) => import("react").JSX.Element;
+export interface BadgeProps extends ComponentPropsWithoutRef<'span'> {
+    variant?: BadgeVariant;
+}
+export declare const Badge: ({ className, variant, ...props }: BadgeProps) => import("react").JSX.Element;
+export type BreadcrumbProps = ComponentPropsWithoutRef<'nav'>;
+export declare const Breadcrumb: ({ "aria-label": ariaLabel, className, ...props }: BreadcrumbProps) => import("react").JSX.Element;
+export interface BubbleProps extends ComponentPropsWithoutRef<'article'> {
+    from?: MessageFrom;
+    glass?: LumenGlassProp;
+}
+export declare const Bubble: ({ className, from, glass, ...props }: BubbleProps) => import("react").JSX.Element;
+export interface ButtonProps extends ComponentPropsWithoutRef<'button'> {
+    loading?: boolean;
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+}
+export declare const Button: ({ children, className, disabled, loading, size, type, variant, ...props }: ButtonProps) => import("react").JSX.Element;
+export type ButtonGroupProps = ComponentPropsWithoutRef<'div'>;
+export declare const ButtonGroup: ({ className, ...props }: ButtonGroupProps) => import("react").JSX.Element;
+export interface CalendarProps extends ComponentPropsWithoutRef<'div'> {
+    defaultValue?: string | undefined;
+    disabled?: boolean | undefined;
+    glass?: LumenGlassProp;
+    locale?: string | undefined;
+    max?: string | undefined;
+    min?: string | undefined;
+    month?: string | undefined;
+    name?: string | undefined;
+    onValueChange?: ((value: string) => void) | undefined;
+    value?: string | undefined;
+}
+export declare const Calendar: ({ className, defaultValue, disabled, glass, locale, max, min, month, name, onValueChange, value, ...props }: CalendarProps) => import("react").JSX.Element;
+export type CardProps<T extends ElementType = 'div'> = PrimitiveProps & {
+    'data-variant'?: CardVariant;
+    as?: T;
+    glass?: LumenGlassProp;
+    variant?: CardVariant;
+};
+export declare const Card: <T extends ElementType = "div">({ as, className, glass, variant, ...props }: CardProps<T>) => import("react").JSX.Element;
+export interface CarouselProps extends ComponentPropsWithoutRef<'section'> {
+    glass?: LumenGlassProp;
+}
+export declare const Carousel: ({ className, glass, ...props }: CarouselProps) => import("react").JSX.Element;
+export interface ChartProps extends ComponentPropsWithoutRef<'figure'> {
+    glass?: LumenGlassProp;
+}
+export declare const Chart: ({ className, glass, ...props }: ChartProps) => import("react").JSX.Element;
+export type CheckboxProps = Omit<ComponentPropsWithoutRef<'input'>, 'type'>;
+export declare const Checkbox: ({ className, ...props }: CheckboxProps) => import("react").JSX.Element;
+export type CollapsibleProps = ComponentPropsWithoutRef<'details'>;
+export declare const Collapsible: ({ className, ...props }: CollapsibleProps) => import("react").JSX.Element;
+export interface CodeProps extends ComponentPropsWithoutRef<'figure'> {
+    code?: string;
+    copy?: boolean;
+    highlighted?: boolean;
+    label?: ReactNode;
+    language?: string;
+    theme?: CodeTheme;
+    variant?: CodeVariant;
+}
+export declare const Code: ({ children, className, code, copy, highlighted, label, language, theme, variant, ...props }: CodeProps) => import("react").JSX.Element;
+export interface ComboboxProps extends ComponentPropsWithoutRef<'input'> {
+    label?: ReactNode;
+    list: string;
+    options?: string[];
+    wrapperClassName?: string;
+}
+export declare const Combobox: ({ className, defaultValue, id, label, list, onBlur, onChange, onFocus, onKeyDown, options, type, value: valueProp, wrapperClassName, ...props }: ComboboxProps) => import("react").JSX.Element;
+export interface CommandProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const Command: ({ className, glass, ...props }: CommandProps) => import("react").JSX.Element;
+export interface ContextMenuProps extends ComponentPropsWithoutRef<'menu'>, SurfaceProps {
+}
+export declare const ContextMenu: ({ className, glass, surface, ...props }: ContextMenuProps) => import("react").JSX.Element;
+export type ColorPickerProps = ComponentPropsWithoutRef<'input'>;
+export declare const ColorPicker: ({ className, type, ...props }: ColorPickerProps) => import("react").JSX.Element;
+export interface DataTableProps extends ComponentPropsWithoutRef<'div'> {
+    columns?: DataTableColumn[];
+    glass?: LumenGlassProp;
+    name?: string;
+    rows?: DataTableRow[];
+    selectable?: boolean;
+}
+export declare const DataTable: ({ children, className, columns, glass, name, rows, selectable, ...props }: DataTableProps) => import("react").JSX.Element;
+export type DatePickerProps = Omit<ComponentPropsWithoutRef<'input'>, 'defaultValue' | 'type' | 'value'> & SurfaceProps & {
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    value?: string;
+};
+export declare const DatePicker: ({ className, defaultValue, disabled, glass, id, max, min, name, onChange, onInvalid, onValueChange, placeholder, required, value, ...props }: DatePickerProps) => import("react").JSX.Element;
+export type DateRangePickerProps = ComponentPropsWithoutRef<'div'> & {
+    onRangeChange?: (range: {
+        end?: string;
+        start?: string;
+    }) => void;
+};
+export declare const DateRangePicker: ({ className, onInput, onRangeChange, ...props }: DateRangePickerProps) => import("react").JSX.Element;
+export type DialogProps = Omit<ComponentPropsWithoutRef<'dialog'>, 'open'> & SurfaceProps & Omit<DialogOptions, 'id'>;
+export declare const Dialog: ({ className, defaultOpen, glass, onClick, onClose, onOpenChange, open, surface, ...props }: DialogProps) => import("react").JSX.Element;
+export type DirectionProps = ComponentPropsWithoutRef<'div'>;
+export declare const Direction: ({ className, dir, ...props }: DirectionProps) => import("react").JSX.Element;
+export interface DrawerProps extends ComponentPropsWithoutRef<'dialog'>, SurfaceProps {
+}
+export declare const Drawer: ({ className, glass, surface, ...props }: DrawerProps) => import("react").JSX.Element;
+export type DropdownMenuProps = ComponentPropsWithoutRef<'menu'> & SurfaceProps & Omit<DropdownMenuOptions, 'id'>;
+export declare const DropdownMenu: ({ children, className, defaultOpen, glass, onOpenChange, open, surface, ...props }: DropdownMenuProps) => import("react").JSX.Element;
+export type DropdownMenuTriggerProps = ComponentPropsWithoutRef<'button'>;
+export declare const DropdownMenuTrigger: ({ onClick, onKeyDown, ...props }: DropdownMenuTriggerProps) => import("react").JSX.Element;
+export type DropdownMenuContentProps = ComponentPropsWithoutRef<'div'>;
+export declare const DropdownMenuContent: ({ className, onKeyDown, ...props }: DropdownMenuContentProps) => import("react").JSX.Element;
+export interface EmptyProps extends ComponentPropsWithoutRef<'section'> {
+    glass?: LumenGlassProp;
+}
+export declare const Empty: ({ className, glass, ...props }: EmptyProps) => import("react").JSX.Element;
+export interface FieldProps extends ComponentPropsWithoutRef<'div'> {
+    controlId?: string;
+    describedBy?: string;
+    glass?: LumenGlassProp;
+}
+export declare const Field: ({ "aria-describedby": ariaDescribedby, className, controlId, describedBy, glass, ...props }: FieldProps) => import("react").JSX.Element;
+export interface HoverCardProps extends ComponentPropsWithoutRef<'aside'>, SurfaceProps {
+}
+export declare const HoverCard: ({ className, glass, surface, ...props }: HoverCardProps) => import("react").JSX.Element;
+export interface IconProps extends ComponentPropsWithoutRef<'span'> {
+    decorative?: boolean;
+    label?: string;
+    name?: LumenIconName;
+    size?: IconSize;
+}
+export declare const Icon: ({ "aria-hidden": ariaHidden, "aria-label": ariaLabel, children, className, decorative, label, name, role, size, ...props }: IconProps) => import("react").JSX.Element;
+export interface InputProps extends Omit<ComponentPropsWithoutRef<'input'>, 'size'> {
+    size?: 'default' | 'lg' | 'sm';
+}
+export declare const Input: ({ className, size, type, ...props }: InputProps) => import("react").JSX.Element;
+export type InputGroupProps = ComponentPropsWithoutRef<'div'>;
+export declare const InputGroup: ({ className, ...props }: InputGroupProps) => import("react").JSX.Element;
+export interface InputOTPProps extends Omit<ComponentPropsWithoutRef<'input'>, 'className' | 'maxLength' | 'type'> {
+    className?: string | undefined;
+    inputClassName?: string | undefined;
+    length?: number;
+    maxLength?: number;
+}
+export declare const InputOTP: ({ "aria-invalid": ariaInvalid, className, defaultValue, disabled, inputClassName, inputMode, length, maxLength, pattern, value, ...props }: InputOTPProps) => import("react").JSX.Element;
+export type NumberFieldProps = ComponentPropsWithoutRef<'input'>;
+export declare const NumberField: ({ className, type, ...props }: NumberFieldProps) => import("react").JSX.Element;
+export interface ItemProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const Item: ({ className, glass, ...props }: ItemProps) => import("react").JSX.Element;
+export type KbdProps = ComponentPropsWithoutRef<'kbd'>;
+export declare const Kbd: ({ className, ...props }: KbdProps) => import("react").JSX.Element;
+export type LabelProps = ComponentPropsWithoutRef<'label'>;
+export declare const Label: ({ className, ...props }: LabelProps) => import("react").JSX.Element;
+export interface MarkerProps extends ComponentPropsWithoutRef<'span'> {
+    variant?: MarkerVariant;
+}
+export declare const Marker: ({ className, variant, ...props }: MarkerProps) => import("react").JSX.Element;
+export interface MenubarProps extends ComponentPropsWithoutRef<'nav'>, SurfaceProps {
+}
+export declare const Menubar: ({ className, glass, surface, ...props }: MenubarProps) => import("react").JSX.Element;
+export interface MessageProps extends ComponentPropsWithoutRef<'article'> {
+    from?: MessageFrom;
+}
+export declare const Message: ({ className, from, ...props }: MessageProps) => import("react").JSX.Element;
+export interface MessageScrollerProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const MessageScroller: ({ className, glass, ...props }: MessageScrollerProps) => import("react").JSX.Element;
+export interface NativeSelectProps extends ComponentPropsWithoutRef<'select'> {
+    options?: SelectOption[];
+    placeholder?: string;
+}
+export declare const NativeSelect: ({ children, className, defaultValue, options, placeholder, value, ...props }: NativeSelectProps) => import("react").JSX.Element;
+export interface PhoneInputProps extends Omit<ComponentPropsWithoutRef<'div'>, 'defaultValue'> {
+    countries?: SelectOption[];
+    countryLabel?: string;
+    countryName?: string;
+    defaultCountryValue?: string;
+    defaultValue?: string;
+    name?: string;
+    placeholder?: string;
+    size?: 'default' | 'lg' | 'sm';
+}
+export declare const PhoneInput: ({ className, countries, countryLabel, countryName, defaultCountryValue, defaultValue, name, placeholder, size, ...props }: PhoneInputProps) => import("react").JSX.Element;
+export interface NavigationMenuProps extends ComponentPropsWithoutRef<'nav'>, SurfaceProps {
+}
+export declare const NavigationMenu: ({ className, glass, surface, ...props }: NavigationMenuProps) => import("react").JSX.Element;
+export type PaginationProps = ComponentPropsWithoutRef<'nav'>;
+export declare const Pagination: ({ "aria-label": ariaLabel, className, ...props }: PaginationProps) => import("react").JSX.Element;
+export type PopoverProps = ComponentPropsWithoutRef<'div'> & SurfaceProps & Omit<PopoverOptions, 'id'>;
+export declare const Popover: ({ children, className, defaultOpen, glass, onOpenChange, open, surface, ...props }: PopoverProps) => import("react").JSX.Element;
+export type PopoverTriggerProps = ComponentPropsWithoutRef<'button'>;
+export declare const PopoverTrigger: ({ onClick, onKeyDown, ...props }: PopoverTriggerProps) => import("react").JSX.Element;
+export type PopoverPanelProps = ComponentPropsWithoutRef<'div'>;
+export declare const PopoverPanel: ({ onKeyDown, ...props }: PopoverPanelProps) => import("react").JSX.Element;
+export interface ProgressProps extends ComponentPropsWithoutRef<'div'> {
+    max?: number;
+    value?: number;
+}
+export declare const Progress: ({ className, max, value, ...props }: ProgressProps) => import("react").JSX.Element;
+export type RadioGroupProps = ComponentPropsWithoutRef<'fieldset'>;
+export declare const RadioGroup: ({ className, ...props }: RadioGroupProps) => import("react").JSX.Element;
+export interface ResizableProps extends ComponentPropsWithoutRef<'div'> {
+    defaultSizes?: number[] | undefined;
+    direction?: ResizableDirection | undefined;
+    maxSize?: number | number[] | undefined;
+    minSize?: number | number[] | undefined;
+    resetOnDoubleClick?: boolean | undefined;
+}
+export declare const Resizable: ({ children, className, defaultSizes, direction, maxSize, minSize, resetOnDoubleClick, ...props }: ResizableProps) => import("react").JSX.Element;
+export interface RichTextEditorProps extends ComponentPropsWithoutRef<'section'> {
+    glass?: LumenGlassProp;
+}
+export declare const RichTextEditor: ({ className, glass, ...props }: RichTextEditorProps) => import("react").JSX.Element;
+export interface ScrollAreaProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const ScrollArea: ({ className, glass, ...props }: ScrollAreaProps) => import("react").JSX.Element;
+export interface ScheduleProps extends ComponentPropsWithoutRef<'section'> {
+    glass?: LumenGlassProp;
+}
+export declare const Schedule: ({ className, glass, ...props }: ScheduleProps) => import("react").JSX.Element;
+export type SearchFieldProps = ComponentPropsWithoutRef<'input'>;
+export declare const SearchField: ({ className, type, ...props }: SearchFieldProps) => import("react").JSX.Element;
+export interface SelectProps extends Omit<NativeSelectProps, 'defaultValue' | 'disabled' | 'id' | 'name' | 'onChange' | 'options' | 'placeholder' | 'required' | 'size' | 'value'>, SelectOptions {
+    glass?: LumenGlassProp;
+    onChange?: ComponentPropsWithoutRef<'select'>['onChange'];
+    size?: 'default' | 'lg' | 'md' | 'sm';
+}
+export declare const Select: ({ children, className, defaultValue, disabled, glass, id, name, onChange, onValueChange, options, placeholder, required, size, value, ...props }: SelectProps) => import("react").JSX.Element;
+export interface SeparatorProps extends ComponentPropsWithoutRef<'hr'> {
+    orientation?: Orientation;
+}
+export declare const Separator: ({ className, orientation, ...props }: SeparatorProps) => import("react").JSX.Element;
+export interface SheetProps extends ComponentPropsWithoutRef<'dialog'>, SurfaceProps {
+}
+export declare const Sheet: ({ className, glass, surface, ...props }: SheetProps) => import("react").JSX.Element;
+export interface SidebarProps extends ComponentPropsWithoutRef<'aside'>, SurfaceProps {
+}
+export declare const Sidebar: ({ className, glass, surface, ...props }: SidebarProps) => import("react").JSX.Element;
+export type SkeletonProps = ComponentPropsWithoutRef<'div'>;
+export declare const Skeleton: ({ className, ...props }: SkeletonProps) => import("react").JSX.Element;
+export type SliderProps = ComponentPropsWithoutRef<'input'>;
+export declare const Slider: ({ className, type, ...props }: SliderProps) => import("react").JSX.Element;
+export type SonnerProps = ComponentPropsWithoutRef<'div'>;
+export declare const Sonner: ({ className, ...props }: SonnerProps) => import("react").JSX.Element;
+export type SpinnerProps = ComponentPropsWithoutRef<'span'>;
+export declare const Spinner: ({ "aria-hidden": ariaHidden, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, className, role, ...props }: SpinnerProps) => import("react").JSX.Element;
+export type SwitchProps = Omit<ComponentPropsWithoutRef<'input'>, 'type'>;
+export declare const Switch: ({ className, role, ...props }: SwitchProps) => import("react").JSX.Element;
+export interface TableProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const Table: ({ className, glass, ...props }: TableProps) => import("react").JSX.Element;
+export interface TabsProps extends Omit<ComponentPropsWithoutRef<'div'>, 'defaultValue' | 'id' | 'onChange'>, Omit<TabsOptions, 'id'> {
+    glass?: LumenGlassProp;
+}
+export declare const Tabs: ({ children, className, defaultValue, glass, onValueChange, orientation, value, ...props }: TabsProps) => import("react").JSX.Element;
+export type TabsListProps = ComponentPropsWithoutRef<'div'>;
+export declare const TabsList: ({ ...props }: TabsListProps) => import("react").JSX.Element;
+export interface TabsTriggerProps extends ComponentPropsWithoutRef<'button'> {
+    value: string;
+}
+export declare const TabsTrigger: ({ onClick, onKeyDown, value, ...props }: TabsTriggerProps) => import("react").JSX.Element;
+export interface TabsPanelProps extends ComponentPropsWithoutRef<'div'> {
+    value: string;
+}
+export declare const TabsPanel: ({ value, ...props }: TabsPanelProps) => import("react").JSX.Element;
+export type TagGroupProps = ComponentPropsWithoutRef<'div'>;
+export declare const TagGroup: ({ className, role, ...props }: TagGroupProps) => import("react").JSX.Element;
+export type TextareaProps = ComponentPropsWithoutRef<'textarea'>;
+export declare const Textarea: ({ className, rows, ...props }: TextareaProps) => import("react").JSX.Element;
+export interface ThemeBuilderProps extends ComponentPropsWithoutRef<'section'> {
+    glass?: LumenGlassProp;
+}
+export declare const ThemeBuilder: ({ className, glass, ...props }: ThemeBuilderProps) => import("react").JSX.Element;
+export type TimeFieldProps = ComponentPropsWithoutRef<'input'>;
+export declare const TimeField: ({ className, type, ...props }: TimeFieldProps) => import("react").JSX.Element;
+export interface ToastProps extends ComponentPropsWithoutRef<'aside'>, SurfaceProps {
+    variant?: AlertVariant;
+}
+export declare const Toast: ({ "aria-live": ariaLive, className, glass, role, surface, variant, ...props }: ToastProps) => import("react").JSX.Element;
+export interface ToggleProps extends ComponentPropsWithoutRef<'button'> {
+    pressed?: boolean;
+}
+export declare const Toggle: ({ className, pressed, type, ...props }: ToggleProps) => import("react").JSX.Element;
+export type ToggleGroupProps = ComponentPropsWithoutRef<'div'>;
+export declare const ToggleGroup: ({ className, ...props }: ToggleGroupProps) => import("react").JSX.Element;
+export type TooltipProps = ComponentPropsWithoutRef<'span'> & Omit<TooltipOptions, 'id'>;
+export declare const Tooltip: ({ children, className, defaultOpen, delay, onKeyDown, onMouseEnter, onMouseLeave, onOpenChange, open, ...props }: TooltipProps) => import("react").JSX.Element;
+export type TooltipContentProps = ComponentPropsWithoutRef<'span'>;
+export declare const TooltipContent: ({ ...props }: TooltipContentProps) => import("react").JSX.Element;
+export interface TreeProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const Tree: ({ className, glass, role, ...props }: TreeProps) => import("react").JSX.Element;
+export interface TreeGridProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+}
+export declare const TreeGrid: ({ className, glass, role, ...props }: TreeGridProps) => import("react").JSX.Element;
+export type TypographyProps = ComponentPropsWithoutRef<'div'>;
+export declare const Typography: ({ className, ...props }: TypographyProps) => import("react").JSX.Element;
+export interface VirtualListProps extends ComponentPropsWithoutRef<'div'> {
+    glass?: LumenGlassProp;
+    itemSize?: number | string;
+    overscan?: number | string;
+}
+export declare const VirtualList: ({ className, glass, itemSize, overscan, ...props }: VirtualListProps) => import("react").JSX.Element;
+export type BackToTopProps = ComponentPropsWithoutRef<'button'>;
+export declare const BackToTop: ({ className, type, ...props }: BackToTopProps) => import("react").JSX.Element;
+export type CalloutProps = ComponentPropsWithoutRef<'aside'>;
+export declare const Callout: ({ className, ...props }: CalloutProps) => import("react").JSX.Element;
+export type EyebrowProps = ComponentPropsWithoutRef<'p'>;
+export declare const Eyebrow: ({ className, ...props }: EyebrowProps) => import("react").JSX.Element;
+export type FloatingBadgeProps = ComponentPropsWithoutRef<'span'>;
+export declare const FloatingBadge: ({ className, ...props }: FloatingBadgeProps) => import("react").JSX.Element;
+export type FormattedDateProps = ComponentPropsWithoutRef<'time'>;
+export declare const FormattedDate: ({ className, ...props }: FormattedDateProps) => import("react").JSX.Element;
+export type ImageProps<T extends ElementType = 'img'> = {
+    as?: T;
+    className?: string;
+    invertOnDark?: boolean;
+    loading?: 'eager' | 'lazy';
+} & Omit<ComponentPropsWithoutRef<T>, 'as' | 'className' | 'loading'>;
+export declare const Image: <T extends ElementType = "img">({ as, className, invertOnDark, loading, ...props }: ImageProps<T>) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;
+export type LinkProps = ComponentPropsWithoutRef<'a'>;
+export declare const Link: ({ className, ...props }: LinkProps) => import("react").JSX.Element;
+export type PillProps = ComponentPropsWithoutRef<'span'> & {
+    count?: number | string;
+};
+export declare const Pill: ({ className, count, children, ...props }: PillProps) => import("react").JSX.Element;
+export type ProseProps = ComponentPropsWithoutRef<'div'>;
+export declare const Prose: ({ className, ...props }: ProseProps) => import("react").JSX.Element;
+export type SkipLinkProps = ComponentPropsWithoutRef<'a'>;
+export declare const SkipLink: ({ className, ...props }: SkipLinkProps) => import("react").JSX.Element;
+export type ThemeToggleProps = ComponentPropsWithoutRef<'button'>;
+export declare const ThemeToggle: ({ className, type, ...props }: ThemeToggleProps) => import("react").JSX.Element;
+export type LanguageToggleProps = ComponentPropsWithoutRef<'button'>;
+export declare const LanguageToggle: ({ className, type, ...props }: LanguageToggleProps) => import("react").JSX.Element;
+export interface ParticlesProps extends ComponentPropsWithoutRef<'div'> {
+    density?: 'low' | 'medium' | 'high';
+}
+export declare const Particles: ({ className, density, ...props }: ParticlesProps) => import("react").JSX.Element;
+type MotionAnimation = 'fade' | 'scale' | 'slide-up';
+type MotionDuration = 'fast' | 'slow' | 'standard';
+export interface ScrollRevealProps extends ComponentPropsWithoutRef<'div'> {
+    animation?: MotionAnimation;
+    delay?: number;
+    duration?: MotionDuration;
+    once?: boolean;
+    threshold?: number;
+}
+export declare const ScrollReveal: ({ animation, className, delay, duration, once, style, threshold, ...props }: ScrollRevealProps) => import("react").JSX.Element;
+export interface RevealGroupProps extends ComponentPropsWithoutRef<'div'> {
+    animation?: MotionAnimation;
+    delay?: number;
+    duration?: MotionDuration;
+    once?: boolean;
+    stagger?: number;
+    threshold?: number;
+}
+export declare const RevealGroup: ({ animation, className, delay, duration, once, stagger, style, threshold, ...props }: RevealGroupProps) => import("react").JSX.Element;
+export interface AnimatedNumberProps extends Omit<ComponentPropsWithoutRef<'span'>, 'prefix'> {
+    decimals?: number;
+    duration?: MotionDuration;
+    from?: number;
+    locale?: string;
+    prefix?: string;
+    suffix?: string;
+    value: number;
+}
+export declare const AnimatedNumber: ({ className, decimals, duration, from, locale, prefix, suffix, value, ...props }: AnimatedNumberProps) => import("react").JSX.Element;
+export interface StatProps extends ComponentPropsWithoutRef<'div'> {
+    label?: string;
+    value?: string;
+}
+export declare const Stat: ({ className, label, value, children, ...props }: StatProps) => import("react").JSX.Element;
+export type MeterProps = ComponentPropsWithoutRef<'meter'>;
+export declare const Meter: ({ className, ...props }: MeterProps) => import("react").JSX.Element;
+export interface NoteProps extends ComponentPropsWithoutRef<'div'> {
+    label?: string;
+    borderPosition?: 'left' | 'right' | 'none';
+}
+export declare const Note: ({ className, label, borderPosition, children, ...props }: NoteProps) => import("react").JSX.Element;
+export interface RatingProps extends ComponentPropsWithoutRef<'div'> {
+    value?: number;
+    max?: number;
+    readonly?: boolean;
+}
+export declare const Rating: ({ className, value, max, readonly, ...props }: RatingProps) => import("react").JSX.Element;
+export type TimelineProps = ComponentPropsWithoutRef<'ol'>;
+export declare const Timeline: ({ className, ...props }: TimelineProps) => import("react").JSX.Element;
+export type TimelineItemProps = ComponentPropsWithoutRef<'li'> & {
+    dot?: React.ReactNode;
+};
+export declare const TimelineItem: ({ className, children, dot, ...props }: TimelineItemProps) => import("react").JSX.Element;
+export type AnimatedLogoProps = ComponentPropsWithoutRef<'span'> & {
+    animation?: 'reveal' | 'sequence';
+};
+export declare const AnimatedLogo: ({ animation, className, ...props }: AnimatedLogoProps) => import("react").JSX.Element;
+export type AnimatedPortraitProps = ComponentPropsWithoutRef<'div'>;
+export declare const AnimatedPortrait: ({ className, ...props }: AnimatedPortraitProps) => import("react").JSX.Element;
+export type ButtonLinkProps = ComponentPropsWithoutRef<'a'> & {
+    shape?: 'default' | 'icon';
+    variant?: 'ghost' | 'inline' | 'primary' | 'secondary';
+};
+export declare const ButtonLink: ({ className, shape, variant, ...props }: ButtonLinkProps) => import("react").JSX.Element;
+export type CoverImageProps = ComponentPropsWithoutRef<'div'> & {
+    hover?: boolean;
+    showBottomGradient?: boolean;
+};
+export declare const CoverImage: ({ className, hover, showBottomGradient, children, ...props }: CoverImageProps) => import("react").JSX.Element;
+export type GradientDividerProps = ComponentPropsWithoutRef<'div'>;
+export declare const GradientDivider: ({ className, ...props }: GradientDividerProps) => import("react").JSX.Element;
+export type StepItem = string | {
+    description?: string;
+    title: string;
+};
+export interface StepperProps extends ComponentPropsWithoutRef<'ol'> {
+    currentStep?: number;
+    orientation?: Orientation;
+    steps?: StepItem[];
+}
+export declare const Stepper: ({ children, className, currentStep, orientation, steps, ...props }: StepperProps) => import("react").JSX.Element;
+export interface FileUploadProps extends Omit<ComponentPropsWithoutRef<'input'>, 'type' | 'size'> {
+    hint?: ReactNode;
+    inputClassName?: string;
+    label?: ReactNode;
+}
+export declare const FileUpload: ({ children, className, hint, id, inputClassName, label, onChange, ...props }: FileUploadProps) => import("react").JSX.Element;
+export interface TourStep {
+    content: ReactNode;
+    target: string;
+    title?: ReactNode;
+}
+export interface TourProps extends ComponentPropsWithoutRef<'div'> {
+    closeLabel?: string;
+    nextLabel?: string;
+    steps?: TourStep[];
+}
+export declare const Tour: ({ children, className, closeLabel, hidden, nextLabel, steps, ...props }: TourProps) => import("react").JSX.Element;
+export interface AnchorLink {
+    href: string;
+    label: ReactNode;
+}
+export interface AnchorProps extends ComponentPropsWithoutRef<'nav'> {
+    items?: AnchorLink[];
+}
+export declare const Anchor: ({ "aria-label": ariaLabel, children, className, items, ...props }: AnchorProps) => import("react").JSX.Element;
+export interface SegmentedProps extends Omit<ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    defaultValue?: string;
+    name?: string;
+    onValueChange?: (value: string) => void;
+    options?: SelectOption[];
+    size?: 'default' | 'lg' | 'sm';
+    value?: string;
+}
+export declare const Segmented: ({ children, className, defaultValue, name, onValueChange, options, size, value, ...props }: SegmentedProps) => import("react").JSX.Element;
+export interface ToolbarProps extends ComponentPropsWithoutRef<'div'> {
+    orientation?: Orientation;
+}
+export declare const Toolbar: ({ "aria-label": ariaLabel, className, orientation, ...props }: ToolbarProps) => import("react").JSX.Element;
+export interface DescriptionsItem {
+    label: ReactNode;
+    value: ReactNode;
+}
+export interface DescriptionsProps extends ComponentPropsWithoutRef<'dl'> {
+    columns?: number;
+    items?: DescriptionsItem[];
+}
+export declare const Descriptions: ({ children, className, columns, items, style, ...props }: DescriptionsProps) => import("react").JSX.Element;
+export interface PopconfirmProps extends Omit<ComponentPropsWithoutRef<'div'>, 'title'> {
+    cancelLabel?: string;
+    confirmLabel?: string;
+    title?: ReactNode;
+}
+export declare const Popconfirm: ({ cancelLabel, children, className, confirmLabel, title, ...props }: PopconfirmProps) => import("react").JSX.Element;
+export interface TransferItem {
+    key: string;
+    label: ReactNode;
+}
+export interface TransferProps extends ComponentPropsWithoutRef<'div'> {
+    items?: TransferItem[];
+    name?: string;
+    sourceTitle?: string;
+    targetItems?: TransferItem[];
+    targetTitle?: string;
+}
+export declare const Transfer: ({ className, items, name, sourceTitle, targetItems, targetTitle, ...props }: TransferProps) => import("react").JSX.Element;
+export interface CascaderOption {
+    children?: CascaderOption[];
+    label: ReactNode;
+    value: string;
+}
+export interface CascaderProps extends ComponentPropsWithoutRef<'div'> {
+    name?: string;
+    options?: CascaderOption[];
+    placeholder?: string;
+}
+export declare const Cascader: ({ children, className, id, name, options, placeholder, ...props }: CascaderProps) => import("react").JSX.Element;
+export interface TreeSelectNode {
+    children?: TreeSelectNode[];
+    label: ReactNode;
+    value: string;
+}
+export interface TreeSelectProps extends ComponentPropsWithoutRef<'div'> {
+    name?: string;
+    placeholder?: string;
+    treeData?: TreeSelectNode[];
+}
+export declare const TreeSelect: ({ children, className, name, placeholder, treeData, ...props }: TreeSelectProps) => import("react").JSX.Element;
+export interface MentionsProps extends Omit<ComponentPropsWithoutRef<'div'>, 'onChange'> {
+    name?: string;
+    options?: SelectOption[];
+    placeholder?: string;
+    trigger?: string;
+}
+export declare const Mentions: ({ className, name, options, placeholder, trigger, ...props }: MentionsProps) => import("react").JSX.Element;
+export interface QRCodeProps extends ComponentPropsWithoutRef<'figure'> {
+    size?: number;
+    src?: string;
+    value?: string;
+}
+export declare const QRCode: ({ children, className, size, src, style, value, ...props }: QRCodeProps) => import("react").JSX.Element;
+export interface WatermarkProps extends ComponentPropsWithoutRef<'div'> {
+    content?: string;
+    gap?: number;
+    rotate?: number;
+    text?: string;
+}
+export declare const Watermark: ({ children, className, content, gap, rotate, style, text, ...props }: WatermarkProps) => import("react").JSX.Element;
+export interface AffixProps extends ComponentPropsWithoutRef<'div'> {
+    offset?: number;
+    offsetBottom?: number;
+    offsetTop?: number;
+    position?: 'bottom' | 'top';
+}
+export declare const Affix: ({ className, offset, offsetBottom, offsetTop, position: positionProp, style, ...props }: AffixProps) => import("react").JSX.Element;
+export interface SpeedDialAction {
+    icon?: string;
+    label: string;
+    value?: string;
+}
+export interface SpeedDialProps extends ComponentPropsWithoutRef<'div'> {
+    actions?: SpeedDialAction[];
+    defaultOpen?: boolean;
+    direction?: 'down' | 'left' | 'right' | 'up';
+    label?: string;
+}
+export declare const SpeedDial: ({ actions, children, className, defaultOpen, direction, label, onBlur, ...props }: SpeedDialProps) => import("react").JSX.Element;
+export {};
+//# sourceMappingURL=components.d.ts.map