@chellaa/react 0.2.1 → 0.2.2

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 import React__default, { CSSProperties } from 'react';
 import * as _emotion_styled from '@emotion/styled';
+import { FloatingContext, ExtendedRefs, MiddlewareData } from '@floating-ui/react';
 
 type ColorMode = "light" | "dark";
 interface PaletteColor {
@@ -1033,6 +1034,10 @@ interface InputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "
      * Ref forwarded directly to the native <input> element
      */
     inputRef?: React.Ref<HTMLInputElement>;
+    /**
+     * Slotted child element when asChild is true
+     */
+    children?: React.ReactNode;
 }
 
 /**
@@ -1154,6 +1159,10 @@ interface TextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaEl
      * Additional HTML attributes forwarded to the native HTMLTextAreaElement.
      */
     textareaProps?: React.TextareaHTMLAttributes<HTMLTextAreaElement> | undefined;
+    /**
+     * Slotted child element when asChild is true
+     */
+    children?: React.ReactNode;
 }
 
 /**
@@ -1166,9 +1175,13 @@ interface FormFieldProps extends React.HTMLAttributes<HTMLDivElement> {
     id?: string | undefined;
     name?: string | undefined;
     required?: boolean | undefined;
+    isRequired?: boolean | undefined;
     disabled?: boolean | undefined;
+    isDisabled?: boolean | undefined;
     readOnly?: boolean | undefined;
+    isReadOnly?: boolean | undefined;
     error?: boolean | undefined;
+    isInvalid?: boolean | undefined;
     fullWidth?: boolean | undefined;
     asChild?: boolean | undefined;
     component?: React.ElementType | undefined;
@@ -1875,6 +1888,7 @@ interface PaperProps extends React.HTMLAttributes<HTMLElement>, PaperOwnerState
     sx?: SxProps;
     children?: React.ReactNode;
 }
+
 /**
  * Material Paper elevation surface container with 24-level elevation shadows,
  * dark-mode surface elevation overlays, and outlined variants.
@@ -1886,7 +1900,7 @@ interface PaperProps extends React.HTMLAttributes<HTMLElement>, PaperOwnerState
  */
 declare const Paper: React.ForwardRefExoticComponent<PaperProps & React.RefAttributes<HTMLElement>>;
 
-type CardVariant = "elevated" | "outlined" | "filled";
+type CardVariant = "elevated" | "outlined" | "filled" | "outline";
 type CardSize = "sm" | "md" | "lg";
 interface CardOwnerState {
     variant: CardVariant;
@@ -1895,6 +1909,16 @@ interface CardOwnerState {
     hoverable: boolean;
     square: boolean;
 }
+interface CardTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean;
+    sx?: SxProps;
+}
+interface CardDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean;
+    sx?: SxProps;
+}
 interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
     /**
      * Visual surface treatment of the card.
@@ -1912,10 +1936,15 @@ interface CardProps extends React.HTMLAttributes<HTMLDivElement> {
      */
     size?: CardSize;
     /**
-     * When true, raises elevation by 2 stops and lifts the card 2px on hover.
+     * When true, raises elevation and lifts the card on hover.
      * @default false
      */
     hoverable?: boolean;
+    /**
+     * When true, changes cursor to pointer and enables interactive hover lift.
+     * @default false
+     */
+    isClickable?: boolean;
     /**
      * If true, removes the card's border-radius.
      * @default false
@@ -1987,6 +2016,11 @@ interface CardActionsProps extends React.HTMLAttributes<HTMLDivElement> {
      * @default false
      */
     disableSpacing?: boolean;
+    /**
+     * Horizontal alignment of action triggers.
+     * @default "start"
+     */
+    align?: "start" | "center" | "end" | "between";
     sx?: SxProps;
 }
 
