@tenerife.music/ui 1.0.8 → 1.0.13

package/dist/index.d.ts

@@ -1,39 +1,4020 @@
-export * from './tokens';
-export { ICON_TOKENS, type IconColor, type IconSize, type IconStroke, } from './tokens/components/icon';
-export { Button, type ButtonProps, buttonVariants } from './components/ui/button';
-export { Text, type TextProps, type TextSize, textVariants, type TextWeight, } from './components/ui/text';
-export { Alert, type AlertProps, alertVariants } from './components/ui/alert';
-export { Body, type BodyProps, bodyVariants } from './components/ui/body';
-export { Caption, type CaptionProps, captionVariants } from './components/ui/caption';
-export { Code, type CodeProps, codeVariants } from './components/ui/code';
-export { Display, type DisplayProps, displayVariants } from './components/ui/display';
-export { Heading, type HeadingProps, headingVariants } from './components/ui/heading';
-export { Lead, type LeadProps, leadVariants } from './components/ui/lead';
-export { Checkbox, type CheckboxProps, checkboxVariants } from './components/checkbox';
-export { Input, type InputProps, inputVariants } from './components/input';
-export { Radio, RadioGroup, type RadioGroupProps, type RadioProps, radioVariants, } from './components/radio';
-export { Select, SelectListbox, type SelectListboxProps, selectListboxVariants, SelectOption, type SelectOptionProps, selectOptionVariants, SelectRoot, type SelectRootProps, type SelectSize, SelectTrigger, type SelectTriggerProps, selectTriggerVariants, type SelectVariant, } from './components/select';
-export { Textarea, type TextareaProps, textareaVariants } from './components/textarea';
-export { Field, type FieldControlProps, type FieldDescriptionProps, type FieldErrorProps, type FieldLabelProps, type FieldProps, } from './components/ui/field';
-export { Label, type LabelProps, labelVariants } from './components/ui/label';
-export { Box, type BoxProps, Column, type ColumnProps, Container, type ContainerProps, Flex, type FlexProps, Grid, type GridProps, Row, type RowProps, Stack, type StackProps, Surface, type SurfaceProps, surfaceVariants, } from './components/layout';
-export { Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, Surface as ContainerSurface, type SurfaceProps as ContainerSurfaceProps, surfaceVariants as containerSurfaceVariants, Section, type SectionProps, } from './components/containers';
-export { Backdrop, type BackdropProps, Dialog, DialogBody, type DialogBodyProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, type DialogProps, DialogRoot, DialogTitle, type DialogTitleProps, Modal, ModalBody, type ModalBodyProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalProps, modalVariants, Portal, type PortalProps, Toast, type ToastAction, type ToastData, type ToastOptions, type ToastPosition, type ToastProps, ToastProvider, type ToastProviderProps, ToastViewport, type ToastViewportProps, useToast, } from './components/overlays';
-export { type GroupByFunction, NotificationCenter, NotificationCenterDismissAll, type NotificationCenterDismissAllProps, NotificationCenterGroupHeader, type NotificationCenterGroupHeaderProps, NotificationCenterItem, type NotificationCenterItemProps, NotificationCenterList, type NotificationCenterListProps, NotificationCenterPanel, type NotificationCenterPanelProps, NotificationCenterProvider, type NotificationCenterProviderProps, NotificationCenterTrigger, type NotificationCenterTriggerProps, type NotificationChannel, type NotificationContextType, type NotificationData, type NotificationOptions, type NotificationVariant, useNotificationCenter, useNotificationCenterContext, } from './components/notifications';
-export { ContextMenuContent, type ContextMenuContentProps, ContextMenuGroup, type ContextMenuGroupProps, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, type ContextMenuLabelProps, ContextMenuRoot, type ContextMenuRootProps, ContextMenuSeparator, type ContextMenuSeparatorProps, ContextMenuTrigger, type ContextMenuTriggerProps, DropdownMenuCheckItem, type DropdownMenuCheckItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, type DropdownMenuGroupProps, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuRadioGroup, type DropdownMenuRadioGroupProps, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuRoot, type DropdownMenuRootProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubContentProps, type DropdownMenuSubProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, HoverCardContent, type HoverCardContentProps, HoverCardRoot, type HoverCardRootProps, HoverCardTrigger, type HoverCardTriggerProps, PopoverArrow, type PopoverArrowProps, PopoverContent, type PopoverContentProps, popoverContentVariants, PopoverRoot, type PopoverRootProps, PopoverTrigger, type PopoverTriggerProps, } from './components/menus';
-export { DataList, DataListItem, type DataListItemProps, DataListLabel, type DataListLabelProps, DataListRoot, type DataListRootProps, DataListValue, type DataListValueProps, EmptyState, EmptyStateAction, type EmptyStateActionProps, EmptyStateDescription, type EmptyStateDescriptionProps, EmptyStateIcon, type EmptyStateIconProps, type EmptyStateProps, EmptyStateTitle, type EmptyStateTitleProps, Skeleton, type SkeletonProps, skeletonVariants, type SortDirection, type SortState, Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, type TableColumn, type TableContextValue, TableEmpty, type TableEmptyProps, TableExpandableContent, type TableExpandableContentProps, TableHead, TableHeader, type TableHeaderProps, type TableHeadProps, TableLoadingState, type TableLoadingStateProps, TableRoot, type TableRootProps, TableRow, type TableRowProps, TableSortIcon, type TableSortIconProps, useTableContext, } from './components/data';
-export { type BreadcrumbItem, Breadcrumbs, type BreadcrumbsItemProps, type BreadcrumbsRootProps, type BreadcrumbsSeparatorProps, Pagination, type PaginationEllipsisProps, type PaginationItemProps, type PaginationNextProps, type PaginationPrevProps, type PaginationRootProps, SegmentedControl, type SegmentedControlItemProps, segmentedControlItemVariants, type SegmentedControlRootProps, segmentedControlRootVariants, Stepper, type StepperContentProps, type StepperIndicatorProps, type StepperItemProps, type StepperLabelProps, type StepperRootProps, type StepperStep, Tabs, type TabsContentProps, type TabsListProps, tabsListVariants, type TabsRootProps, type TabsTriggerProps, tabsTriggerVariants, } from './components/navigation';
-export { Icon, type IconProps, iconVariants } from './components/icon';
-export { IconArrowRight, IconCalendar, IconCheck, IconChevronDown, IconChevronRight, IconClose, type IconProps as IconComponentProps, IconError, IconInfo, IconLocation, IconMenu, type IconName, ICONS_MAP, IconSearch, IconSuccess, IconWarning, } from './icons';
-export type { ArtistCardProps } from './components/cards/ArtistCard';
-export { ArtistCard } from './components/cards/ArtistCard';
-export type { ArtistCardSize, ArtistCardVariant, } from './components/cards/ArtistCard/ArtistCard.types';
-export type { EventCardProps } from './components/cards/EventCard';
-export { EventCard } from './components/cards/EventCard';
-export type { EventCardSize, EventCardVariant } from './components/cards/EventCard/EventCard.types';
-export type { PromoCardProps } from './components/cards/PromoCard';
-export { PromoCard } from './components/cards/PromoCard';
-export type { PromoCardSize, PromoCardVariant } from './components/cards/PromoCard/PromoCard.types';
-export type { TicketCardProps } from './components/cards/TicketCard';
-export { TicketCard } from './components/cards/TicketCard';
-export type { TicketAvailability, TicketCardSize, TicketCardVariant, } from './components/cards/TicketCard/TicketCard.types';
+import { R as ResponsiveSelectSize, S as SelectVariantToken, a as ResponsiveSelectWidth, b as ResponsiveSideOffset, c as ResponsiveAlignOffset, d as SelectSizeToken, e as SelectStateToken, f as SelectWidthToken, g as ResponsiveModalSize, h as ResponsiveModalWidth, i as ResponsiveModalHeight, j as ResponsiveSpace, k as RadiusToken, l as SurfaceToken, M as ModalFooterAlignToken, m as ResponsiveRadius$1, n as ShadowToken, o as ResponsiveColor$1, p as Responsive, q as ResponsiveContainerMaxWidth, r as ResponsiveFlexBasis, s as ResponsiveDelay, t as ResponsiveContextMenuSize, u as ResponsiveContextMenuWidth, C as ContextMenuItemToneToken, v as ResponsiveTabsSize, T as TabsVariantToken, w as TabsToneToken, x as ResponsiveAnimationPreset } from './index-Bv4wWj9I.js';
+export { A as ALERT_TOKENS, y as AlertVariant, bB as Animation, z as BUTTON_TOKENS, c2 as BorderRadius, B as Breakpoint, D as ButtonFontSize, E as ButtonHeight, F as ButtonPaddingHorizontal, G as ButtonPaddingVertical, H as ButtonShadow, I as CARD_TOKENS, P as CHECKBOX_TOKENS, cz as CanonicalFontSize, cA as CanonicalFontWeight, cB as CanonicalLetterSpacing, cC as CanonicalLineHeight, cD as CanonicalTextColor, J as CardPadding, K as CardRadius, L as CardShadow, N as CardSize, O as CardSpacingVertical, Q as CheckboxSize, U as CheckboxState, V as CheckboxVariant, c8 as ColoredShadow, c3 as ComponentRadius, cm as ComponentSpacing, cn as ContainerSpacing, W as DATA_TOKENS, Z as DOMAIN_TOKENS, a7 as DROPDOWN_TOKENS, X as DataListLabelWidth, Y as DataListRowPadding, _ as DomainCardBadge, $ as DomainCardImage, a0 as DomainCardLayout, a1 as DomainCardMetadata, a2 as DomainCardMotion, a3 as DomainCardPriceCapacity, a4 as DomainCardSkeleton, a5 as DomainCardSkeletonContentWidth, a6 as DomainCardSurface, a8 as DropdownItemSize, a9 as DropdownMenuSize, aa as DropdownTriggerSize, ab as DropdownVariant, bC as Duration, bD as Easing, c9 as ElevationShadow, ac as EmptyStateIconSize, ca as FocusRing, cE as FontFamily, cF as FontSize, cG as FontWeight, cb as GlowEffect, co as GridSpacing, bt as ICON_TOKENS, ad as INPUT_TOKENS, bu as IconColor, bv as IconSize, bw as IconStroke, ae as InputFontSize, af as InputHeight, ag as InputPaddingHorizontal, ah as InputPaddingVertical, ai as InputRadius, aj as InputSize, bE as Keyframe, cH as LetterSpacing, cI as LineHeight, ak as MENU_TOKENS, ax as MOTION_TOKENS, al as MenuContentMinWidth, am as MenuContentPadding, an as MenuContentRadius, ao as MenuContentShadow, ap as MenuIndicatorOffset, aq as MenuIndicatorSize, ar as MenuItemGap, as as MenuItemHeight, at as MenuItemPadding, au as MenuItemRadius, av as MenuLabelPadding, aw as MenuSeparatorMargin, ay as MotionAnimation, az as MotionDuration, aA as MotionEasing, aB as MotionTransition, aC as MotionTransitionPreset, bF as MotionV2CombinedType, bG as MotionV2Duration, bH as MotionV2Easing, bI as MotionV2SlideDirection, bJ as MotionV2Transition, aD as NAVIGATION_TOKENS, aK as NOTIFICATION_TOKENS, aE as NavigationItemPadding, aF as NavigationListGap, aG as NavigationRadius, aH as NavigationShadow, aI as NavigationSize, aJ as NavigationState, aL as NotificationPanelWidth, aM as NotificationTokenVariant, aN as OVERLAY_TOKENS, aO as OverlayBackdropVariant, aP as OverlayModalSize, aQ as POPOVER_TOKENS, aR as PopoverArrowOffset, aS as PopoverArrowSize, aT as PopoverContentPadding, aU as PopoverContentRadius, aV as PopoverContentShadow, aW as PopoverContentWidth, aX as RADIO_TOKENS, aY as RadioSize, aZ as RadioState, a_ as RadioVariant, a$ as SECTION_TOKENS, b5 as SURFACE_TOKENS, ba as SWITCH_TOKENS, b0 as SectionGap, b1 as SectionPadding, cp as SectionSpacing, cq as SemanticSpacing, b2 as SkeletonAnimation, b3 as SkeletonBackground, b4 as SkeletonVariant, cr as Spacing, bK as Spring, cs as StackSpacing, b6 as SurfacePadding, b7 as SurfaceRadius, b8 as SurfaceShadow, b9 as SurfaceVariant, bb as SwitchSize, bc as SwitchState, bd as SwitchVariant, bj as TEXT_TOKENS, bo as TOAST_TOKENS, bq as TOOLTIP_TOKENS, be as TableCellPadding, bf as TableGap, bg as TableHeaderPadding, bh as TableRowHeight, bi as TableShadow, bk as TextFontSize, bl as TextFontWeight, bm as TextLetterSpacing, bn as TextLineHeight, cJ as TextStyle, bp as ToastVariant, br as TooltipContentRadius, bs as TooltipContentShadow, bL as Transition, cy as UI_COLORS, cc as accentColoredShadows, bx as allCSSVariables, by as allCSSVariablesCSS, bM as animations, c4 as borderRadius, c5 as componentRadius, cd as componentShadowMapping, bN as durations, bO as easings, ce as elevationShadows, cf as focusRings, cK as fontFamily, cL as fontSize, cM as fontSizeWithMd, cN as fontWeight, bz as generateCSSVariablesCSS, cg as glowEffects, bP as keyframes, ct as layoutSpacing, cO as letterSpacing, cP as lineHeight, bQ as motionCSSVariables, bS as motionV2CSSVariables, bR as motionV2Combined, bT as motionV2Durations, bU as motionV2Easings, bV as motionV2Fade, bW as motionV2Scale, bX as motionV2Slide, bY as motionV2TailwindConfig, bZ as motionV2Transitions, ch as primaryColoredShadows, c6 as radiusCSSVariables, b_ as reducedMotion, cu as semanticSpacing, ci as shadowBase, cj as shadowCSSVariables, ck as shadowOpacity, cv as spacing, cw as spacingCSSVariables, b$ as springs, c0 as tailwindMotionConfig, c7 as tailwindRadiusConfig, cl as tailwindShadowConfig, cx as tailwindSpacingConfig, cQ as tailwindTypographyConfig, cR as textStyles, bA as tokenSystemSummary, c1 as transitions, cS as typographyCSSVariables } from './index-Bv4wWj9I.js';
+export { B as BaseColorTokens, b as ChartColors, C as ColorScale, c as ColorTokens, M as Mode, a as SemanticColors, S as SurfaceColors, T as TextColors, e as accentColors, f as baseColors, g as chartColors, h as colorCSSVariables, d as cssVariableColorTokens, p as primaryColors, s as secondaryColors, i as semanticColors, j as surfaceColors, t as tailwindThemeColors, k as textColors } from './colors-CVA7_16U.js';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as React$1 from 'react';
+import { ReactNode } from 'react';
+import * as SelectPrimitive from '@radix-ui/react-select';
+import * as DialogPrimitive from '@radix-ui/react-dialog';
+import * as LabelPrimitive from '@radix-ui/react-label';
+import * as ToastPrimitives from '@radix-ui/react-toast';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { Placement } from '@floating-ui/react-dom';
+import * as ContextMenuPrimitive from '@radix-ui/react-context-menu';
+import * as TabsPrimitive from '@radix-ui/react-tabs';
+
+declare const buttonVariants: (props?: ({
+    variant?: "primary" | "secondary" | "accent" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+    leftIcon?: React$1.ReactNode;
+    rightIcon?: React$1.ReactNode;
+}
+declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+declare const textVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    weight?: "normal" | "medium" | "semibold" | "bold" | null | undefined;
+    muted?: boolean | null | undefined;
+    variant?: "primary" | "secondary" | "muted" | "accent" | "destructive" | "outline" | "ghost" | "link" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof textVariants> {
+    /**
+     * @deprecated Use muted prop or semantic text colors instead
+     */
+    variant?: "primary" | "secondary" | "accent" | "outline" | "ghost" | "link" | "destructive" | "muted";
+}
+declare const Text: React$1.ForwardRefExoticComponent<TextProps & React$1.RefAttributes<HTMLSpanElement>>;
+type TextSize = VariantProps<typeof textVariants>["size"];
+type TextWeight = VariantProps<typeof textVariants>["weight"];
+
+declare const alertVariants: (props?: ({
+    variant?: "primary" | "secondary" | "accent" | "destructive" | "default" | "success" | "warning" | "danger" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+}
+declare const Alert: React$1.ForwardRefExoticComponent<AlertProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const bodyVariants: (props?: ({
+    size?: "md" | "lg" | null | undefined;
+    weight?: "normal" | "medium" | "semibold" | "bold" | null | undefined;
+    muted?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BodyProps extends React$1.HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof bodyVariants> {
+    as?: "p" | "span" | "div";
+}
+declare const Body: React$1.ForwardRefExoticComponent<BodyProps & React$1.RefAttributes<HTMLElement>>;
+
+declare const captionVariants: (props?: ({
+    weight?: "normal" | "medium" | null | undefined;
+    muted?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CaptionProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof captionVariants> {
+    as?: "span" | "p" | "div";
+}
+declare const Caption: React$1.ForwardRefExoticComponent<CaptionProps & React$1.RefAttributes<HTMLElement>>;
+
+declare const codeVariants: (props?: ({
+    variant?: "inline" | "block" | null | undefined;
+    muted?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CodeProps extends React$1.HTMLAttributes<HTMLElement>, VariantProps<typeof codeVariants> {
+    as?: "code" | "pre";
+}
+declare const Code: React$1.ForwardRefExoticComponent<CodeProps & React$1.RefAttributes<HTMLElement>>;
+
+declare const displayVariants: (props?: ({
+    size?: "xl" | "2xl" | "3xl" | "4xl" | null | undefined;
+    weight?: "normal" | "medium" | "semibold" | "bold" | null | undefined;
+    muted?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface DisplayProps extends React$1.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof displayVariants> {
+    as?: "h1" | "h2" | "div";
+}
+declare const Display: React$1.ForwardRefExoticComponent<DisplayProps & React$1.RefAttributes<HTMLElement>>;
+
+declare const headingVariants: (props?: ({
+    level?: 1 | 2 | 4 | 6 | 3 | 5 | null | undefined;
+    weight?: "normal" | "medium" | "semibold" | "bold" | null | undefined;
+    muted?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface HeadingProps extends React$1.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof headingVariants> {
+    as?: "h1" | "h2" | "h3" | "h4" | "h5" | "h6";
+}
+declare const Heading: React$1.ForwardRefExoticComponent<HeadingProps & React$1.RefAttributes<HTMLHeadingElement>>;
+
+declare const leadVariants: (props?: ({
+    size?: "lg" | "xl" | null | undefined;
+    muted?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface LeadProps extends React$1.HTMLAttributes<HTMLParagraphElement>, VariantProps<typeof leadVariants> {
+    as?: "p" | "span" | "div";
+}
+declare const Lead: React$1.ForwardRefExoticComponent<LeadProps & React$1.RefAttributes<HTMLElement>>;
+
+interface SelectRootProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Root> {
+}
+/**
+ * Select Root component
+ * Radix Root is a context provider, not a DOM element, so it doesn't accept refs
+ */
+declare const SelectRoot: React$1.FC<SelectRootProps>;
+interface SelectTriggerProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Trigger>, "size" | "variant" | "width"> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveSelectSize;
+    /**
+     * Visual variant - token-based
+     */
+    variant?: SelectVariantToken;
+    /**
+     * Width - token-based
+     */
+    width?: ResponsiveSelectWidth;
+}
+declare const SelectTrigger: React$1.ForwardRefExoticComponent<SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface SelectValueProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Value> {
+}
+declare const SelectValue: React$1.ForwardRefExoticComponent<SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface SelectIconProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Icon> {
+}
+declare const SelectIcon: React$1.ForwardRefExoticComponent<SelectIconProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface SelectContentProps extends Omit<React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Content>, "size" | "sideOffset" | "alignOffset"> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveSelectSize;
+    /**
+     * Side offset - token-based
+     */
+    sideOffset?: ResponsiveSideOffset;
+    /**
+     * Alignment offset - token-based
+     */
+    alignOffset?: ResponsiveAlignOffset;
+}
+declare const SelectContent: React$1.ForwardRefExoticComponent<SelectContentProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SelectViewportProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Viewport> {
+}
+declare const SelectViewport: React$1.ForwardRefExoticComponent<SelectViewportProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SelectItemProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Item> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveSelectSize;
+}
+declare const SelectItem: React$1.ForwardRefExoticComponent<SelectItemProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SelectItemTextProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.ItemText> {
+}
+declare const SelectItemText: React$1.ForwardRefExoticComponent<SelectItemTextProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface SelectItemIndicatorProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.ItemIndicator> {
+}
+declare const SelectItemIndicator: React$1.ForwardRefExoticComponent<SelectItemIndicatorProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface SelectSeparatorProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Separator> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveSelectSize;
+}
+declare const SelectSeparator: React$1.ForwardRefExoticComponent<SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SelectGroupProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Group> {
+}
+declare const SelectGroup: React$1.ForwardRefExoticComponent<SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+interface SelectLabelProps extends React$1.ComponentPropsWithoutRef<typeof SelectPrimitive.Label> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveSelectSize;
+}
+declare const SelectLabel: React$1.ForwardRefExoticComponent<SelectLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const Select: {
+    Root: React$1.FC<SelectRootProps>;
+    Trigger: React$1.ForwardRefExoticComponent<SelectTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Value: React$1.ForwardRefExoticComponent<SelectValueProps & React$1.RefAttributes<HTMLSpanElement>>;
+    Icon: React$1.ForwardRefExoticComponent<SelectIconProps & React$1.RefAttributes<HTMLSpanElement>>;
+    Content: React$1.ForwardRefExoticComponent<SelectContentProps & React$1.RefAttributes<HTMLDivElement>>;
+    Viewport: React$1.ForwardRefExoticComponent<SelectViewportProps & React$1.RefAttributes<HTMLDivElement>>;
+    Item: React$1.ForwardRefExoticComponent<SelectItemProps & React$1.RefAttributes<HTMLDivElement>>;
+    ItemText: React$1.ForwardRefExoticComponent<SelectItemTextProps & React$1.RefAttributes<HTMLSpanElement>>;
+    ItemIndicator: React$1.ForwardRefExoticComponent<SelectItemIndicatorProps & React$1.RefAttributes<HTMLSpanElement>>;
+    Separator: React$1.ForwardRefExoticComponent<SelectSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
+    Group: React$1.ForwardRefExoticComponent<SelectGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+    Label: React$1.ForwardRefExoticComponent<SelectLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+};
+
+/**
+ * Select size token type
+ */
+type SelectSize = SelectSizeToken;
+/**
+ * Select variant token type
+ */
+type SelectVariant = SelectVariantToken;
+/**
+ * Select width token type
+ */
+type SelectWidth = SelectWidthToken;
+/**
+ * Select state token type
+ */
+type SelectState = SelectStateToken;
+
+/**
+ * Modal Component
+ *
+ * Radix-based modal component with token-driven styling.
+ * All behavior (focus trap, keyboard navigation, a11y, portal) is handled by Radix Dialog.
+ * Tenerife UI provides visual styling through tokens only.
+ */
+
+interface ModalRootProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Root> {
+}
+/**
+ * Modal Root component
+ * Radix Root is a context provider, not a DOM element, so it doesn't accept refs
+ */
+declare const ModalRoot: React$1.FC<ModalRootProps>;
+interface ModalTriggerProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Trigger> {
+}
+/**
+ * Modal Trigger component
+ * Wrapper around Radix Dialog Trigger
+ */
+declare const ModalTrigger: React$1.ForwardRefExoticComponent<ModalTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+interface ModalOverlayProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Overlay> {
+}
+/**
+ * Modal Overlay component
+ * Wrapper around Radix Dialog Overlay with token-based styling
+ */
+declare const ModalOverlay: React$1.ForwardRefExoticComponent<ModalOverlayProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ModalContentProps extends Omit<React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Content>, "size" | "width" | "height" | "padding" | "radius" | "surface"> {
+    /**
+     * Size variant - token-based
+     *
+     * **Precedence Rule:** The `size` prop applies a preset configuration (width, height, padding, radius, shadow).
+     * Individual override props (`width`, `height`, `padding`, `radius`) take precedence over the size preset.
+     *
+     * **Example:**
+     * - `size="md"` → applies md preset (max-w-md, p-lg, rounded-lg, etc.)
+     * - `size="md" width="lg"` → md preset applied, but width overridden to lg (max-w-lg)
+     * - `width="lg"` (no size) → only width applied, other defaults used
+     *
+     * @default "md"
+     */
+    size?: ResponsiveModalSize;
+    /**
+     * Width - token-based
+     *
+     * **Precedence:** Overrides the width from the `size` preset if provided.
+     * If `size` is not provided, only this width is applied.
+     *
+     * @example
+     * ```tsx
+     * <Modal.Content size="md" width="lg" />
+     * // Applies md preset, but width is overridden to lg
+     * ```
+     */
+    width?: ResponsiveModalWidth;
+    /**
+     * Height - token-based
+     *
+     * **Precedence:** Overrides the height from the `size` preset if provided.
+     * If `size` is not provided, only this height is applied.
+     */
+    height?: ResponsiveModalHeight;
+    /**
+     * Padding - token-based
+     *
+     * **Precedence:** Overrides the padding from the `size` preset if provided.
+     * If `size` is not provided, only this padding is applied.
+     */
+    padding?: ResponsiveSpace;
+    /**
+     * Border radius - token-based
+     *
+     * **Precedence:** Overrides the radius from the `size` preset if provided.
+     * If `size` is not provided, only this radius is applied.
+     */
+    radius?: RadiusToken;
+    /**
+     * Surface variant - token-based
+     *
+     * Applies surface styling (background, shadow) independent of size preset.
+     *
+     * @example
+     * ```tsx
+     * <Modal.Content size="md" surface="raised" />
+     * // Applies md preset + raised surface styling
+     * ```
+     */
+    surface?: SurfaceToken;
+}
+/**
+ * Modal Content component
+ * Wrapper around Radix Dialog Content with token-based styling.
+ *
+ * **Prop Precedence:**
+ * 1. `size` prop applies a preset configuration (width, height, padding, radius, shadow)
+ * 2. Individual override props (`width`, `height`, `padding`, `radius`) take precedence over size preset
+ * 3. `surface` is applied independently and does not conflict with size preset
+ *
+ * **Usage:**
+ * ```tsx
+ * // Use size preset only
+ * <Modal.Content size="md" />
+ *
+ * // Override specific properties from preset
+ * <Modal.Content size="md" width="lg" padding="xl" />
+ *
+ * // Use individual props without preset
+ * <Modal.Content width="lg" padding="md" />
+ * ```
+ */
+declare const ModalContent: React$1.ForwardRefExoticComponent<ModalContentProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ModalHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Gap between header items - token-based
+     */
+    gap?: ResponsiveSpace;
+}
+/**
+ * Modal Header component
+ * Presentational wrapper for modal header content
+ */
+declare const ModalHeader: React$1.ForwardRefExoticComponent<ModalHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ModalTitleProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Title> {
+}
+/**
+ * Modal Title component
+ * Wrapper around Radix Dialog Title with token-based typography
+ */
+declare const ModalTitle: React$1.ForwardRefExoticComponent<ModalTitleProps & React$1.RefAttributes<HTMLHeadingElement>>;
+interface ModalDescriptionProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Description> {
+}
+/**
+ * Modal Description component
+ * Wrapper around Radix Dialog Description with token-based typography
+ */
+declare const ModalDescription: React$1.ForwardRefExoticComponent<ModalDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+interface ModalFooterProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Gap between footer items - token-based
+     */
+    gap?: ResponsiveSpace;
+    /**
+     * Footer alignment - token-based
+     */
+    align?: ModalFooterAlignToken;
+}
+/**
+ * Modal Footer component
+ * Presentational wrapper for modal footer content
+ */
+declare const ModalFooter: React$1.ForwardRefExoticComponent<ModalFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ModalCloseProps extends React$1.ComponentPropsWithoutRef<typeof DialogPrimitive.Close> {
+}
+/**
+ * Modal Close component
+ * Wrapper around Radix Dialog Close with token-based styling
+ */
+declare const ModalClose: React$1.ForwardRefExoticComponent<ModalCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Modal Component
+ *
+ * Radix Dialog-based modal component with token-driven styling.
+ *
+ * **Usage:**
+ * ```tsx
+ * <Modal.Root open={open} onOpenChange={setOpen}>
+ *   <Modal.Trigger>Open</Modal.Trigger>
+ *   <Modal.Content>
+ *     <Modal.Header>
+ *       <Modal.Title>Title</Modal.Title>
+ *       <Modal.Description>Description</Modal.Description>
+ *     </Modal.Header>
+ *     <div>Content</div>
+ *     <Modal.Footer>
+ *       <Modal.Close>Close</Modal.Close>
+ *     </Modal.Footer>
+ *     <Modal.Close />
+ *   </Modal.Content>
+ * </Modal.Root>
+ * ```
+ *
+ * **Note:** Modal.Portal and Modal.Overlay are internal and should not be used directly.
+ * ModalContent automatically handles portal and overlay rendering.
+ */
+declare const Modal: {
+    Root: React$1.FC<ModalRootProps>;
+    Trigger: React$1.ForwardRefExoticComponent<ModalTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Overlay: React$1.ForwardRefExoticComponent<ModalOverlayProps & React$1.RefAttributes<HTMLDivElement>>;
+    Content: React$1.ForwardRefExoticComponent<ModalContentProps & React$1.RefAttributes<HTMLDivElement>>;
+    Header: React$1.ForwardRefExoticComponent<ModalHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+    Title: React$1.ForwardRefExoticComponent<ModalTitleProps & React$1.RefAttributes<HTMLHeadingElement>>;
+    Description: React$1.ForwardRefExoticComponent<ModalDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+    Footer: React$1.ForwardRefExoticComponent<ModalFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+    Close: React$1.ForwardRefExoticComponent<ModalCloseProps & React$1.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Checkbox Variants
+ *
+ * CVA-based variant system for Checkbox component.
+ * Supports variants (primary, secondary, outline, ghost, destructive),
+ * sizes (xs, sm, md, lg, xl), and states (default, checked, disabled, error, indeterminate).
+ * All styling uses token-based values with CSS variable references.
+ */
+declare const checkboxVariants: (props?: ({
+    variant?: "primary" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    state?: "default" | "disabled" | "error" | "checked" | "indeterminate" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+/**
+ * Checkbox Component Props
+ *
+ * Extends native button HTML attributes with variant props, checked state, and accessibility props.
+ * Uses button role="checkbox" pattern for full keyboard accessibility.
+ */
+interface CheckboxProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "size" | "onChange">, VariantProps<typeof checkboxVariants> {
+    /**
+     * Checkbox variant style
+     * @default "outline"
+     */
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "destructive";
+    /**
+     * Checkbox size
+     * @default "md"
+     */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /**
+     * Checkbox state
+     * @default "default"
+     */
+    state?: "default" | "checked" | "indeterminate" | "error" | "disabled";
+    /**
+     * Whether checkbox is checked (controlled)
+     */
+    checked?: boolean;
+    /**
+     * Whether checkbox is in indeterminate state
+     * When true, overrides checked state visually
+     */
+    indeterminate?: boolean;
+    /**
+     * Whether checkbox is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Callback fired when checked state changes
+     */
+    onCheckedChange?: (checked: boolean) => void;
+    /**
+     * Custom icon to display when checked
+     * Defaults to IconCheck from icon system
+     */
+    icon?: React$1.ReactNode;
+    /**
+     * Custom icon to display when indeterminate
+     * Defaults to horizontal line indicator
+     */
+    indeterminateIcon?: React$1.ReactNode;
+    /**
+     * ARIA label for the checkbox
+     * Required if no visible label is present
+     */
+    "aria-label"?: string;
+    /**
+     * ARIA labelledby reference
+     * Points to the ID of the element that labels this checkbox
+     */
+    "aria-labelledby"?: string;
+    /**
+     * ARIA describedby reference
+     * Points to the ID of the element that describes this checkbox
+     */
+    "aria-describedby"?: string;
+}
+
+/**
+ * Checkbox Component
+ *
+ * A fully accessible, theme-aware checkbox component with variant support,
+ * keyboard navigation, and comprehensive state management.
+ * Uses button role="checkbox" pattern for full accessibility.
+ *
+ * @example
+ * ```tsx
+ * <Checkbox
+ *   variant="outline"
+ *   size="md"
+ *   checked={isChecked}
+ *   onCheckedChange={setIsChecked}
+ *   aria-label="Accept terms"
+ * />
+ * ```
+ */
+declare const Checkbox: React$1.ForwardRefExoticComponent<CheckboxProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * Input Variants
+ *
+ * CVA-based variant system for Input component.
+ * Supports variants (primary, secondary, outline, ghost, destructive),
+ * sizes (xs, sm, md, lg, xl), and states (default, disabled, error, success).
+ * All styling uses token-based values with CSS variable references.
+ */
+declare const inputVariants: (props?: ({
+    variant?: "primary" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    state?: "default" | "disabled" | "success" | "error" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+/**
+ * Input Component Props
+ *
+ * Extends native input HTML attributes with variant props, icon slots, and accessibility props.
+ */
+interface InputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "size">, VariantProps<typeof inputVariants> {
+    /**
+     * Input variant style
+     * @default "outline"
+     */
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "destructive";
+    /**
+     * Input size
+     * @default "md"
+     */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /**
+     * Input state
+     * @default "default"
+     */
+    state?: "default" | "disabled" | "error" | "success";
+    /**
+     * Whether input should take full width
+     * @default true
+     */
+    fullWidth?: boolean;
+    /**
+     * Icon to display on the left side of the input
+     */
+    iconLeft?: React$1.ReactNode;
+    /**
+     * Icon to display on the right side of the input
+     */
+    iconRight?: React$1.ReactNode;
+}
+
+/**
+ * Input Component
+ *
+ * A fully accessible, theme-aware input component with variant support,
+ * icon slots, and comprehensive state management.
+ *
+ * @example
+ * ```tsx
+ * <Input
+ *   variant="outline"
+ *   size="md"
+ *   placeholder="Enter text..."
+ *   iconLeft={<Icon name="search" />}
+ * />
+ * ```
+ */
+declare const Input: React$1.ForwardRefExoticComponent<InputProps & React$1.RefAttributes<HTMLInputElement>>;
+
+/**
+ * Radio Variants
+ *
+ * CVA-based variant system for Radio component.
+ * Supports variants (primary, secondary, outline, ghost, destructive),
+ * sizes (xs, sm, md, lg, xl), and states (default, checked, disabled, error).
+ * All styling uses token-based values with CSS variable references.
+ */
+declare const radioVariants: (props?: ({
+    variant?: "primary" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    state?: "default" | "disabled" | "error" | "checked" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+/**
+ * Radio Component Props
+ *
+ * Extends native button HTML attributes with variant props, checked state, and accessibility props.
+ * Uses button role="radio" pattern for full keyboard accessibility.
+ */
+interface RadioProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "size" | "onChange">, VariantProps<typeof radioVariants> {
+    /**
+     * Radio variant style
+     * @default "outline"
+     */
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "destructive";
+    /**
+     * Radio size
+     * @default "md"
+     */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /**
+     * Radio state
+     * @default "default"
+     */
+    state?: "default" | "checked" | "disabled" | "error";
+    /**
+     * Whether radio is checked (controlled)
+     */
+    checked?: boolean;
+    /**
+     * Whether radio is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Value of this radio button
+     * Required when used within RadioGroup
+     */
+    value?: string;
+    /**
+     * Callback fired when radio is selected
+     */
+    onCheckedChange?: (checked: boolean) => void;
+    /**
+     * Custom icon to display when checked
+     * Defaults to filled circle dot
+     */
+    icon?: React$1.ReactNode;
+    /**
+     * ARIA label for the radio
+     * Required if no visible label is present
+     */
+    "aria-label"?: string;
+    /**
+     * ARIA labelledby reference
+     * Points to the ID of the element that labels this radio
+     */
+    "aria-labelledby"?: string;
+    /**
+     * ARIA describedby reference
+     * Points to the ID of the element that describes this radio
+     */
+    "aria-describedby"?: string;
+}
+
+/**
+ * Radio Component
+ *
+ * A fully accessible, theme-aware radio button component with variant support,
+ * keyboard navigation, and comprehensive state management.
+ * Uses button role="radio" pattern for full accessibility.
+ * Can be used standalone or within RadioGroup for group behavior.
+ *
+ * @example
+ * ```tsx
+ * <RadioGroup value={value} onValueChange={setValue}>
+ *   <Radio value="option1" aria-label="Option 1" />
+ *   <Radio value="option2" aria-label="Option 2" />
+ * </RadioGroup>
+ * ```
+ */
+
+/**
+ * Radio component
+ */
+declare const Radio: React$1.ForwardRefExoticComponent<RadioProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+/**
+ * RadioGroup Component Props
+ *
+ * Container component for Radio buttons with keyboard navigation and state management.
+ */
+interface RadioGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Controlled value
+     */
+    value?: string;
+    /**
+     * Default value for uncontrolled usage
+     */
+    defaultValue?: string;
+    /**
+     * Callback when value changes
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Name attribute for the radio group
+     */
+    name?: string;
+    /**
+     * Orientation of the radio group
+     * @default "vertical"
+     */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * Size for all radios in the group
+     * Can be overridden by individual Radio components
+     */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+}
+
+/**
+ * RadioGroup Component
+ *
+ * Container component for Radio buttons with keyboard navigation and state management.
+ * Supports horizontal and vertical orientations, controlled/uncontrolled modes,
+ * and full keyboard accessibility with ArrowUp/ArrowDown navigation.
+ */
+
+/**
+ * RadioGroup - Container component that manages state and keyboard navigation
+ */
+declare const RadioGroup: React$1.ForwardRefExoticComponent<RadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Textarea Variants
+ *
+ * CVA-based variant system for Textarea component.
+ * Supports variants (primary, secondary, outline, ghost, destructive),
+ * sizes (xs, sm, md, lg, xl), and states (default, disabled, error, success).
+ * All styling uses token-based values with CSS variable references.
+ */
+declare const textareaVariants: (props?: ({
+    variant?: "primary" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "sm" | "md" | "lg" | "xl" | "xs" | null | undefined;
+    state?: "default" | "disabled" | "success" | "error" | null | undefined;
+    fullWidth?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+
+/**
+ * Textarea Component Props
+ *
+ * Extends native textarea HTML attributes with variant props, character counter, and accessibility props.
+ */
+interface TextareaProps extends React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, VariantProps<typeof textareaVariants> {
+    /**
+     * Textarea variant style
+     * @default "outline"
+     */
+    variant?: "primary" | "secondary" | "outline" | "ghost" | "destructive";
+    /**
+     * Textarea size
+     * @default "md"
+     */
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    /**
+     * Textarea state
+     * @default "default"
+     */
+    state?: "default" | "disabled" | "error" | "success";
+    /**
+     * Whether textarea should take full width
+     * @default true
+     */
+    fullWidth?: boolean;
+    /**
+     * Maximum character length (for character counter)
+     */
+    maxLength?: number;
+    /**
+     * Show character counter
+     * Only displays when both showCharacterCount and maxLength are provided
+     * @default false
+     */
+    showCharacterCount?: boolean;
+}
+
+/**
+ * Textarea Component
+ *
+ * A fully accessible, theme-aware textarea component with variant support,
+ * character counter, and comprehensive state management.
+ *
+ * @example
+ * ```tsx
+ * <Textarea
+ *   variant="outline"
+ *   size="md"
+ *   placeholder="Enter text..."
+ *   showCharacterCount
+ *   maxLength={200}
+ * />
+ * ```
+ */
+declare const Textarea: React$1.ForwardRefExoticComponent<TextareaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+declare const labelVariants: (props?: class_variance_authority_types.ClassProp | undefined) => string;
+interface LabelProps extends React$1.ComponentPropsWithoutRef<typeof LabelPrimitive.Root>, VariantProps<typeof labelVariants> {
+    /**
+     * Whether the field is required (shows asterisk)
+     */
+    required?: boolean;
+}
+declare const Label: React$1.ForwardRefExoticComponent<LabelProps & React$1.RefAttributes<HTMLLabelElement>>;
+
+/**
+ * Field Container Component
+ * Provides spacing between field elements using Stack
+ */
+interface FieldProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const Field: React$1.ForwardRefExoticComponent<FieldProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Field Label Component
+ * Wraps Label component with proper styling
+ */
+interface FieldLabelProps extends React$1.ComponentProps<typeof Label> {
+}
+declare const FieldLabel: React$1.ForwardRefExoticComponent<Omit<FieldLabelProps, "ref"> & React$1.RefAttributes<HTMLLabelElement>>;
+/**
+ * Field Control Component
+ * Wrapper for input/textarea/select controls
+ */
+interface FieldControlProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const FieldControl: React$1.ForwardRefExoticComponent<FieldControlProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Field Description Component
+ * Helper text displayed below the control
+ */
+interface FieldDescriptionProps extends React$1.ComponentProps<typeof Text> {
+}
+declare const FieldDescription: React$1.ForwardRefExoticComponent<Omit<FieldDescriptionProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+/**
+ * Field Error Component
+ * Error message displayed below the control
+ */
+interface FieldErrorProps extends React$1.ComponentProps<typeof Text> {
+}
+declare const FieldError: React$1.ForwardRefExoticComponent<Omit<FieldErrorProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+declare const FieldRoot: typeof Field & {
+    Label: typeof FieldLabel;
+    Control: typeof FieldControl;
+    Description: typeof FieldDescription;
+    Error: typeof FieldError;
+};
+
+/**
+ * Layout Primitives Shared Types
+ *
+ * Common types used across Box, Flex, Grid, and Stack components.
+ */
+
+/**
+ * Alignment values for flexbox/grid
+ */
+type AlignmentValue = "start" | "end" | "center" | "baseline" | "stretch";
+/**
+ * Justify content values for flexbox/grid
+ */
+type JustifyValue = "start" | "end" | "center" | "between" | "around" | "evenly";
+/**
+ * Flex direction values
+ */
+type FlexDirectionValue = "row" | "column" | "row-reverse" | "column-reverse";
+/**
+ * Flex wrap values
+ */
+type FlexWrapValue = "nowrap" | "wrap" | "wrap-reverse";
+/**
+ * Grid column values
+ */
+type ColumnValue = 1 | 2 | 3 | 4 | 5 | 6 | 12 | "none";
+/**
+ * Grid row values
+ */
+type RowValue = 1 | 2 | 3 | 4 | 5 | 6 | "none";
+/**
+ * Grid flow values
+ */
+type FlowValue = "row" | "col" | "dense" | "row-dense" | "col-dense";
+/**
+ * Shadow token values
+ */
+type ShadowValue = ShadowToken;
+/**
+ * Display type values
+ */
+type DisplayValue = "block" | "inline" | "inline-block" | "flex" | "grid" | "inline-flex" | "inline-grid" | "none";
+/**
+ * Responsive spacing prop type
+ */
+type ResponsiveSpacing = ResponsiveSpace;
+/**
+ * Responsive radius prop type
+ */
+type ResponsiveRadius = ResponsiveRadius$1;
+/**
+ * Responsive color prop type
+ */
+type ResponsiveColor = ResponsiveColor$1;
+/**
+ * Responsive alignment prop type
+ */
+type ResponsiveAlignment = Responsive<AlignmentValue>;
+/**
+ * Responsive justify prop type
+ */
+type ResponsiveJustify = Responsive<JustifyValue>;
+/**
+ * Responsive direction prop type
+ */
+type ResponsiveFlexDirection = Responsive<FlexDirectionValue>;
+/**
+ * Responsive wrap prop type
+ */
+type ResponsiveFlexWrap = Responsive<FlexWrapValue>;
+/**
+ * Responsive column prop type
+ */
+type ResponsiveColumns = Responsive<ColumnValue>;
+/**
+ * Responsive row prop type
+ */
+type ResponsiveRows = Responsive<RowValue>;
+/**
+ * Responsive flow prop type
+ */
+type ResponsiveFlow = Responsive<FlowValue>;
+/**
+ * Surface variant values
+ */
+type SurfaceVariant = "flat" | "raised" | "sunken";
+
+/**
+ * Box Primitive Component
+ *
+ * Token-driven base container component with support for padding, margin,
+ * display, flex, grid, radius, and shadow. All styling uses token-based
+ * Tailwind classes only (no raw numeric values).
+ */
+
+/**
+ * Box component props
+ */
+interface BoxProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Render as different HTML element
+     */
+    as?: keyof React$1.JSX.IntrinsicElements;
+    /**
+     * Padding (all sides) - token-based (xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl)
+     */
+    p?: ResponsiveSpacing;
+    /**
+     * Padding horizontal (left + right)
+     */
+    px?: ResponsiveSpacing;
+    /**
+     * Padding vertical (top + bottom)
+     */
+    py?: ResponsiveSpacing;
+    /**
+     * Padding top
+     */
+    pt?: ResponsiveSpacing;
+    /**
+     * Padding right
+     */
+    pr?: ResponsiveSpacing;
+    /**
+     * Padding bottom
+     */
+    pb?: ResponsiveSpacing;
+    /**
+     * Padding left
+     */
+    pl?: ResponsiveSpacing;
+    /**
+     * Margin (all sides) - token-based
+     */
+    m?: ResponsiveSpacing;
+    /**
+     * Margin horizontal (left + right)
+     */
+    mx?: ResponsiveSpacing;
+    /**
+     * Margin vertical (top + bottom)
+     */
+    my?: ResponsiveSpacing;
+    /**
+     * Margin top
+     */
+    mt?: ResponsiveSpacing;
+    /**
+     * Margin right
+     */
+    mr?: ResponsiveSpacing;
+    /**
+     * Margin bottom
+     */
+    mb?: ResponsiveSpacing;
+    /**
+     * Margin left
+     */
+    ml?: ResponsiveSpacing;
+    /**
+     * Display type
+     */
+    display?: DisplayValue;
+    /**
+     * Flex direction (when display is flex)
+     */
+    flexDirection?: FlexDirectionValue;
+    /**
+     * Border radius - token-based (none, xs, sm, md, lg, xl, 2xl, 3xl, full)
+     */
+    radius?: ResponsiveRadius;
+    /**
+     * Shadow - token-based (none, xs, sm, md, lg, xl, 2xl)
+     */
+    shadow?: ShadowValue;
+    /**
+     * Background color - token-based
+     */
+    bg?: ResponsiveColor;
+    /**
+     * Gap (for flex/grid layouts) - token-based
+     */
+    gap?: ResponsiveSpacing;
+    /**
+     * Align items (for flex/grid layouts)
+     */
+    align?: "start" | "end" | "center" | "baseline" | "stretch";
+    /**
+     * Justify content (for flex/grid layouts)
+     */
+    justify?: "start" | "end" | "center" | "between" | "around" | "evenly";
+}
+/**
+ * Box component
+ */
+declare const Box: React$1.ForwardRefExoticComponent<BoxProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Stack Primitive Component
+ *
+ * Token-driven vertical layout component (flex column). Uses Box internally
+ * with flex display and column direction. All spacing uses token-based values.
+ */
+
+interface StackProps extends Omit<BoxProps, "display" | "flexDirection" | "gap"> {
+    /**
+     * Stack direction - vertical (column) or horizontal (row)
+     */
+    direction?: "vertical" | "horizontal";
+    /**
+     * Spacing between stack items - token-based (xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl)
+     * Alias for gap prop
+     */
+    spacing?: ResponsiveSpacing;
+    /**
+     * Gap between stack items - token-based (xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl)
+     * Alias for spacing prop
+     */
+    gap?: ResponsiveSpacing;
+    /**
+     * Align items
+     */
+    align?: "start" | "end" | "center" | "baseline" | "stretch";
+    /**
+     * Justify content
+     */
+    justify?: "start" | "end" | "center" | "between" | "around" | "evenly";
+}
+/**
+ * Stack component - vertical layout using flex column by default
+ */
+declare const Stack: React$1.ForwardRefExoticComponent<StackProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Column component - alias for Stack (semantic name)
+ */
+declare const Column: React$1.ForwardRefExoticComponent<StackProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Container Layout Primitive Component
+ *
+ * Token-driven container component for constraining content width and centering.
+ * Uses CSS-layer class .tm-container with token-based padding and max-width.
+ */
+
+interface ContainerProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Maximum width of the container
+     * Token-based: accepts container size tokens (sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl, 6xl, 7xl, full) or spacing tokens
+     * @example maxWidth="lg" // 32rem (512px)
+     * @example maxWidth={{ base: "md", lg: "xl" }} // Responsive
+     * @example maxWidth="96" // Uses spacing token
+     */
+    maxWidth?: ResponsiveContainerMaxWidth;
+    /**
+     * Padding (horizontal) - token-based
+     * Supports: spacing tokens or container spacing tokens (container-xs, container-sm, container-md, etc.)
+     * Default: container-md (24px)
+     */
+    padding?: ResponsiveSpacing;
+    /**
+     * Center the container horizontally with auto margins
+     * Default: true
+     */
+    center?: boolean;
+}
+/**
+ * Container component - layout primitive for constraining content width
+ */
+declare const Container: React$1.ForwardRefExoticComponent<ContainerProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Flex Primitive Component
+ *
+ * Token-driven flexbox container with full control over direction, wrap,
+ * grow, shrink, basis, alignment, and spacing. Uses Box internally.
+ * All spacing values use tokens only.
+ */
+
+interface FlexProps extends Omit<BoxProps, "display" | "flexDirection" | "align" | "justify"> {
+    /**
+     * Flex direction
+     */
+    direction?: ResponsiveFlexDirection;
+    /**
+     * Flex wrap
+     */
+    wrap?: ResponsiveFlexWrap;
+    /**
+     * Flex grow (0 or 1, or use Tailwind flex-grow-*)
+     */
+    grow?: 0 | 1 | boolean;
+    /**
+     * Flex shrink (0 or 1, or use Tailwind flex-shrink-*)
+     */
+    shrink?: 0 | 1 | boolean;
+    /**
+     * Flex basis - token-based
+     * Accepts spacing tokens (xs, sm, md, lg, etc.) or semantic CSS values (auto, 0, 100%, fit-content, max-content, min-content)
+     * @example basis="md" // Uses spacing token
+     * @example basis="auto" // Semantic CSS value
+     * @example basis={{ base: "sm", md: "lg" }} // Responsive
+     */
+    basis?: ResponsiveFlexBasis;
+    /**
+     * Align items
+     */
+    align?: ResponsiveAlignment;
+    /**
+     * Justify content
+     */
+    justify?: ResponsiveJustify;
+    /**
+     * Gap between flex items - token-based
+     */
+    gap?: ResponsiveSpacing;
+}
+/**
+ * Flex component
+ */
+declare const Flex: React$1.ForwardRefExoticComponent<FlexProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Grid Primitive Component
+ *
+ * Token-driven CSS Grid container with support for columns, rows, gap,
+ * flow, and alignment. Uses Box internally. All spacing values use tokens only.
+ */
+
+interface GridProps extends Omit<BoxProps, "display" | "align" | "justify"> {
+    /**
+     * Number of columns (1-6, 12, or none)
+     */
+    cols?: ResponsiveColumns;
+    /**
+     * Number of columns at sm breakpoint
+     */
+    sm?: 1 | 2 | 3 | 4 | 5 | 6 | 12 | "none";
+    /**
+     * Number of columns at md breakpoint
+     */
+    md?: 1 | 2 | 3 | 4 | 5 | 6 | 12 | "none";
+    /**
+     * Number of columns at lg breakpoint
+     */
+    lg?: 1 | 2 | 3 | 4 | 5 | 6 | 12 | "none";
+    /**
+     * Number of columns at xl breakpoint
+     */
+    xl?: 1 | 2 | 3 | 4 | 5 | 6 | 12 | "none";
+    /**
+     * Number of columns at 2xl breakpoint
+     */
+    "2xl"?: 1 | 2 | 3 | 4 | 5 | 6 | 12 | "none";
+    /**
+     * Number of rows (1-6 or none)
+     */
+    rows?: ResponsiveRows;
+    /**
+     * Gap between grid items - token-based (xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl)
+     */
+    gap?: ResponsiveSpacing;
+    /**
+     * Grid flow direction
+     */
+    flow?: ResponsiveFlow;
+    /**
+     * Align items
+     */
+    align?: ResponsiveAlignment;
+    /**
+     * Justify content
+     */
+    justify?: ResponsiveJustify;
+}
+/**
+ * Grid component
+ */
+declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Row Primitive Component
+ *
+ * Token-driven horizontal layout component (flex row). Uses Box internally
+ * with flex display and row direction. All spacing uses token-based values.
+ */
+
+interface RowProps extends Omit<BoxProps, "display" | "flexDirection"> {
+    /**
+     * Gap between row items - token-based (xs, sm, md, lg, xl, 2xl, 3xl, 4xl, 5xl)
+     */
+    gap?: ResponsiveSpacing;
+    /**
+     * Align items
+     */
+    align?: "start" | "end" | "center" | "baseline" | "stretch";
+    /**
+     * Justify content
+     */
+    justify?: "start" | "end" | "center" | "between" | "around" | "evenly";
+}
+/**
+ * Row component - horizontal layout using flex row
+ */
+declare const Row: React$1.ForwardRefExoticComponent<RowProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const surfaceVariants$1: (props?: ({
+    variant?: "flat" | "raised" | "sunken" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SurfaceProps$1 extends Omit<BoxProps, "bg" | "shadow"> {
+    /**
+     * Surface variant
+     */
+    variant?: SurfaceVariant;
+    /**
+     * Border radius - token-based
+     */
+    radius?: BoxProps["radius"];
+}
+/**
+ * Surface component - elevation variant component
+ */
+declare const Surface$1: React$1.ForwardRefExoticComponent<SurfaceProps$1 & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Card Container Component
+ *
+ * Token-driven card component with Header, Body, and Footer subcomponents.
+ * Uses SURFACE_TOKENS + CARD_TOKENS for styling.
+ * All styling uses tokens exclusively (no raw CSS values).
+ */
+
+interface CardProps extends Omit<BoxProps, "radius" | "shadow" | "p"> {
+    /**
+     * Card size - maps to CARD_TOKENS.size
+     */
+    size?: "sm" | "md" | "lg";
+    /**
+     * Border radius - token-based (overrides size default)
+     */
+    radius?: ResponsiveRadius;
+    /**
+     * Shadow - token-based (overrides size default)
+     */
+    shadow?: ShadowValue;
+    /**
+     * Padding - token-based (overrides size default)
+     */
+    p?: ResponsiveSpacing;
+}
+/**
+ * Card component - main container
+ */
+declare const Card: React$1.ForwardRefExoticComponent<CardProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * CardHeader component - uses Stack for vertical spacing
+ */
+interface CardHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Card size - determines padding from CARD_TOKENS
+     */
+    size?: "sm" | "md" | "lg";
+    /**
+     * Padding - token-based (overrides size default)
+     */
+    p?: ResponsiveSpacing;
+}
+declare const CardHeader: React$1.ForwardRefExoticComponent<CardHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * CardBody component - main content area
+ */
+interface CardBodyProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Card size - determines padding from CARD_TOKENS
+     */
+    size?: "sm" | "md" | "lg";
+    /**
+     * Padding - token-based (overrides size default)
+     */
+    p?: ResponsiveSpacing;
+}
+declare const CardBody: React$1.ForwardRefExoticComponent<CardBodyProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * CardFooter component - uses Row for horizontal layout
+ */
+interface CardFooterProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Card size - determines padding from CARD_TOKENS
+     */
+    size?: "sm" | "md" | "lg";
+    /**
+     * Padding - token-based (overrides size default)
+     */
+    p?: ResponsiveSpacing;
+}
+declare const CardFooter: React$1.ForwardRefExoticComponent<CardFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Section Container Component
+ *
+ * Token-driven section component for page/landing layout composition.
+ * Uses SECTION_TOKENS for padding and spacing.
+ * Uses Stack internally for content block composition.
+ * All styling uses tokens exclusively (no raw CSS values).
+ */
+
+interface SectionProps extends Omit<StackProps, "py" | "gap"> {
+    /**
+     * Vertical padding - token-based
+     * Accepts spacing tokens (xs, sm, md, lg, xl, 2xl, etc.) or responsive object
+     * @example padding="md"
+     * @example padding={{ base: "sm", lg: "xl" }}
+     */
+    padding?: ResponsiveSpacing;
+    /**
+     * Gap spacing for content blocks - token-based
+     * Accepts spacing tokens (xs, sm, md, lg, xl, 2xl, etc.) or responsive object
+     * @example gap="md"
+     * @example gap={{ base: "sm", lg: "xl" }}
+     */
+    gap?: ResponsiveSpacing;
+    /**
+     * Render as different HTML element
+     */
+    as?: keyof React$1.JSX.IntrinsicElements;
+}
+/**
+ * Section component - page/landing layout container
+ */
+declare const Section: React$1.ForwardRefExoticComponent<SectionProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const surfaceVariants: (props?: ({
+    variant?: "flat" | "raised" | "sunken" | "outline" | "subtle" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SurfaceProps extends Omit<BoxProps, "bg" | "shadow" | "radius" | "p">, VariantProps<typeof surfaceVariants> {
+    /**
+     * Surface variant
+     */
+    variant?: "flat" | "raised" | "sunken" | "outline" | "subtle";
+    /**
+     * Padding - token-based (sm, md, lg, xl)
+     * Overrides default variant padding
+     */
+    p?: ResponsiveSpacing;
+    /**
+     * Border radius - token-based (sm, md, lg, xl, 2xl, 3xl, full)
+     * Overrides default variant radius
+     */
+    radius?: ResponsiveRadius;
+}
+/**
+ * Surface component - elevation variant container
+ */
+declare const Surface: React$1.ForwardRefExoticComponent<SurfaceProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Portal Component
+ *
+ * SSR-safe portal component for rendering children outside the DOM hierarchy.
+ * Mounts to document.body by default, with optional custom container support.
+ */
+
+interface PortalProps {
+    /**
+     * Children to portal
+     */
+    children: React$1.ReactNode;
+    /**
+     * Container element to portal into (defaults to document.body)
+     */
+    container?: Element | null;
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+    /**
+     * Additional inline styles
+     */
+    style?: React$1.CSSProperties;
+}
+/**
+ * Portal component - SSR-safe portal rendering
+ */
+declare const Portal: React$1.ForwardRefExoticComponent<PortalProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const backdropVariants: (props?: ({
+    variant?: "default" | "transparent" | "blurred" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BackdropProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof backdropVariants> {
+    /**
+     * Backdrop variant
+     */
+    variant?: "default" | "blurred" | "transparent";
+    /**
+     * Whether backdrop is visible (for animation)
+     */
+    isVisible?: boolean;
+    /**
+     * Click handler for backdrop dismiss
+     */
+    onClick?: (event: React$1.MouseEvent<HTMLDivElement>) => void;
+}
+/**
+ * Backdrop component - overlay background
+ */
+declare const Backdrop: React$1.ForwardRefExoticComponent<BackdropProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Dialog Component
+ *
+ * Semantic modal wrapper built on Modal component.
+ * Provides Dialog.Header, Dialog.Title, Dialog.Description, Dialog.Body, Dialog.Footer subcomponents.
+ * Full A11y compliance with aria-labelledby and aria-describedby.
+ */
+
+interface DialogProps extends React$1.ComponentPropsWithoutRef<typeof Modal.Root> {
+    /**
+     * ID for the dialog title (for aria-labelledby)
+     */
+    titleId?: string;
+    /**
+     * ID for the dialog description (for aria-describedby)
+     */
+    descriptionId?: string;
+}
+/**
+ * Dialog Root - Main dialog wrapper
+ *
+ * **Note:** This component is a semantic wrapper over Modal.Root and Modal.Content.
+ * It provides Dialog-specific subcomponents but uses the new Radix-based Modal internally.
+ */
+declare const DialogRoot: React$1.FC<DialogProps>;
+/**
+ * Dialog Header - Header section with spacing
+ */
+interface DialogHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    titleId?: string;
+    descriptionId?: string;
+}
+declare const DialogHeader: React$1.ForwardRefExoticComponent<DialogHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Dialog Title - h2 with aria-labelledby
+ */
+interface DialogTitleProps extends React$1.HTMLAttributes<HTMLHeadingElement> {
+    titleId?: string;
+}
+declare const DialogTitle: React$1.ForwardRefExoticComponent<DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>>;
+/**
+ * Dialog Description - p with aria-describedby
+ */
+interface DialogDescriptionProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+    descriptionId?: string;
+}
+declare const DialogDescription: React$1.ForwardRefExoticComponent<DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Dialog Body - Main content area
+ */
+interface DialogBodyProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const DialogBody: React$1.ForwardRefExoticComponent<DialogBodyProps & React$1.RefAttributes<HTMLDivElement>>;
+/**
+ * Dialog Footer - Footer section with Row layout
+ */
+interface DialogFooterProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+declare const DialogFooter: React$1.ForwardRefExoticComponent<DialogFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const Dialog: React$1.FC<DialogProps> & {
+    Root: React$1.FC<DialogProps>;
+    Header: React$1.ForwardRefExoticComponent<DialogHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+    Title: React$1.ForwardRefExoticComponent<DialogTitleProps & React$1.RefAttributes<HTMLHeadingElement>>;
+    Description: React$1.ForwardRefExoticComponent<DialogDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+    Body: React$1.ForwardRefExoticComponent<DialogBodyProps & React$1.RefAttributes<HTMLDivElement>>;
+    Footer: React$1.ForwardRefExoticComponent<DialogFooterProps & React$1.RefAttributes<HTMLDivElement>>;
+};
+
+declare const toastVariants: (props?: ({
+    variant?: "default" | "success" | "warning" | "danger" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ToastActionData {
+    label: string;
+    onClick: () => void;
+}
+interface ToastData {
+    id: string;
+    title?: string;
+    description?: string;
+    variant?: "default" | "success" | "info" | "warning" | "danger";
+    action?: ToastActionData;
+    /**
+     * Toast duration - token-based
+     * Uses motion duration tokens
+     * Passed to Radix Toast.Root duration prop
+     */
+    duration?: ResponsiveDelay;
+}
+interface ToastRootProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ToastPrimitives.Root>, "duration">, VariantProps<typeof toastVariants> {
+    /**
+     * Toast data
+     */
+    toast: ToastData;
+}
+/**
+ * Toast Action component
+ * Wrapper around Radix Toast.Action with token-based styling
+ */
+declare const ToastAction: React$1.ForwardRefExoticComponent<Omit<ToastPrimitives.ToastActionProps & React$1.RefAttributes<HTMLButtonElement>, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+/**
+ * Legacy Exports (Backward Compatibility)
+ *
+ * These exports maintain backward compatibility with existing code:
+ *
+ * - Toast: Alias for ToastRoot
+ *   Rationale: Previous API used `Toast` as the main component name.
+ *   This alias allows existing code to continue working without changes.
+ *   Note: This is a simple alias - no legacy behavior is preserved.
+ *   The component is fully Radix-based regardless of which name is used.
+ *
+ * - ToastProps: Alias for ToastRootProps
+ *   Rationale: Previous API used `ToastProps` as the type name.
+ *   This alias maintains type compatibility for existing TypeScript code.
+ *
+ * Migration Path:
+ * - Existing code using `Toast` will continue to work
+ * - New code should use `ToastRoot` for clarity
+ * - These legacy exports may be removed in a future major version
+ */
+type ToastProps = ToastRootProps;
+declare const Toast: React$1.ForwardRefExoticComponent<ToastRootProps & React$1.RefAttributes<HTMLLIElement>>;
+
+/**
+ * ToastViewport Component
+ *
+ * 🔒 FOUNDATION COMPONENT - ARCHITECTURE LOCKED
+ *
+ * Radix-based toast viewport with token-driven positioning.
+ * Radix Toast.Viewport handles portal rendering internally.
+ * Tenerife UI provides visual styling and positioning through tokens only.
+ *
+ * This component is locked as a foundation component per TUI_ARCHITECTURE_LOCK.md.
+ * DO NOT reimplement portal logic - Radix handles this internally.
+ */
+
+type ToastPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+interface ToastViewportProps extends React$1.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport> {
+    /**
+     * Position of toast viewport
+     */
+    position?: ToastPosition;
+}
+/**
+ * ToastViewport component
+ * Wrapper around Radix Toast.Viewport with token-based positioning.
+ * Radix handles portal rendering internally - no custom Portal needed.
+ */
+declare const ToastViewport: React$1.ForwardRefExoticComponent<ToastViewportProps & React$1.RefAttributes<HTMLOListElement>>;
+
+interface ToastOptions {
+    title?: string;
+    description?: string;
+    variant?: "default" | "success" | "info" | "warning" | "danger";
+    action?: ToastActionData;
+    /**
+     * Toast duration - token-based
+     * Uses motion duration tokens
+     * Passed to Radix Toast.Root duration prop (Radix handles auto-dismiss)
+     */
+    duration?: ResponsiveDelay;
+}
+interface ToastContextType {
+    toast: (options: ToastOptions) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+interface ToastProviderProps {
+    /**
+     * Children to render
+     */
+    children: React$1.ReactNode;
+    /**
+     * Position of toast viewport
+     */
+    position?: ToastPosition;
+    /**
+     * Swipe direction for toast dismissal
+     * Radix handles swipe gestures internally
+     */
+    swipeDirection?: "up" | "down" | "left" | "right";
+    /**
+     * Default duration for toasts in milliseconds
+     * Radix handles auto-dismiss based on this value
+     *
+     * NOTE: This is a behavioral prop for Radix Toast.Provider API (requires number),
+     * not a visual prop. The eslint rule is disabled for this specific case.
+     */
+    duration?: number;
+}
+/**
+ * ToastProvider component
+ * Wrapper around Radix Toast.Provider with convenience toast() function.
+ * Radix handles all state management, auto-dismiss, and queue management.
+ */
+declare function ToastProvider({ children, position, swipeDirection, duration, }: ToastProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to use toast context
+ */
+declare function useToast(): ToastContextType;
+
+/**
+ * NotificationCenter.DismissAll Component
+ *
+ * Button component to clear all notifications.
+ * Located in Panel header.
+ */
+
+interface NotificationCenterDismissAllProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Show confirmation before clearing
+     */
+    confirm?: boolean;
+    /**
+     * Confirmation message
+     */
+    confirmMessage?: string;
+}
+/**
+ * NotificationCenter.DismissAll component - clear all notifications button
+ */
+declare const NotificationCenterDismissAll: React$1.ForwardRefExoticComponent<NotificationCenterDismissAllProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface NotificationCenterGroupHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Group label text
+     */
+    label: string;
+    /**
+     * Whether the group is collapsed
+     */
+    collapsed?: boolean;
+    /**
+     * Callback when collapse/expand is toggled
+     */
+    onToggleCollapse?: () => void;
+    /**
+     * Show collapse/expand button
+     */
+    collapsible?: boolean;
+}
+/**
+ * NotificationCenter.GroupHeader component - group section header
+ */
+declare const NotificationCenterGroupHeader: React$1.ForwardRefExoticComponent<NotificationCenterGroupHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * Notification Center Types
+ *
+ * Type definitions for Notification Center components.
+ */
+
+/**
+ * Notification channel types
+ */
+type NotificationChannel = "success" | "error" | "info" | "warning" | "system" | "log";
+/**
+ * Notification variant (extends toast variants)
+ */
+type NotificationVariant = "default" | "success" | "info" | "warning" | "danger" | "system" | "log";
+/**
+ * Notification data structure
+ */
+interface NotificationData {
+    id: string;
+    title?: string;
+    description?: string;
+    variant?: NotificationVariant;
+    channel?: NotificationChannel;
+    action?: ToastActionData;
+    /**
+     * Notification duration - token-based
+     * Uses motion duration tokens
+     */
+    duration?: ResponsiveDelay;
+    persistent?: boolean;
+    timestamp: number;
+    read?: boolean;
+}
+/**
+ * Notification options for creating notifications
+ */
+interface NotificationOptions {
+    title?: string;
+    description?: string;
+    variant?: NotificationVariant;
+    channel?: NotificationChannel;
+    action?: ToastActionData;
+    /**
+     * Notification duration - token-based
+     * Uses motion duration tokens
+     */
+    duration?: ResponsiveDelay;
+    persistent?: boolean;
+}
+/**
+ * Group by function type
+ */
+type GroupByFunction = (notification: NotificationData) => string;
+/**
+ * Notification context type
+ */
+interface NotificationContextType {
+    /**
+     * Push a new notification
+     */
+    push: (notification: NotificationOptions) => string;
+    /**
+     * Remove a specific notification by ID
+     */
+    remove: (id: string) => void;
+    /**
+     * Clear all notifications
+     */
+    clearAll: () => void;
+    /**
+     * Clear notifications by channel
+     */
+    clearChannel: (channel: NotificationChannel) => void;
+    /**
+     * Group notifications by function
+     */
+    groupBy: (fn: GroupByFunction) => Record<string, NotificationData[]>;
+    /**
+     * Get persistent history
+     */
+    getHistory: () => NotificationData[];
+    /**
+     * Get notifications by channel
+     */
+    getByChannel: (channel: NotificationChannel) => NotificationData[];
+    /**
+     * Get all notifications
+     */
+    getAll: () => NotificationData[];
+    /**
+     * Mark notification as read
+     */
+    markAsRead: (id: string) => void;
+    /**
+     * Mark all as read
+     */
+    markAllAsRead: () => void;
+    /**
+     * Get unread count
+     */
+    getUnreadCount: () => number;
+}
+
+interface NotificationCenterItemProps extends Omit<React$1.HTMLAttributes<HTMLLIElement>, "onClick"> {
+    /**
+     * Notification data
+     */
+    notification: NotificationData;
+    /**
+     * Callback when notification is dismissed
+     */
+    onDismiss?: (id: string) => void;
+    /**
+     * Callback when notification is clicked
+     */
+    onClick?: (id: string) => void;
+    /**
+     * Show expandable details
+     */
+    expandable?: boolean;
+}
+/**
+ * NotificationCenter.Item component - individual notification item
+ */
+declare const NotificationCenterItem: React$1.ForwardRefExoticComponent<NotificationCenterItemProps & React$1.RefAttributes<HTMLLIElement>>;
+
+/**
+ * NotificationCenter.List Component
+ *
+ * Vertical list container for notifications.
+ * Uses Stack component with token-based spacing.
+ * Provides proper ARIA roles for accessibility.
+ */
+
+interface NotificationCenterListProps extends React$1.HTMLAttributes<HTMLUListElement> {
+    /**
+     * Children to render (notification items)
+     */
+    children: React$1.ReactNode;
+    /**
+     * ARIA label for the list
+     */
+    "aria-label"?: string;
+}
+/**
+ * NotificationCenter.List component - vertical list container
+ */
+declare const NotificationCenterList: React$1.ForwardRefExoticComponent<NotificationCenterListProps & React$1.RefAttributes<HTMLUListElement>>;
+
+interface NotificationCenterTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Callback when trigger is clicked
+     */
+    onClick?: () => void;
+    /**
+     * Show unread badge
+     */
+    showBadge?: boolean;
+}
+/**
+ * NotificationCenter.Trigger component - open panel button
+ */
+declare const NotificationCenterTrigger: React$1.ForwardRefExoticComponent<NotificationCenterTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+
+interface NotificationCenterPanelProps {
+    /**
+     * Whether panel is open
+     */
+    isOpen: boolean;
+    /**
+     * Callback when panel should close
+     */
+    onClose: () => void;
+    /**
+     * Function to group notifications (by date, type, or custom)
+     */
+    groupBy?: GroupByFunction;
+    /**
+     * Panel width variant
+     */
+    width?: "sm" | "md" | "lg";
+    /**
+     * Auto-collapse older notifications
+     */
+    autoCollapse?: boolean;
+    /**
+     * Element to return focus to when panel closes
+     */
+    returnFocusRef?: React$1.RefObject<HTMLElement>;
+}
+/**
+ * NotificationCenter.Panel component - side drawer notification panel
+ */
+declare const NotificationCenterPanel: React$1.ForwardRefExoticComponent<NotificationCenterPanelProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface NotificationCenterProviderProps {
+    /**
+     * Children to render
+     */
+    children: React$1.ReactNode;
+    /**
+     * Maximum number of notifications to keep in history
+     */
+    maxHistory?: number;
+    /**
+     * Enable persistent history (in-memory, can be extended to localStorage)
+     */
+    persistent?: boolean;
+}
+/**
+ * NotificationCenter.Provider component - global notification state management
+ */
+declare function NotificationCenterProvider({ children, maxHistory, persistent, }: NotificationCenterProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to use notification center context
+ */
+declare function useNotificationCenterContext(): NotificationContextType;
+
+interface NotificationAPI {
+    /**
+     * Show success notification
+     */
+    success: (message: string, options?: Omit<NotificationOptions, "variant" | "channel">) => string;
+    /**
+     * Show error notification
+     */
+    error: (message: string, options?: Omit<NotificationOptions, "variant" | "channel">) => string;
+    /**
+     * Show info notification
+     */
+    info: (message: string, options?: Omit<NotificationOptions, "variant" | "channel">) => string;
+    /**
+     * Show warning notification
+     */
+    warning: (message: string, options?: Omit<NotificationOptions, "variant" | "channel">) => string;
+    /**
+     * Show system notification
+     */
+    system: (message: string, options?: Omit<NotificationOptions, "variant" | "channel">) => string;
+    /**
+     * Show log notification
+     */
+    log: (message: string, options?: Omit<NotificationOptions, "variant" | "channel">) => string;
+    /**
+     * Push custom notification
+     */
+    push: (options: NotificationOptions) => string;
+    /**
+     * Remove notification by ID
+     */
+    remove: (id: string) => void;
+    /**
+     * Clear all notifications
+     */
+    clearAll: () => void;
+    /**
+     * Clear notifications by channel
+     */
+    clearChannel: (channel: "success" | "error" | "info" | "warning" | "system" | "log") => void;
+}
+/**
+ * useNotificationCenter hook - multi-channel notification API
+ */
+declare function useNotificationCenter(): NotificationAPI;
+
+/**
+ * NotificationCenter compound component
+ */
+declare const NotificationCenter: {
+    Provider: typeof NotificationCenterProvider;
+    Panel: React$1.ForwardRefExoticComponent<NotificationCenterPanelProps & React$1.RefAttributes<HTMLDivElement>>;
+    Trigger: React$1.ForwardRefExoticComponent<NotificationCenterTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+    List: React$1.ForwardRefExoticComponent<NotificationCenterListProps & React$1.RefAttributes<HTMLUListElement>>;
+    Item: React$1.ForwardRefExoticComponent<NotificationCenterItemProps & React$1.RefAttributes<HTMLLIElement>>;
+    GroupHeader: React$1.ForwardRefExoticComponent<NotificationCenterGroupHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+    DismissAll: React$1.ForwardRefExoticComponent<NotificationCenterDismissAllProps & React$1.RefAttributes<HTMLButtonElement>>;
+};
+
+/**
+ * Popover Arrow Component
+ *
+ * Arrow indicator pointing to the trigger element.
+ * Uses POPOVER_TOKENS for sizing and positioning.
+ */
+
+interface PopoverArrowProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Arrow size
+     */
+    size?: "sm" | "md";
+}
+/**
+ * Popover Arrow component
+ */
+declare const PopoverArrow: React$1.ForwardRefExoticComponent<PopoverArrowProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const popoverContentVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xs" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface PopoverContentProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onAnimationEnd">, VariantProps<typeof popoverContentVariants> {
+    /**
+     * Placement preference
+     */
+    placement?: Placement;
+    /**
+     * Offset between trigger and content - token-based
+     * Uses spacing tokens for positioning offsets
+     */
+    offset?: ResponsiveAlignOffset;
+    /**
+     * Whether to close on outside click
+     */
+    closeOnInteractOutside?: boolean;
+}
+/**
+ * Popover Content component
+ */
+declare const PopoverContent: React$1.ForwardRefExoticComponent<PopoverContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface PopoverRootProps {
+    /**
+     * Whether the popover is open (controlled mode)
+     */
+    open?: boolean;
+    /**
+     * Callback when open state changes
+     */
+    onOpenChange?: (open: boolean) => void;
+    /**
+     * Default open state (uncontrolled mode)
+     */
+    defaultOpen?: boolean;
+    /**
+     * Whether the popover is modal (blocks interaction with other elements)
+     */
+    modal?: boolean;
+    /**
+     * Children
+     */
+    children: React$1.ReactNode;
+}
+/**
+ * Popover Root component
+ */
+declare function PopoverRoot({ open: controlledOpen, onOpenChange, defaultOpen, children, }: PopoverRootProps): react_jsx_runtime.JSX.Element;
+declare namespace PopoverRoot {
+    var displayName: string;
+}
+
+/**
+ * Popover Trigger Component
+ *
+ * Trigger element that opens/closes the popover.
+ * Supports asChild pattern for composition.
+ */
+
+interface PopoverTriggerProps extends React$1.HTMLAttributes<HTMLElement> {
+    /**
+     * Render as child element (composition pattern)
+     */
+    asChild?: boolean;
+}
+/**
+ * Popover Trigger component
+ */
+declare const PopoverTrigger: React$1.ForwardRefExoticComponent<PopoverTriggerProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * DropdownMenu Item Component
+ *
+ * Menu item with keyboard navigation support (roving tabindex).
+ * Uses MENU_TOKENS for styling.
+ */
+
+interface DropdownMenuItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onSelect"> {
+    /**
+     * Whether the item is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Whether the item is selected
+     */
+    selected?: boolean;
+    /**
+     * Callback when item is selected
+     * Receives native Event (not SyntheticEvent)
+     */
+    onSelect?: (event: Event) => void;
+    /**
+     * Whether item has inset padding (for nested items)
+     */
+    inset?: boolean;
+}
+/**
+ * DropdownMenu Item component
+ */
+declare const DropdownMenuItem: React$1.ForwardRefExoticComponent<DropdownMenuItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu CheckItem Component
+ *
+ * Menu item with checkbox indicator.
+ * Uses MENU_TOKENS for styling.
+ */
+
+interface DropdownMenuCheckItemProps extends Omit<DropdownMenuItemProps, "selected"> {
+    /**
+     * Whether the item is checked
+     */
+    checked?: boolean;
+}
+/**
+ * DropdownMenu CheckItem component
+ */
+declare const DropdownMenuCheckItem: React$1.ForwardRefExoticComponent<DropdownMenuCheckItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu Content Component
+ *
+ * Content container for dropdown menu.
+ * Wraps PopoverContent with menu-specific styling and role.
+ * Handles keyboard navigation (Arrow keys, Home/End, Escape).
+ */
+
+interface DropdownMenuContentProps extends PopoverContentProps {
+}
+/**
+ * DropdownMenu Content component
+ */
+declare const DropdownMenuContent: React$1.ForwardRefExoticComponent<DropdownMenuContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu Group Component
+ *
+ * Group container for related menu items.
+ */
+
+interface DropdownMenuGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * DropdownMenu Group component
+ */
+declare const DropdownMenuGroup: React$1.ForwardRefExoticComponent<DropdownMenuGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu Label Component
+ *
+ * Label/section header for menu items.
+ * Uses MENU_TOKENS for styling.
+ */
+
+interface DropdownMenuLabelProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Whether label has inset padding (for nested items)
+     */
+    inset?: boolean;
+}
+/**
+ * DropdownMenu Label component
+ */
+declare const DropdownMenuLabel: React$1.ForwardRefExoticComponent<DropdownMenuLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu RadioGroup Component
+ *
+ * Radio group container for radio menu items.
+ */
+
+interface DropdownMenuRadioGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Selected value
+     */
+    value?: string;
+    /**
+     * Callback when value changes
+     */
+    onValueChange?: (value: string) => void;
+}
+/**
+ * DropdownMenu RadioGroup component
+ */
+declare const DropdownMenuRadioGroup: React$1.ForwardRefExoticComponent<DropdownMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu RadioItem Component
+ *
+ * Menu item with radio indicator.
+ * Uses MENU_TOKENS for styling.
+ */
+
+interface DropdownMenuRadioItemProps extends Omit<DropdownMenuItemProps, "selected"> {
+    /**
+     * Radio item value
+     */
+    value: string;
+}
+/**
+ * DropdownMenu RadioItem component
+ */
+declare const DropdownMenuRadioItem: React$1.ForwardRefExoticComponent<DropdownMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface DropdownMenuRootProps extends PopoverRootProps {
+}
+/**
+ * DropdownMenu Root component
+ */
+declare function DropdownMenuRoot(props: DropdownMenuRootProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownMenuRoot {
+    var displayName: string;
+}
+
+/**
+ * DropdownMenu Separator Component
+ *
+ * Visual separator between menu items.
+ * Uses MENU_TOKENS for styling.
+ */
+
+interface DropdownMenuSeparatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+}
+/**
+ * DropdownMenu Separator component
+ */
+declare const DropdownMenuSeparator: React$1.ForwardRefExoticComponent<DropdownMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface DropdownMenuSubProps extends PopoverRootProps {
+}
+/**
+ * DropdownMenu Sub component
+ */
+declare function DropdownMenuSub(props: DropdownMenuSubProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownMenuSub {
+    var displayName: string;
+}
+
+/**
+ * DropdownMenu SubContent Component
+ *
+ * Content container for submenu.
+ */
+
+interface DropdownMenuSubContentProps extends DropdownMenuContentProps {
+}
+/**
+ * DropdownMenu SubContent component
+ */
+declare const DropdownMenuSubContent: React$1.ForwardRefExoticComponent<DropdownMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu SubTrigger Component
+ *
+ * Trigger for submenu items.
+ */
+
+interface DropdownMenuSubTriggerProps extends DropdownMenuItemProps {
+}
+/**
+ * DropdownMenu SubTrigger component
+ */
+declare const DropdownMenuSubTrigger: React$1.ForwardRefExoticComponent<DropdownMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DropdownMenu Trigger Component
+ *
+ * Trigger element for dropdown menu.
+ * Wraps PopoverTrigger with menu-specific ARIA attributes.
+ */
+
+interface DropdownMenuTriggerProps extends PopoverTriggerProps {
+}
+/**
+ * DropdownMenu Trigger component
+ */
+declare const DropdownMenuTrigger: React$1.ForwardRefExoticComponent<DropdownMenuTriggerProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * HoverCard Content Component
+ *
+ * Content container for HoverCard.
+ * Wraps PopoverContent with hover-specific behavior.
+ */
+
+interface HoverCardContentProps extends PopoverContentProps {
+}
+/**
+ * HoverCard Content component
+ */
+declare const HoverCardContent: React$1.ForwardRefExoticComponent<HoverCardContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface HoverCardRootProps extends Omit<PopoverRootProps, "open" | "onOpenChange"> {
+    /**
+     * Delay before opening - token-based
+     * Uses motion duration tokens
+     * @default 0
+     */
+    openDelay?: ResponsiveDelay;
+    /**
+     * Delay before closing - token-based
+     * Uses motion duration tokens
+     * @default 300
+     */
+    closeDelay?: ResponsiveDelay;
+}
+/**
+ * HoverCard Root component
+ */
+declare function HoverCardRoot({ openDelay, closeDelay, defaultOpen, ...props }: HoverCardRootProps): react_jsx_runtime.JSX.Element;
+declare namespace HoverCardRoot {
+    var displayName: string;
+}
+
+/**
+ * HoverCard Trigger Component
+ *
+ * Trigger element that opens HoverCard on hover/focus.
+ */
+
+interface HoverCardTriggerProps extends PopoverTriggerProps {
+}
+/**
+ * HoverCard Trigger component
+ */
+declare const HoverCardTrigger: React$1.ForwardRefExoticComponent<HoverCardTriggerProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * ============================================================================
+ * 🔒 FOUNDATION LOCK - ContextMenu Component
+ * ============================================================================
+ *
+ * This component is LOCKED as part of the UI Foundation Layer.
+ *
+ * **ARCHITECTURE LOCK DOCUMENTATION:**
+ * See: docs/architecture/TUI_ARCHITECTURE_LOCK.md
+ *
+ * This component must not be modified except for critical bug fixes.
+ * All architectural decisions are final. Museum-grade quality achieved.
+ *
+ * LOCKED STATUS:
+ * - Component: ContextMenu (Radix ContextMenu wrapper)
+ * - Category: Menus (Foundation Layer)
+ * - Lock Date: 2025-12-12
+ * - Status: ✅ LOCKED (FOUNDATION_LOCKED)
+ *
+ * ALLOWED CHANGES (Minimal, approval required):
+ * - Critical bug fixes only (with explicit approval)
+ * - Typing improvements (TypeScript only, no runtime changes)
+ * - Token wiring improvements (connecting existing tokens, no new tokens)
+ * - Stories/tests fixes (test updates only, no component changes)
+ * - Documentation updates (comments, docs only)
+ * - Code comments explaining intentional design decisions
+ *
+ * FORBIDDEN CHANGES (Strictly prohibited):
+ * - ❌ New foundation components or subcomponents
+ * - ❌ Duplicate component implementations
+ * - ❌ Custom behavior that Radix ContextMenu should handle
+ * - ❌ String/number visual props (must use tokens only)
+ * - ❌ Re-implementing focus/keyboard/aria/portal logic
+ * - ❌ Breaking API changes
+ * - ❌ Behavioral rewrites or custom logic additions
+ * - ❌ Token system modifications (additions/removals)
+ * - ❌ Style modifications beyond token wiring
+ * - ❌ New props that change component behavior
+ *
+ * **If you believe changes are necessary, review TUI_ARCHITECTURE_LOCK.md first.**
+ *
+ * ============================================================================
+ *
+ * ContextMenu Component
+ *
+ * Radix-based context menu component with token-driven styling.
+ * All behavior (pointer, keyboard, focus, ARIA, positioning, collision handling)
+ * is handled by Radix ContextMenu. Tenerife UI provides visual styling through
+ * tokens only. This is a strict wrapper pattern - no custom behavior logic.
+ */
+
+type ContextMenuRootProps = React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Root>;
+/**
+ * ContextMenu Root component
+ * Radix Root is a context provider, not a DOM element, so it doesn't accept refs
+ */
+declare const ContextMenuRoot: React$1.FC<ContextMenuRootProps>;
+interface ContextMenuTriggerProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Trigger>, "children"> {
+    children?: React$1.ReactNode;
+}
+/**
+ * ContextMenu Trigger component
+ * Radix handles right-click behavior automatically
+ */
+declare const ContextMenuTrigger: React$1.ForwardRefExoticComponent<ContextMenuTriggerProps & React$1.RefAttributes<HTMLSpanElement>>;
+interface ContextMenuContentProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Content>, "size" | "width" | "padding" | "radius" | "surface"> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveContextMenuSize;
+    /**
+     * Width - token-based
+     */
+    width?: ResponsiveContextMenuWidth;
+    /**
+     * Padding - token-based
+     */
+    padding?: ResponsiveSpace;
+    /**
+     * Radius - token-based
+     */
+    radius?: RadiusToken;
+    /**
+     * Surface variant - token-based
+     */
+    surface?: SurfaceToken;
+}
+/**
+ * ContextMenu Content component
+ * Wrapper around Radix ContextMenu Content with token-based styling.
+ */
+declare const ContextMenuContent: React$1.ForwardRefExoticComponent<ContextMenuContentProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuItemProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Item>, "children"> {
+    children?: React$1.ReactNode;
+    /**
+     * Size variant - token-based
+     *
+     * @default Inherited from ContextMenuContent
+     * @note If not specified, the size is automatically inherited from the parent
+     * ContextMenuContent. You can override this by providing an explicit size prop.
+     * This allows you to set size once on Content and have all Items inherit it.
+     */
+    size?: ResponsiveContextMenuSize;
+    /**
+     * Tone variant - token-based
+     */
+    tone?: ContextMenuItemToneToken;
+    /**
+     * Gap between item content - token-based
+     */
+    gap?: ResponsiveSpace;
+    /**
+     * Inset padding for item
+     */
+    inset?: boolean;
+}
+/**
+ * ContextMenu Item component
+ * Wrapper around Radix ContextMenu Item with token-based styling.
+ */
+declare const ContextMenuItem: React$1.ForwardRefExoticComponent<ContextMenuItemProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuCheckboxItemProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.CheckboxItem>, "children"> {
+    children?: React$1.ReactNode;
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveContextMenuSize;
+    /**
+     * Tone variant - token-based
+     */
+    tone?: ContextMenuItemToneToken;
+    /**
+     * Gap between item content - token-based
+     */
+    gap?: ResponsiveSpace;
+}
+/**
+ * ContextMenu CheckboxItem component
+ * Wrapper around Radix ContextMenu CheckboxItem with token-based styling.
+ */
+declare const ContextMenuCheckboxItem: React$1.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuRadioGroupProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.RadioGroup>, "children"> {
+    children?: React$1.ReactNode;
+}
+/**
+ * ContextMenu RadioGroup component
+ * Wrapper around Radix ContextMenu RadioGroup.
+ */
+declare const ContextMenuRadioGroup: React$1.ForwardRefExoticComponent<ContextMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuRadioItemProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.RadioItem>, "children"> {
+    children?: React$1.ReactNode;
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveContextMenuSize;
+    /**
+     * Tone variant - token-based
+     */
+    tone?: ContextMenuItemToneToken;
+    /**
+     * Gap between item content - token-based
+     */
+    gap?: ResponsiveSpace;
+}
+/**
+ * ContextMenu RadioItem component
+ * Wrapper around Radix ContextMenu RadioItem with token-based styling.
+ */
+declare const ContextMenuRadioItem: React$1.ForwardRefExoticComponent<ContextMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuSeparatorProps extends React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Separator> {
+    className?: string;
+}
+/**
+ * ContextMenu Separator component
+ * Wrapper around Radix ContextMenu Separator with token-based styling.
+ */
+declare const ContextMenuSeparator: React$1.ForwardRefExoticComponent<ContextMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuLabelProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Label>, "children"> {
+    children?: React$1.ReactNode;
+    /**
+     * Padding - token-based
+     */
+    padding?: ResponsiveSpace;
+}
+/**
+ * ContextMenu Label component
+ * Wrapper around Radix ContextMenu Label with token-based styling.
+ */
+declare const ContextMenuLabel: React$1.ForwardRefExoticComponent<ContextMenuLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuSubProps extends React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.Sub> {
+    children?: React$1.ReactNode;
+}
+/**
+ * ContextMenu Sub component
+ * Wrapper around Radix ContextMenu Sub.
+ */
+declare const ContextMenuSub: React$1.FC<ContextMenuSubProps>;
+interface ContextMenuSubTriggerProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubTrigger>, "children"> {
+    children?: React$1.ReactNode;
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveContextMenuSize;
+    /**
+     * Tone variant - token-based
+     */
+    tone?: ContextMenuItemToneToken;
+    /**
+     * Gap between item content - token-based
+     */
+    gap?: ResponsiveSpace;
+}
+/**
+ * ContextMenu SubTrigger component
+ * Wrapper around Radix ContextMenu SubTrigger with token-based styling.
+ */
+declare const ContextMenuSubTrigger: React$1.ForwardRefExoticComponent<ContextMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>>;
+interface ContextMenuSubContentProps extends Omit<React$1.ComponentPropsWithoutRef<typeof ContextMenuPrimitive.SubContent>, "size" | "width" | "padding" | "radius" | "surface"> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveContextMenuSize;
+    /**
+     * Width - token-based
+     */
+    width?: ResponsiveContextMenuWidth;
+    /**
+     * Padding - token-based
+     */
+    padding?: ResponsiveSpace;
+    /**
+     * Radius - token-based
+     */
+    radius?: RadiusToken;
+    /**
+     * Surface variant - token-based
+     */
+    surface?: SurfaceToken;
+}
+/**
+ * ContextMenu SubContent component
+ * Wrapper around Radix ContextMenu SubContent with token-based styling.
+ */
+declare const ContextMenuSubContent: React$1.ForwardRefExoticComponent<ContextMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * ContextMenu Component
+ *
+ * Radix ContextMenu-based component with token-driven styling.
+ *
+ * **Usage:**
+ * ```tsx
+ * <ContextMenu.Root>
+ *   <ContextMenu.Trigger>Right-click me</ContextMenu.Trigger>
+ *   <ContextMenu.Content>
+ *     <ContextMenu.Item>Item 1</ContextMenu.Item>
+ *     <ContextMenu.Item>Item 2</ContextMenu.Item>
+ *     <ContextMenu.Separator />
+ *     <ContextMenu.Sub>
+ *       <ContextMenu.SubTrigger>Submenu</ContextMenu.SubTrigger>
+ *       <ContextMenu.SubContent>
+ *         <ContextMenu.Item>Sub Item 1</ContextMenu.Item>
+ *       </ContextMenu.SubContent>
+ *     </ContextMenu.Sub>
+ *   </ContextMenu.Content>
+ * </ContextMenu.Root>
+ * ```
+ */
+declare const ContextMenu: {
+    Root: React$1.FC<ContextMenuPrimitive.ContextMenuProps>;
+    Trigger: React$1.ForwardRefExoticComponent<ContextMenuTriggerProps & React$1.RefAttributes<HTMLSpanElement>>;
+    Content: React$1.ForwardRefExoticComponent<ContextMenuContentProps & React$1.RefAttributes<HTMLDivElement>>;
+    Item: React$1.ForwardRefExoticComponent<ContextMenuItemProps & React$1.RefAttributes<HTMLDivElement>>;
+    CheckboxItem: React$1.ForwardRefExoticComponent<ContextMenuCheckboxItemProps & React$1.RefAttributes<HTMLDivElement>>;
+    RadioGroup: React$1.ForwardRefExoticComponent<ContextMenuRadioGroupProps & React$1.RefAttributes<HTMLDivElement>>;
+    RadioItem: React$1.ForwardRefExoticComponent<ContextMenuRadioItemProps & React$1.RefAttributes<HTMLDivElement>>;
+    Separator: React$1.ForwardRefExoticComponent<ContextMenuSeparatorProps & React$1.RefAttributes<HTMLDivElement>>;
+    Label: React$1.ForwardRefExoticComponent<ContextMenuLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+    Sub: React$1.FC<ContextMenuSubProps>;
+    SubTrigger: React$1.ForwardRefExoticComponent<ContextMenuSubTriggerProps & React$1.RefAttributes<HTMLDivElement>>;
+    SubContent: React$1.ForwardRefExoticComponent<ContextMenuSubContentProps & React$1.RefAttributes<HTMLDivElement>>;
+};
+
+declare const skeletonVariants: (props?: ({
+    variant?: "card" | "text" | "circle" | "inline" | "block" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof skeletonVariants> {
+    /**
+     * Whether to hide from screen readers
+     * @default true
+     */
+    "aria-hidden"?: boolean;
+}
+/**
+ * Skeleton component for loading states
+ *
+ * @example
+ * ```tsx
+ * <Skeleton variant="text" />
+ * <Skeleton variant="circle" />
+ * <Skeleton variant="card" />
+ * ```
+ */
+declare const Skeleton: React$1.ForwardRefExoticComponent<SkeletonProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * EmptyState Component
+ *
+ * Token-driven empty state component for displaying empty or no-data states.
+ * Uses DATA_TOKENS for all spacing and sizing.
+ * Integrates with Surface and Stack components.
+ */
+
+interface EmptyStateProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Unique ID for accessibility (auto-generated if not provided)
+     */
+    id?: string;
+}
+/**
+ * EmptyState root component
+ *
+ * @example
+ * ```tsx
+ * <EmptyState>
+ *   <EmptyState.Icon>📭</EmptyState.Icon>
+ *   <EmptyState.Title>No items found</EmptyState.Title>
+ *   <EmptyState.Description>Try adjusting your filters</EmptyState.Description>
+ *   <EmptyState.Action>
+ *     <Button>Create Item</Button>
+ *   </EmptyState.Action>
+ * </EmptyState>
+ * ```
+ */
+declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * EmptyState Action Component
+ *
+ * Action subcomponent for EmptyState (typically contains Button).
+ */
+
+interface EmptyStateActionProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Action button or link (typically Button component)
+     */
+    children: React$1.ReactNode;
+}
+/**
+ * EmptyState Action component
+ */
+declare const EmptyStateAction: React$1.ForwardRefExoticComponent<EmptyStateActionProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * EmptyState Description Component
+ *
+ * Description subcomponent for EmptyState.
+ */
+
+interface EmptyStateDescriptionProps extends React$1.HTMLAttributes<HTMLParagraphElement> {
+    /**
+     * Description text
+     */
+    children: React$1.ReactNode;
+}
+/**
+ * EmptyState Description component
+ */
+declare const EmptyStateDescription: React$1.ForwardRefExoticComponent<EmptyStateDescriptionProps & React$1.RefAttributes<HTMLParagraphElement>>;
+
+/**
+ * EmptyState Icon Component
+ *
+ * Icon subcomponent for EmptyState.
+ */
+
+interface EmptyStateIconProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Icon content (any ReactNode)
+     */
+    children: React$1.ReactNode;
+    /**
+     * Icon size
+     * @default "md"
+     */
+    size?: "sm" | "md" | "lg";
+}
+/**
+ * EmptyState Icon component
+ */
+declare const EmptyStateIcon: React$1.ForwardRefExoticComponent<EmptyStateIconProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * EmptyState Title Component
+ *
+ * Title subcomponent for EmptyState.
+ */
+
+interface EmptyStateTitleProps extends React$1.HTMLAttributes<HTMLHeadingElement> {
+    /**
+     * Title text
+     */
+    children: React$1.ReactNode;
+}
+/**
+ * EmptyState Title component
+ */
+declare const EmptyStateTitle: React$1.ForwardRefExoticComponent<EmptyStateTitleProps & React$1.RefAttributes<HTMLHeadingElement>>;
+
+/**
+ * DataList Root Component
+ *
+ * Mobile-first data list component for displaying key-value pairs.
+ * Uses Stack for vertical layout and DATA_TOKENS for spacing.
+ */
+
+interface DataListRootProps extends React$1.HTMLAttributes<HTMLDListElement> {
+    /**
+     * Label width for desktop layout
+     * @default "md"
+     */
+    labelWidth?: "sm" | "md" | "lg";
+}
+/**
+ * DataList Root component
+ *
+ * @example
+ * ```tsx
+ * <DataList.Root>
+ *   <DataList.Item>
+ *     <DataList.Label>Name</DataList.Label>
+ *     <DataList.Value>John Doe</DataList.Value>
+ *   </DataList.Item>
+ * </DataList.Root>
+ * ```
+ */
+declare const DataListRoot: React$1.ForwardRefExoticComponent<DataListRootProps & React$1.RefAttributes<HTMLDListElement>>;
+
+/**
+ * DataList Component Types
+ *
+ * TypeScript interfaces and types for DataList component.
+ */
+
+/**
+ * DataList Item component props
+ */
+interface DataListItemProps$1 extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Row padding - token-based
+     * Accepts spacing tokens (xs, sm, md, lg, xl, etc.) or responsive object
+     * @default "md"
+     * @example padding="sm"
+     * @example padding={{ base: "sm", md: "lg" }}
+     */
+    padding?: ResponsiveSpacing;
+}
+
+/**
+ * DataList Item Component
+ *
+ * Individual item in DataList (contains Label and Value).
+ */
+
+interface DataListItemProps extends DataListItemProps$1 {
+}
+/**
+ * DataList Item component
+ * Mobile: vertical layout (label above value)
+ * Desktop: horizontal layout (label left, value right)
+ */
+declare const DataListItem: React$1.ForwardRefExoticComponent<DataListItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * DataList Label Component
+ *
+ * Label subcomponent for DataList items.
+ */
+
+interface DataListLabelProps extends React$1.HTMLAttributes<HTMLElement> {
+    /**
+     * Label text
+     */
+    children: React$1.ReactNode;
+}
+/**
+ * DataList Label component
+ * Mobile: full width
+ * Desktop: fixed width (from tokens)
+ */
+declare const DataListLabel: React$1.ForwardRefExoticComponent<DataListLabelProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * DataList Value Component
+ *
+ * Value subcomponent for DataList items.
+ */
+
+interface DataListValueProps extends React$1.HTMLAttributes<HTMLElement> {
+    /**
+     * Value content
+     */
+    children: React$1.ReactNode;
+}
+/**
+ * DataList Value component
+ * Flex-grow to fill remaining space on desktop
+ */
+declare const DataListValue: React$1.ForwardRefExoticComponent<DataListValueProps & React$1.RefAttributes<HTMLElement>>;
+
+/**
+ * Table Component Types
+ *
+ * TypeScript interfaces and types for Table component.
+ */
+
+/**
+ * Table column definition
+ */
+interface TableColumn<T = Record<string, unknown>> {
+    /**
+     * Column key (must match a key in the data object)
+     */
+    key: keyof T;
+    /**
+     * Column header title
+     */
+    title: string;
+    /**
+     * Custom render function for cell content
+     */
+    render?: (value: T[keyof T], item: T, index: number) => ReactNode;
+    /**
+     * Column alignment
+     * @default "left"
+     */
+    align?: "left" | "center" | "right";
+    /**
+     * Column width (CSS value or Tailwind class)
+     */
+    width?: string;
+    /**
+     * Whether column is sortable
+     * @default false
+     */
+    sortable?: boolean;
+    /**
+     * Cell size
+     * @default "md"
+     */
+    size?: "sm" | "md" | "lg";
+}
+/**
+ * Sort direction
+ */
+type SortDirection = "asc" | "desc" | null;
+/**
+ * Sort state
+ */
+interface SortState {
+    /**
+     * Column key being sorted
+     */
+    column: string | null;
+    /**
+     * Sort direction
+     */
+    direction: SortDirection;
+}
+/**
+ * Table context value
+ */
+interface TableContextValue {
+    /**
+     * Current sort state
+     */
+    sortState: SortState;
+    /**
+     * Set sort state
+     */
+    setSortState: (state: SortState) => void;
+    /**
+     * Expanded rows (for expandable rows)
+     */
+    expandedRows: Set<string | number>;
+    /**
+     * Toggle row expansion
+     */
+    toggleRow: (rowKey: string | number) => void;
+    /**
+     * Whether table has expandable rows
+     */
+    expandable?: boolean;
+    /**
+     * Render function for expandable content
+     */
+    renderExpandableContent?: (item: unknown, index: number) => ReactNode;
+}
+/**
+ * Table Root component props
+ */
+interface TableRootProps<T = Record<string, unknown>> extends React.HTMLAttributes<HTMLTableElement> {
+    /**
+     * Table data array
+     */
+    data: T[];
+    /**
+     * Column definitions
+     */
+    columns: TableColumn<T>[];
+    /**
+     * Key to use for row identification
+     */
+    rowKey: keyof T | ((item: T, index: number) => string | number);
+    /**
+     * Whether table supports sorting
+     * @default false
+     */
+    sortable?: boolean;
+    /**
+     * Whether table supports expandable rows
+     * @default false
+     */
+    expandable?: boolean;
+    /**
+     * Render function for expandable content
+     */
+    renderExpandableContent?: (item: T, index: number) => ReactNode;
+    /**
+     * Whether table is in loading state
+     * @default false
+     */
+    loading?: boolean;
+    /**
+     * Empty state message (shown when data is empty)
+     */
+    emptyMessage?: string;
+    /**
+     * Whether header is sticky
+     * @default false
+     */
+    stickyHeader?: boolean;
+    /**
+     * Row size
+     * @default "md"
+     */
+    rowSize?: "sm" | "md" | "lg";
+}
+/**
+ * Table Header component props
+ */
+interface TableHeaderProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    /**
+     * Whether header is sticky
+     * @default false
+     */
+    sticky?: boolean;
+}
+/**
+ * Table Head component props
+ */
+interface TableHeadProps extends React.HTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Column alignment
+     * @default "left"
+     */
+    align?: "left" | "center" | "right";
+    /**
+     * Whether column is sortable
+     * @default false
+     */
+    sortable?: boolean;
+    /**
+     * Column key (for sorting)
+     */
+    columnKey?: string;
+    /**
+     * Cell size
+     * @default "md"
+     */
+    size?: "sm" | "md" | "lg";
+}
+/**
+ * Table Body component props
+ */
+interface TableBodyProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+}
+/**
+ * Table Row component props
+ */
+interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /**
+     * Whether row is selected
+     * @default false
+     */
+    selected?: boolean;
+    /**
+     * Whether row is expandable
+     * @default false
+     */
+    expandable?: boolean;
+    /**
+     * Row key (for expansion tracking)
+     */
+    rowKey?: string | number;
+    /**
+     * Whether row is expanded
+     * @default false
+     */
+    expanded?: boolean;
+}
+/**
+ * Table Cell component props
+ */
+interface TableCellProps extends React.HTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Cell alignment
+     * @default "left"
+     */
+    align?: "left" | "center" | "right";
+    /**
+     * Cell size
+     * @default "md"
+     */
+    size?: "sm" | "md" | "lg";
+}
+/**
+ * Table SortIcon component props
+ */
+interface TableSortIconProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Sort direction
+     */
+    direction: SortDirection;
+}
+/**
+ * Table Empty component props
+ */
+interface TableEmptyProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /**
+     * Number of columns to span
+     */
+    colSpan: number;
+    /**
+     * Empty message
+     */
+    message?: string;
+}
+/**
+ * Table LoadingState component props
+ */
+interface TableLoadingStateProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /**
+     * Number of columns to span
+     */
+    colSpan: number;
+    /**
+     * Number of skeleton rows to show
+     * @default 5
+     */
+    rows?: number;
+}
+/**
+ * Table ExpandableContent component props
+ */
+interface TableExpandableContentProps extends React.HTMLAttributes<HTMLTableCellElement> {
+    /**
+     * Number of columns to span
+     */
+    colSpan: number;
+    /**
+     * Whether content is expanded
+     */
+    expanded: boolean;
+    /**
+     * Content to render
+     */
+    children: ReactNode;
+}
+
+declare function useTableContext(): TableContextValue;
+/**
+ * Table Root component
+ *
+ * @example
+ * ```tsx
+ * <Table.Root
+ *   data={users}
+ *   columns={columns}
+ *   rowKey="id"
+ *   sortable
+ * >
+ *   <Table.Header>
+ *     <Table.Row>
+ *       <Table.Head>Name</Table.Head>
+ *     </Table.Row>
+ *   </Table.Header>
+ *   <Table.Body>
+ *     {users.map((user) => (
+ *       <Table.Row key={user.id}>
+ *         <Table.Cell>{user.name}</Table.Cell>
+ *       </Table.Row>
+ *     ))}
+ *   </Table.Body>
+ * </Table.Root>
+ * ```
+ */
+declare function TableRoot<T extends Record<string, unknown>>({ data: _data, columns: _columns, rowKey: _rowKey, sortable: _sortable, expandable, renderExpandableContent, loading: _loading, emptyMessage: _emptyMessage, stickyHeader: _stickyHeader, rowSize: _rowSize, className, children, ...props }: TableRootProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace TableRoot {
+    var displayName: string;
+}
+
+/**
+ * Table Body Component
+ *
+ * Body section for table (tbody element).
+ */
+
+/**
+ * Table Body component
+ */
+declare const TableBody: React$1.ForwardRefExoticComponent<TableBodyProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+
+/**
+ * Table Cell Component
+ *
+ * Table cell component with alignment and size support.
+ */
+
+/**
+ * Table Cell component
+ */
+declare const TableCell: React$1.ForwardRefExoticComponent<TableCellProps & React$1.RefAttributes<HTMLTableCellElement>>;
+
+/**
+ * Table Empty Component
+ *
+ * Empty state row for table (uses EmptyState component).
+ */
+
+/**
+ * Table Empty component
+ */
+declare const TableEmpty: React$1.ForwardRefExoticComponent<TableEmptyProps & React$1.RefAttributes<HTMLTableRowElement>>;
+
+/**
+ * Table ExpandableContent Component
+ *
+ * Expandable content cell with CSS height transitions.
+ */
+
+/**
+ * Table ExpandableContent component
+ * Uses CSS height transitions (no framer-motion)
+ */
+declare const TableExpandableContent: React$1.ForwardRefExoticComponent<TableExpandableContentProps & React$1.RefAttributes<HTMLTableCellElement>>;
+
+/**
+ * Table Head Component
+ *
+ * Header cell component with sorting support.
+ */
+
+/**
+ * Table Head component
+ */
+declare const TableHead: React$1.ForwardRefExoticComponent<TableHeadProps & React$1.RefAttributes<HTMLTableCellElement>>;
+
+/**
+ * Table Header Component
+ *
+ * Header section for table (thead element).
+ */
+
+/**
+ * Table Header component
+ */
+declare const TableHeader: React$1.ForwardRefExoticComponent<TableHeaderProps & React$1.RefAttributes<HTMLTableSectionElement>>;
+
+/**
+ * Table LoadingState Component
+ *
+ * Loading state row for table (uses Skeleton component).
+ */
+
+/**
+ * Table LoadingState component
+ */
+declare const TableLoadingState: React$1.ForwardRefExoticComponent<TableLoadingStateProps & React$1.RefAttributes<HTMLTableRowElement>>;
+
+/**
+ * Table Row Component
+ *
+ * Table row component with hover and selected states.
+ */
+
+/**
+ * Table Row component
+ */
+declare const TableRow: React$1.ForwardRefExoticComponent<TableRowProps & React$1.RefAttributes<HTMLTableRowElement>>;
+
+/**
+ * Table SortIcon Component
+ *
+ * Sort indicator icon with rotation animation.
+ */
+
+/**
+ * Table SortIcon component
+ * Uses CSS rotation animation (no framer-motion)
+ */
+declare const TableSortIcon: React$1.ForwardRefExoticComponent<TableSortIconProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+/**
+ * Tabs Component
+ *
+ * Radix-based tabs component with token-driven styling.
+ * All behavior (keyboard navigation, focus management, a11y) is handled by Radix.
+ * Tenerife UI provides visual styling through tokens only.
+ */
+
+interface TabsRootProps extends React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Root> {
+}
+interface TabsListProps extends Omit<React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.List>, "size" | "variant"> {
+    /**
+     * Size variant - token-based
+     */
+    size?: ResponsiveTabsSize;
+    /**
+     * Visual variant - token-based
+     */
+    variant?: TabsVariantToken;
+}
+interface TabsTriggerProps extends Omit<React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Trigger>, "size" | "variant" | "tone"> {
+    /**
+     * Size variant - token-based (inherited from context if not provided)
+     */
+    size?: ResponsiveTabsSize;
+    /**
+     * Visual variant - token-based (inherited from context if not provided)
+     */
+    variant?: TabsVariantToken;
+    /**
+     * Tone - token-based (inherited from context if not provided)
+     */
+    tone?: TabsToneToken;
+    /**
+     * Leading icon - semantic prop
+     */
+    leadingIcon?: React$1.ReactNode;
+    /**
+     * Trailing icon - semantic prop
+     */
+    trailingIcon?: React$1.ReactNode;
+    /**
+     * Icon - semantic prop (for backward compatibility, maps to leadingIcon)
+     */
+    icon?: React$1.ReactNode;
+}
+interface TabsContentProps extends Omit<React$1.ComponentPropsWithoutRef<typeof TabsPrimitive.Content>, "size"> {
+    /**
+     * Size variant - token-based (for padding)
+     */
+    size?: ResponsiveTabsSize;
+}
+declare const Tabs: {
+    Root: React$1.FC<TabsRootProps>;
+    List: React$1.ForwardRefExoticComponent<TabsListProps & React$1.RefAttributes<HTMLDivElement>>;
+    Trigger: React$1.ForwardRefExoticComponent<TabsTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Content: React$1.ForwardRefExoticComponent<TabsContentProps & React$1.RefAttributes<HTMLDivElement>>;
+};
+
+declare const segmentedControlRootVariants: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    size?: "sm" | "md" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const segmentedControlItemVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | null | undefined;
+    state?: "default" | "selected" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SegmentedControlRootProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "role">, VariantProps<typeof segmentedControlRootVariants> {
+    /**
+     * Controlled value
+     */
+    value?: string;
+    /**
+     * Default value for uncontrolled usage
+     */
+    defaultValue?: string;
+    /**
+     * Callback when value changes
+     */
+    onValueChange?: (value: string) => void;
+    /**
+     * Name for the radio group
+     */
+    name?: string;
+}
+interface SegmentedControlItemProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "role">, VariantProps<typeof segmentedControlItemVariants> {
+    /**
+     * Value of this item
+     */
+    value: string;
+    /**
+     * Whether this item is disabled
+     */
+    disabled?: boolean;
+}
+declare const SegmentedControl: React$1.ForwardRefExoticComponent<SegmentedControlRootProps & React$1.RefAttributes<HTMLDivElement>> & {
+    Root: React$1.ForwardRefExoticComponent<SegmentedControlRootProps & React$1.RefAttributes<HTMLDivElement>>;
+    Item: React$1.ForwardRefExoticComponent<SegmentedControlItemProps & React$1.RefAttributes<HTMLButtonElement>>;
+};
+
+interface BreadcrumbItem {
+    /**
+     * Label text for the breadcrumb item
+     */
+    label: string;
+    /**
+     * Optional href for clickable items
+     */
+    href?: string;
+    /**
+     * Whether this item is disabled
+     */
+    disabled?: boolean;
+}
+interface BreadcrumbsRootProps extends React$1.HTMLAttributes<HTMLElement> {
+    /**
+     * Array of breadcrumb items
+     */
+    items: BreadcrumbItem[];
+    /**
+     * Custom separator component or string
+     * @default ChevronRight icon
+     */
+    separator?: React$1.ReactNode;
+    /**
+     * ARIA label for the navigation element
+     * @default "Breadcrumb"
+     */
+    ariaLabel?: string;
+}
+interface BreadcrumbsItemProps extends React$1.HTMLAttributes<HTMLLIElement> {
+    /**
+     * Whether this is the last item (current page)
+     */
+    isLast?: boolean;
+    /**
+     * Whether this item is disabled
+     */
+    disabled?: boolean;
+}
+interface BreadcrumbsSeparatorProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Custom separator content
+     */
+    children?: React$1.ReactNode;
+}
+declare const Breadcrumbs: React$1.ForwardRefExoticComponent<BreadcrumbsRootProps & React$1.RefAttributes<HTMLElement>> & {
+    Root: React$1.ForwardRefExoticComponent<BreadcrumbsRootProps & React$1.RefAttributes<HTMLElement>>;
+    Item: React$1.ForwardRefExoticComponent<BreadcrumbsItemProps & React$1.RefAttributes<HTMLLIElement>>;
+    Separator: React$1.ForwardRefExoticComponent<BreadcrumbsSeparatorProps & React$1.RefAttributes<HTMLSpanElement>>;
+};
+
+interface PaginationRootProps extends React$1.HTMLAttributes<HTMLElement> {
+    /**
+     * Current active page (1-indexed)
+     */
+    currentPage: number;
+    /**
+     * Total number of pages
+     */
+    totalPages: number;
+    /**
+     * Callback when page changes
+     */
+    onPageChange: (page: number) => void;
+    /**
+     * Number of pages to show on each side of current page
+     * @default 2
+     */
+    delta?: number;
+    /**
+     * ARIA label for the navigation element
+     * @default "Pagination"
+     */
+    ariaLabel?: string;
+}
+interface PaginationItemProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Page number (or "..." for ellipsis)
+     */
+    page: number | "...";
+    /**
+     * Whether this is the current page
+     */
+    isCurrent?: boolean;
+    /**
+     * Whether this item is disabled
+     */
+    disabled?: boolean;
+}
+interface PaginationPrevProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Whether previous button is disabled
+     */
+    disabled?: boolean;
+}
+interface PaginationNextProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Whether next button is disabled
+     */
+    disabled?: boolean;
+}
+interface PaginationEllipsisProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+}
+declare const Pagination: React$1.ForwardRefExoticComponent<PaginationRootProps & React$1.RefAttributes<HTMLElement>> & {
+    Root: React$1.ForwardRefExoticComponent<PaginationRootProps & React$1.RefAttributes<HTMLElement>>;
+    Item: React$1.ForwardRefExoticComponent<PaginationItemProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Prev: React$1.ForwardRefExoticComponent<PaginationPrevProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Next: React$1.ForwardRefExoticComponent<PaginationNextProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Ellipsis: React$1.ForwardRefExoticComponent<PaginationEllipsisProps & React$1.RefAttributes<HTMLSpanElement>>;
+};
+
+interface StepperStep {
+    /**
+     * Unique identifier for the step
+     */
+    id: string;
+    /**
+     * Label text for the step
+     */
+    label: string;
+    /**
+     * Optional description for the step
+     */
+    description?: string;
+    /**
+     * Optional icon for the step indicator
+     */
+    icon?: React$1.ReactNode;
+    /**
+     * Whether this step is disabled
+     */
+    disabled?: boolean;
+}
+interface StepperRootProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Array of steps
+     */
+    steps: StepperStep[];
+    /**
+     * Current active step index (0-indexed)
+     */
+    activeStep: number;
+    /**
+     * Orientation of the stepper
+     * @default "horizontal"
+     */
+    orientation?: "horizontal" | "vertical";
+    /**
+     * Whether to show step numbers
+     * @default true
+     */
+    showNumbers?: boolean;
+}
+interface StepperItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Step data
+     */
+    step: StepperStep;
+    /**
+     * Step index (0-indexed)
+     */
+    index: number;
+    /**
+     * Whether this is the active step
+     */
+    isActive: boolean;
+    /**
+     * Whether this step is completed
+     */
+    isCompleted: boolean;
+    /**
+     * Whether to show step number
+     */
+    showNumber?: boolean;
+}
+interface StepperIndicatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Step index
+     */
+    index: number;
+    /**
+     * Whether this is the active step
+     */
+    isActive: boolean;
+    /**
+     * Whether this step is completed
+     */
+    isCompleted: boolean;
+    /**
+     * Whether this step is disabled
+     */
+    disabled?: boolean;
+    /**
+     * Custom icon
+     */
+    icon?: React$1.ReactNode;
+    /**
+     * Whether to show step number
+     */
+    showNumber?: boolean;
+}
+interface StepperLabelProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Step label text
+     */
+    label: string;
+    /**
+     * Optional description
+     */
+    description?: string;
+    /**
+     * Whether this is the active step
+     */
+    isActive: boolean;
+}
+interface StepperContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Step index this content belongs to
+     */
+    stepIndex: number;
+    /**
+     * Whether this content should be visible
+     */
+    isActive: boolean;
+}
+/**
+ * Stepper.Item - Individual step container
+ */
+interface StepperItemPropsInternal extends StepperItemProps {
+    orientation?: "horizontal" | "vertical";
+}
+declare const Stepper: React$1.ForwardRefExoticComponent<StepperRootProps & React$1.RefAttributes<HTMLDivElement>> & {
+    Root: React$1.ForwardRefExoticComponent<StepperRootProps & React$1.RefAttributes<HTMLDivElement>>;
+    Item: React$1.ForwardRefExoticComponent<StepperItemPropsInternal & React$1.RefAttributes<HTMLDivElement>>;
+    Indicator: React$1.ForwardRefExoticComponent<StepperIndicatorProps & React$1.RefAttributes<HTMLDivElement>>;
+    Label: React$1.ForwardRefExoticComponent<StepperLabelProps & React$1.RefAttributes<HTMLDivElement>>;
+    Content: React$1.ForwardRefExoticComponent<StepperContentProps & React$1.RefAttributes<HTMLDivElement>>;
+};
+
+/**
+ * Icon Props Interface
+ *
+ * Shared props interface for all icon components.
+ * Ensures consistent API across all icons in the registry.
+ */
+
+/**
+ * Base props for all icon components
+ */
+interface IconProps$1 extends React$1.SVGProps<SVGSVGElement> {
+    /**
+     * Additional CSS classes
+     */
+    className?: string;
+    /**
+     * Hide icon from screen readers
+     * @default true
+     */
+    "aria-hidden"?: boolean;
+    /**
+     * Accessible label for the icon
+     */
+    "aria-label"?: string;
+}
+
+/**
+ * Arrow right icon component
+ */
+declare const IconArrowRight: React$1.FC<IconProps$1>;
+
+/**
+ * Calendar icon component
+ */
+declare const IconCalendar: React$1.FC<IconProps$1>;
+
+/**
+ * Check icon component (checkmark)
+ */
+declare const IconCheck: React$1.FC<IconProps$1>;
+
+/**
+ * Chevron down icon component
+ */
+declare const IconChevronDown: React$1.FC<IconProps$1>;
+
+/**
+ * Chevron right icon component
+ */
+declare const IconChevronRight: React$1.FC<IconProps$1>;
+
+/**
+ * Close icon component (X)
+ */
+declare const IconClose: React$1.FC<IconProps$1>;
+
+/**
+ * Error icon component (X in circle - used as fallback)
+ */
+declare const IconError: React$1.FC<IconProps$1>;
+
+/**
+ * Info icon component (information circle)
+ */
+declare const IconInfo: React$1.FC<IconProps$1>;
+
+/**
+ * Location icon component
+ */
+declare const IconLocation: React$1.FC<IconProps$1>;
+
+/**
+ * Menu icon component (hamburger menu)
+ */
+declare const IconMenu: React$1.FC<IconProps$1>;
+
+/**
+ * Search icon component
+ */
+declare const IconSearch: React$1.FC<IconProps$1>;
+
+/**
+ * Success icon component (checkmark in circle)
+ */
+declare const IconSuccess: React$1.FC<IconProps$1>;
+
+/**
+ * Warning icon component (warning triangle)
+ */
+declare const IconWarning: React$1.FC<IconProps$1>;
+
+/**
+ * Icon Registry
+ *
+ * Central registry for all icon components.
+ * Supports tree-shaking through individual named exports.
+ */
+
+/**
+ * Icons map for registry lookup
+ * Used by Icon component to resolve icon by name
+ */
+declare const ICONS_MAP: Record<string, React$1.FC<IconProps$1>>;
+/**
+ * Icon name type - union of all available icon names
+ */
+type IconName = keyof typeof ICONS_MAP;
+
+declare const iconVariants: (props?: ({
+    size?: "sm" | "md" | "lg" | "xl" | null | undefined;
+    color?: "muted" | "default" | "success" | "warning" | "danger" | "info" | null | undefined;
+    stroke?: "normal" | "bold" | "thin" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface IconProps extends Omit<React$1.SVGProps<SVGSVGElement>, "color" | "stroke">, VariantProps<typeof iconVariants> {
+    /**
+     * Icon name from registry
+     */
+    name: IconName;
+    /**
+     * Render as child element (composition pattern)
+     * Uses Radix UI Slot for composition
+     */
+    asChild?: boolean;
+}
+/**
+ * Icon component
+ *
+ * Unified icon component with token-driven sizing, colors, and stroke.
+ * Supports SSR-safe rendering and tree-shakeable icon registry.
+ *
+ * @example
+ * ```tsx
+ * <Icon name="search" size="md" color="default" />
+ * ```
+ */
+declare const Icon: React$1.ForwardRefExoticComponent<Omit<IconProps, "ref"> & React$1.RefAttributes<SVGSVGElement>>;
+
+/**
+ * Tenerife Animation System Types
+ *
+ * Type definitions for TAS animation system
+ */
+
+/**
+ * Animation props for layout primitives
+ * Returns CSS class names for Motion Tokens V2 animations
+ */
+interface AnimationProps {
+    /**
+     * CSS class name for the animation
+     * Maps to tm-motion-* utility classes
+     */
+    className?: string;
+}
+/**
+ * Component animation configuration
+ * Allows components to accept animation presets as props
+ */
+interface ComponentAnimationConfig {
+    /**
+     * Animation preset for initial mount/entrance - token-based
+     * Uses predefined animation preset tokens
+     */
+    animation?: ResponsiveAnimationPreset | string;
+    /**
+     * Animation preset for hover state
+     * Can be a preset name string or CSS class name
+     */
+    hoverAnimation?: "hoverLift" | "hoverScale" | "tapScale" | string;
+    /**
+     * Custom animation class name (overrides preset names)
+     */
+    animationProps?: AnimationProps;
+}
+
+/**
+ * ArtistCard Size Variant
+ */
+type ArtistCardSize = "default" | "compact";
+/**
+ * ArtistCard Style Variant
+ */
+type ArtistCardVariant = "default" | "featured";
+/**
+ * Props for ArtistCard component.
+ * All props are flat and domain-agnostic. Consumer should provide pre-localized strings.
+ */
+interface ArtistCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Artist name (pre-localized string, required) */
+    name: string;
+    /** Artist description (pre-localized string, optional) */
+    description?: string;
+    /** Genres as comma-separated string (e.g., "Jazz, Blues, Rock", optional) */
+    genres?: string;
+    /** Follower count for popularity metric (optional) */
+    followers?: number;
+    /** Plays/listens count for popularity metric (optional) */
+    plays?: number;
+    /** Image URL (optional) */
+    imageUrl?: string;
+    /** Link URL for artist details page (optional) */
+    href?: string;
+    /** Whether this is a featured artist */
+    featured?: boolean;
+    /** Show image section */
+    showImage?: boolean;
+    /** Badge text for featured artists (optional) */
+    popularBadgeText?: string;
+    /** Label for followers count (required) */
+    followersLabel: string;
+    /** Label for plays count (required) */
+    playsLabel: string;
+    /** Size variant - controls padding and gap */
+    size?: ArtistCardSize;
+    /** Style variant - controls visual appearance */
+    variant?: ArtistCardVariant;
+    /** Animation configuration for entrance and hover animations */
+    animation?: ComponentAnimationConfig;
+}
+
+/**
+ * ArtistCard Component
+ *
+ * Domain-specific card component for displaying artist information.
+ * Uses CardBase for layout and DOMAIN_TOKENS for all styling.
+ * Supports size variants (default, compact) and style variants (default, featured).
+ *
+ * @example
+ * ```tsx
+ * <ArtistCard
+ *   name="Artist Name"
+ *   genres="Jazz, Blues"
+ *   followers={1200}
+ *   plays={50000}
+ *   followersLabel="followers"
+ *   playsLabel="plays"
+ * />
+ * ```
+ */
+declare const ArtistCard: React$1.ForwardRefExoticComponent<ArtistCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * EventCard Size Variant
+ */
+type EventCardSize = "default" | "compact";
+/**
+ * EventCard Style Variant
+ */
+type EventCardVariant = "default" | "featured";
+/**
+ * Props for EventCard component.
+ * All props are flat and domain-agnostic. Consumer should provide pre-localized strings.
+ */
+interface EventCardProps {
+    /** Event title (pre-localized string) */
+    title: string;
+    /** Event description (pre-localized string, optional) */
+    description?: string;
+    /** Event date/time display string (pre-formatted, optional) */
+    date?: string;
+    /** Venue name (pre-localized string, optional) */
+    venueName?: string;
+    /** Price display string with currency (e.g., "€20 - €50", optional) */
+    price?: string;
+    /** Image URL (optional) */
+    imageUrl?: string;
+    /** Link URL for event details page (optional) */
+    href?: string;
+    /** External ticket purchase URL (optional) */
+    ticketUrl?: string;
+    /** Whether this is a featured event */
+    featured?: boolean;
+    /** Show image section */
+    showImage?: boolean;
+    /** Label for "Get Tickets" button (required) */
+    getTicketsLabel: string;
+    /** Badge text for featured events (optional) */
+    featuredBadgeText?: string;
+    /** Size variant - controls padding and spacing */
+    size?: EventCardSize;
+    /** Style variant - controls visual appearance */
+    variant?: EventCardVariant;
+    /** Additional CSS classes */
+    className?: string;
+    /** Animation configuration for entrance and hover animations */
+    animation?: ComponentAnimationConfig;
+}
+
+/**
+ * EventCard Component
+ *
+ * Domain-specific card component for displaying event information.
+ * Uses CardBase for layout and DOMAIN_TOKENS for all styling.
+ *
+ * @example
+ * ```tsx
+ * <EventCard
+ *   title="Concert"
+ *   date="2024-01-01"
+ *   venueName="Venue"
+ *   getTicketsLabel="Get Tickets"
+ * />
+ * ```
+ */
+declare const EventCard: React$1.ForwardRefExoticComponent<EventCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * PromoCard Size Variant
+ */
+type PromoCardSize = "default" | "compact";
+/**
+ * PromoCard Style Variant
+ */
+type PromoCardVariant = "default" | "featured";
+/**
+ * Props for PromoCard component.
+ * All props are flat and domain-agnostic. Consumer should provide pre-localized strings.
+ */
+interface PromoCardProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Promo title (pre-localized string, required) */
+    title: string;
+    /** Promo description (pre-localized string, optional) */
+    description?: string;
+    /** Image URL (optional) */
+    imageUrl?: string;
+    /** Link URL for promo details page (optional) */
+    href?: string;
+    /** CTA button URL (optional) */
+    ctaUrl?: string;
+    /** Label for CTA button (required) */
+    ctaLabel: string;
+    /** Whether this is a featured promo */
+    featured?: boolean;
+    /** Badge text for featured promos (optional) */
+    featuredBadgeText?: string;
+    /** Show image section */
+    showImage?: boolean;
+    /** Size variant - controls padding and spacing */
+    size?: PromoCardSize;
+    /** Style variant - controls visual appearance */
+    variant?: PromoCardVariant;
+    /** Additional CSS classes */
+    className?: string;
+    /** Animation configuration for entrance and hover animations */
+    animation?: ComponentAnimationConfig;
+}
+
+/**
+ * PromoCard Component
+ *
+ * Domain-specific card component for displaying promotional content.
+ * Uses CardBase for layout and DOMAIN_TOKENS for all styling.
+ * CTA button uses BUTTON_TOKENS for styling.
+ *
+ * @example
+ * ```tsx
+ * <PromoCard
+ *   title="Special Offer"
+ *   description="Get 20% off on all tickets"
+ *   ctaLabel="Learn More"
+ *   ctaUrl="/promo"
+ * />
+ * ```
+ */
+declare const PromoCard: React$1.ForwardRefExoticComponent<PromoCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+/**
+ * TicketCard Size Variant
+ */
+type TicketCardSize = "default" | "compact";
+/**
+ * TicketCard Style Variant
+ */
+type TicketCardVariant = "default" | "featured";
+/**
+ * Ticket Availability Status
+ */
+type TicketAvailability = "available" | "sold_out" | "available_soon";
+/**
+ * Props for TicketCard component.
+ * All props are flat and domain-agnostic. Consumer should provide pre-localized strings.
+ */
+interface TicketCardProps {
+    /** Ticket type/name (pre-localized string) */
+    title: string;
+    /** Ticket description (pre-localized string, optional) */
+    description?: string;
+    /** Price display string with currency (e.g., "€20", optional) */
+    price?: string;
+    /** Capacity display string (e.g., "50 tickets", optional) */
+    capacity?: string;
+    /** Availability status */
+    availability?: TicketAvailability;
+    /** Image URL (optional) */
+    imageUrl?: string;
+    /** Link URL for ticket details (optional) */
+    href?: string;
+    /** Purchase action URL (optional) */
+    purchaseUrl?: string;
+    /** Label for purchase button (required) */
+    purchaseLabel: string;
+    /** VIP badge text (optional) */
+    vipBadgeText?: string;
+    /** Discount badge text (optional) */
+    discountBadgeText?: string;
+    /** Whether this is a featured ticket */
+    featured?: boolean;
+    /** Badge text for featured tickets (optional) */
+    featuredBadgeText?: string;
+    /** Show image section */
+    showImage?: boolean;
+    /** Size variant - controls padding and spacing */
+    size?: TicketCardSize;
+    /** Style variant - controls visual appearance */
+    variant?: TicketCardVariant;
+    /** Additional CSS classes */
+    className?: string;
+    /** Animation configuration for entrance and hover animations */
+    animation?: ComponentAnimationConfig;
+}
+
+/**
+ * TicketCard Component
+ *
+ * Domain-specific card component for displaying ticket information.
+ * Uses CardBase for layout and DOMAIN_TOKENS for all styling.
+ *
+ * @example
+ * ```tsx
+ * <TicketCard
+ *   title="VIP Ticket"
+ *   price="€50"
+ *   capacity="10 tickets left"
+ *   purchaseLabel="Buy Now"
+ * />
+ * ```
+ */
+declare const TicketCard: React$1.ForwardRefExoticComponent<TicketCardProps & React$1.RefAttributes<HTMLDivElement>>;
+
+export { Alert, type AlertProps, ArtistCard, type ArtistCardProps, type ArtistCardSize, type ArtistCardVariant, Backdrop, type BackdropProps, Body, type BodyProps, Box, type BoxProps, type BreadcrumbItem, Breadcrumbs, type BreadcrumbsItemProps, type BreadcrumbsRootProps, type BreadcrumbsSeparatorProps, Button, type ButtonProps, Caption, type CaptionProps, Card, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, type CardProps, Checkbox, type CheckboxProps, Code, type CodeProps, Column, type StackProps as ColumnProps, Container, type ContainerProps, Surface as ContainerSurface, type SurfaceProps as ContainerSurfaceProps, ContextMenu, ContextMenuCheckboxItem, type ContextMenuCheckboxItemProps, ContextMenuContent, type ContextMenuContentProps, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, type ContextMenuLabelProps, ContextMenuRadioGroup, type ContextMenuRadioGroupProps, ContextMenuRadioItem, type ContextMenuRadioItemProps, ContextMenuRoot, type ContextMenuRootProps, ContextMenuSeparator, type ContextMenuSeparatorProps, ContextMenuSub, ContextMenuSubContent, type ContextMenuSubContentProps, type ContextMenuSubProps, ContextMenuSubTrigger, type ContextMenuSubTriggerProps, ContextMenuTrigger, type ContextMenuTriggerProps, DataListRoot as DataList, DataListItem, type DataListItemProps, DataListLabel, type DataListLabelProps, DataListRoot, type DataListRootProps, DataListValue, type DataListValueProps, Dialog, DialogBody, type DialogBodyProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, type DialogProps, DialogRoot, DialogTitle, type DialogTitleProps, Display, type DisplayProps, DropdownMenuCheckItem, type DropdownMenuCheckItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuGroup, type DropdownMenuGroupProps, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuRadioGroup, type DropdownMenuRadioGroupProps, DropdownMenuRadioItem, type DropdownMenuRadioItemProps, DropdownMenuRoot, type DropdownMenuRootProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuSub, DropdownMenuSubContent, type DropdownMenuSubContentProps, type DropdownMenuSubProps, DropdownMenuSubTrigger, type DropdownMenuSubTriggerProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, EmptyState, EmptyStateAction, type EmptyStateActionProps, EmptyStateDescription, type EmptyStateDescriptionProps, EmptyStateIcon, type EmptyStateIconProps, type EmptyStateProps, EmptyStateTitle, type EmptyStateTitleProps, EventCard, type EventCardProps, type EventCardSize, type EventCardVariant, FieldRoot as Field, type FieldControlProps, type FieldDescriptionProps, type FieldErrorProps, type FieldLabelProps, type FieldProps, Flex, type FlexProps, Grid, type GridProps, type GroupByFunction, Heading, type HeadingProps, HoverCardContent, type HoverCardContentProps, HoverCardRoot, type HoverCardRootProps, HoverCardTrigger, type HoverCardTriggerProps, ICONS_MAP, Icon, IconArrowRight, IconCalendar, IconCheck, IconChevronDown, IconChevronRight, IconClose, type IconProps$1 as IconComponentProps, IconError, IconInfo, IconLocation, IconMenu, type IconName, type IconProps, IconSearch, IconSuccess, IconWarning, Input, type InputProps, Label, type LabelProps, Lead, type LeadProps, Modal, ModalClose, type ModalCloseProps, ModalContent, type ModalContentProps, ModalDescription, type ModalDescriptionProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, ModalOverlay, type ModalOverlayProps, ModalRoot, type ModalRootProps, ModalTitle, type ModalTitleProps, ModalTrigger, type ModalTriggerProps, NotificationCenter, NotificationCenterDismissAll, type NotificationCenterDismissAllProps, NotificationCenterGroupHeader, type NotificationCenterGroupHeaderProps, NotificationCenterItem, type NotificationCenterItemProps, NotificationCenterList, type NotificationCenterListProps, NotificationCenterPanel, type NotificationCenterPanelProps, NotificationCenterProvider, type NotificationCenterProviderProps, NotificationCenterTrigger, type NotificationCenterTriggerProps, type NotificationChannel, type NotificationContextType, type NotificationData, type NotificationOptions, type NotificationVariant, Pagination, type PaginationEllipsisProps, type PaginationItemProps, type PaginationNextProps, type PaginationPrevProps, type PaginationRootProps, PopoverArrow, type PopoverArrowProps, PopoverContent, type PopoverContentProps, PopoverRoot, type PopoverRootProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, PromoCard, type PromoCardProps, type PromoCardSize, type PromoCardVariant, Radio, RadioGroup, type RadioGroupProps, type RadioProps, Responsive, Row, type RowProps, Section, type SectionProps, SegmentedControl, type SegmentedControlItemProps, type SegmentedControlRootProps, Select, SelectContent, type SelectContentProps, SelectGroup, type SelectGroupProps, SelectIcon, type SelectIconProps, SelectItem, SelectItemIndicator, type SelectItemIndicatorProps, type SelectItemProps, SelectItemText, type SelectItemTextProps, SelectLabel, type SelectLabelProps, SelectRoot, type SelectRootProps, SelectSeparator, type SelectSeparatorProps, type SelectSize, type SelectState, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, type SelectVariant, SelectViewport, type SelectViewportProps, type SelectWidth, Skeleton, type SkeletonProps, type SortDirection, type SortState, Stack, type StackProps, Stepper, type StepperContentProps, type StepperIndicatorProps, type StepperItemProps, type StepperLabelProps, type StepperRootProps, type StepperStep, Surface$1 as Surface, type SurfaceProps$1 as SurfaceProps, TableRoot as Table, TableBody, type TableBodyProps, TableCell, type TableCellProps, type TableColumn, type TableContextValue, TableEmpty, type TableEmptyProps, TableExpandableContent, type TableExpandableContentProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, TableLoadingState, type TableLoadingStateProps, TableRoot, type TableRootProps, TableRow, type TableRowProps, TableSortIcon, type TableSortIconProps, Tabs, type TabsContentProps, type TabsListProps, type TabsRootProps, type TabsTriggerProps, Text, type TextProps, type TextSize, type TextWeight, Textarea, type TextareaProps, type TicketAvailability, TicketCard, type TicketCardProps, type TicketCardSize, type TicketCardVariant, Toast, ToastAction, type ToastData, type ToastOptions, type ToastPosition, type ToastProps, ToastProvider, type ToastProviderProps, ToastViewport, type ToastViewportProps, alertVariants, bodyVariants, buttonVariants, captionVariants, checkboxVariants, codeVariants, surfaceVariants as containerSurfaceVariants, displayVariants, headingVariants, iconVariants, inputVariants, labelVariants, leadVariants, popoverContentVariants, radioVariants, segmentedControlItemVariants, segmentedControlRootVariants, skeletonVariants, surfaceVariants$1 as surfaceVariants, textVariants, textareaVariants, useNotificationCenter, useNotificationCenterContext, useTableContext, useToast };