@cascivo/react 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -1 +1,2619 @@
-export * from './types/packages/react/src/index'
+import { ErrorBoundary, FocusScope, Portal, RovingOrientation, Signal, SuspenseBoundary } from "@cascivo/core";
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, FormHTMLAttributes, HTMLAttributes, InputHTMLAttributes, LabelHTMLAttributes, LiHTMLAttributes, MouseEvent, ReactElement, ReactNode, SelectHTMLAttributes, TextareaHTMLAttributes } from "react";
+
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: 'primary' | 'secondary' | 'ghost' | 'destructive';
+  size?: 'sm' | 'md' | 'lg';
+  loading?: boolean;
+}
+declare function Button({
+  variant,
+  size,
+  loading,
+  className,
+  disabled,
+  children,
+  ...props
+}: ButtonProps): import("react").JSX.Element;
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+  label?: string;
+  hint?: string;
+  error?: string;
+  size?: 'sm' | 'md' | 'lg';
+}
+declare function Input({
+  label,
+  hint,
+  error,
+  size,
+  className,
+  id,
+  onFocus,
+  onBlur,
+  ...props
+}: InputProps): import("react").JSX.Element;
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+  variant?: 'default' | 'outlined' | 'elevated';
+  padding?: 'none' | 'sm' | 'md' | 'lg';
+}
+declare function Card({
+  variant,
+  padding,
+  className,
+  children,
+  ...props
+}: CardProps): import("react").JSX.Element;
+interface CardHeaderProps extends HTMLAttributes<HTMLDivElement> {}
+declare function CardHeader({
+  className,
+  children,
+  ...props
+}: CardHeaderProps): import("react").JSX.Element;
+interface CardTitleProps extends HTMLAttributes<HTMLHeadingElement> {}
+declare function CardTitle({
+  className,
+  children,
+  ...props
+}: CardTitleProps): import("react").JSX.Element;
+interface CardContentProps extends HTMLAttributes<HTMLDivElement> {}
+declare function CardContent({
+  className,
+  children,
+  ...props
+}: CardContentProps): import("react").JSX.Element;
+interface CardFooterProps extends HTMLAttributes<HTMLDivElement> {}
+declare function CardFooter({
+  className,
+  children,
+  ...props
+}: CardFooterProps): import("react").JSX.Element;
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+  variant?: 'default' | 'secondary' | 'success' | 'warning' | 'destructive' | 'outline';
+  size?: 'sm' | 'md';
+}
+declare function Badge({
+  variant,
+  size,
+  className,
+  children,
+  ...props
+}: BadgeProps): import("react").JSX.Element;
+interface ModalProps {
+  open?: boolean;
+  onClose?: () => void;
+  title?: string;
+  description?: string;
+  children?: ReactNode;
+  className?: string;
+  size?: 'sm' | 'md' | 'lg';
+}
+declare function Modal({
+  open,
+  onClose,
+  title,
+  description,
+  children,
+  className,
+  size
+}: ModalProps): import("react").JSX.Element;
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+  size?: 'sm' | 'md' | 'lg';
+  label?: string;
+}
+declare function Spinner({
+  size,
+  label,
+  className,
+  ...props
+}: SpinnerProps): import("react").JSX.Element;
+interface SeparatorProps extends HTMLAttributes<HTMLElement> {
+  orientation?: 'horizontal' | 'vertical';
+  decorative?: boolean;
+}
+declare function Separator({
+  orientation,
+  decorative,
+  className,
+  ...props
+}: SeparatorProps): import("react").JSX.Element;
+interface AlertProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+  variant?: 'default' | 'info' | 'success' | 'warning' | 'destructive';
+  title?: string;
+  icon?: ReactNode;
+  dismissible?: boolean;
+  onDismiss?: () => void;
+  action?: {
+    label: string;
+    onClick: () => void;
+  };
+}
+declare function Alert({
+  variant,
+  title,
+  icon,
+  dismissible,
+  onDismiss,
+  action,
+  className,
+  children,
+  ...props
+}: AlertProps): import("react").JSX.Element | null;
+interface AvatarProps extends HTMLAttributes<HTMLSpanElement> {
+  src?: string;
+  alt?: string;
+  fallback?: string;
+  size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+  status?: 'online' | 'offline' | 'busy';
+}
+declare function Avatar({
+  src,
+  alt,
+  fallback,
+  size,
+  status,
+  className,
+  ...props
+}: AvatarProps): import("react").JSX.Element;
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+  label?: string;
+  hint?: string;
+  error?: string;
+  resize?: 'none' | 'vertical' | 'both';
+}
+declare function Textarea({
+  label,
+  hint,
+  error,
+  resize,
+  rows,
+  className,
+  id,
+  onFocus,
+  onBlur,
+  ...props
+}: TextareaProps): import("react").JSX.Element;
+interface SelectOption {
+  value: string;
+  label: string;
+  disabled?: boolean;
+}
+interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
+  label?: string;
+  hint?: string;
+  error?: string;
+  placeholder?: string;
+  options: SelectOption[];
+  size?: 'sm' | 'md' | 'lg';
+}
+declare function Select({
+  label,
+  hint,
+  error,
+  placeholder,
+  options,
+  size,
+  className,
+  id,
+  defaultValue,
+  value,
+  onFocus,
+  onBlur,
+  ...props
+}: SelectProps): import("react").JSX.Element;
+interface CheckboxProps extends InputHTMLAttributes<HTMLInputElement> {
+  label?: string;
+  indeterminate?: boolean;
+}
+declare function Checkbox({
+  label,
+  indeterminate,
+  className,
+  id,
+  disabled,
+  ...props
+}: CheckboxProps): import("react").JSX.Element;
+interface RadioProps extends InputHTMLAttributes<HTMLInputElement> {
+  label?: string;
+  value: string;
+}
+declare function Radio({
+  label,
+  className,
+  id,
+  disabled,
+  value,
+  ...props
+}: RadioProps): import("react").JSX.Element;
+interface RadioGroupProps {
+  name: string;
+  value?: string;
+  defaultValue?: string;
+  onChange?: (value: string) => void;
+  orientation?: 'horizontal' | 'vertical';
+  className?: string;
+  children: ReactNode;
+}
+declare function RadioGroup({
+  name,
+  value,
+  defaultValue,
+  onChange,
+  orientation,
+  className,
+  children
+}: RadioGroupProps): import("react").JSX.Element;
+interface ToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange'> {
+  checked?: boolean;
+  defaultChecked?: boolean;
+  onChange?: (checked: boolean) => void;
+  label?: string;
+  size?: 'sm' | 'md';
+}
+declare function Toggle({
+  checked,
+  defaultChecked,
+  onChange,
+  label,
+  size,
+  className,
+  disabled,
+  ...props
+}: ToggleProps): import("react").JSX.Element;
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
+  label?: string;
+}
+declare function Slider({
+  label,
+  className,
+  id,
+  min,
+  max,
+  step,
+  disabled,
+  ...props
+}: SliderProps): import("react").JSX.Element;
+interface TooltipProps {
+  content: ReactNode;
+  placement?: 'top' | 'right' | 'bottom' | 'left';
+  children: ReactElement;
+  delay?: number;
+}
+declare function Tooltip({
+  content,
+  placement,
+  children,
+  delay
+}: TooltipProps): import("react").JSX.Element;
+interface DropdownItem {
+  label: string;
+  value: string;
+  icon?: ReactNode;
+  disabled?: boolean;
+  separator?: boolean;
+}
+interface DropdownProps {
+  trigger: ReactElement;
+  items: DropdownItem[];
+  onSelect?: (value: string) => void;
+  placement?: 'bottom-start' | 'bottom-end';
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
+}
+declare function Dropdown({
+  trigger,
+  items,
+  onSelect,
+  placement,
+  open,
+  onOpenChange
+}: DropdownProps): import("react").JSX.Element;
+type ToastVariant = 'default' | 'success' | 'warning' | 'destructive';
+interface ToastOptions {
+  title: string;
+  description?: string;
+  variant?: ToastVariant;
+  duration?: number;
+}
+declare function enqueue(options: ToastOptions): void;
+declare function ToastProvider({
+  children
+}: {
+  children: ReactNode;
+}): import("react").JSX.Element;
+declare function useToast(): {
+  toast: typeof enqueue;
+};
+declare function dismissAllToasts(): void;
+interface TabsProps {
+  defaultValue?: string;
+  value?: string;
+  onValueChange?: (value: string) => void;
+  className?: string;
+  children: ReactNode;
+}
+declare function Tabs({
+  defaultValue,
+  value,
+  onValueChange,
+  className,
+  children
+}: TabsProps): import("react").JSX.Element;
+declare function TabsList({
+  className,
+  children,
+  ...props
+}: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+interface TabsTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+  value: string;
+  disabled?: boolean;
+}
+declare function TabsTrigger(props: TabsTriggerProps): import("react").JSX.Element;
+interface TabsContentProps extends HTMLAttributes<HTMLDivElement> {
+  value: string;
+}
+declare function TabsContent(props: TabsContentProps): import("react").JSX.Element;
+interface AccordionProps {
+  type?: 'single' | 'multiple';
+  defaultValue?: string | string[];
+  value?: string | string[];
+  onValueChange?: (value: string | string[]) => void;
+  className?: string;
+  children: ReactNode;
+}
+declare function Accordion({
+  type,
+  defaultValue,
+  value,
+  onValueChange,
+  className,
+  children
+}: AccordionProps): import("react").JSX.Element;
+interface AccordionItemProps extends HTMLAttributes<HTMLDivElement> {
+  value: string;
+}
+declare function AccordionItem({
+  value,
+  className,
+  children,
+  ...props
+}: AccordionItemProps): import("react").JSX.Element;
+declare function AccordionTrigger(props: HTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+declare function AccordionContent(props: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+interface KbdProps extends HTMLAttributes<HTMLElement> {
+  size?: 'sm' | 'md';
+}
+declare function Kbd({
+  size,
+  className,
+  children,
+  ...props
+}: KbdProps): import("react").JSX.Element;
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+  variant?: 'standalone' | 'inline';
+  size?: 'sm' | 'md' | 'lg';
+  external?: boolean;
+}
+declare function Link({
+  variant,
+  size,
+  external,
+  className,
+  children,
+  ...props
+}: LinkProps): import("react").JSX.Element;
+interface BreadcrumbItem {
+  label: string;
+  href?: string;
+}
+interface BreadcrumbProps {
+  items: BreadcrumbItem[];
+  maxVisible?: number;
+  className?: string;
+  /** Accessible label for the nav landmark */
+  ariaLabel?: string;
+}
+declare function Breadcrumb({
+  items,
+  maxVisible,
+  className,
+  ariaLabel
+}: BreadcrumbProps): import("react").JSX.Element;
+interface HeaderLink {
+  label: string;
+  href: string;
+  active?: boolean;
+}
+interface HeaderLabels {
+  nav?: string;
+}
+interface HeaderProps extends HTMLAttributes<HTMLElement> {
+  brand?: ReactNode;
+  links?: HeaderLink[];
+  actions?: ReactNode;
+  sticky?: boolean;
+  labels?: HeaderLabels;
+}
+declare function Header({
+  brand,
+  links,
+  actions,
+  sticky,
+  labels,
+  className,
+  ...props
+}: HeaderProps): import("react").JSX.Element;
+interface SideNavSubItem {
+  label: string;
+  href: string;
+  active?: boolean;
+}
+interface SideNavItem {
+  label: string;
+  href?: string;
+  icon?: ReactNode;
+  active?: boolean;
+  items?: SideNavSubItem[];
+  onClick?: (e: MouseEvent<HTMLAnchorElement>) => void;
+}
+interface SideNavGroup {
+  label?: string;
+  items: SideNavItem[];
+}
+interface SideNavProps {
+  items?: SideNavItem[];
+  groups?: SideNavGroup[];
+  collapsed?: boolean;
+  defaultCollapsed?: boolean;
+  onCollapsedChange?: (collapsed: boolean) => void;
+  ariaLabel?: string;
+  collapseLabel?: string;
+  expandLabel?: string;
+  expandOnHover?: boolean;
+  showCollapseToggle?: boolean;
+  footer?: ReactNode;
+  className?: string;
+}
+declare function SideNav({
+  items,
+  groups,
+  collapsed,
+  defaultCollapsed,
+  onCollapsedChange,
+  ariaLabel,
+  collapseLabel,
+  expandLabel,
+  expandOnHover,
+  showCollapseToggle,
+  footer,
+  className
+}: SideNavProps): import("react").JSX.Element;
+interface PaginationLabels {
+  nav?: string;
+  itemsPerPage?: string;
+  pageOf?: (page: number, total: number) => string;
+  range?: (start: number, end: number, total: number) => string;
+  previous?: string;
+  next?: string;
+}
+interface PaginationProps {
+  page: number;
+  pageSize: number;
+  totalItems: number;
+  onPageChange: (page: number) => void;
+  onPageSizeChange?: (size: number) => void;
+  pageSizeOptions?: number[];
+  labels?: PaginationLabels;
+  className?: string;
+}
+declare function Pagination({
+  page,
+  pageSize,
+  totalItems,
+  onPageChange,
+  onPageSizeChange,
+  pageSizeOptions,
+  labels,
+  className
+}: PaginationProps): import("react").JSX.Element;
+interface ProgressStep {
+  label: string;
+  description?: string;
+}
+interface ProgressIndicatorProps {
+  steps: ProgressStep[];
+  currentIndex: number;
+  vertical?: boolean;
+  className?: string;
+}
+declare function ProgressIndicator({
+  steps,
+  currentIndex,
+  vertical,
+  className
+}: ProgressIndicatorProps): import("react").JSX.Element;
+interface TagProps extends HTMLAttributes<HTMLSpanElement> {
+  variant?: 'default' | 'info' | 'success' | 'warning' | 'error';
+  size?: 'sm' | 'md';
+  onDismiss?: () => void;
+  dismissLabel?: string;
+}
+declare function Tag$1({
+  variant,
+  size,
+  onDismiss,
+  dismissLabel,
+  className,
+  children,
+  ...props
+}: TagProps): import("react").JSX.Element;
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+  variant?: 'text' | 'circle' | 'rect';
+  width?: string;
+  height?: string;
+  lines?: number;
+}
+declare function Skeleton({
+  variant,
+  width,
+  height,
+  lines,
+  className,
+  style,
+  ...props
+}: SkeletonProps): import("react").JSX.Element;
+interface ProgressBarProps {
+  /** Current value from 0 to max. Omit for an indeterminate bar. */
+  value?: number;
+  max?: number;
+  label?: string;
+  helperText?: string;
+  size?: 'sm' | 'md';
+  status?: 'active' | 'success' | 'error';
+  className?: string;
+}
+declare function ProgressBar({
+  value,
+  max,
+  label,
+  helperText,
+  size,
+  status,
+  className
+}: ProgressBarProps): import("react").JSX.Element;
+interface EmptyStateProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+  icon?: ReactNode;
+  title: string;
+  description?: string;
+  action?: ReactNode;
+  size?: 'md' | 'lg';
+}
+declare function EmptyState({
+  icon,
+  title,
+  description,
+  action,
+  size,
+  className,
+  ...props
+}: EmptyStateProps): import("react").JSX.Element;
+interface OverflowMenuItem {
+  label: string;
+  value: string;
+  icon?: ReactNode;
+  disabled?: boolean;
+  destructive?: boolean;
+}
+interface OverflowMenuProps {
+  items: OverflowMenuItem[];
+  onSelect?: (value: string) => void;
+  placement?: 'bottom-start' | 'bottom-end';
+  ariaLabel?: string;
+  size?: 'sm' | 'md';
+  disabled?: boolean;
+  className?: string;
+}
+declare function OverflowMenu({
+  items,
+  onSelect,
+  placement,
+  ariaLabel,
+  size,
+  disabled,
+  className
+}: OverflowMenuProps): import("react").JSX.Element;
+interface SearchProps {
+  value?: string;
+  defaultValue?: string;
+  onChange?: (value: string) => void;
+  onSearch?: (value: string) => void;
+  debounceMs?: number;
+  placeholder?: string;
+  size?: 'sm' | 'md' | 'lg';
+  label?: string;
+  disabled?: boolean;
+  clearLabel?: string;
+  id?: string;
+  className?: string;
+}
+declare function Search({
+  value,
+  defaultValue,
+  onChange,
+  onSearch,
+  debounceMs,
+  placeholder,
+  size,
+  label,
+  disabled,
+  clearLabel,
+  id,
+  className
+}: SearchProps): import("react").JSX.Element;
+interface NumberInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'value' | 'defaultValue' | 'onChange' | 'min' | 'max' | 'step'> {
+  value?: number | null;
+  defaultValue?: number;
+  onChange?: (value: number | null) => void;
+  min?: number;
+  max?: number;
+  step?: number;
+  precision?: number;
+  formatOptions?: Intl.NumberFormatOptions;
+  label?: string;
+  hint?: string;
+  error?: string;
+  size?: 'sm' | 'md' | 'lg';
+  incrementLabel?: string;
+  decrementLabel?: string;
+}
+declare function NumberInput({
+  value,
+  defaultValue,
+  onChange,
+  min,
+  max,
+  step,
+  precision,
+  formatOptions,
+  label,
+  hint,
+  error,
+  size,
+  disabled,
+  incrementLabel,
+  decrementLabel,
+  className,
+  id,
+  onFocus,
+  onBlur,
+  onKeyDown,
+  ...props
+}: NumberInputProps): import("react").JSX.Element;
+interface Column<Row> {
+  key: string;
+  header: string;
+  sortable?: boolean;
+  render?: (row: Row) => ReactNode;
+  align?: 'start' | 'end';
+  width?: string;
+}
+type SortDirection = 'asc' | 'desc';
+interface SortState {
+  key: string;
+  direction: SortDirection;
+}
+interface DataTableLabels {
+  search?: string;
+  empty?: string;
+  selectAll?: string;
+  selectRow?: string;
+  itemsSelected?: (n: number) => string;
+  expandRow?: string;
+}
+interface DataTableProps<Row> {
+  columns: Column<Row>[];
+  rows: Row[];
+  getRowId?: (row: Row) => string;
+  sort?: SortState;
+  defaultSort?: SortState;
+  sortMode?: 'client' | 'server';
+  onSortChange?: (sort: SortState | undefined) => void;
+  searchable?: boolean;
+  pagination?: {
+    pageSize: number;
+    pageSizeOptions?: number[];
+  };
+  selection?: {
+    mode: 'single' | 'multi';
+    selected?: string[];
+    onChange?: (ids: string[]) => void;
+  };
+  batchActions?: {
+    label: string;
+    onClick: (selectedIds: string[]) => void;
+  }[];
+  renderExpandedRow?: (row: Row) => ReactNode;
+  density?: 'compact' | 'normal' | 'relaxed';
+  zebra?: boolean;
+  stickyHeader?: boolean;
+  loading?: boolean;
+  emptyState?: ReactNode;
+  title?: string;
+  description?: string;
+  labels?: DataTableLabels;
+  className?: string;
+  virtualized?: boolean;
+  rowHeight?: number;
+  windowSize?: number;
+  overscan?: number;
+}
+declare function DataTable<Row>({
+  columns,
+  rows,
+  getRowId,
+  sort,
+  defaultSort,
+  sortMode,
+  onSortChange,
+  searchable,
+  pagination,
+  selection,
+  batchActions,
+  renderExpandedRow,
+  density,
+  zebra,
+  stickyHeader,
+  loading,
+  emptyState,
+  title,
+  description,
+  labels,
+  className,
+  virtualized,
+  rowHeight,
+  windowSize,
+  overscan
+}: DataTableProps<Row>): import("react").JSX.Element;
+interface CommandPage {
+  placeholder?: string;
+  groups: CommandGroup[];
+}
+interface CommandItem {
+  id: string;
+  label: string;
+  icon?: ReactNode;
+  shortcut?: string[];
+  keywords?: string[];
+  /** Exactly one of onSelect or page is required */
+  onSelect?: () => void;
+  disabled?: boolean;
+  page?: CommandPage;
+}
+interface CommandGroup {
+  heading?: string;
+  items: CommandItem[];
+}
+interface CommandMenuProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  groups: CommandGroup[];
+  placeholder?: string;
+  emptyLabel?: string;
+  hotkey?: boolean;
+  label?: string;
+  loading?: boolean;
+  onQueryChange?: (query: string) => void;
+  className?: string;
+}
+/**
+ * Fuzzy subsequence matcher. Every character of `query` must appear in order
+ * (case-insensitive) in `text`. Returns 0 for no match; higher is better.
+ * Consecutive runs and word-start matches score bonuses.
+ */
+declare function fuzzyScore(query: string, text: string): number;
+declare function CommandMenu({
+  open,
+  onOpenChange,
+  groups,
+  placeholder,
+  emptyLabel,
+  hotkey,
+  label,
+  loading,
+  onQueryChange,
+  className
+}: CommandMenuProps): import("react").JSX.Element;
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  readonly '~standard': {
+    readonly version: 1;
+    readonly vendor: string;
+    readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
+    readonly types?: {
+      readonly input: Input;
+      readonly output: Output;
+    } | undefined;
+  };
+}
+type StandardResult<Output> = {
+  readonly value: Output;
+  readonly issues?: undefined;
+} | {
+  readonly issues: ReadonlyArray<StandardIssue>;
+};
+interface StandardIssue {
+  readonly message: string;
+  readonly path?: ReadonlyArray<string | number | {
+    readonly key: string | number;
+  }>;
+}
+type Errors<T> = Partial<Record<keyof T, string>>;
+type Touched<T> = Partial<Record<keyof T, boolean>>;
+interface FormConfig<T extends Record<string, unknown>> {
+  initialValues: T;
+  /** Sync or async; return a (partial) field→message map. Empty map = valid. */
+  validate?: (values: T) => Errors<T> | Promise<Errors<T>>;
+  /** Standard Schema V1 compatible schema (zod, valibot, arktype, …). Runs before validate(). */
+  schema?: StandardSchemaV1;
+}
+interface FormStore<T extends Record<string, unknown>> {
+  values: Signal<T>;
+  errors: Signal<Errors<T>>;
+  touched: Signal<Touched<T>>;
+  submitting: Signal<boolean>;
+  field<K extends keyof T>(name: K): {
+    value: T[K];
+    onChange: (value: T[K]) => void;
+    onBlur: () => void;
+    error: string | undefined;
+  };
+  setValue<K extends keyof T>(name: K, value: T[K]): void;
+  submit(onValid: (values: T) => void | Promise<void>): Promise<void>;
+  reset(): void;
+}
+declare function createForm<T extends Record<string, unknown>>(config: FormConfig<T>): FormStore<T>;
+/** Stable per-mount form store. Config is captured on first render. */
+declare function useForm<T extends Record<string, unknown>>(config: FormConfig<T>): FormStore<T>;
+interface FormProps<T extends Record<string, unknown>> extends Omit<FormHTMLAttributes<HTMLFormElement>, 'onSubmit'> {
+  form: FormStore<T>;
+  onValid: (values: T) => void | Promise<void>;
+  children: ReactNode;
+}
+declare function Form<T extends Record<string, unknown>>({
+  form,
+  onValid,
+  children,
+  className,
+  ...props
+}: FormProps<T>): import("react").JSX.Element;
+interface ComboboxOption {
+  value: string;
+  label: string;
+  disabled?: boolean;
+}
+interface ComboboxLabels {
+  placeholder?: string;
+  empty?: string;
+  clear?: string;
+}
+interface ComboboxProps {
+  options: ComboboxOption[];
+  value?: string;
+  defaultValue?: string;
+  onChange?: (value: string | undefined) => void;
+  clearable?: boolean;
+  searchable?: boolean;
+  label?: string;
+  hint?: string;
+  error?: string;
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+  labels?: ComboboxLabels;
+  className?: string;
+  id?: string;
+}
+declare function Combobox({
+  options,
+  value,
+  defaultValue,
+  onChange,
+  clearable,
+  searchable,
+  label,
+  hint,
+  error,
+  size,
+  disabled,
+  labels,
+  className,
+  id
+}: ComboboxProps): import("react").JSX.Element;
+interface DatePickerLabels {
+  placeholder?: string;
+  previousMonth?: string;
+  nextMonth?: string;
+  clear?: string;
+}
+interface DatePickerProps {
+  value?: string;
+  defaultValue?: string;
+  onChange?: (value: string | undefined) => void;
+  min?: string;
+  max?: string;
+  clearable?: boolean;
+  label?: string;
+  hint?: string;
+  error?: string;
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+  labels?: DatePickerLabels;
+  className?: string;
+  id?: string;
+}
+declare function DatePicker({
+  value,
+  defaultValue,
+  onChange,
+  min,
+  max,
+  clearable,
+  label,
+  hint,
+  error,
+  size,
+  disabled,
+  labels,
+  className,
+  id
+}: DatePickerProps): import("react").JSX.Element;
+interface UploaderFile {
+  id: string;
+  name: string;
+  size?: number;
+  status: 'uploading' | 'complete' | 'error';
+  errorMessage?: string;
+}
+interface FileUploaderLabels {
+  label?: string;
+  drop?: string;
+  remove?: string;
+  uploading?: string;
+  complete?: string;
+  error?: string;
+}
+interface FileUploaderProps {
+  files?: UploaderFile[];
+  onFilesAdded?: (files: File[]) => void;
+  onRemove?: (id: string) => void;
+  multiple?: boolean;
+  accept?: string;
+  maxSize?: number;
+  onRejected?: (files: File[], reason: 'size' | 'type') => void;
+  label?: string;
+  hint?: string;
+  labels?: FileUploaderLabels;
+  disabled?: boolean;
+  className?: string;
+}
+declare function FileUploader({
+  files,
+  onFilesAdded,
+  onRemove,
+  multiple,
+  accept,
+  maxSize,
+  onRejected,
+  label,
+  hint,
+  labels,
+  disabled,
+  className
+}: FileUploaderProps): import("react").JSX.Element;
+interface TimePickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'value' | 'defaultValue' | 'onChange' | 'min' | 'max' | 'step'> {
+  value?: string;
+  defaultValue?: string;
+  onChange?: (value: string) => void;
+  min?: string;
+  max?: string;
+  step?: number;
+  label?: string;
+  hint?: string;
+  error?: string;
+  size?: 'sm' | 'md' | 'lg';
+}
+declare function TimePicker({
+  value,
+  defaultValue,
+  onChange,
+  min,
+  max,
+  step,
+  label,
+  hint,
+  error,
+  size,
+  className,
+  id,
+  onFocus,
+  onBlur,
+  ...props
+}: TimePickerProps): import("react").JSX.Element;
+interface UsePopoverOptions {
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  placement?: 'top' | 'bottom' | 'left' | 'right';
+  offset?: number;
+}
+interface UsePopoverReturn {
+  triggerRef: React.RefObject<HTMLElement | null>;
+  popoverRef: React.RefObject<HTMLElement | null>;
+  isOpen: Signal<boolean>;
+  anchorName: string;
+  open: () => void;
+  close: () => void;
+  toggle: () => void;
+}
+declare function usePopover(options?: UsePopoverOptions): UsePopoverReturn;
+interface PopoverProps extends UsePopoverOptions {
+  children: ReactNode;
+}
+declare function Popover({
+  children,
+  ...options
+}: PopoverProps): import("react").JSX.Element;
+interface PopoverTriggerProps {
+  children: ReactNode;
+  asChild?: boolean;
+}
+declare function PopoverTrigger({
+  children
+}: PopoverTriggerProps): import("react").JSX.Element;
+interface PopoverContentProps {
+  children: ReactNode;
+  className?: string;
+}
+declare function PopoverContent({
+  children,
+  className
+}: PopoverContentProps): import("react").JSX.Element;
+interface MenuProps {
+  children: ReactNode;
+}
+declare function Menu({
+  children
+}: MenuProps): import("react").JSX.Element;
+interface MenuTriggerProps {
+  children: ReactNode;
+  'aria-label'?: string;
+}
+declare function MenuTrigger({
+  children,
+  'aria-label': ariaLabel
+}: MenuTriggerProps): import("react").JSX.Element;
+interface MenuItemProps {
+  children: ReactNode;
+  onSelect: () => void;
+  disabled?: boolean;
+}
+declare function MenuItem({
+  children,
+  onSelect,
+  disabled
+}: MenuItemProps): import("react").JSX.Element;
+declare function MenuSeparator(): import("react").JSX.Element;
+interface AlertDialogLabels {
+  confirm?: string;
+  cancel?: string;
+}
+interface AlertDialogProps {
+  open: boolean;
+  title: string;
+  description: string;
+  onConfirm: () => void;
+  onCancel: () => void;
+  labels?: AlertDialogLabels;
+  variant?: 'destructive' | 'default';
+}
+declare function AlertDialog({
+  open,
+  title,
+  description,
+  onConfirm,
+  onCancel,
+  labels,
+  variant
+}: AlertDialogProps): import("react").JSX.Element;
+interface SheetProps {
+  open: boolean;
+  onClose: () => void;
+  title: string;
+  children: ReactNode;
+  side?: 'start' | 'end' | 'top' | 'bottom';
+}
+declare function Sheet({
+  open,
+  onClose,
+  title,
+  children,
+  side
+}: SheetProps): import("react").JSX.Element;
+interface ContextMenuProps {
+  children: ReactNode;
+}
+declare function ContextMenu({
+  children
+}: ContextMenuProps): import("react").JSX.Element;
+interface ContextMenuItemProps {
+  children: ReactNode;
+  onSelect: () => void;
+  disabled?: boolean;
+}
+declare function ContextMenuItem({
+  children,
+  onSelect,
+  disabled
+}: ContextMenuItemProps): import("react").JSX.Element;
+interface HoverCardProps {
+  children: ReactNode;
+  openDelay?: number;
+  closeDelay?: number;
+}
+declare function HoverCard({
+  children,
+  openDelay,
+  closeDelay
+}: HoverCardProps): import("react").JSX.Element;
+interface HoverCardTriggerProps {
+  children: ReactNode;
+}
+declare function HoverCardTrigger({
+  children
+}: HoverCardTriggerProps): import("react").JSX.Element;
+interface HoverCardContentProps {
+  children: ReactNode;
+  className?: string;
+}
+declare function HoverCardContent({
+  children,
+  className
+}: HoverCardContentProps): import("react").JSX.Element;
+interface PasswordInputLabels {
+  reveal?: string;
+  hide?: string;
+  strengthLabel?: (level: string) => string;
+}
+interface PasswordInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+  showStrengthMeter?: boolean;
+  size?: 'sm' | 'md' | 'lg';
+  labels?: PasswordInputLabels;
+}
+declare function PasswordInput({
+  showStrengthMeter,
+  size,
+  labels,
+  className,
+  id,
+  value,
+  defaultValue,
+  onChange,
+  ...props
+}: PasswordInputProps): import("react").JSX.Element;
+interface MultiSelectOption {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+interface MultiSelectLabels {
+  placeholder?: string;
+  selected?: (count: number) => string;
+  search?: string;
+  noResults?: string;
+}
+interface MultiSelectProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  options: MultiSelectOption[];
+  value: string[];
+  onValueChange: (v: string[]) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  labels?: MultiSelectLabels;
+}
+declare function MultiSelect({
+  options,
+  value,
+  onValueChange,
+  placeholder,
+  disabled,
+  labels,
+  className,
+  ...props
+}: MultiSelectProps): import("react").JSX.Element;
+interface TagsInputProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  value: string[];
+  onValueChange: (v: string[]) => void;
+  placeholder?: string;
+  validate?: (tag: string) => boolean;
+  max?: number;
+  disabled?: boolean;
+}
+declare function TagsInput({
+  value,
+  onValueChange,
+  placeholder,
+  validate,
+  max,
+  disabled,
+  className,
+  ...props
+}: TagsInputProps): import("react").JSX.Element;
+interface OtpInputProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  length?: number;
+  value: string;
+  onValueChange: (v: string) => void;
+  disabled?: boolean;
+  type?: 'numeric' | 'alphanumeric';
+}
+declare function OtpInput({
+  length,
+  value,
+  onValueChange,
+  disabled,
+  type,
+  className,
+  ...props
+}: OtpInputProps): import("react").JSX.Element;
+interface SegmentedControlOption {
+  label: string;
+  value: string;
+  disabled?: boolean;
+}
+interface SegmentedControlProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  options: SegmentedControlOption[];
+  value: string;
+  onValueChange: (v: string) => void;
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+}
+declare function SegmentedControl({
+  options,
+  value,
+  onValueChange,
+  size,
+  disabled,
+  className,
+  ...props
+}: SegmentedControlProps): import("react").JSX.Element;
+interface InputGroupAddonProps extends HTMLAttributes<HTMLSpanElement> {
+  /** Visual side, logical: 'inline-start' (leading) or 'inline-end' (trailing). */
+  align?: 'inline-start' | 'inline-end';
+  children: ReactNode;
+}
+/** Inline adornment (icon, unit) rendered INSIDE the field border. Decorative by default. */
+declare function InputGroupAddon({
+  align,
+  children,
+  className,
+  ...props
+}: InputGroupAddonProps): import("react").JSX.Element;
+interface InputGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'prefix' | 'suffix'> {
+  prefix?: ReactNode;
+  suffix?: ReactNode;
+  children: ReactNode;
+}
+declare function InputGroup({
+  prefix,
+  suffix,
+  children,
+  className,
+  ...props
+}: InputGroupProps): import("react").JSX.Element;
+interface RatingGroupLabels {
+  rating?: (value: number, max: number) => string;
+}
+interface RatingGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  value: number;
+  onValueChange?: (v: number) => void;
+  max?: number;
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+  readOnly?: boolean;
+  labels?: RatingGroupLabels;
+}
+declare function RatingGroup({
+  value,
+  onValueChange,
+  max,
+  size,
+  disabled,
+  readOnly,
+  labels,
+  className,
+  ...props
+}: RatingGroupProps): import("react").JSX.Element;
+interface EditableProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+  value: string;
+  onValueChange: (v: string) => void;
+  placeholder?: string;
+  disabled?: boolean;
+  submitOnBlur?: boolean;
+  onCancel?: () => void;
+}
+declare function Editable({
+  value,
+  onValueChange,
+  placeholder,
+  disabled,
+  submitOnBlur,
+  onCancel,
+  className,
+  ...props
+}: EditableProps): import("react").JSX.Element;
+interface RadioCardGroupProps {
+  name: string;
+  label: string;
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string) => void;
+  children: ReactNode;
+  className?: string | undefined;
+}
+declare function RadioCardGroup({
+  name,
+  label,
+  value,
+  defaultValue,
+  onValueChange,
+  children,
+  className
+}: RadioCardGroupProps): import("react").JSX.Element;
+interface RadioCardProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'name' | 'value' | 'title'> {
+  value: string;
+  title: ReactNode;
+  description?: ReactNode;
+  disabled?: boolean;
+  hideIndicator?: boolean;
+}
+declare function RadioCard({
+  value,
+  title,
+  description,
+  disabled,
+  hideIndicator,
+  ...props
+}: RadioCardProps): import("react").JSX.Element;
+interface ShellHeaderBrand {
+  prefix?: string;
+  name: string;
+  href?: string;
+}
+interface ShellHeaderNavLink {
+  label: string;
+  href: string;
+  active?: boolean;
+}
+interface ShellHeaderNavMenuItem {
+  label: string;
+  href: string;
+  active?: boolean;
+}
+interface ShellHeaderNavMenu {
+  label: string;
+  items: ShellHeaderNavMenuItem[];
+}
+type ShellHeaderNavItem = ShellHeaderNavLink | ShellHeaderNavMenu;
+interface ShellHeaderAction {
+  id: string;
+  label: string;
+  icon: ReactNode;
+  active?: boolean;
+  onClick?: (() => void) | undefined;
+}
+interface ShellHeaderLabels {
+  skipToContent?: string;
+  nav?: string;
+  openMenu?: string;
+  closeMenu?: string;
+}
+interface ShellHeaderProps {
+  brand?: ShellHeaderBrand | ReactNode;
+  nav?: ShellHeaderNavItem[];
+  actions?: ShellHeaderAction[];
+  end?: ReactNode;
+  onMenuClick?: (() => void) | undefined;
+  menuExpanded?: boolean;
+  skipToContentHref?: string | false;
+  labels?: ShellHeaderLabels;
+  className?: string | undefined;
+}
+declare function ShellHeader({
+  brand,
+  nav,
+  actions,
+  end,
+  onMenuClick,
+  menuExpanded,
+  skipToContentHref,
+  labels,
+  className
+}: ShellHeaderProps): import("react").JSX.Element;
+interface HeaderPanelLabels {
+  close?: string;
+}
+interface HeaderPanelProps {
+  open: boolean;
+  onClose: () => void;
+  label: string;
+  children: ReactNode;
+  labels?: HeaderPanelLabels;
+  className?: string | undefined;
+}
+declare function HeaderPanel({
+  open,
+  onClose,
+  label,
+  children,
+  labels,
+  className
+}: HeaderPanelProps): import("react").JSX.Element;
+interface SwitcherLink {
+  label: string;
+  href: string;
+  active?: boolean;
+  icon?: ReactNode;
+}
+type SwitcherEntry = SwitcherLink | {
+  divider: true;
+};
+interface SwitcherProps {
+  items: SwitcherEntry[];
+  label?: string;
+  className?: string | undefined;
+}
+declare function Switcher({
+  items,
+  label,
+  className
+}: SwitcherProps): import("react").JSX.Element;
+interface CheckboxCardProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'title' | 'onChange'> {
+  title: ReactNode;
+  description?: ReactNode;
+  onCheckedChange?: (checked: boolean) => void;
+  className?: string | undefined;
+}
+declare function CheckboxCard({
+  title,
+  description,
+  checked,
+  defaultChecked,
+  disabled,
+  onCheckedChange,
+  className,
+  ...props
+}: CheckboxCardProps): import("react").JSX.Element;
+interface CopyButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
+  /** The text written to the clipboard on click. */
+  value: string;
+  size?: 'sm' | 'md';
+  labels?: {
+    copy?: string;
+    copied?: string;
+  };
+}
+declare function CopyButton({
+  value,
+  size,
+  labels,
+  className,
+  ...props
+}: CopyButtonProps): import("react").JSX.Element;
+interface StatProps extends HTMLAttributes<HTMLDivElement> {
+  label: string;
+  value: string | number;
+  delta?: string;
+  trend?: 'up' | 'down' | 'flat';
+  helpText?: string;
+}
+declare function Stat({
+  label,
+  value,
+  delta,
+  trend,
+  helpText,
+  className,
+  ...props
+}: StatProps): import("react").JSX.Element;
+interface StatusProps extends HTMLAttributes<HTMLSpanElement> {
+  status?: 'success' | 'warning' | 'error' | 'info' | 'neutral';
+  /** Pulses the dot — only when the user allows motion. */
+  pulse?: boolean;
+}
+declare function Status({
+  status,
+  pulse,
+  className,
+  children,
+  ...props
+}: StatusProps): import("react").JSX.Element;
+interface VisuallyHiddenProps extends HTMLAttributes<HTMLSpanElement> {
+  children: ReactNode;
+}
+declare function VisuallyHidden({
+  children,
+  className,
+  ...props
+}: VisuallyHiddenProps): import("react").JSX.Element;
+interface SkipNavLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'href'> {
+  targetId?: string;
+  labels?: {
+    label?: string;
+  };
+}
+/** Render as the FIRST focusable element on the page — visually hidden until focused. */
+declare function SkipNavLink({
+  targetId,
+  labels,
+  className,
+  ...props
+}: SkipNavLinkProps): import("react").JSX.Element;
+interface SkipNavTargetProps extends HTMLAttributes<HTMLDivElement> {
+  id?: string;
+}
+/** Place where the main content starts; the link's hash navigation moves focus here. */
+declare function SkipNavTarget({
+  id,
+  ...props
+}: SkipNavTargetProps): import("react").JSX.Element;
+type ProgressVariant = 'primary' | 'info' | 'success' | 'warning' | 'error';
+type ProgressSize = 'sm' | 'md' | 'lg';
+interface ProgressProps {
+  /** 0–100. Omit for indeterminate state. */
+  value?: number;
+  variant?: ProgressVariant;
+  size?: ProgressSize;
+  'aria-label'?: string;
+  'aria-describedby'?: string;
+  className?: string;
+}
+declare function Progress({
+  value,
+  variant,
+  size,
+  className,
+  ...aria
+}: ProgressProps): import("react").JSX.Element;
+interface ProgressCircleProps extends HTMLAttributes<HTMLDivElement> {
+  /** Current value from 0 to max — clamped. */
+  value: number;
+  max?: number;
+  size?: 'sm' | 'md' | 'lg';
+  /** Renders the rounded percentage in the center — pairs best with md and lg. */
+  showValue?: boolean;
+  /** Accessible name for the progressbar. */
+  label?: string;
+}
+declare function ProgressCircle({
+  value,
+  max,
+  size,
+  showValue,
+  label,
+  className,
+  ...props
+}: ProgressCircleProps): import("react").JSX.Element;
+type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
+type HeadingSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
+  level?: HeadingLevel;
+  size?: HeadingSize;
+}
+declare function Heading({
+  level,
+  size,
+  className,
+  children,
+  ...props
+}: HeadingProps): import("react").JSX.Element;
+interface TextProps extends HTMLAttributes<HTMLElement> {
+  as?: 'p' | 'span' | 'div';
+  size?: 'sm' | 'md' | 'lg';
+  weight?: 'normal' | 'medium' | 'semibold';
+  muted?: boolean;
+}
+declare function Text({
+  as: Tag,
+  size,
+  weight,
+  muted,
+  className,
+  children,
+  ...props
+}: TextProps): import("react").JSX.Element;
+interface CodeProps extends HTMLAttributes<HTMLElement> {
+  size?: 'sm' | 'md';
+}
+declare function Code({
+  size,
+  className,
+  children,
+  ...props
+}: CodeProps): import("react").JSX.Element;
+interface BlockquoteProps extends HTMLAttributes<HTMLQuoteElement> {
+  cite?: string;
+}
+declare function Blockquote({
+  cite,
+  className,
+  children,
+  ...props
+}: BlockquoteProps): import("react").JSX.Element;
+interface ListProps extends HTMLAttributes<HTMLElement> {
+  as?: 'ul' | 'ol';
+  marker?: 'disc' | 'decimal' | 'none';
+}
+declare function List({
+  as: Tag,
+  marker,
+  className,
+  children,
+  ...props
+}: ListProps): import("react").JSX.Element;
+type ListItemProps = LiHTMLAttributes<HTMLLIElement>;
+declare function ListItem({
+  className,
+  children,
+  ...props
+}: ListItemProps): import("react").JSX.Element;
+type ProseProps = HTMLAttributes<HTMLDivElement>;
+declare function Prose({
+  className,
+  children,
+  ...props
+}: ProseProps): import("react").JSX.Element;
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+  /** Renders into the child element (Slot composition) instead of a native `<label>`. */
+  asChild?: boolean;
+  /** Shows a required marker after the label text. */
+  required?: boolean;
+  /** Dims the label to match an associated disabled control. */
+  disabled?: boolean;
+  children: ReactNode;
+  /** Override built-in strings (e.g. the required-marker accessible text). */
+  labels?: {
+    required?: string;
+  };
+}
+declare function Label({
+  asChild,
+  required,
+  disabled,
+  className,
+  children,
+  labels,
+  ...props
+}: LabelProps): import("react").JSX.Element;
+interface FieldProps {
+  /** Label text for the control. */
+  label?: ReactNode;
+  /** Helper text describing the control, wired via aria-describedby. */
+  description?: ReactNode;
+  /** Error message; sets aria-invalid on the control and is announced via role="alert". */
+  error?: ReactNode;
+  /** Marks the field required (forwarded to the Label marker). */
+  required?: boolean;
+  /** Dims the label and is forwarded to the cloned control. */
+  disabled?: boolean;
+  /** Explicit id for the control; auto-generated when omitted. */
+  id?: string;
+  /** The single form control element. */
+  children: ReactElement<{
+    id?: string;
+    'aria-describedby'?: string;
+    'aria-invalid'?: boolean;
+    disabled?: boolean;
+  }>;
+  className?: string;
+}
+declare function Field({
+  label,
+  description,
+  error,
+  required,
+  disabled,
+  id,
+  children,
+  className
+}: FieldProps): import("react").JSX.Element;
+type FilterVariant = 'pill' | 'outline';
+interface FilterOption {
+  label: string;
+  value: string;
+}
+interface FilterProps {
+  options: FilterOption[];
+  value?: string[];
+  defaultValue?: string[];
+  onChange?: (selected: string[]) => void;
+  multi?: boolean;
+  variant?: FilterVariant;
+  'aria-label'?: string;
+  className?: string;
+}
+declare function Filter({
+  options,
+  value,
+  defaultValue,
+  onChange,
+  multi,
+  variant,
+  className,
+  ...aria
+}: FilterProps): import("react").JSX.Element;
+interface IconButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+  /** Accessible name for the icon-only control. Required — there is no visible text. */
+  label: string;
+  /** The icon to render. Alias for `children`. */
+  icon?: ReactNode;
+  size?: 'sm' | 'md' | 'lg';
+  variant?: 'ghost' | 'outline' | 'filled';
+  /** Render the single child element instead of a `<button>` (composition). */
+  asChild?: boolean;
+}
+declare const IconButton: import("react").ForwardRefExoticComponent<IconButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+interface ButtonGroupProps extends HTMLAttributes<HTMLDivElement> {
+  orientation?: 'horizontal' | 'vertical';
+  size?: 'sm' | 'md' | 'lg';
+  /** Enable arrow-key roving focus across the group's focusable buttons. */
+  roving?: boolean;
+  loop?: boolean;
+}
+declare const ButtonGroup: import("react").ForwardRefExoticComponent<ButtonGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+interface ToggleGroupItem {
+  value: string;
+  label?: string;
+  icon?: ReactNode;
+  disabled?: boolean;
+}
+interface ToggleGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+  type: 'single' | 'multiple';
+  value?: string | string[];
+  defaultValue?: string | string[];
+  onValueChange?: (value: string | string[]) => void;
+  items: ToggleGroupItem[];
+  orientation?: 'horizontal' | 'vertical';
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+}
+declare const ToggleGroup: import("react").ForwardRefExoticComponent<ToggleGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+type InlineLoadingStatus = 'inactive' | 'active' | 'finished' | 'error';
+interface InlineLoadingProps extends HTMLAttributes<HTMLDivElement> {
+  status: InlineLoadingStatus;
+  label?: ReactNode;
+  labels?: {
+    active?: string;
+    finished?: string;
+    error?: string;
+  };
+}
+declare function InlineLoading({
+  status,
+  label,
+  labels,
+  className,
+  ...props
+}: InlineLoadingProps): import("react").JSX.Element;
+type NotificationVariant = 'info' | 'success' | 'warning' | 'error';
+interface NotificationProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+  title: ReactNode;
+  description?: ReactNode;
+  variant?: NotificationVariant;
+  dismissible?: boolean;
+  onDismiss?: () => void;
+  actions?: ReactNode;
+  icon?: ReactNode;
+  labels?: {
+    dismiss?: string;
+  };
+}
+declare function Notification({
+  title,
+  description,
+  variant,
+  dismissible,
+  onDismiss,
+  actions,
+  icon,
+  labels,
+  className,
+  ...props
+}: NotificationProps): import("react").JSX.Element;
+interface ScrollAreaProps extends HTMLAttributes<HTMLDivElement> {
+  /** Max block size of the scroll container (any CSS length). */
+  height?: string;
+  /** Max inline size of the scroll container (any CSS length). */
+  width?: string;
+  /** Which axes may scroll. */
+  orientation?: 'vertical' | 'horizontal' | 'both';
+  children?: ReactNode;
+}
+declare function ScrollArea({
+  height,
+  width,
+  orientation,
+  className,
+  style,
+  children,
+  ...props
+}: ScrollAreaProps): import("react").JSX.Element;
+interface CollapsibleProps {
+  /** Controlled open state. */
+  open?: boolean;
+  /** Initial open state for uncontrolled use. */
+  defaultOpen?: boolean;
+  /** Called whenever the open state should change. */
+  onOpenChange?: (open: boolean) => void;
+  /** Content rendered inside the trigger button. */
+  trigger: ReactNode;
+  /** Disables the trigger. */
+  disabled?: boolean;
+  className?: string;
+  children?: ReactNode;
+}
+declare function Collapsible({
+  open,
+  defaultOpen,
+  onOpenChange,
+  trigger,
+  disabled,
+  className,
+  children
+}: CollapsibleProps): import("react").JSX.Element;
+interface AspectRatioProps extends HTMLAttributes<HTMLDivElement> {
+  /** Width-to-height ratio (e.g. 16 / 9). Defaults to 16/9. */
+  ratio?: number;
+  children?: ReactNode;
+}
+declare function AspectRatio({
+  ratio,
+  className,
+  style,
+  children,
+  ...props
+}: AspectRatioProps): import("react").JSX.Element;
+interface MenuButtonItem {
+  id: string;
+  label: ReactNode;
+  onSelect?: () => void;
+  disabled?: boolean;
+}
+interface MenuButtonProps {
+  label: ReactNode;
+  items: MenuButtonItem[];
+  variant?: 'primary' | 'secondary' | 'ghost';
+  size?: 'sm' | 'md' | 'lg';
+  disabled?: boolean;
+  align?: 'start' | 'end';
+  labels?: {
+    open?: string;
+  };
+  className?: string;
+}
+declare function MenuButton({
+  label,
+  items,
+  variant,
+  size,
+  disabled,
+  align,
+  labels,
+  className
+}: MenuButtonProps): import("react").JSX.Element;
+type ToggletipPlacement = 'top' | 'bottom' | 'left' | 'right' | 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+interface ToggletipProps {
+  /** The trigger node (e.g. an info icon). Rendered inside a button. */
+  trigger: ReactNode;
+  /** The popover content. Interactive and selectable. */
+  children: ReactNode;
+  placement?: ToggletipPlacement;
+  defaultOpen?: boolean;
+  open?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  labels?: {
+    label?: string;
+  };
+  className?: string;
+}
+declare function Toggletip({
+  trigger,
+  children,
+  placement,
+  defaultOpen,
+  open,
+  onOpenChange,
+  labels,
+  className
+}: ToggletipProps): import("react").JSX.Element;
+interface MenubarItem {
+  id: string;
+  label: ReactNode;
+  onSelect?: () => void;
+  disabled?: boolean;
+}
+interface MenubarMenu {
+  id: string;
+  label: ReactNode;
+  items: MenubarItem[];
+}
+interface MenubarProps {
+  menus: MenubarMenu[];
+  'aria-label': string;
+  className?: string;
+}
+declare function Menubar({
+  menus,
+  'aria-label': ariaLabel,
+  className
+}: MenubarProps): import("react").JSX.Element;
+interface NavigationMenuItem {
+  id: string;
+  label: ReactNode;
+  href?: string;
+  content?: ReactNode;
+}
+interface NavigationMenuProps {
+  items: NavigationMenuItem[];
+  'aria-label'?: string;
+  orientation?: RovingOrientation;
+  className?: string;
+}
+declare function NavigationMenu({
+  items,
+  'aria-label': ariaLabel,
+  orientation,
+  className
+}: NavigationMenuProps): import("react").JSX.Element;
+interface TreeNode {
+  id: string;
+  label: ReactNode;
+  icon?: ReactNode;
+  children?: TreeNode[];
+}
+interface TreeViewProps {
+  items: TreeNode[];
+  selectionMode?: 'single' | 'multi';
+  selected?: string | string[];
+  defaultSelected?: string | string[];
+  onSelectChange?: (selected: string | string[]) => void;
+  expanded?: string[];
+  defaultExpanded?: string[];
+  onExpandedChange?: (expanded: string[]) => void;
+  className?: string;
+  'aria-label'?: string;
+}
+declare function TreeView({
+  items,
+  selectionMode,
+  selected,
+  defaultSelected,
+  onSelectChange,
+  expanded,
+  defaultExpanded,
+  onExpandedChange,
+  className,
+  'aria-label': ariaLabel
+}: TreeViewProps): import("react").JSX.Element;
+declare const treeViewMessages: {
+  loading: () => string;
+  expand: () => string;
+  collapse: () => string;
+};
+interface StructuredListItem {
+  id: string;
+  cells: ReactNode[];
+  selected?: boolean;
+}
+interface StructuredListProps {
+  items: StructuredListItem[];
+  headers?: ReactNode[];
+  selectable?: boolean;
+  value?: string;
+  defaultValue?: string;
+  onSelect?: (id: string) => void;
+  className?: string;
+  'aria-label'?: string;
+}
+declare function StructuredList(props: StructuredListProps): import("react").JSX.Element;
+interface ContainedListProps extends HTMLAttributes<HTMLDivElement> {
+  label: ReactNode;
+  kind?: 'on-page' | 'disclosed';
+  action?: ReactNode;
+}
+declare function ContainedList({
+  label,
+  kind,
+  action,
+  className,
+  children,
+  ...props
+}: ContainedListProps): import("react").JSX.Element;
+interface ContainedListItemProps extends HTMLAttributes<HTMLDivElement> {
+  asChild?: boolean;
+}
+declare function ContainedListItem({
+  asChild,
+  onClick,
+  className,
+  children,
+  ...props
+}: ContainedListItemProps): import("react").JSX.Element;
+interface DataListItem {
+  id?: string;
+  label: ReactNode;
+  value: ReactNode;
+}
+interface DataListProps extends HTMLAttributes<HTMLDListElement> {
+  items: DataListItem[];
+  orientation?: 'horizontal' | 'vertical';
+  dividers?: boolean;
+  size?: 'sm' | 'md';
+}
+declare function DataList({
+  items,
+  orientation,
+  dividers,
+  size,
+  className,
+  ...props
+}: DataListProps): import("react").JSX.Element;
+interface TimelineItem {
+  id: string;
+  title: ReactNode;
+  description?: ReactNode;
+  time?: string;
+  icon?: ReactNode;
+  status?: 'complete' | 'current' | 'upcoming';
+}
+interface TimelineProps extends HTMLAttributes<HTMLOListElement> {
+  items: TimelineItem[];
+  orientation?: 'vertical' | 'horizontal';
+}
+declare function Timeline({
+  items,
+  orientation,
+  className,
+  ...props
+}: TimelineProps): import("react").JSX.Element;
+interface ItemProps extends HTMLAttributes<HTMLDivElement> {
+  asChild?: boolean;
+  variant?: 'default' | 'muted';
+  size?: 'sm' | 'md';
+}
+declare function Item({
+  asChild,
+  variant,
+  size,
+  className,
+  children,
+  ...props
+}: ItemProps): import("react").JSX.Element;
+interface ItemMediaProps extends HTMLAttributes<HTMLDivElement> {}
+declare function ItemMedia({
+  className,
+  children,
+  ...props
+}: ItemMediaProps): import("react").JSX.Element;
+interface ItemContentProps extends HTMLAttributes<HTMLDivElement> {}
+declare function ItemContent({
+  className,
+  children,
+  ...props
+}: ItemContentProps): import("react").JSX.Element;
+interface ItemTitleProps extends HTMLAttributes<HTMLDivElement> {}
+declare function ItemTitle({
+  className,
+  children,
+  ...props
+}: ItemTitleProps): import("react").JSX.Element;
+interface ItemDescriptionProps extends HTMLAttributes<HTMLParagraphElement> {}
+declare function ItemDescription({
+  className,
+  children,
+  ...props
+}: ItemDescriptionProps): import("react").JSX.Element;
+interface ItemActionsProps extends HTMLAttributes<HTMLDivElement> {}
+declare function ItemActions({
+  className,
+  children,
+  ...props
+}: ItemActionsProps): import("react").JSX.Element;
+interface CalendarLabels {
+  previousMonth?: string;
+  nextMonth?: string;
+}
+interface CalendarProps {
+  value?: Date | null;
+  defaultValue?: Date;
+  onValueChange?: (date: Date) => void;
+  min?: Date;
+  max?: Date;
+  disabled?: (date: Date) => boolean;
+  locale?: string;
+  size?: 'sm' | 'md' | 'lg';
+  labels?: CalendarLabels;
+  className?: string;
+  /** Highlight predicate for range previews (date-range-picker). */
+  isInRange?: (date: Date) => boolean;
+  /** Range endpoint markers for styling. */
+  isRangeStart?: (date: Date) => boolean;
+  isRangeEnd?: (date: Date) => boolean;
+  /** Hover handler for range preview. */
+  onDayHover?: (date: Date | null) => void;
+  /** Controlled view month (0-11). When set, the calendar's displayed month is owned by the parent. */
+  month?: number;
+  /** Controlled view year. */
+  year?: number;
+  /** Called when the user navigates months (prev/next or keyboard). */
+  onViewChange?: (view: {
+    month: number;
+    year: number;
+  }) => void;
+  /** Hide the prev/next header nav (parent drives navigation). */
+  hideNav?: boolean;
+}
+declare function Calendar({
+  value,
+  defaultValue,
+  onValueChange,
+  min,
+  max,
+  disabled,
+  locale: localeProp,
+  size,
+  labels,
+  className,
+  isInRange,
+  isRangeStart,
+  isRangeEnd,
+  onDayHover,
+  month,
+  year,
+  onViewChange,
+  hideNav
+}: CalendarProps): import("react").JSX.Element;
+interface DateRange {
+  start: Date;
+  end: Date;
+}
+interface DateRangePreset {
+  label: string;
+  range: DateRange;
+}
+interface DateRangePickerLabels {
+  placeholder?: string;
+  start?: string;
+  end?: string;
+  apply?: string;
+  clear?: string;
+  previousMonth?: string;
+  nextMonth?: string;
+}
+interface DateRangePickerProps {
+  value?: DateRange | null;
+  defaultValue?: DateRange;
+  onValueChange?: (range: DateRange) => void;
+  min?: Date;
+  max?: Date;
+  disabled?: (date: Date) => boolean;
+  presets?: DateRangePreset[];
+  locale?: string;
+  placeholder?: string;
+  size?: 'sm' | 'md' | 'lg';
+  labels?: DateRangePickerLabels;
+  className?: string;
+}
+declare function DateRangePicker({
+  value,
+  defaultValue,
+  onValueChange,
+  min,
+  max,
+  disabled,
+  presets,
+  locale: localeProp,
+  placeholder,
+  size,
+  labels,
+  className
+}: DateRangePickerProps): import("react").JSX.Element;
+interface ColorPickerLabels {
+  hue?: string;
+  alpha?: string;
+  colorArea?: string;
+  eyedropper?: string;
+}
+interface ColorPickerProps {
+  value?: string;
+  defaultValue?: string;
+  onValueChange?: (value: string) => void;
+  presets?: string[];
+  alpha?: boolean;
+  label?: string;
+  disabled?: boolean;
+  size?: 'sm' | 'md' | 'lg';
+  className?: string;
+  labels?: ColorPickerLabels;
+}
+declare function ColorPicker({
+  value,
+  defaultValue,
+  onValueChange,
+  presets,
+  alpha,
+  label,
+  disabled,
+  size,
+  className,
+  labels
+}: ColorPickerProps): import("react").JSX.Element;
+interface CarouselLabels {
+  region?: string;
+  previous?: string;
+  next?: string;
+}
+interface CarouselProps {
+  children?: ReactNode;
+  slides?: ReactNode[];
+  index?: number;
+  defaultIndex?: number;
+  onIndexChange?: (index: number) => void;
+  loop?: boolean;
+  className?: string;
+  labels?: CarouselLabels;
+}
+declare function Carousel({
+  children,
+  slides,
+  index,
+  defaultIndex,
+  onIndexChange,
+  loop,
+  className,
+  labels
+}: CarouselProps): import("react").JSX.Element;
+interface ResizableProps {
+  children: ReactNode;
+  orientation?: 'horizontal' | 'vertical';
+  defaultRatio?: number;
+  ratio?: number;
+  minRatio?: number;
+  maxRatio?: number;
+  onRatioChange?: (ratio: number) => void;
+  className?: string;
+  label?: string;
+}
+declare function Resizable({
+  children,
+  orientation,
+  defaultRatio,
+  ratio,
+  minRatio,
+  maxRatio,
+  onRatioChange,
+  className,
+  label
+}: ResizableProps): import("react").JSX.Element;
+interface DockItem {
+  label: string;
+  icon: React.ReactNode;
+  onClick?: () => void;
+  href?: string;
+}
+interface DockProps {
+  items: DockItem[];
+  activeIndex?: number;
+  className?: string;
+}
+declare function Dock({
+  items,
+  activeIndex,
+  className
+}: DockProps): import("react").JSX.Element;
+interface DrawerProps {
+  /** Controlled open state. */
+  open?: boolean;
+  /** Initial open state for uncontrolled use. */
+  defaultOpen?: boolean;
+  /** Called whenever the open state should change. */
+  onOpenChange?: (open: boolean) => void;
+  /** Edge the panel is anchored to. Drives the slide direction. */
+  side?: 'start' | 'end' | 'top' | 'bottom';
+  /** Panel size along its cross axis (width for start/end, height for top/bottom). */
+  size?: string;
+  /** Accessible title shown in the header and used to label the dialog. */
+  title?: ReactNode;
+  /** Optional supporting description shown under the title. */
+  description?: ReactNode;
+  children?: ReactNode;
+  labels?: {
+    close?: string;
+  };
+  className?: string;
+}
+/**
+ * Edge-anchored panel. Unlike Sheet's gesture-driven sheet, Drawer is a plain dialog surface that
+ * slides in from an edge with CSS-only enter/exit motion (data-state + @starting-style). Open state
+ * is controllable; while open, body scroll is locked, focus is trapped, and outside pointer /
+ * Escape dismiss it.
+ */
+declare function Drawer({
+  open,
+  defaultOpen,
+  onOpenChange,
+  side,
+  size,
+  title,
+  description,
+  children,
+  labels,
+  className
+}: DrawerProps): import("react").JSX.Element;
+interface NativeSelectOption {
+  value: string;
+  label: string;
+  disabled?: boolean;
+}
+interface NativeSelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
+  /** Options to render. Alternatively pass `<option>` children. */
+  options?: NativeSelectOption[];
+  /** Raw `<option>` children (used when `options` is not provided). */
+  children?: ReactNode;
+  size?: 'sm' | 'md' | 'lg';
+  /** Marks the control as invalid for error styling and a11y. */
+  invalid?: boolean;
+  /** Placeholder rendered as a disabled, hidden first option. */
+  placeholder?: string;
+}
+/**
+ * A styled native `<select>` — keeps the platform's open/close, keyboard, and form behavior, and
+ * layers on a custom chevron and focus/invalid rings via CSS only. No JS interactivity, so no
+ * signals: the browser owns all state. Distinct from the custom-rendered `Select` listbox.
+ */
+declare function NativeSelect({
+  options,
+  children,
+  size,
+  invalid,
+  disabled,
+  placeholder,
+  value,
+  defaultValue,
+  className,
+  ...props
+}: NativeSelectProps): import("react").JSX.Element;
+type CodeLang = 'bash' | 'css' | 'js' | 'ts';
+interface CodeSnippetProps {
+  /** The code to display (and copy). */
+  code: string;
+  /** inline = a <code> span; single = one-line <pre>; multi = multi-line <pre>. */
+  variant?: 'inline' | 'single' | 'multi';
+  /**
+   * Enables lightweight, dependency-free syntax highlighting for the block
+   * variants. Omit for plain text. Inline code is never highlighted.
+   */
+  language?: CodeLang;
+  /**
+   * Renders terminal-window chrome (a title bar with traffic-light dots). Pair
+   * with `language="bash"` for a shell transcript. Block variants only.
+   */
+  terminal?: boolean;
+  /** Optional label shown in the terminal title bar. */
+  title?: string;
+  /** Show line numbers (multi only; ignored when `language` is set). */
+  showLineNumbers?: boolean;
+  /** Show the copy-to-clipboard button. Defaults true for single/multi, false for inline. */
+  showCopyButton?: boolean;
+  labels?: {
+    copy?: string;
+    copied?: string;
+  };
+  className?: string;
+}
+/**
+ * Code display with optional, dependency-free syntax highlighting. `inline`
+ * renders a `<code>` chip in flowing text; `single` a horizontally scrolling
+ * one-liner; `multi` a block with optional line numbers. Pass `language` to
+ * colour bash/css/js/ts, and `terminal` for shell-window chrome. An optional
+ * copy button uses `useClipboard` to copy the raw `code`.
+ */
+declare function CodeSnippet({
+  code,
+  variant,
+  language,
+  terminal,
+  title,
+  showLineNumbers,
+  showCopyButton,
+  labels,
+  className
+}: CodeSnippetProps): import("react").JSX.Element;
+type StepState = 'pending' | 'active' | 'complete' | 'error';
+interface Step {
+  label: string;
+  state?: StepState;
+}
+interface StepsProps {
+  steps: Step[];
+  activeStep?: number;
+  orientation?: 'horizontal' | 'vertical';
+  className?: string;
+}
+declare function Steps({
+  steps,
+  activeStep: controlledActiveStep,
+  orientation,
+  className
+}: StepsProps): import("react").JSX.Element;
+interface TileProps {
+  /** Identifies this tile within a group. */
+  value: string;
+  /** Controlled selected state. */
+  selected?: boolean;
+  /** Initial selected state for uncontrolled use. */
+  defaultSelected?: boolean;
+  /** Called with this tile's value whenever it is toggled on (or off for multi). */
+  onSelect?: (value: string) => void;
+  /** Single = radio semantics (toggle on); multi = checkbox semantics (toggle on/off). */
+  selectable?: 'single' | 'multi';
+  disabled?: boolean;
+  /** Optional leading icon/visual. */
+  icon?: ReactNode;
+  /** Render as the child element instead of a div (Radix-style composition). */
+  asChild?: boolean;
+  children?: ReactNode;
+  className?: string;
+}
+/**
+ * A selectable card. Renders with radio (single) or checkbox (multi) semantics and toggles via
+ * click or Space/Enter. Selection is controllable; `data-selected` drives the visuals via CSS.
+ */
+declare function Tile({
+  value,
+  selected,
+  defaultSelected,
+  onSelect,
+  selectable,
+  disabled,
+  icon,
+  asChild,
+  children,
+  className
+}: TileProps): import("react").JSX.Element;
+type IndicatorPlacement = 'top-start' | 'top-end' | 'bottom-start' | 'bottom-end';
+interface IndicatorProps {
+  children: React.ReactNode;
+  overlay: React.ReactNode;
+  placement?: IndicatorPlacement;
+  className?: string;
+}
+declare function Indicator({
+  children,
+  overlay,
+  placement,
+  className
+}: IndicatorProps): import("react").JSX.Element;
+type JoinOrientation = 'horizontal' | 'vertical';
+interface JoinProps {
+  children: React.ReactNode;
+  orientation?: JoinOrientation;
+  className?: string;
+}
+declare function Join({
+  children,
+  orientation,
+  className
+}: JoinProps): import("react").JSX.Element;
+interface StackProps {
+  children: React.ReactNode;
+  offset?: number;
+  className?: string;
+}
+declare function Stack({
+  children,
+  offset,
+  className
+}: StackProps): import("react").JSX.Element;
+interface AppShellProps {
+  /**
+   * Top bar — typically a `<ShellHeader>`. If it is a React element, AppShell
+   * binds its burger (`onMenuClick`/`menuExpanded`) to the nav open state so the
+   * header button toggles the nav out of the box.
+   */
+  header: ReactNode;
+  /** Side navigation — typically a `<SideNav>`. Fills full height and scrolls internally. */
+  nav?: ReactNode;
+  /** Main content. Lives in the single scroll container. */
+  children: ReactNode;
+  /** Optional footer pinned below the content area. */
+  footer?: ReactNode;
+  /** Controlled nav open/visible state. Omit for uncontrolled (see `defaultOpen`). */
+  open?: boolean;
+  /** Initial open state when uncontrolled. Defaults to open on desktop, closed on small screens. */
+  defaultOpen?: boolean;
+  /** Fired when the nav requests open/close (burger, Escape, scrim). */
+  onOpenChange?: ((open: boolean) => void) | undefined;
+  className?: string | undefined;
+}
+/**
+ * App shell: composes a header + side navigation + main content into one
+ * sticky-header, full-height-nav, single-scroll-container layout (#11). The
+ * header burger toggles the nav with an animated show/hide that honors
+ * `prefers-reduced-motion` (via `--cascivo-motion-*`), toggles `inert` on the
+ * hidden nav so it leaves the tab order, and renders a mobile drawer + scrim
+ * (#12). Below `lg` (64rem) the nav is an overlay drawer; at `lg`+ it is an
+ * in-flow column whose width animates between its open width and 0.
+ *
+ * Rail vs full-hide reconcile cleanly: AppShell owns the full show/hide (this
+ * `open` state); the SideNav you pass owns its own rail collapse
+ * (`showCollapseToggle`). They compose on different axes and never fight.
+ */
+declare function AppShell({
+  header,
+  nav,
+  children,
+  footer,
+  open,
+  defaultOpen,
+  onOpenChange,
+  className
+}: AppShellProps): import("react").JSX.Element;
+type ChatBubbleSide = 'start' | 'end';
+interface ChatBubbleProps {
+  children: React.ReactNode;
+  side?: ChatBubbleSide;
+  avatar?: React.ReactNode;
+  name?: string;
+  time?: string;
+  className?: string;
+}
+declare function ChatBubble({
+  children,
+  side,
+  avatar,
+  name,
+  time,
+  className
+}: ChatBubbleProps): import("react").JSX.Element;
+type RadialProgressSize = 'sm' | 'md' | 'lg';
+type RadialProgressVariant = 'primary' | 'info' | 'success' | 'warning' | 'error';
+interface RadialProgressProps {
+  value: number;
+  size?: RadialProgressSize;
+  variant?: RadialProgressVariant;
+  children?: React.ReactNode;
+  'aria-label'?: string;
+  className?: string;
+}
+declare function RadialProgress({
+  value,
+  size,
+  variant,
+  children,
+  className,
+  ...aria
+}: RadialProgressProps): import("react").JSX.Element;
+type SwapMode = 'rotate' | 'flip';
+interface SwapProps {
+  on: React.ReactNode;
+  off: React.ReactNode;
+  checked?: boolean;
+  onChange?: (checked: boolean) => void;
+  mode?: SwapMode;
+  'aria-label'?: string;
+  className?: string;
+}
+declare function Swap({
+  on,
+  off,
+  checked,
+  onChange,
+  mode,
+  className,
+  ...aria
+}: SwapProps): import("react").JSX.Element;
+export { Accordion, AccordionContent, AccordionItem, AccordionItemProps, AccordionProps, AccordionTrigger, Alert, AlertDialog, AlertDialogLabels, AlertDialogProps, AlertProps, AppShell, AppShellProps, AspectRatio, AspectRatioProps, Avatar, AvatarProps, Badge, BadgeProps, Blockquote, BlockquoteProps, Breadcrumb, BreadcrumbItem, BreadcrumbProps, Button, ButtonGroup, ButtonGroupProps, ButtonProps, Calendar, CalendarLabels, CalendarProps, Card, CardContent, CardContentProps, CardFooter, CardFooterProps, CardHeader, CardHeaderProps, CardProps, CardTitle, CardTitleProps, Carousel, CarouselLabels, CarouselProps, ChatBubble, ChatBubbleProps, ChatBubbleSide, Checkbox, CheckboxCard, CheckboxCardProps, CheckboxProps, Code, type CodeLang, CodeProps, CodeSnippet, CodeSnippetProps, Collapsible, CollapsibleProps, ColorPicker, ColorPickerLabels, ColorPickerProps, Column, Combobox, ComboboxLabels, ComboboxOption, ComboboxProps, CommandGroup, CommandItem, CommandMenu, CommandMenuProps, CommandPage, ContainedList, ContainedListItem, ContainedListItemProps, ContainedListProps, ContextMenu, ContextMenuItem, ContextMenuItemProps, ContextMenuProps, CopyButton, CopyButtonProps, DataList, DataListItem, DataListProps, DataTable, DataTableLabels, DataTableProps, DatePicker, DatePickerLabels, DatePickerProps, DateRange, DateRangePicker, DateRangePickerLabels, DateRangePickerProps, DateRangePreset, Dock, DockItem, DockProps, Drawer, DrawerProps, Dropdown, DropdownItem, DropdownProps, Editable, EditableProps, EmptyState, EmptyStateProps, ErrorBoundary, Field, FieldProps, FileUploader, FileUploaderLabels, FileUploaderProps, Filter, FilterOption, FilterProps, FilterVariant, FocusScope, Form, FormConfig, FormProps, FormStore, Header, HeaderLabels, HeaderLink, HeaderPanel, HeaderPanelLabels, HeaderPanelProps, HeaderProps, Heading, HeadingLevel, HeadingProps, HeadingSize, HoverCard, HoverCardContent, HoverCardContentProps, HoverCardProps, HoverCardTrigger, HoverCardTriggerProps, IconButton, IconButtonProps, Indicator, IndicatorPlacement, IndicatorProps, InlineLoading, InlineLoadingProps, InlineLoadingStatus, Input, InputGroup, InputGroupAddon, type InputGroupAddonProps, type InputGroupProps, InputProps, Item, ItemActions, ItemActionsProps, ItemContent, ItemContentProps, ItemDescription, ItemDescriptionProps, ItemMedia, ItemMediaProps, ItemProps, ItemTitle, ItemTitleProps, Join, JoinOrientation, JoinProps, Kbd, KbdProps, Label, LabelProps, Link, LinkProps, List, ListItem, ListItemProps, ListProps, Menu, MenuButton, MenuButtonItem, MenuButtonProps, MenuItem, MenuItemProps, MenuProps, MenuSeparator, MenuTrigger, MenuTriggerProps, Menubar, MenubarItem, MenubarMenu, MenubarProps, Modal, ModalProps, MultiSelect, MultiSelectLabels, MultiSelectOption, MultiSelectProps, NativeSelect, NativeSelectOption, NativeSelectProps, NavigationMenu, NavigationMenuItem, NavigationMenuProps, Notification, NotificationProps, NotificationVariant, NumberInput, NumberInputProps, OtpInput, OtpInputProps, OverflowMenu, OverflowMenuItem, OverflowMenuProps, Pagination, PaginationLabels, PaginationProps, PasswordInput, PasswordInputLabels, PasswordInputProps, Popover, PopoverContent, PopoverContentProps, PopoverProps, PopoverTrigger, PopoverTriggerProps, Portal, Progress, ProgressBar, ProgressBarProps, ProgressCircle, ProgressCircleProps, ProgressIndicator, ProgressIndicatorProps, ProgressProps, ProgressSize, ProgressStep, ProgressVariant, Prose, ProseProps, RadialProgress, RadialProgressProps, RadialProgressSize, RadialProgressVariant, Radio, RadioCard, RadioCardGroup, RadioCardGroupProps, RadioCardProps, RadioGroup, RadioGroupProps, RadioProps, RatingGroup, RatingGroupLabels, RatingGroupProps, Resizable, ResizableProps, ScrollArea, ScrollAreaProps, Search, SearchProps, SegmentedControl, SegmentedControlOption, SegmentedControlProps, Select, SelectOption, SelectProps, Separator, SeparatorProps, Sheet, SheetProps, ShellHeader, ShellHeaderAction, ShellHeaderBrand, ShellHeaderLabels, ShellHeaderNavItem, ShellHeaderNavLink, ShellHeaderNavMenu, ShellHeaderNavMenuItem, ShellHeaderProps, SideNav, SideNavGroup, SideNavItem, SideNavProps, SideNavSubItem, Skeleton, SkeletonProps, SkipNavLink, SkipNavLinkProps, SkipNavTarget, SkipNavTargetProps, Slider, SliderProps, SortDirection, SortState, Spinner, SpinnerProps, Stack, StackProps, type StandardSchemaV1, Stat, StatProps, Status, StatusProps, Step, StepState, Steps, StepsProps, StructuredList, StructuredListItem, StructuredListProps, SuspenseBoundary, Swap, SwapMode, SwapProps, Switcher, SwitcherEntry, SwitcherLink, SwitcherProps, Tabs, TabsContent, TabsContentProps, TabsList, TabsProps, TabsTrigger, TabsTriggerProps, Tag$1 as Tag, TagProps, TagsInput, TagsInputProps, Text, TextProps, Textarea, TextareaProps, Tile, TileProps, TimePicker, TimePickerProps, Timeline, TimelineItem, TimelineProps, ToastOptions, ToastProvider, ToastVariant, Toggle, ToggleGroup, ToggleGroupItem, ToggleGroupProps, ToggleProps, Toggletip, ToggletipPlacement, ToggletipProps, Tooltip, TooltipProps, TreeNode, TreeView, TreeViewProps, UploaderFile, type UsePopoverOptions, type UsePopoverReturn, VisuallyHidden, VisuallyHiddenProps, createForm, dismissAllToasts, fuzzyScore, treeViewMessages, useForm, usePopover, useToast };