@@ -2005,7 +2039,7 @@ interface CardActionsProps extends React.HTMLAttributes<HTMLDivElement> {
  *   </CardActions>
  * </Card>
  */
-declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+declare const CardRoot: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
 /**
  * Header zone of a Card. Supports avatar, title, subheader, and trailing action slots.
  * Automatically inherits `size` from the parent Card via CardContext.
@@ -2033,6 +2067,26 @@ declare const CardFooter: React.ForwardRefExoticComponent<CardFooterProps & Reac
  * flush to the card's padding box. Use `disableSpacing` to remove this.
  */
 declare const CardActions: React.ForwardRefExoticComponent<CardActionsProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Semantic heading component for a Card, typically rendered inside CardHeader.
+ * Supports `asChild` for slot delegation to custom heading levels.
+ */
+declare const CardTitle: React.ForwardRefExoticComponent<CardTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+/**
+ * Supporting subtext or subtitle paragraph for a Card.
+ * Supports `asChild` for slot delegation.
+ */
+declare const CardDescription: React.ForwardRefExoticComponent<CardDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+declare const Card: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>> & {
+    Root: React.ForwardRefExoticComponent<CardProps & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<CardHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<CardTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<CardDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+    Body: React.ForwardRefExoticComponent<CardBodyProps & React.RefAttributes<HTMLDivElement>>;
+    Footer: React.ForwardRefExoticComponent<CardFooterProps & React.RefAttributes<HTMLDivElement>>;
+    Media: React.ForwardRefExoticComponent<CardMediaProps & React.RefAttributes<HTMLDivElement>>;
+    Actions: React.ForwardRefExoticComponent<CardActionsProps & React.RefAttributes<HTMLDivElement>>;
+};
 
 interface RippleItem {
     key: number;
@@ -2079,4 +2133,1566 @@ interface UseRippleReturn {
  */
 declare function useRipple(options?: UseRippleOptions): UseRippleReturn;
 
-export { Box, type BoxProps, type BreakpointKey, type Breakpoints, Button, type ButtonColorScheme, ButtonGroup, ButtonGroupContext, type ButtonGroupContextValue, type ButtonGroupOrientation, type ButtonGroupProps, type ButtonLoadingPosition, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardActions, type CardActionsProps, CardBody, type CardBodyProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, type CardOwnerState, type CardProps, type CardSize, type CardVariant, Checkbox, type CheckboxColorScheme, CheckboxContext, type CheckboxContextValue, CheckboxGroup, type CheckboxGroupProps, type CheckboxOwnerState, type CheckboxProps, type CheckboxSize, type ChellaaTheme, Code, type CodeColorScheme, type CodeOwnerState, type CodeProps, type ColorMode, type ComponentOverride, type ComponentOverrideOptions, Container, type ContainerOwnerState, type ContainerProps, type DeepPartial, Divider, type DividerLineStyle, type DividerOrientation, type DividerOwnerState, type DividerProps, type DividerTextAlign, type DividerVariant, type ExtendedThemeContextValue, Flex, type FlexOwnerState, type FlexProps, FormErrorMessage, type FormErrorMessageProps, FormField, FormFieldContext, type FormFieldContextValue, type FormFieldProps, FormHelperText, type FormHelperTextProps, FormLabel, type FormLabelProps, Grid, type GridDirection, type GridOwnerState, type GridProps, type GridSize, type GridWrap, Heading, type HeadingLevel, type HeadingProps, Input, InputAdornment, type InputAdornmentProps, InputBase, type InputOwnerState, type InputProps, type InputSize, type InputVariant, Kbd, type KbdModifier, type KbdOwnerState, type KbdProps, type KbdSize, type KbdVariant, MODIFIER_SYMBOLS, type Palette, type PaletteColor, Paper, type PaperOwnerState, type PaperProps, type PaperVariant, Paragraph, type ParagraphProps, Radio, type RadioColorScheme, RadioContext, type RadioContextValue, RadioGroup, type RadioGroupProps, type RadioOwnerState, type RadioProps, type RadioSize, type ResponsiveValue, type RippleItem, Stack, type StackDirection, type StackOwnerState, type StackProps, type StandardCSSProperties, type StyleInterpolation, type StyledOptions, Switch, type SwitchColorScheme, type SwitchLabelPlacement, type SwitchOwnerState, type SwitchProps, type SwitchSize, type SxObject, type SxPropValue, type SxProps, type SystemCssProperties, type SystemStyleProperties, Text, TextField, type TextFieldProps, type TextProps, type TextSize, Textarea, type TextareaOwnerState, type TextareaProps, type TextareaResize, type TextareaSize, type TextareaVariant, type ThemeContextValue, type ThemeMode, type ThemeOptions, ThemeProvider, type ThemeProviderProps, ThemeScript, type ThemeScriptProps, TouchRipple, type TouchRippleProps, type TouchRippleRef, type Transitions, type TypeAction, type TypeBackground, type TypeText, Typography, type TypographyAlign, type TypographyOwnerState, type TypographyProps, type TypographyStyle, type TypographyTheme, type TypographyVariant, type UseRippleOptions, type UseRippleReturn, type ZIndex, breakpointKeys, createBreakpoints, createPalette, createShadows, createShouldForwardProp, createSpacing, createTheme, darkPalette, defaultBreakpoints, defaultDarkTheme, defaultShadows, defaultSpacing, defaultTheme, defaultTransitions, defaultTypography, defaultZIndex, lightPalette, parseSx, resolveComponentOverrides, resolveTypographyColor, rootShouldForwardProp, styled, useButtonGroupContext, useCheckboxGroup, useFormField, useRadioGroup, useRipple, useTheme };
+interface SlotProps extends React.HTMLAttributes<HTMLElement> {
+    children?: React.ReactNode;
+}
+/**
+ * Merges Slot props onto its immediate child element.
+ * Preserves child identity, merges classNames, styles, ref forwarding, and event handlers.
+ */
+declare const Slot: React.ForwardRefExoticComponent<SlotProps & React.RefAttributes<HTMLElement>>;
+
+interface PortalProps {
+    children?: React.ReactNode;
+    container?: HTMLElement | null;
+}
+/**
+ * Renders child elements into a DOM container outside the parent component tree (default: document.body).
+ * Preserves React Context across the portal boundary and is completely SSR/hydration safe.
+ */
+declare function Portal({ children, container, }: PortalProps): React.ReactPortal | null;
+declare namespace Portal {
+    var displayName: string;
+}
+
+type TooltipPlacement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end" | "right" | "right-start" | "right-end";
+interface TooltipProps {
+    /** The text content or descriptive React element to display inside the tooltip */
+    content: React.ReactNode;
+    /** The interactive trigger element that activates the tooltip */
+    children: React.ReactElement;
+    /** Preferred placement relative to the trigger. Defaults to "top" */
+    placement?: TooltipPlacement;
+    /** Delay in milliseconds before opening after pointer enters trigger. Defaults to 200 */
+    openDelay?: number;
+    /** Delay in milliseconds before closing after pointer leaves. Defaults to 150 */
+    closeDelay?: number;
+    /** Controlled open state */
+    isOpen?: boolean;
+    /** Initial open state when uncontrolled. Defaults to false */
+    defaultOpen?: boolean;
+    /** Callback fired when the open state changes */
+    onOpenChange?: (isOpen: boolean) => void;
+    /** Whether to render a decorative pointer arrow. Defaults to true */
+    hasArrow?: boolean;
+    /** Whether the tooltip is completely disabled and prevented from opening. Defaults to false */
+    isDisabled?: boolean;
+    /** Offset distance in pixels between the trigger and tooltip. Defaults to 8 */
+    offset?: number;
+    /** Optional keyboard shortcut string to render inside tooltip (e.g. "Ctrl+S") */
+    shortcut?: string;
+    /** Additional custom CSS class name applied to the tooltip container */
+    className?: string;
+    /** Additional inline CSS properties applied to the tooltip container */
+    style?: React.CSSProperties;
+}
+interface TooltipOwnerState {
+    placement: TooltipPlacement;
+    isOpen: boolean;
+    hasArrow: boolean;
+}
+
+/**
+ * Tooltip provides a lightweight, accessible floating text popup anchored to a target
+ * trigger element, triggered via pointer hover or keyboard focus.
+ *
+ * Conforms to WCAG 2.2 AA (SC 1.4.13 Content on Hover or Focus) and WAI-ARIA APG Tooltip Pattern.
+ */
+declare const Tooltip: React.ForwardRefExoticComponent<TooltipProps & React.RefAttributes<HTMLDivElement>>;
+
+type PopoverPlacement = TooltipPlacement;
+interface PopoverRootProps {
+    children: React.ReactNode;
+    /** Controlled open state of the popover */
+    isOpen?: boolean;
+    /** Uncontrolled default open state of the popover */
+    defaultOpen?: boolean;
+    /** Callback fired when the open state changes */
+    onOpenChange?: (open: boolean) => void;
+    /** Preferred placement relative to the trigger. Defaults to "bottom" */
+    placement?: PopoverPlacement;
+    /** Offset distance in pixels from the trigger. Defaults to 8 */
+    offset?: number;
+    /** Whether to trap focus inside the popover content. Defaults to true */
+    trapFocus?: boolean;
+    /** Whether to close the popover on blur. Defaults to true */
+    closeOnBlur?: boolean;
+    /** Whether to close the popover when the Escape key is pressed. Defaults to true */
+    closeOnEsc?: boolean;
+    /** Ref to the element that should receive focus when opened */
+    initialFocusRef?: React.RefObject<HTMLElement | null>;
+    /** Ref to the element that should receive focus when closed */
+    returnFocusRef?: React.RefObject<HTMLElement | null>;
+}
+interface PopoverProps extends PopoverRootProps {
+}
+interface PopoverTriggerProps {
+    children: React.ReactElement;
+    /** Whether to delegate props to the child element via Slot primitive */
+    asChild?: boolean;
+}
+interface PopoverPortalProps {
+    children: React.ReactNode;
+    /** Custom container element to portal into. Defaults to document.body */
+    container?: HTMLElement | null;
+}
+interface PopoverContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    /** Whether to render a decorative pointer arrow. Defaults to true */
+    hasArrow?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface PopoverCloseProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    children?: React.ReactNode;
+    /** Whether to delegate props to the child element via Slot primitive */
+    asChild?: boolean;
+    className?: string;
+}
+interface PopoverArrowProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string;
+    style?: React.CSSProperties;
+}
+interface PopoverHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface PopoverTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface PopoverBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface PopoverFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    className?: string;
+}
+interface PopoverContextValue {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    placement: PopoverPlacement;
+    actualPlacement: PopoverPlacement;
+    trapFocus: boolean;
+    id: string;
+    titleId: string;
+    hasTitle: boolean;
+    setHasTitle: (hasTitle: boolean) => void;
+    hasPortalParent: boolean;
+    setHasPortalParent: (hasPortal: boolean) => void;
+    initialFocusRef?: React.RefObject<HTMLElement | null> | undefined;
+    returnFocusRef?: React.RefObject<HTMLElement | null> | undefined;
+}
+
+interface PopoverInternalContextValue extends PopoverContextValue {
+    floatingContext: FloatingContext;
+    getReferenceProps: (userProps?: React.HTMLProps<Element>) => Record<string, unknown>;
+    getFloatingProps: (userProps?: React.HTMLProps<HTMLElement>) => Record<string, unknown>;
+    refs: ExtendedRefs<Element>;
+    floatingStyles: React.CSSProperties;
+    middlewareData: MiddlewareData;
+    arrowRef: React.RefObject<HTMLDivElement | null>;
+}
+declare function usePopoverContext(): PopoverInternalContextValue;
+/**
+ * Popover.Root (or <Popover>) manages the open state and floating positioning context
+ * for anchored rich interactive popup overlays.
+ */
+declare function PopoverRoot({ children, isOpen: controlledOpen, defaultOpen, onOpenChange, placement, offset: offsetProp, trapFocus, closeOnEsc, initialFocusRef, returnFocusRef, }: PopoverRootProps): React.JSX.Element;
+declare namespace PopoverRoot {
+    var displayName: string;
+}
+/**
+ * Popover.Trigger wraps the anchor element, binding click and aria attributes.
+ */
+declare const PopoverTrigger: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLElement>>;
+/**
+ * Popover.Portal mounts popover content into document.body or a custom container.
+ */
+declare function PopoverPortal({ children, container }: PopoverPortalProps): React.JSX.Element | null;
+declare namespace PopoverPortal {
+    var displayName: string;
+}
+/**
+ * Popover.Content renders the floating dialog container with focus trapping and styling.
+ */
+declare const PopoverContent: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Popover.Arrow renders the directional pointer diamond.
+ */
+declare const PopoverArrow: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Popover.Close renders a dismiss button or decorates a child button via asChild.
+ */
+declare const PopoverClose: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Popover.Header provides the top bar of the popover.
+ */
+declare const PopoverHeader: React.ForwardRefExoticComponent<PopoverHeaderProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Popover.Title provides the dialog title and links via aria-labelledby.
+ */
+declare const PopoverTitle: React.ForwardRefExoticComponent<PopoverTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+/**
+ * Popover.Body provides the main interactive container inside the popover.
+ */
+declare const PopoverBody: React.ForwardRefExoticComponent<PopoverBodyProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Popover.Footer provides the action footer of the popover.
+ */
+declare const PopoverFooter: React.ForwardRefExoticComponent<PopoverFooterProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Popover compound component aggregation.
+ */
+declare const Popover: typeof PopoverRoot & {
+    Root: typeof PopoverRoot;
+    Trigger: React.ForwardRefExoticComponent<PopoverTriggerProps & React.RefAttributes<HTMLElement>>;
+    Portal: typeof PopoverPortal;
+    Content: React.ForwardRefExoticComponent<PopoverContentProps & React.RefAttributes<HTMLDivElement>>;
+    Close: React.ForwardRefExoticComponent<PopoverCloseProps & React.RefAttributes<HTMLButtonElement>>;
+    Arrow: React.ForwardRefExoticComponent<PopoverArrowProps & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<PopoverHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<PopoverTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+    Body: React.ForwardRefExoticComponent<PopoverBodyProps & React.RefAttributes<HTMLDivElement>>;
+    Footer: React.ForwardRefExoticComponent<PopoverFooterProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+type AlertStatus = "info" | "success" | "warning" | "danger" | "neutral";
+type AlertVariant = "subtle" | "solid" | "outline" | "left-accent";
+interface AlertContextValue {
+    status: AlertStatus;
+    variant: AlertVariant;
+    onClose?: (() => void) | undefined;
+    handleClose: () => void;
+    isClosed: boolean;
+}
+interface AlertProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Semantic status determining colors, icons, and ARIA roles. Defaults to "info" */
+    status?: AlertStatus | undefined;
+    /** Visual treatment of the alert surface. Defaults to "subtle" */
+    variant?: AlertVariant | undefined;
+    /** Whether the alert can be dismissed with a close button */
+    isClosable?: boolean | undefined;
+    /** Callback fired when the close button is clicked */
+    onClose?: (() => void) | undefined;
+    /** Polymorphic slot delegation */
+    asChild?: boolean | undefined;
+    children?: React.ReactNode | undefined;
+}
+type AlertRootProps = AlertProps;
+interface AlertIconProps extends React.SVGAttributes<SVGSVGElement> {
+    /** Custom icon override */
+    icon?: React.ReactNode | undefined;
+}
+interface AlertTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    children?: React.ReactNode | undefined;
+}
+interface AlertDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    children?: React.ReactNode | undefined;
+}
+interface AlertBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode | undefined;
+}
+interface AlertActionProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode | undefined;
+}
+interface AlertCloseButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+
+declare function useAlertContext(): AlertContextValue;
+/**
+ * Alert.Root (or <Alert>) provides in-flow contextual feedback with accessible live-region semantics.
+ */
+declare const AlertRoot: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Alert.Icon renders an accessible status indicator SVG or custom icon override.
+ */
+declare const AlertIcon: React.ForwardRefExoticComponent<AlertIconProps & React.RefAttributes<SVGSVGElement>>;
+/**
+ * Alert.Body wraps the title and description in a flex column layout.
+ */
+declare const AlertBody: React.ForwardRefExoticComponent<AlertBodyProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Alert.Title renders the prominent heading for the alert notice.
+ */
+declare const AlertTitle: React.ForwardRefExoticComponent<AlertTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+/**
+ * Alert.Description renders the accompanying body text for the alert notice.
+ */
+declare const AlertDescription: React.ForwardRefExoticComponent<AlertDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * Alert.Action contains contextual action buttons (e.g. Retry, Learn More).
+ */
+declare const AlertAction: React.ForwardRefExoticComponent<AlertActionProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Alert.CloseButton renders an accessible dismiss button for the alert.
+ */
+declare const AlertCloseButton: React.ForwardRefExoticComponent<AlertCloseButtonProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Alert compound component aggregation.
+ */
+declare const Alert: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>> & {
+    Root: React.ForwardRefExoticComponent<AlertProps & React.RefAttributes<HTMLDivElement>>;
+    Icon: React.ForwardRefExoticComponent<AlertIconProps & React.RefAttributes<SVGSVGElement>>;
+    Body: React.ForwardRefExoticComponent<AlertBodyProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<AlertTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<AlertDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+    Action: React.ForwardRefExoticComponent<AlertActionProps & React.RefAttributes<HTMLDivElement>>;
+    CloseButton: React.ForwardRefExoticComponent<AlertCloseButtonProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+type ToastPosition = "top" | "top-left" | "top-right" | "bottom" | "bottom-left" | "bottom-right";
+type ToastStatus = "info" | "success" | "warning" | "danger" | "neutral";
+interface ToastOptions {
+    /** Optional unique identifier for toast */
+    id?: string | undefined;
+    /** Primary headline text */
+    title?: React.ReactNode | undefined;
+    /** Secondary descriptive copy */
+    description?: React.ReactNode | undefined;
+    /** Semantic color and icon intent */
+    status?: ToastStatus | undefined;
+    /** Lifetime in ms before auto-dismissal. Set null for persistent toast */
+    duration?: number | null | undefined;
+    /** Whether a manual close button is rendered */
+    isClosable?: boolean | undefined;
+    /** Viewport anchor corner */
+    position?: ToastPosition | undefined;
+    /** Custom action slot (e.g. Undo button) */
+    action?: React.ReactNode | undefined;
+    /** Callback fired when toast is dismissed */
+    onClose?: (() => void) | undefined;
+}
+interface ToastRecord extends ToastOptions {
+    id: string;
+    createdAt: number;
+    duration: number | null;
+    position: ToastPosition;
+    isClosable: boolean;
+    status: ToastStatus;
+}
+interface UseToastReturn {
+    (options: ToastOptions): string;
+    close: (id: string) => void;
+    closeAll: () => void;
+    update: (id: string, options: Partial<ToastOptions>) => void;
+    isActive: (id: string) => boolean;
+}
+interface ToastProviderProps {
+    children?: React.ReactNode | undefined;
+    /** Default lifetime in ms before auto-dismissal. Defaults to 5000 */
+    defaultDuration?: number | undefined;
+    /** Default viewport position. Defaults to "bottom-right" */
+    defaultPosition?: ToastPosition | undefined;
+    /** Max visible toasts per position. Defaults to 5 */
+    maxVisibleToasts?: number | undefined;
+}
+interface SnackbarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Controlled open state of the snackbar */
+    isOpen?: boolean | undefined;
+    /** Primary headline message */
+    message?: React.ReactNode | undefined;
+    /** Secondary descriptive copy */
+    description?: React.ReactNode | undefined;
+    /** Semantic color and icon intent */
+    status?: ToastStatus | undefined;
+    /** Lifetime in ms before auto-dismissal. Set null for persistent toast */
+    duration?: number | null | undefined;
+    /** Viewport anchor corner */
+    position?: ToastPosition | undefined;
+    /** Custom action slot (e.g. Undo button) */
+    action?: React.ReactNode | undefined;
+    /** Whether a manual close button is rendered */
+    isClosable?: boolean | undefined;
+    /** Callback fired when snackbar is dismissed */
+    onClose?: (() => void) | undefined;
+    children?: React.ReactNode | undefined;
+}
+
+/**
+ * Snackbar provides a declarative component API for viewport-anchored transient notifications.
+ */
+declare const Snackbar: React.ForwardRefExoticComponent<SnackbarProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Toast is the approved alias for Snackbar.
+ */
+declare const Toast: React.ForwardRefExoticComponent<SnackbarProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const ToastContext: React.Context<UseToastReturn | null>;
+/**
+ * Individual Toast Item with pauseable timer and accessible live-region semantics.
+ */
+declare const ToastItem: React.ForwardRefExoticComponent<{
+    toast: ToastRecord;
+    onClose: () => void;
+} & React.RefAttributes<HTMLDivElement>>;
+/**
+ * ToastProvider manages notification queue, automatic dismissals, and portal layout.
+ */
+declare function ToastProvider({ children, defaultDuration, defaultPosition, maxVisibleToasts, }: ToastProviderProps): React.JSX.Element;
+
+/**
+ * Hook to imperatively trigger, update, or dismiss toast notifications.
+ */
+declare function useToast(): UseToastReturn;
+
+type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl" | "2xl";
+type AvatarShape = "circular" | "rounded" | "square";
+type AvatarStatus = "online" | "offline" | "busy" | "away";
+type AvatarPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end";
+type ImageLoadingStatus = "idle" | "loading" | "loaded" | "error";
+interface AvatarContextValue {
+    size: AvatarSize;
+    shape: AvatarShape;
+    imageStatus: ImageLoadingStatus;
+    setImageStatus: (status: ImageLoadingStatus) => void;
+}
+interface AvatarGroupContextValue {
+    size?: AvatarSize | undefined;
+    shape?: AvatarShape | undefined;
+}
+interface AvatarProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Source URL of the avatar image */
+    src?: string | undefined;
+    /** Responsive image srcset attribute */
+    srcSet?: string | undefined;
+    /** Alternate text for accessibility and screen readers */
+    alt?: string | undefined;
+    /** Entity or user name used to automatically derive initials */
+    name?: string | undefined;
+    /** Standardized optical size scale */
+    size?: AvatarSize | undefined;
+    /** Geometric border radius shape */
+    shape?: AvatarShape | undefined;
+    /** Custom fallback element rendered when image is absent or errors */
+    fallback?: React.ReactNode | undefined;
+    /** Custom generic icon rendered when initials and image are absent */
+    icon?: React.ReactNode | undefined;
+    /** Delegate root DOM element rendering via Slot primitive */
+    asChild?: boolean | undefined;
+    /** Callback fired when image fails to load */
+    onError?: React.ReactEventHandler<HTMLImageElement> | undefined;
+    /** Callback fired when image loads successfully */
+    onLoad?: React.ReactEventHandler<HTMLImageElement> | undefined;
+}
+interface AvatarImageProps extends React.ImgHTMLAttributes<HTMLImageElement> {
+    /** Delegate image DOM element rendering via Slot primitive */
+    asChild?: boolean | undefined;
+}
+interface AvatarFallbackProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Delegate fallback DOM element rendering via Slot primitive */
+    asChild?: boolean | undefined;
+    /** Optional delay in ms before rendering fallback to avoid flashing */
+    delayMs?: number | undefined;
+}
+interface AvatarBadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Presence indicator status intent */
+    status?: AvatarStatus | undefined;
+    /** Corner anchor position relative to avatar */
+    placement?: AvatarPlacement | undefined;
+    /** Delegate badge DOM element rendering via Slot primitive */
+    asChild?: boolean | undefined;
+}
+interface AvatarGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Maximum number of avatars to render before displaying +N excess count */
+    max?: number | undefined;
+    /** Propagated size scale across all child avatars */
+    size?: AvatarSize | undefined;
+    /** Propagated geometric shape across all child avatars */
+    shape?: AvatarShape | undefined;
+    /** Overlap margin offset (default: -8px) */
+    spacing?: number | string | undefined;
+    /** Avatar elements to group */
+    children: React.ReactNode;
+}
+
+declare const AvatarGroupContext: React.Context<AvatarGroupContextValue>;
+declare const useAvatarGroupContext: () => AvatarGroupContextValue;
+/**
+ * AvatarGroup stacks multiple avatars with negative margin overlap and calculates +N excess items.
+ */
+declare const AvatarGroup: React.ForwardRefExoticComponent<AvatarGroupProps & React.RefAttributes<HTMLDivElement>>;
+
+declare const AvatarContext: React.Context<AvatarContextValue | null>;
+declare const useAvatarContext: () => AvatarContextValue | null;
+/**
+ * Extracts up to two uppercase initials from a given name string.
+ * Handles single names, multi-word names, hyphens, and unicode characters.
+ */
+declare function getInitials(name?: string): string;
+/**
+ * Avatar.Image renders the image element with automatic error and load management.
+ */
+declare const AvatarImage: React.ForwardRefExoticComponent<AvatarImageProps & React.RefAttributes<HTMLImageElement>>;
+/**
+ * Avatar.Fallback renders fallback initials, icons, or custom elements when image has not loaded.
+ */
+declare const AvatarFallback: React.ForwardRefExoticComponent<AvatarFallbackProps & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * Avatar.Badge renders presence status indicator dot anchored to an avatar corner.
+ */
+declare const AvatarBadge: React.ForwardRefExoticComponent<AvatarBadgeProps & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * Avatar represents a user, entity, or organization identity with automated fallbacks and presence indicators.
+ */
+declare const AvatarBase: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+interface AvatarComponent extends React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>> {
+    Root: typeof AvatarBase;
+    Image: typeof AvatarImage;
+    Fallback: typeof AvatarFallback;
+    Badge: typeof AvatarBadge;
+    Group: typeof AvatarGroup;
+}
+declare const Avatar: AvatarComponent;
+declare const AvatarRoot: React.ForwardRefExoticComponent<AvatarProps & React.RefAttributes<HTMLDivElement>>;
+
+type AccordionType = "single" | "multiple";
+type AccordionVariant = "outline" | "separated" | "flush";
+interface AccordionSingleProps {
+    /** Single expansion mode */
+    type?: "single" | undefined;
+    /** Controlled active item value in single mode */
+    value?: string | undefined;
+    /** Default active item value in uncontrolled single mode */
+    defaultValue?: string | undefined;
+    /** Callback fired when the active item value changes in single mode */
+    onValueChange?: ((value: string) => void) | undefined;
+    /** Whether the active item can be collapsed when clicked */
+    collapsible?: boolean | undefined;
+}
+interface AccordionMultipleProps {
+    /** Multiple simultaneous expansion mode */
+    type: "multiple";
+    /** Controlled active item values in multiple mode */
+    value?: string[] | undefined;
+    /** Default active item values in uncontrolled multiple mode */
+    defaultValue?: string[] | undefined;
+    /** Callback fired when the active item values change in multiple mode */
+    onValueChange?: ((value: string[]) => void) | undefined;
+    /** Not applicable in multiple mode */
+    collapsible?: never | undefined;
+}
+type AccordionRootProps = (AccordionSingleProps | AccordionMultipleProps) & Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue"> & {
+    /** Visual style treatment: outline, separated, or flush */
+    variant?: AccordionVariant | undefined;
+    /** Whether all accordion items are globally disabled */
+    isDisabled?: boolean | undefined;
+    /** Child Accordion.Item elements */
+    children: React.ReactNode;
+};
+type AccordionProps = AccordionRootProps;
+interface AccordionContextValue {
+    type: AccordionType;
+    variant: AccordionVariant;
+    collapsible: boolean;
+    isDisabled: boolean;
+    expandedValues: string[];
+    toggleItem: (value: string) => void;
+    rootRef: React.RefObject<HTMLDivElement | null>;
+}
+interface AccordionItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Unique identifier for the accordion item */
+    value: string;
+    /** Whether this individual item is disabled */
+    isDisabled?: boolean | undefined;
+    /** Subcomponents: Accordion.Header and Accordion.Content */
+    children: React.ReactNode;
+}
+interface AccordionItemContextValue {
+    value: string;
+    isOpen: boolean;
+    isDisabled: boolean;
+    triggerId: string;
+    panelId: string;
+}
+interface AccordionHeaderProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    /** Semantic HTML heading tag level (h2 - h6). Defaults to 3 (h3) */
+    level?: 2 | 3 | 4 | 5 | 6 | undefined;
+    /** Child Accordion.Trigger element */
+    children: React.ReactNode;
+}
+interface AccordionTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Delegate button element rendering via Slot primitive */
+    asChild?: boolean | undefined;
+    /** Trigger text and optional Accordion.Icon */
+    children: React.ReactNode;
+}
+interface AccordionContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Panel body elements */
+    children: React.ReactNode;
+}
+interface AccordionIconProps extends React.SVGAttributes<SVGSVGElement> {
+    className?: string | undefined;
+}
+
+declare const AccordionContext: React.Context<AccordionContextValue | null>;
+declare const useAccordionContext: () => AccordionContextValue;
+declare const AccordionItemContext: React.Context<AccordionItemContextValue | null>;
+declare const useAccordionItemContext: () => AccordionItemContextValue;
+/**
+ * Accordion.Root provides expansion state management and keyboard navigation for accordion items.
+ */
+declare const AccordionRoot: React.ForwardRefExoticComponent<AccordionRootProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Accordion.Item encapsulates a single collapsible panel and header.
+ */
+declare const AccordionItem: React.ForwardRefExoticComponent<AccordionItemProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Accordion.Header renders a semantic heading wrapper (h2 - h6) around the trigger button.
+ */
+declare const AccordionHeader: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLHeadingElement>>;
+/**
+ * Accordion.Trigger renders the interactive button that toggles expansion.
+ */
+declare const AccordionTrigger: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Accordion.Content renders the collapsible body region with CSS grid height transition.
+ */
+declare const AccordionContent: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Accordion.Icon renders a 16x16 chevron SVG icon that rotates 180° when expanded.
+ */
+declare const AccordionIcon: React.ForwardRefExoticComponent<AccordionIconProps & React.RefAttributes<SVGSVGElement>>;
+interface AccordionComponent extends React.ForwardRefExoticComponent<AccordionRootProps & React.RefAttributes<HTMLDivElement>> {
+    Root: typeof AccordionRoot;
+    Item: typeof AccordionItem;
+    Header: typeof AccordionHeader;
+    Trigger: typeof AccordionTrigger;
+    Content: typeof AccordionContent;
+    Icon: typeof AccordionIcon;
+}
+declare const Accordion: AccordionComponent;
+
+type TabsOrientation = "horizontal" | "vertical";
+type TabsVariant = "line" | "enclosed" | "pill" | "unstyled";
+type TabsSize = "sm" | "md" | "lg";
+type TabsActivationMode = "automatic" | "manual";
+interface TabsRootProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "defaultValue" | "onChange"> {
+    /** Controlled active tab value */
+    value?: string | undefined;
+    /** Uncontrolled default active tab value */
+    defaultValue?: string | undefined;
+    /** Callback fired when the active tab value changes */
+    onValueChange?: ((value: string) => void) | undefined;
+    /** Layout orientation: horizontal (default) or vertical */
+    orientation?: TabsOrientation | undefined;
+    /** Visual style variant: line (default), enclosed, pill, unstyled */
+    variant?: TabsVariant | undefined;
+    /** Sizing scale: sm (32px), md (40px, default), lg (48px) */
+    size?: TabsSize | undefined;
+    /** Tab activation mode: automatic (on focus) or manual (on Enter/Space) */
+    activationMode?: TabsActivationMode | undefined;
+    /** When true, inactive tab panels are unmounted instead of hidden */
+    isLazy?: boolean | undefined;
+    /** Child elements: Tabs.List and Tabs.Content */
+    children: React.ReactNode;
+}
+type TabsProps = TabsRootProps;
+interface TabsListProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Accessible label for the tablist */
+    "aria-label"?: string | undefined;
+    /** Tab trigger buttons */
+    children: React.ReactNode;
+}
+interface TabsTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Unique identifier matching a Tabs.Content panel */
+    value: string;
+    /** Whether the tab is disabled and cannot be activated */
+    isDisabled?: boolean | undefined;
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+    /** Tab label and optional icons */
+    children: React.ReactNode;
+}
+interface TabsContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Unique identifier matching a Tabs.Trigger */
+    value: string;
+    /** Panel content */
+    children: React.ReactNode;
+}
+interface TabsIndicatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string | undefined;
+}
+interface TabsContextValue {
+    selectedValue: string;
+    setSelectedValue: (value: string) => void;
+    orientation: TabsOrientation;
+    variant: TabsVariant;
+    size: TabsSize;
+    activationMode: TabsActivationMode;
+    isLazy: boolean;
+    baseId: string;
+    listRef: React.RefObject<HTMLDivElement | null>;
+}
+
+declare const TabsContext: React.Context<TabsContextValue | null>;
+declare function useTabsContext(): TabsContextValue;
+/**
+ * Tabs.Root (Tabs) provides context, state synchronization, and orientation management.
+ */
+declare const TabsRoot: React.ForwardRefExoticComponent<TabsRootProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Tabs.List renders the semantic role="tablist" container with roving keyboard navigation.
+ */
+declare const TabsList: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Tabs.Trigger renders the interactive tab button adhering to WAI-ARIA APG roving tabindex.
+ */
+declare const TabsTrigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Tabs.Content renders the role="tabpanel" for a corresponding tab trigger.
+ */
+declare const TabsContent: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Tabs.Indicator renders an optional visual indicator track.
+ */
+declare const TabsIndicator: React.ForwardRefExoticComponent<TabsIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * Compound export namespace adhering to Chellaa React standards.
+ */
+declare const Tabs: React.ForwardRefExoticComponent<TabsRootProps & React.RefAttributes<HTMLDivElement>> & {
+    Root: React.ForwardRefExoticComponent<TabsRootProps & React.RefAttributes<HTMLDivElement>>;
+    List: React.ForwardRefExoticComponent<TabsListProps & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<TabsTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Content: React.ForwardRefExoticComponent<TabsContentProps & React.RefAttributes<HTMLDivElement>>;
+    Indicator: React.ForwardRefExoticComponent<TabsIndicatorProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+type PaginationSize = "sm" | "md" | "lg";
+type PaginationVariant = "outline" | "solid" | "ghost" | "subtle";
+interface PaginationRootProps extends React.HTMLAttributes<HTMLElement> {
+    /** Total number of items across all pages */
+    total: number;
+    /** Number of items displayed per page. Default is 10 */
+    pageSize?: number | undefined;
+    /** Controlled current active page number (1-indexed) */
+    page?: number | undefined;
+    /** Uncontrolled default active page number. Default is 1 */
+    defaultPage?: number | undefined;
+    /** Callback fired when the active page changes */
+    onPageChange?: ((page: number) => void) | undefined;
+    /** Callback fired when the page size is modified */
+    onPageSizeChange?: ((pageSize: number) => void) | undefined;
+    /** Number of adjacent sibling page buttons around active page. Default is 1 */
+    siblingCount?: number | undefined;
+    /** Number of boundary page buttons shown at beginning and end. Default is 1 */
+    boundaryCount?: number | undefined;
+    /** Sizing scale: sm (28px), md (36px, default), lg (44px) */
+    size?: PaginationSize | undefined;
+    /** Visual button variant: outline (default), solid, ghost, subtle */
+    variant?: PaginationVariant | undefined;
+    /** Globally disables all pagination controls */
+    isDisabled?: boolean | undefined;
+    /** Whether to render the integrated page size selector dropdown */
+    showSizeChanger?: boolean | undefined;
+    /** Available page size options for showSizeChanger. Default [10, 20, 50, 100] */
+    pageSizeOptions?: number[] | undefined;
+    /** Whether to render the direct page number quick jumper box */
+    showQuickJumper?: boolean | undefined;
+    /** Accessible label for the navigation landmark */
+    "aria-label"?: string | undefined;
+    /** Child elements or custom composition. When omitted, standard pagination layout is auto-generated */
+    children?: React.ReactNode | undefined;
+}
+type PaginationProps = PaginationRootProps;
+interface PaginationListProps extends React.HTMLAttributes<HTMLUListElement> {
+    children?: React.ReactNode | undefined;
+}
+interface PaginationItemProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** The 1-indexed page number represented by this button */
+    page: number;
+    /** Whether this button represents the currently active page */
+    isCurrent?: boolean | undefined;
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+    /** Custom content, defaults to page number */
+    children?: React.ReactNode | undefined;
+}
+interface PaginationActionProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface PaginationEllipsisProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children?: React.ReactNode | undefined;
+}
+interface PaginationSizeSelectProps extends Omit<React.HTMLAttributes<HTMLElement>, "onChange"> {
+    /** Available page size options. Default [10, 20, 50, 100] */
+    options?: number[] | undefined;
+    /** Optional callback fired when page size changes */
+    onChange?: ((pageSize: number) => void) | undefined;
+    /** Accessible label for the select trigger button. Default "Page size" */
+    "aria-label"?: string | undefined;
+    /** Whether the selector is disabled */
+    isDisabled?: boolean | undefined;
+}
+interface PaginationJumperProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children?: React.ReactNode | undefined;
+}
+interface PaginationContextValue {
+    currentPage: number;
+    totalPages: number;
+    pageSize: number;
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    size: PaginationSize;
+    variant: PaginationVariant;
+    isDisabled: boolean;
+    siblingCount: number;
+    boundaryCount: number;
+}
+
+declare const PaginationContext: React.Context<PaginationContextValue | null>;
+declare function usePaginationContext(): PaginationContextValue;
+type PaginationRangeItem = number | "ellipsis-start" | "ellipsis-end";
+/**
+ * Calculates a windowed range of page items with ellipsis compression.
+ */
+declare function getPaginationRange({ totalPages, currentPage, siblingCount, boundaryCount, }: {
+    totalPages: number;
+    currentPage: number;
+    siblingCount?: number;
+    boundaryCount?: number;
+}): PaginationRangeItem[];
+/**
+ * Pagination.Root (Pagination) manages pagination state, page mathematics, and accessibility landmark.
+ */
+declare const PaginationRoot: React.ForwardRefExoticComponent<PaginationRootProps & React.RefAttributes<HTMLElement>>;
+/**
+ * Pagination.List renders the semantic <ul role="list"> wrapper for page controls.
+ */
+declare const PaginationList: React.ForwardRefExoticComponent<PaginationListProps & React.RefAttributes<HTMLUListElement>>;
+/**
+ * Pagination.Item renders a numeric page button with aria-current marking.
+ */
+declare const PaginationItem: React.ForwardRefExoticComponent<PaginationItemProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Pagination.Prev navigates to the preceding page.
+ */
+declare const PaginationPrev: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Pagination.Next navigates to the succeeding page.
+ */
+declare const PaginationNext: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Pagination.First jumps directly to the first page (Page 1).
+ */
+declare const PaginationFirst: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Pagination.Last jumps directly to the final page.
+ */
+declare const PaginationLast: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Pagination.Ellipsis renders the non-interactive truncation indicator.
+ */
+declare const PaginationEllipsis: React.ForwardRefExoticComponent<PaginationEllipsisProps & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * Pagination.SizeSelect renders the page size dropdown reusing @chellaa/react's Select component.
+ */
+declare const PaginationSizeSelect: React.ForwardRefExoticComponent<PaginationSizeSelectProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Pagination.Jumper renders a direct page jump number input.
+ */
+declare const PaginationJumper: React.ForwardRefExoticComponent<PaginationJumperProps & React.RefAttributes<HTMLSpanElement>>;
+/**
+ * Compound export object adhering to Chellaa React component architecture.
+ */
+declare const Pagination: React.ForwardRefExoticComponent<PaginationRootProps & React.RefAttributes<HTMLElement>> & {
+    Root: React.ForwardRefExoticComponent<PaginationRootProps & React.RefAttributes<HTMLElement>>;
+    List: React.ForwardRefExoticComponent<PaginationListProps & React.RefAttributes<HTMLUListElement>>;
+    Item: React.ForwardRefExoticComponent<PaginationItemProps & React.RefAttributes<HTMLButtonElement>>;
+    Prev: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+    Next: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+    First: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+    Last: React.ForwardRefExoticComponent<PaginationActionProps & React.RefAttributes<HTMLButtonElement>>;
+    Ellipsis: React.ForwardRefExoticComponent<PaginationEllipsisProps & React.RefAttributes<HTMLSpanElement>>;
+    SizeSelect: React.ForwardRefExoticComponent<PaginationSizeSelectProps & React.RefAttributes<HTMLButtonElement>>;
+    Jumper: React.ForwardRefExoticComponent<PaginationJumperProps & React.RefAttributes<HTMLSpanElement>>;
+};
+
+type ComboboxSize = "sm" | "md" | "lg";
+type ComboboxVariant = "outline" | "filled" | "flushed";
+interface ComboboxOption {
+    value: string;
+    label?: React.ReactNode;
+    disabled?: boolean;
+}
+interface ComboboxRootProps<TValue = string | string[]> extends Omit<React.HTMLAttributes<HTMLDivElement>, "value" | "defaultValue" | "onChange"> {
+    /** Value of the combobox in controlled mode */
+    value?: TValue | undefined;
+    /** Initial value in uncontrolled mode */
+    defaultValue?: TValue | undefined;
+    /** Callback fired when selection changes */
+    onValueChange?: ((value: TValue) => void) | undefined;
+    /** Current text inside search input in controlled mode */
+    searchValue?: string | undefined;
+    /** Initial search text in uncontrolled mode */
+    defaultSearchValue?: string | undefined;
+    /** Callback fired when search text changes */
+    onSearchChange?: ((search: string) => void) | undefined;
+    /** Open state of the listbox popup in controlled mode */
+    isOpen?: boolean | undefined;
+    /** Initial open state in uncontrolled mode */
+    defaultOpen?: boolean | undefined;
+    /** Callback fired when listbox popup opens or closes */
+    onOpenChange?: ((open: boolean) => void) | undefined;
+    /** Whether the combobox is globally disabled */
+    isDisabled?: boolean | undefined;
+    /** Whether the combobox is in an error / invalid state */
+    isInvalid?: boolean | undefined;
+    /** Whether search or asynchronous data fetch is loading */
+    isLoading?: boolean | undefined;
+    /** Whether multi-selection mode is enabled */
+    isMulti?: boolean | undefined;
+    /** Sizing scale: sm (32px), md (40px, default), lg (48px) */
+    size?: ComboboxSize | undefined;
+    /** Visual variant matching Input: outline (default), filled, flushed */
+    variant?: ComboboxVariant | undefined;
+    /** Optional custom filter function. Set false to disable local filtering */
+    filter?: ((itemValue: string, itemText: string, search: string) => boolean) | false | undefined;
+    /** Optional flat options array for convenience auto-layout */
+    options?: ComboboxOption[] | undefined;
+    /** Placeholder for the auto-layout input */
+    placeholder?: string | undefined;
+    /** Name of the input element for form submission */
+    name?: string | undefined;
+    /** Whether the combobox input is required */
+    isRequired?: boolean | undefined;
+    /** Accessible description element ID */
+    "aria-describedby"?: string | undefined;
+    /** Compound children or custom layout */
+    children?: React.ReactNode | undefined;
+}
+type ComboboxProps<TValue = string | string[]> = ComboboxRootProps<TValue>;
+interface ComboboxControlProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+}
+interface ComboboxInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, "size"> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+}
+interface ComboboxTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+}
+interface ComboboxPortalProps {
+    children: React.ReactNode;
+    container?: HTMLElement | null | undefined;
+}
+interface ComboboxContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+}
+interface ComboboxItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Unique value represented by this option */
+    value: string;
+    /** Optional text label for search matching and display */
+    label?: string | undefined;
+    /** Whether this specific item is disabled */
+    isDisabled?: boolean | undefined;
+    /** When true, delegates rendering to child element via Slot */
+    asChild?: boolean | undefined;
+    /** Option contents */
+    children: React.ReactNode;
+}
+interface ComboboxGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    /** Optional heading text or node */
+    heading?: React.ReactNode | undefined;
+}
+interface ComboboxGroupLabelProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface ComboboxEmptyProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface ComboboxTagProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /** Value of the item represented by this tag */
+    value: string;
+    /** Callback fired when remove button is clicked */
+    onRemove?: (() => void) | undefined;
+    /** Whether remove action is disabled */
+    isDisabled?: boolean | undefined;
+}
+interface ComboboxClearProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+}
+interface RegisteredItem {
+    id: string;
+    value: string;
+    text: string;
+    disabled: boolean;
+    isVisible: boolean;
+}
+interface ComboboxContextValue {
+    value: any;
+    selectItem: (value: string, text: string) => void;
+    removeItem: (value: string) => void;
+    clearSelection: () => void;
+    searchValue: string;
+    setSearchValue: (search: string) => void;
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    activeId: string | null;
+    setActiveId: (id: string | null) => void;
+    inputRef: React.MutableRefObject<HTMLInputElement | null>;
+    controlRef: (node: HTMLElement | null) => void;
+    contentRef: (node: HTMLElement | null) => void;
+    floatingStyles: React.CSSProperties;
+    listboxId: string;
+    inputId: string;
+    isMulti: boolean;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    isLoading: boolean;
+    size: ComboboxSize;
+    variant: ComboboxVariant;
+    filter: ((itemValue: string, itemText: string, search: string) => boolean) | false;
+    isFiltering: boolean;
+    setIsFiltering: (filtering: boolean) => void;
+    pendingHighlight: "first" | "last" | "selected" | null;
+    setPendingHighlight: (target: "first" | "last" | "selected" | null) => void;
+    openWithHighlight: (target: "first" | "last" | "selected") => void;
+    ariaDescribedBy?: string | undefined;
+    isRequired?: boolean | undefined;
+    name?: string | undefined;
+    registerItem: (item: RegisteredItem) => () => void;
+    updateItemVisibility: (id: string, isVisible: boolean) => void;
+    visibleItems: RegisteredItem[];
+    filteredCount: number;
+}
+
+declare function useComboboxContext(): ComboboxContextValue;
+declare const useCombobox: typeof useComboboxContext;
+declare const ComboboxRoot: React.ForwardRefExoticComponent<ComboboxRootProps<string | string[]> & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxControl: React.ForwardRefExoticComponent<ComboboxControlProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxInput: React.ForwardRefExoticComponent<ComboboxInputProps & React.RefAttributes<HTMLInputElement>>;
+declare const ComboboxTrigger: React.ForwardRefExoticComponent<ComboboxTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const ComboboxPortal: React.FC<ComboboxPortalProps>;
+declare const ComboboxContent: React.ForwardRefExoticComponent<ComboboxContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxItem: React.ForwardRefExoticComponent<ComboboxItemProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxGroupLabel: React.ForwardRefExoticComponent<ComboboxGroupLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxGroup: React.ForwardRefExoticComponent<ComboboxGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxEmpty: React.ForwardRefExoticComponent<ComboboxEmptyProps & React.RefAttributes<HTMLDivElement>>;
+declare const ComboboxTag: React.ForwardRefExoticComponent<ComboboxTagProps & React.RefAttributes<HTMLSpanElement>>;
+declare const ComboboxClear: React.ForwardRefExoticComponent<ComboboxClearProps & React.RefAttributes<HTMLButtonElement>>;
+interface ComboboxComponent extends React.ForwardRefExoticComponent<ComboboxProps & React.RefAttributes<HTMLDivElement>> {
+    Root: typeof ComboboxRoot;
+    Control: typeof ComboboxControl;
+    Input: typeof ComboboxInput;
+    Trigger: typeof ComboboxTrigger;
+    Portal: typeof ComboboxPortal;
+    Content: typeof ComboboxContent;
+    Item: typeof ComboboxItem;
+    Group: typeof ComboboxGroup;
+    GroupLabel: typeof ComboboxGroupLabel;
+    Empty: typeof ComboboxEmpty;
+    Tag: typeof ComboboxTag;
+    Clear: typeof ComboboxClear;
+}
+declare const Combobox: ComboboxComponent;
+declare const Autocomplete: ComboboxComponent;
+
+type SelectVariant = "outline" | "filled" | "flushed";
+type SelectSize = "xs" | "sm" | "md" | "lg" | "xl";
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean | undefined;
+}
+interface SelectContextValue<TValue extends string = string> {
+    value: TValue | undefined;
+    setValue: (value: TValue) => void;
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    highlightedValue: string | null;
+    setHighlightedValue: (value: string | null) => void;
+    size: SelectSize;
+    variant: SelectVariant;
+    isDisabled: boolean;
+    isInvalid: boolean;
+    isRequired: boolean;
+    name?: string | undefined;
+    triggerId: string;
+    contentId: string;
+    triggerRef: React.MutableRefObject<HTMLButtonElement | null>;
+    contentRef: React.MutableRefObject<HTMLDivElement | null>;
+    selectedLabel: string | null;
+    registerItem: (value: string, label: string) => () => void;
+    refs: {
+        setReference: (node: HTMLElement | null) => void;
+        setFloating: (node: HTMLElement | null) => void;
+    };
+    floatingStyles: React.CSSProperties;
+}
+interface SelectRootProps<TValue extends string = string> {
+    value?: TValue | undefined;
+    defaultValue?: TValue | undefined;
+    onValueChange?: ((value: TValue) => void) | undefined;
+    isOpen?: boolean | undefined;
+    defaultOpen?: boolean | undefined;
+    onOpenChange?: ((open: boolean) => void) | undefined;
+    size?: SelectSize | undefined;
+    variant?: SelectVariant | undefined;
+    isDisabled?: boolean | undefined;
+    isInvalid?: boolean | undefined;
+    isRequired?: boolean | undefined;
+    name?: string | undefined;
+    placeholder?: string | undefined;
+    options?: SelectOption[] | undefined;
+    children?: React.ReactNode;
+    className?: string | undefined;
+    "aria-describedby"?: string | undefined;
+}
+interface SelectTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean | undefined;
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectValueProps extends React.HTMLAttributes<HTMLSpanElement> {
+    placeholder?: string | undefined;
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectIconProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectPortalProps {
+    children: React.ReactNode;
+    container?: HTMLElement | null | undefined;
+}
+interface SelectContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    position?: "popper" | "item-aligned" | undefined;
+    sideOffset?: number | undefined;
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectItemProps<TValue extends string = string> extends React.HTMLAttributes<HTMLDivElement> {
+    value: TValue;
+    isDisabled?: boolean | undefined;
+    textValue?: string | undefined;
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectItemTextProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectItemIndicatorProps extends React.HTMLAttributes<HTMLSpanElement> {
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectLabelProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+    className?: string | undefined;
+}
+interface SelectSeparatorProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string | undefined;
+}
+
+declare function useSelectContext<TValue extends string = string>(): SelectContextValue<TValue>;
+declare const SelectRoot: React.ForwardRefExoticComponent<SelectRootProps<string> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectIcon: React.ForwardRefExoticComponent<SelectIconProps & React.RefAttributes<HTMLSpanElement>>;
+declare function SelectPortal({ children, container }: SelectPortalProps): React.JSX.Element | null;
+declare const SelectContent: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<SelectItemProps<string> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItemText: React.ForwardRefExoticComponent<SelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectItemIndicator: React.ForwardRefExoticComponent<SelectItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<SelectLabelProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<SelectSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+declare const Select: React.ForwardRefExoticComponent<SelectRootProps<string> & React.RefAttributes<HTMLDivElement>> & {
+    Root: React.ForwardRefExoticComponent<SelectRootProps<string> & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Value: React.ForwardRefExoticComponent<SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+    Icon: React.ForwardRefExoticComponent<SelectIconProps & React.RefAttributes<HTMLSpanElement>>;
+    Portal: typeof SelectPortal;
+    Content: React.ForwardRefExoticComponent<SelectContentProps & React.RefAttributes<HTMLDivElement>>;
+    Item: React.ForwardRefExoticComponent<SelectItemProps<string> & React.RefAttributes<HTMLDivElement>>;
+    ItemText: React.ForwardRefExoticComponent<SelectItemTextProps & React.RefAttributes<HTMLSpanElement>>;
+    ItemIndicator: React.ForwardRefExoticComponent<SelectItemIndicatorProps & React.RefAttributes<HTMLSpanElement>>;
+    Group: React.ForwardRefExoticComponent<SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+    Label: React.ForwardRefExoticComponent<SelectLabelProps & React.RefAttributes<HTMLDivElement>>;
+    Separator: React.ForwardRefExoticComponent<SelectSeparatorProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+type DialogSize = "sm" | "md" | "lg" | "xl" | "full";
+interface DialogRootProps {
+    /**
+     * Controlled open state of the dialog.
+     */
+    isOpen?: boolean | undefined;
+    /**
+     * Initial open state when uncontrolled.
+     * @default false
+     */
+    defaultOpen?: boolean | undefined;
+    /**
+     * Callback fired when dismissal is requested (via Escape, overlay, or close button).
+     */
+    onClose?: (() => void) | undefined;
+    /**
+     * If true, pressing Escape dismisses the dialog.
+     * @default true
+     */
+    closeOnEsc?: boolean | undefined;
+    /**
+     * If true, clicking the backdrop overlay dismisses the dialog.
+     * @default true
+     */
+    closeOnOverlayClick?: boolean | undefined;
+    /**
+     * Explicit DOM element to focus when the dialog opens.
+     */
+    initialFocusRef?: React.RefObject<HTMLElement | null> | undefined;
+    /**
+     * Explicit DOM element to focus when the dialog closes.
+     * Defaults to the triggering element.
+     */
+    finalFocusRef?: React.RefObject<HTMLElement | null> | undefined;
+    /**
+     * Dialog spatial max-width scale.
+     * @default "md"
+     */
+    size?: DialogSize | undefined;
+    /**
+     * If true, vertically centers the dialog in the viewport.
+     * @default true
+     */
+    isCentered?: boolean | undefined;
+    children: React.ReactNode;
+}
+interface DialogTriggerProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    /**
+     * Change the default rendered element for the one passed as a child, merging their props and behavior.
+     * @default false
+     */
+    asChild?: boolean | undefined;
+    children: React.ReactNode;
+}
+interface DialogPortalProps {
+    /**
+     * Container element to mount the portal into. Defaults to document.body.
+     */
+    container?: HTMLElement | null | undefined;
+    children: React.ReactNode;
+}
+interface DialogOverlayProps extends React.HTMLAttributes<HTMLDivElement> {
+    asChild?: boolean | undefined;
+}
+interface DialogContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    asChild?: boolean | undefined;
+}
+interface DialogHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface DialogTitleProps extends React.HTMLAttributes<HTMLHeadingElement> {
+    asChild?: boolean | undefined;
+}
+interface DialogDescriptionProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    asChild?: boolean | undefined;
+}
+interface DialogBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface DialogFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+}
+interface DialogCloseProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    asChild?: boolean | undefined;
+    children?: React.ReactNode;
+}
+type ModalSize = DialogSize;
+type ModalRootProps = DialogRootProps;
+type ModalTriggerProps = DialogTriggerProps;
+type ModalPortalProps = DialogPortalProps;
+type ModalOverlayProps = DialogOverlayProps;
+type ModalContentProps = DialogContentProps;
+type ModalHeaderProps = DialogHeaderProps;
+type ModalTitleProps = DialogTitleProps;
+type ModalDescriptionProps = DialogDescriptionProps;
+type ModalBodyProps = DialogBodyProps;
+type ModalFooterProps = DialogFooterProps;
+type ModalCloseProps = DialogCloseProps;
+
+/**
+ * DialogRoot component - manages controlled/uncontrolled visibility and dialog context.
+ */
+declare const DialogRoot: React.FC<DialogRootProps>;
+/**
+ * DialogTrigger component - wraps or renders a button that opens the dialog.
+ */
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLElement>>;
+/**
+ * DialogPortal component - mounts dialog children into document.body or container.
+ */
+declare const DialogPortal: React.FC<DialogPortalProps>;
+/**
+ * DialogOverlay component - background backdrop with static CSS centering.
+ */
+declare const DialogOverlay: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * DialogContent component - main dialog window with focus trap and scroll locking.
+ */
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * DialogHeader component - header slot containing title, description, or close button.
+ */
+declare const DialogHeader: React.ForwardRefExoticComponent<DialogHeaderProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * DialogTitle component - accessible title that binds aria-labelledby.
+ */
+declare const DialogTitle: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+/**
+ * DialogDescription component - accessible description that binds aria-describedby.
+ */
+declare const DialogDescription: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+/**
+ * DialogBody component - scrollable content body.
+ */
+declare const DialogBody: React.ForwardRefExoticComponent<DialogBodyProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * DialogFooter component - footer slot containing actions.
+ */
+declare const DialogFooter: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * DialogClose component - button that dismisses the dialog when clicked.
+ */
+declare const DialogClose: React.ForwardRefExoticComponent<DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+/**
+ * Compound Dialog export
+ */
+declare const Dialog: React.FC<DialogRootProps> & {
+    Root: React.FC<DialogRootProps>;
+    Trigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLElement>>;
+    Portal: React.FC<DialogPortalProps>;
+    Overlay: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+    Content: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<DialogHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+    Body: React.ForwardRefExoticComponent<DialogBodyProps & React.RefAttributes<HTMLDivElement>>;
+    Footer: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+    Close: React.ForwardRefExoticComponent<DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+};
+/**
+ * Exact compatibility alias for Modal
+ */
+declare const Modal: React.FC<DialogRootProps> & {
+    Root: React.FC<DialogRootProps>;
+    Trigger: React.ForwardRefExoticComponent<DialogTriggerProps & React.RefAttributes<HTMLElement>>;
+    Portal: React.FC<DialogPortalProps>;
+    Overlay: React.ForwardRefExoticComponent<DialogOverlayProps & React.RefAttributes<HTMLDivElement>>;
+    Content: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<DialogHeaderProps & React.RefAttributes<HTMLDivElement>>;
+    Title: React.ForwardRefExoticComponent<DialogTitleProps & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>>;
+    Body: React.ForwardRefExoticComponent<DialogBodyProps & React.RefAttributes<HTMLDivElement>>;
+    Footer: React.ForwardRefExoticComponent<DialogFooterProps & React.RefAttributes<HTMLDivElement>>;
+    Close: React.ForwardRefExoticComponent<DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+};
+
+type BadgeVariant = "subtle" | "solid" | "outline";
+type BadgeSize = "sm" | "md" | "lg";
+type BadgeColorScheme = "primary" | "secondary" | "success" | "warning" | "danger" | "info" | "neutral";
+interface BadgeProps extends React.HTMLAttributes<HTMLSpanElement> {
+    /**
+     * Visual aesthetic treatment of the badge.
+     * @default "subtle"
+     */
+    variant?: BadgeVariant | undefined;
+    /**
+     * Spatial sizing scale.
+     * @default "md"
+     */
+    size?: BadgeSize | undefined;
+    /**
+     * Semantic color intent.
+     * @default "neutral"
+     */
+    colorScheme?: BadgeColorScheme | undefined;
+    /**
+     * If true, renders with fully rounded pill corners (`--cl-rad-full`).
+     * @default false
+     */
+    isPill?: boolean | undefined;
+    /**
+     * If true, renders a small colored status dot before children.
+     * @default false
+     */
+    hasDot?: boolean | undefined;
+    /**
+     * If true, delegates rendering to the immediate child element.
+     * @default false
+     */
+    asChild?: boolean | undefined;
+    /**
+     * The system-aware sx prop
+     */
+    sx?: SxProps | undefined;
+    children?: React.ReactNode | undefined;
+}
+
+/**
+ * Badge component - A compact visual indicator communicating status, counts, or categorization.
+ */
+declare const Badge: React.ForwardRefExoticComponent<BadgeProps & React.RefAttributes<HTMLSpanElement>>;
+
+type TableVariant = "simple" | "striped" | "bordered";
+type TableSize = "sm" | "md" | "lg";
+interface TableRootProps extends React.TableHTMLAttributes<HTMLTableElement> {
+    /**
+     * Visual aesthetic treatment of the table.
+     * @default "simple"
+     */
+    variant?: TableVariant | undefined;
+    /**
+     * Spatial density scale governing padding and font size.
+     * @default "md"
+     */
+    size?: TableSize | undefined;
+    /**
+     * If true, enables background hover transitions on table body rows.
+     * @default false
+     */
+    isHoverable?: boolean | undefined;
+    /**
+     * If true, pins the table header row to the top of the scrolling container.
+     * @default false
+     */
+    isStickyHeader?: boolean | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface TableContainerProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * If true, applies a rounded border, background surface, and subtle shadow.
+     * @default false
+     */
+    bordered?: boolean | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface TableCaptionProps extends React.HTMLAttributes<HTMLTableCaptionElement> {
+    /**
+     * Placement of the caption relative to the table.
+     * @default "bottom"
+     */
+    placement?: "top" | "bottom" | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface TableTheadProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    children?: React.ReactNode | undefined;
+}
+interface TableTbodyProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    children?: React.ReactNode | undefined;
+}
+interface TableTfootProps extends React.HTMLAttributes<HTMLTableSectionElement> {
+    children?: React.ReactNode | undefined;
+}
+interface TableRowProps extends React.HTMLAttributes<HTMLTableRowElement> {
+    /**
+     * If true, enables hover background highlight on this row specifically.
+     */
+    isHoverable?: boolean | undefined;
+    /**
+     * If true, applies selected background styling to this row.
+     * @default false
+     */
+    isSelected?: boolean | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface TableHeaderCellProps extends React.ThHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * If true, aligns text to the right and applies tabular-nums font styling.
+     * @default false
+     */
+    isNumeric?: boolean | undefined;
+    /**
+     * Text alignment of the cell content.
+     */
+    align?: "left" | "center" | "right" | undefined;
+    /**
+     * If true, renders the header with interactive sort affordance styling.
+     * @default false
+     */
+    isSortable?: boolean | undefined;
+    /**
+     * Current sort direction for accessible aria-sort attribute.
+     * @default "none"
+     */
+    sortDirection?: "asc" | "desc" | "none" | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface TableCellProps extends React.TdHTMLAttributes<HTMLTableCellElement> {
+    /**
+     * If true, aligns text to the right and applies tabular-nums font styling.
+     * @default false
+     */
+    isNumeric?: boolean | undefined;
+    /**
+     * Text alignment of the cell content.
+     */
+    align?: "left" | "center" | "right" | undefined;
+    children?: React.ReactNode | undefined;
+}
+interface TableContextValue {
+    size: TableSize;
+    variant: TableVariant;
+    isHoverable: boolean;
+}
+
+/**
+ * TableRoot component - Container for structured row and column data.
+ */
+declare const TableRoot: React.ForwardRefExoticComponent<TableRootProps & React.RefAttributes<HTMLTableElement>>;
+/**
+ * TableContainer component - Responsive touch scroll container.
+ */
+declare const TableContainer: React.ForwardRefExoticComponent<TableContainerProps & React.RefAttributes<HTMLDivElement>>;
+/**
+ * TableCaption component - Programmatic description of table data.
+ */
+declare const TableCaption: React.ForwardRefExoticComponent<TableCaptionProps & React.RefAttributes<HTMLTableCaptionElement>>;
+/**
+ * TableThead component - Semantic table header section.
+ */
+declare const TableThead: React.ForwardRefExoticComponent<TableTheadProps & React.RefAttributes<HTMLTableSectionElement>>;
+/**
+ * TableTbody component - Semantic table body section.
+ */
+declare const TableTbody: React.ForwardRefExoticComponent<TableTbodyProps & React.RefAttributes<HTMLTableSectionElement>>;
+/**
+ * TableTfoot component - Semantic table footer section.
+ */
+declare const TableTfoot: React.ForwardRefExoticComponent<TableTfootProps & React.RefAttributes<HTMLTableSectionElement>>;
+/**
+ * TableTr component - Semantic table row element.
+ */
+declare const TableTr: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
+/**
+ * TableTh component - Semantic table header cell with scope="col" default.
+ */
+declare const TableTh: React.ForwardRefExoticComponent<TableHeaderCellProps & React.RefAttributes<HTMLTableCellElement>>;
+/**
+ * TableTd component - Semantic table data cell with isNumeric and align support.
+ */
+declare const TableTd: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+/**
+ * Compound Table component export
+ */
+declare const Table: React.ForwardRefExoticComponent<TableRootProps & React.RefAttributes<HTMLTableElement>> & {
+    Root: React.ForwardRefExoticComponent<TableRootProps & React.RefAttributes<HTMLTableElement>>;
+    Container: React.ForwardRefExoticComponent<TableContainerProps & React.RefAttributes<HTMLDivElement>>;
+    Caption: React.ForwardRefExoticComponent<TableCaptionProps & React.RefAttributes<HTMLTableCaptionElement>>;
+    Thead: React.ForwardRefExoticComponent<TableTheadProps & React.RefAttributes<HTMLTableSectionElement>>;
+    Tbody: React.ForwardRefExoticComponent<TableTbodyProps & React.RefAttributes<HTMLTableSectionElement>>;
+    Tfoot: React.ForwardRefExoticComponent<TableTfootProps & React.RefAttributes<HTMLTableSectionElement>>;
+    Tr: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLTableRowElement>>;
+    Th: React.ForwardRefExoticComponent<TableHeaderCellProps & React.RefAttributes<HTMLTableCellElement>>;
+    Td: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLTableCellElement>>;
+};
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionContext, type AccordionContextValue, AccordionHeader, type AccordionHeaderProps, AccordionIcon, type AccordionIconProps, AccordionItem, AccordionItemContext, type AccordionItemContextValue, type AccordionItemProps, type AccordionMultipleProps, type AccordionProps, AccordionRoot, type AccordionRootProps, type AccordionSingleProps, AccordionTrigger, type AccordionTriggerProps, type AccordionType, type AccordionVariant, Alert, AlertAction, type AlertActionProps, AlertBody, type AlertBodyProps, AlertCloseButton, type AlertCloseButtonProps, type AlertContextValue, AlertDescription, type AlertDescriptionProps, AlertIcon, type AlertIconProps, type AlertProps, AlertRoot, type AlertRootProps, type AlertStatus, AlertTitle, type AlertTitleProps, type AlertVariant, Autocomplete, Avatar, AvatarBadge, type AvatarBadgeProps, AvatarContext, type AvatarContextValue, AvatarFallback, type AvatarFallbackProps, AvatarGroup, AvatarGroupContext, type AvatarGroupContextValue, type AvatarGroupProps, AvatarImage, type AvatarImageProps, type AvatarPlacement, type AvatarProps, AvatarRoot, type AvatarShape, type AvatarSize, type AvatarStatus, Badge, type BadgeColorScheme, type BadgeProps, type BadgeSize, type BadgeVariant, Box, type BoxProps, type BreakpointKey, type Breakpoints, Button, type ButtonColorScheme, ButtonGroup, ButtonGroupContext, type ButtonGroupContextValue, type ButtonGroupOrientation, type ButtonGroupProps, type ButtonLoadingPosition, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardActions, type CardActionsProps, CardBody, type CardBodyProps, CardDescription, type CardDescriptionProps, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardMedia, type CardMediaProps, type CardOwnerState, type CardProps, CardRoot, type CardSize, CardTitle, type CardTitleProps, type CardVariant, Checkbox, type CheckboxColorScheme, CheckboxContext, type CheckboxContextValue, CheckboxGroup, type CheckboxGroupProps, type CheckboxOwnerState, type CheckboxProps, type CheckboxSize, type ChellaaTheme, Code, type CodeColorScheme, type CodeOwnerState, type CodeProps, type ColorMode, Combobox, ComboboxClear, type ComboboxClearProps, ComboboxContent, type ComboboxContentProps, type ComboboxContextValue, ComboboxControl, type ComboboxControlProps, ComboboxEmpty, type ComboboxEmptyProps, ComboboxGroup, ComboboxGroupLabel, type ComboboxGroupLabelProps, type ComboboxGroupProps, ComboboxInput, type ComboboxInputProps, ComboboxItem, type ComboboxItemProps, type ComboboxOption, ComboboxPortal, type ComboboxPortalProps, type ComboboxProps, ComboboxRoot, type ComboboxRootProps, type ComboboxSize, ComboboxTag, type ComboboxTagProps, ComboboxTrigger, type ComboboxTriggerProps, type ComboboxVariant, type ComponentOverride, type ComponentOverrideOptions, Container, type ContainerOwnerState, type ContainerProps, type DeepPartial, Dialog, DialogBody, type DialogBodyProps, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogFooter, type DialogFooterProps, DialogHeader, type DialogHeaderProps, DialogOverlay, type DialogOverlayProps, DialogPortal, type DialogPortalProps, DialogRoot, type DialogRootProps, type DialogSize, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, Divider, type DividerLineStyle, type DividerOrientation, type DividerOwnerState, type DividerProps, type DividerTextAlign, type DividerVariant, type ExtendedThemeContextValue, Flex, type FlexOwnerState, type FlexProps, FormErrorMessage, type FormErrorMessageProps, FormField, FormFieldContext, type FormFieldContextValue, type FormFieldProps, FormHelperText, type FormHelperTextProps, FormLabel, type FormLabelProps, Grid, type GridDirection, type GridOwnerState, type GridProps, type GridSize, type GridWrap, Heading, type HeadingLevel, type HeadingProps, type ImageLoadingStatus, Input, InputAdornment, type InputAdornmentProps, InputBase, type InputOwnerState, type InputProps, type InputSize, type InputVariant, Kbd, type KbdModifier, type KbdOwnerState, type KbdProps, type KbdSize, type KbdVariant, MODIFIER_SYMBOLS, Modal, type ModalBodyProps, type ModalCloseProps, type ModalContentProps, type ModalDescriptionProps, type ModalFooterProps, type ModalHeaderProps, type ModalOverlayProps, type ModalPortalProps, type ModalRootProps, type ModalSize, type ModalTitleProps, type ModalTriggerProps, Pagination, type PaginationActionProps, PaginationContext, type PaginationContextValue, PaginationEllipsis, type PaginationEllipsisProps, PaginationFirst, PaginationItem, type PaginationItemProps, PaginationJumper, type PaginationJumperProps, PaginationLast, PaginationList, type PaginationListProps, PaginationNext, PaginationPrev, type PaginationProps, PaginationRoot, type PaginationRootProps, type PaginationSize, PaginationSizeSelect, type PaginationSizeSelectProps, type PaginationVariant, type Palette, type PaletteColor, Paper, type PaperOwnerState, type PaperProps, type PaperVariant, Paragraph, type ParagraphProps, Popover, PopoverArrow, type PopoverArrowProps, PopoverBody, type PopoverBodyProps, PopoverClose, type PopoverCloseProps, PopoverContent, type PopoverContentProps, type PopoverContextValue, PopoverFooter, type PopoverFooterProps, PopoverHeader, type PopoverHeaderProps, type PopoverPlacement, PopoverPortal, type PopoverPortalProps, type PopoverProps, PopoverRoot, type PopoverRootProps, PopoverTitle, type PopoverTitleProps, PopoverTrigger, type PopoverTriggerProps, Portal, type PortalProps, Radio, type RadioColorScheme, RadioContext, type RadioContextValue, RadioGroup, type RadioGroupProps, type RadioOwnerState, type RadioProps, type RadioSize, type RegisteredItem, type ResponsiveValue, type RippleItem, Select, SelectContent, type SelectContentProps, type SelectContextValue, SelectGroup, type SelectGroupProps, SelectIcon, type SelectIconProps, SelectItem, SelectItemIndicator, type SelectItemIndicatorProps, type SelectItemProps, SelectItemText, type SelectItemTextProps, SelectLabel, type SelectLabelProps, type SelectOption, SelectPortal, type SelectPortalProps, SelectRoot, type SelectRootProps, SelectSeparator, type SelectSeparatorProps, type SelectSize, SelectTrigger, type SelectTriggerProps, SelectValue, type SelectValueProps, type SelectVariant, Slot, type SlotProps, Snackbar, type SnackbarProps, Stack, type StackDirection, type StackOwnerState, type StackProps, type StandardCSSProperties, type StyleInterpolation, type StyledOptions, Switch, type SwitchColorScheme, type SwitchLabelPlacement, type SwitchOwnerState, type SwitchProps, type SwitchSize, type SxObject, type SxPropValue, type SxProps, type SystemCssProperties, type SystemStyleProperties, Table, TableCaption, type TableCaptionProps, type TableCellProps, TableContainer, type TableContainerProps, type TableContextValue, type TableHeaderCellProps, TableRoot, type TableRootProps, type TableRowProps, type TableSize, TableTbody, type TableTbodyProps, TableTd, TableTfoot, type TableTfootProps, TableTh, TableThead, type TableTheadProps, TableTr, type TableVariant, Tabs, type TabsActivationMode, TabsContent, type TabsContentProps, TabsContext, type TabsContextValue, TabsIndicator, type TabsIndicatorProps, TabsList, type TabsListProps, type TabsOrientation, type TabsProps, TabsRoot, type TabsRootProps, type TabsSize, TabsTrigger, type TabsTriggerProps, type TabsVariant, Text, TextField, type TextFieldProps, type TextProps, type TextSize, Textarea, type TextareaOwnerState, type TextareaProps, type TextareaResize, type TextareaSize, type TextareaVariant, type ThemeContextValue, type ThemeMode, type ThemeOptions, ThemeProvider, type ThemeProviderProps, ThemeScript, type ThemeScriptProps, Toast, ToastContext, ToastItem, type ToastOptions, type ToastPosition, ToastProvider, type ToastProviderProps, type ToastRecord, type ToastStatus, Tooltip, type TooltipOwnerState, type TooltipPlacement, type TooltipProps, TouchRipple, type TouchRippleProps, type TouchRippleRef, type Transitions, type TypeAction, type TypeBackground, type TypeText, Typography, type TypographyAlign, type TypographyOwnerState, type TypographyProps, type TypographyStyle, type TypographyTheme, type TypographyVariant, type UseRippleOptions, type UseRippleReturn, type UseToastReturn, type ZIndex, breakpointKeys, createBreakpoints, createPalette, createShadows, createShouldForwardProp, createSpacing, createTheme, darkPalette, defaultBreakpoints, defaultDarkTheme, defaultShadows, defaultSpacing, defaultTheme, defaultTransitions, defaultTypography, defaultZIndex, getInitials, getPaginationRange, lightPalette, parseSx, resolveComponentOverrides, resolveTypographyColor, rootShouldForwardProp, styled, useAccordionContext, useAccordionItemContext, useAlertContext, useAvatarContext, useAvatarGroupContext, useButtonGroupContext, useCheckboxGroup, useCombobox, useComboboxContext, useFormField, usePaginationContext, usePopoverContext, useRadioGroup, useRipple, useSelectContext, useTabsContext, useTheme, useToast };