@peppone.choi/ui-kit 0.2.0

package/dist/index-DLX2PSxy.d.cts

@@ -0,0 +1,1936 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { Button as Button$1 } from '@base-ui/react/button';
+import { VariantProps } from 'class-variance-authority';
+import * as React$1 from 'react';
+import { ReactNode, JSX } from 'react';
+import { Checkbox as Checkbox$1 } from '@base-ui/react/checkbox';
+import { Radio as Radio$1 } from '@base-ui/react/radio';
+import { RadioGroup as RadioGroup$1 } from '@base-ui/react/radio-group';
+import { Switch as Switch$1 } from '@base-ui/react/switch';
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "outline" | "secondary" | "ghost" | "destructive" | "link" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, ...props }: Button$1.Props & VariantProps<typeof buttonVariants>): react_jsx_runtime.JSX.Element;
+
+declare const chipVariants: (props?: ({
+    variant?: "filled" | "outlined" | "soft" | null | undefined;
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ChipProps extends React.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof chipVariants> {
+    active?: boolean;
+    disabled?: boolean;
+    onRemove?: () => void;
+    leadingIcon?: React.ReactNode;
+    trailingIcon?: React.ReactNode;
+}
+declare function Chip({ className, variant, size, active, disabled, onRemove, leadingIcon, trailingIcon, children, ...props }: ChipProps): react_jsx_runtime.JSX.Element;
+
+declare const iconButtonVariants: (props?: ({
+    variant?: "ghost" | "outlined" | "normal" | "solid" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface IconButtonProps extends Omit<Button$1.Props, "aria-label">, VariantProps<typeof iconButtonVariants> {
+    "aria-label": string;
+    icon: React.ReactNode;
+}
+declare function IconButton({ className, variant, size, icon, "aria-label": ariaLabel, ...props }: IconButtonProps): react_jsx_runtime.JSX.Element;
+
+declare const textButtonVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof textButtonVariants> {
+    leadingIcon?: React.ReactNode;
+    trailingIcon?: React.ReactNode;
+}
+declare function TextButton({ className, size, leadingIcon, trailingIcon, children, disabled, ...props }: TextButtonProps): react_jsx_runtime.JSX.Element;
+
+interface ActionAreaProps extends React$1.HTMLAttributes<HTMLElement> {
+    href?: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    children: React$1.ReactNode;
+    /**
+     * Component used to render the link when `href` is set. Defaults to a
+     * native `<a>` so the core works in any framework. Pass a framework link
+     * (e.g. Next.js `Link`, React Router `Link`) for client-side navigation.
+     * The "@peppone.choi/ui-kit/next" entry exports a Next.js-wired ActionArea.
+     */
+    linkComponent?: React$1.ElementType;
+}
+declare function ActionArea({ className, href, onClick, disabled, children, linkComponent, ...props }: ActionAreaProps): react_jsx_runtime.JSX.Element;
+
+interface ToggleIconProps {
+    active: boolean;
+    activeIcon: React$1.ReactNode;
+    inactiveIcon: React$1.ReactNode;
+    onToggle: (active: boolean) => void;
+    className?: string;
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+declare function ToggleIcon({ active, activeIcon, inactiveIcon, onToggle, className, size, disabled, ariaLabel, }: ToggleIconProps): react_jsx_runtime.JSX.Element;
+
+interface AccordionProps {
+    children: React$1.ReactNode;
+    type?: "single" | "multiple";
+    defaultValue?: string | string[];
+    value?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    className?: string;
+}
+declare function Accordion({ children, type, defaultValue, value: controlledValue, onValueChange, className, }: AccordionProps): react_jsx_runtime.JSX.Element;
+declare const accordionItemVariants: (props?: ({
+    divider?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AccordionItemProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof accordionItemVariants> {
+    value: string;
+    children: React$1.ReactNode;
+}
+declare function AccordionItem({ value, divider, className, children, ...props }: AccordionItemProps): react_jsx_runtime.JSX.Element;
+declare const accordionTriggerVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AccordionTriggerProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof accordionTriggerVariants> {
+    children: React$1.ReactNode;
+}
+declare function AccordionTrigger({ className, size, children, ...props }: AccordionTriggerProps): react_jsx_runtime.JSX.Element;
+interface AccordionContentProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    children: React$1.ReactNode;
+}
+declare function AccordionContent({ className, children, ...props }: AccordionContentProps): react_jsx_runtime.JSX.Element;
+
+type AvatarSize = "xs" | "sm" | "md" | "lg" | "xl";
+type AvatarStatus = "online" | "offline" | "away";
+declare const sizeMap: Record<AvatarSize, number>;
+declare const avatarVariants: (props?: ({
+    size?: "xs" | "sm" | "lg" | "md" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function getInitials(name: string): string;
+declare function getBorderRadius(size: AvatarSize): number;
+interface AvatarProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof avatarVariants> {
+    src?: string;
+    alt?: string;
+    name?: string;
+    status?: AvatarStatus;
+    fallback?: React$1.ReactNode;
+}
+declare function Avatar({ className, size, src, alt, name, status, fallback, style, ...props }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+interface AvatarGroupItem {
+    src?: string;
+    alt?: string;
+    name?: string;
+    status?: "online" | "offline" | "away";
+}
+interface AvatarGroupProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    items: AvatarGroupItem[];
+    max?: number;
+    size?: AvatarSize;
+    className?: string;
+}
+declare const avatarGroupVariants: (props?: ({
+    size?: "xs" | "sm" | "lg" | "md" | "xl" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare function AvatarGroup({ className, items, max, size, ...props }: AvatarGroupProps): react_jsx_runtime.JSX.Element;
+
+interface AvatarButtonProps {
+    src?: string;
+    alt?: string;
+    name?: string;
+    size?: "xs" | "sm" | "md" | "lg" | "xl";
+    status?: "online" | "offline" | "away";
+    className?: string;
+    disabled?: boolean;
+    onClick?: () => void;
+    ariaLabel?: string;
+}
+declare function AvatarButton({ src, alt, name, size, status, className, disabled, onClick, ariaLabel, }: AvatarButtonProps): react_jsx_runtime.JSX.Element;
+
+interface CardListProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    gap?: "sm" | "md" | "lg";
+    columns?: 1 | 2 | 3;
+}
+declare function CardList({ className, children, gap, columns, ...props }: CardListProps): react_jsx_runtime.JSX.Element;
+
+interface ListProps extends React$1.HTMLAttributes<HTMLUListElement> {
+    spacing?: "none" | "sm" | "md" | "lg";
+    divided?: boolean;
+}
+declare function List({ className, children, spacing, divided, ...props }: ListProps): react_jsx_runtime.JSX.Element;
+interface ListItemProps extends React$1.LiHTMLAttributes<HTMLLIElement> {
+    leading?: React$1.ReactNode;
+    trailing?: React$1.ReactNode;
+    active?: boolean;
+}
+declare function ListItem({ className, children, leading, trailing, active, ...props }: ListItemProps): react_jsx_runtime.JSX.Element;
+
+declare function Card({ className, size, ...props }: React$1.ComponentProps<"div"> & {
+    size?: "default" | "sm";
+}): react_jsx_runtime.JSX.Element;
+declare function CardHeader({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function CardDescription({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function CardContent({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+declare function CardFooter({ className, ...props }: React$1.ComponentProps<"div">): react_jsx_runtime.JSX.Element;
+
+type ContentBadgeVariant = "default" | "brand" | "success" | "warning" | "error";
+declare const contentBadgeVariants: (props?: ({
+    variant?: "default" | "error" | "brand" | "success" | "warning" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const dotVariants: (props?: ({
+    variant?: "default" | "error" | "brand" | "success" | "warning" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ContentBadgeProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof contentBadgeVariants> {
+    count?: number;
+    max?: number;
+    dot?: boolean;
+}
+declare function ContentBadge({ className, variant, size, count, max, dot, children, ...props }: ContentBadgeProps): react_jsx_runtime.JSX.Element;
+
+interface ListCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    leading?: React$1.ReactNode;
+    title: React$1.ReactNode;
+    subtitle?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    trailing?: React$1.ReactNode;
+    thumbnail?: React$1.ReactNode;
+    hoverable?: boolean;
+}
+declare function ListCard({ className, leading, title, subtitle, description, trailing, thumbnail, hoverable, ...props }: ListCardProps): react_jsx_runtime.JSX.Element;
+
+declare const listCellVariants: (props?: ({
+    variant?: "default" | "disabled" | "active" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ListCellBaseProps extends VariantProps<typeof listCellVariants> {
+    leading?: React$1.ReactNode;
+    titleNode: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    trailing?: React$1.ReactNode;
+    divider?: boolean;
+}
+interface ListCellDivProps extends ListCellBaseProps, Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+    as?: "div";
+}
+interface ListCellButtonProps extends ListCellBaseProps, Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "title"> {
+    as: "button";
+}
+interface ListCellAnchorProps extends ListCellBaseProps, Omit<React$1.AnchorHTMLAttributes<HTMLAnchorElement>, "title"> {
+    as: "a";
+    href: string;
+}
+type ListCellProps = ListCellDivProps | ListCellButtonProps | ListCellAnchorProps;
+declare function ListCell({ className, variant, size, leading, titleNode, description, trailing, divider, as, ...props }: ListCellProps): react_jsx_runtime.JSX.Element;
+declare function ListCellChevron({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+declare const sectionHeaderVariants: (props?: ({
+    layout?: "default" | "inline" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SectionHeaderProps extends VariantProps<typeof sectionHeaderVariants> {
+    titleNode: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    action?: React$1.ReactNode;
+    className?: string;
+}
+declare function SectionHeader({ className, layout, titleNode, description, action, }: SectionHeaderProps): react_jsx_runtime.JSX.Element;
+
+type ThumbnailRatio = "1:1" | "4:3" | "16:9" | "3:2";
+declare const ratioMap: Record<ThumbnailRatio, string>;
+declare const thumbnailVariants: (props?: ({
+    ratio?: "1:1" | "4:3" | "16:9" | "3:2" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ThumbnailProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof thumbnailVariants> {
+    src?: string;
+    alt?: string;
+    overlay?: React$1.ReactNode;
+    fallback?: React$1.ReactNode;
+    objectFit?: "cover" | "contain";
+}
+declare function Thumbnail({ className, ratio, src, alt, overlay, fallback, objectFit, style, ...props }: ThumbnailProps): react_jsx_runtime.JSX.Element;
+
+interface PlayBadgeProps {
+    duration?: string;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+declare function PlayBadge({ duration, size, className }: PlayBadgeProps): react_jsx_runtime.JSX.Element;
+
+type TableProps = React$1.HTMLAttributes<HTMLTableElement>;
+declare function Table({ className, ...props }: TableProps): react_jsx_runtime.JSX.Element;
+declare function TableHeader({ className, ...props }: React$1.HTMLAttributes<HTMLTableSectionElement>): react_jsx_runtime.JSX.Element;
+declare function TableBody({ className, ...props }: React$1.HTMLAttributes<HTMLTableSectionElement>): react_jsx_runtime.JSX.Element;
+declare function TableRow({ className, ...props }: React$1.HTMLAttributes<HTMLTableRowElement>): react_jsx_runtime.JSX.Element;
+declare function TableHead({ className, ...props }: React$1.ThHTMLAttributes<HTMLTableCellElement>): react_jsx_runtime.JSX.Element;
+declare function TableCell({ className, ...props }: React$1.TdHTMLAttributes<HTMLTableCellElement>): react_jsx_runtime.JSX.Element;
+
+declare const alertVariants: (props?: ({
+    variant?: "error" | "success" | "warning" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface AlertProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof alertVariants> {
+    title?: string;
+    onClose?: () => void;
+}
+declare function Alert({ className, variant, title, children, onClose, ...props }: AlertProps): react_jsx_runtime.JSX.Element;
+
+interface FallbackViewProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    type?: "empty" | "error" | "search-empty" | "offline";
+    title?: string;
+    description?: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+declare function FallbackView({ className, type, title, description, action, ...props }: FallbackViewProps): react_jsx_runtime.JSX.Element;
+
+interface PushBadgeProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    count?: number;
+    variant?: "dot" | "count" | "max";
+    max?: number;
+}
+declare function PushBadge({ className, count, variant, max, ...props }: PushBadgeProps): react_jsx_runtime.JSX.Element | null;
+
+declare const sectionMessageVariants: (props?: ({
+    variant?: "error" | "success" | "warning" | "info" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SectionMessageProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof sectionMessageVariants> {
+    title?: string;
+}
+declare function SectionMessage({ className, variant, title, children, ...props }: SectionMessageProps): react_jsx_runtime.JSX.Element;
+
+declare const snackbarVariants: (props?: ({
+    state?: "hidden" | "visible" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SnackbarProps extends VariantProps<typeof snackbarVariants> {
+    message: string;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+    onClose?: () => void;
+    duration?: number;
+    className?: string;
+}
+declare function Snackbar({ message, action, onClose, duration, className, }: SnackbarProps): react_jsx_runtime.JSX.Element;
+
+declare const toastVariants: (props?: ({
+    variant?: "normal" | "positive" | "cautionary" | "negative" | null | undefined;
+    state?: "visible" | "entering" | "exiting" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface ToastItem {
+    id: string;
+    message: string;
+    variant?: "normal" | "positive" | "cautionary" | "negative";
+    duration?: number;
+    action?: {
+        label: string;
+        onClick: () => void;
+    };
+}
+interface ToastProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof toastVariants> {
+    toast: ToastItem;
+    onClose: (id: string) => void;
+    index: number;
+}
+declare function Toast({ toast, onClose, index, className, ...props }: ToastProps): react_jsx_runtime.JSX.Element;
+
+interface SkeletonProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    variant?: "text" | "rectangle" | "circle" | "combined";
+    lines?: number;
+}
+declare function Skeleton({ className, variant, lines, ...props }: SkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface LoadingProps {
+    variant?: "spinner" | "dots" | "linear" | "circular";
+    size?: "sm" | "md" | "lg" | "xl";
+    className?: string;
+    value?: number;
+    max?: number;
+}
+declare function Loading({ variant, size, className, value, max, }: LoadingProps): react_jsx_runtime.JSX.Element | null;
+
+declare const tabVariants: (props?: ({
+    variant?: "line" | "pill" | "segmented" | null | undefined;
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TabItem {
+    key: string;
+    label: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+    disabled?: boolean;
+}
+interface TabProps extends VariantProps<typeof tabVariants> {
+    items: TabItem[];
+    activeKey: string;
+    onChange?: (key: string) => void;
+    className?: string;
+    fullWidth?: boolean;
+}
+declare function Tab({ items, activeKey, onChange, variant, size, className, fullWidth, }: TabProps): react_jsx_runtime.JSX.Element;
+
+interface BottomNavItem {
+    key: string;
+    label: string;
+    icon: React$1.ReactNode;
+    activeIcon?: React$1.ReactNode;
+}
+interface BottomNavigationProps {
+    items: BottomNavItem[];
+    activeKey: string;
+    onChange?: (key: string) => void;
+    className?: string;
+}
+declare function BottomNavigation({ items, activeKey, onChange, className, }: BottomNavigationProps): react_jsx_runtime.JSX.Element;
+
+interface CategoryItem {
+    key: string;
+    label: string;
+}
+interface CategoryProps {
+    items: CategoryItem[];
+    activeKey: string;
+    onChange?: (key: string) => void;
+    className?: string;
+}
+declare function Category({ items, activeKey, onChange, className }: CategoryProps): react_jsx_runtime.JSX.Element;
+
+interface PageCounterProps {
+    current: number;
+    total: number;
+    className?: string;
+}
+declare function PageCounter({ current, total, className }: PageCounterProps): react_jsx_runtime.JSX.Element;
+
+interface PaginationProps {
+    page: number;
+    total: number;
+    onChange: (page: number) => void;
+    siblingCount?: number;
+    className?: string;
+}
+declare function Pagination({ page, total, onChange, siblingCount, className, }: PaginationProps): react_jsx_runtime.JSX.Element;
+
+interface PaginationDotsProps {
+    total: number;
+    current: number;
+    onChange?: (index: number) => void;
+    className?: string;
+}
+declare function PaginationDots({ total, current, onChange, className, }: PaginationDotsProps): react_jsx_runtime.JSX.Element;
+
+interface ProgressIndicatorProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    value: number;
+    max?: number;
+    size?: "sm" | "md" | "lg";
+    variant?: "linear" | "circular";
+    showLabel?: boolean;
+    labelPosition?: "inside" | "outside";
+}
+declare function ProgressIndicator({ className, value, max, size, variant, showLabel, labelPosition, ...props }: ProgressIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface TrackerStep {
+    key: string;
+    label: string;
+    description?: string;
+}
+interface ProgressTrackerProps {
+    steps: TrackerStep[];
+    currentStep: number;
+    orientation?: "horizontal" | "vertical";
+    className?: string;
+}
+declare function ProgressTracker({ steps, currentStep, orientation, className, }: ProgressTrackerProps): react_jsx_runtime.JSX.Element;
+
+interface ProgressStep {
+    label?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+}
+interface ProgressStepIndicatorProps extends React$1.HTMLAttributes<HTMLOListElement> {
+    /** Step definitions, or pass `count` for unlabeled dots. */
+    steps?: ProgressStep[];
+    count?: number;
+    /** Zero-based index of the active step. Steps before it are "completed". */
+    current: number;
+    orientation?: "horizontal" | "vertical";
+    size?: "sm" | "md";
+}
+declare const ProgressStepIndicator: React$1.ForwardRefExoticComponent<ProgressStepIndicatorProps & React$1.RefAttributes<HTMLOListElement>>;
+
+declare const topNavVariants: (props?: ({
+    variant?: "default" | "transparent" | "sticky" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TopNavigationProps extends VariantProps<typeof topNavVariants> {
+    leading?: React$1.ReactNode;
+    title?: React$1.ReactNode;
+    actions?: React$1.ReactNode;
+    className?: string;
+    onScrollShadow?: boolean;
+}
+declare function TopNavigation({ variant, leading, title, actions, className, onScrollShadow, }: TopNavigationProps): react_jsx_runtime.JSX.Element;
+
+declare const tooltipContentVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const tooltipArrowVariants: (props?: ({
+    placement?: "left" | "right" | "bottom" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TooltipProviderProps {
+    children: React$1.ReactNode;
+    delay?: number;
+}
+declare function TooltipProvider({ children, delay }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
+interface TooltipProps {
+    content: React$1.ReactNode;
+    children: React$1.ReactElement;
+    placement?: "top" | "bottom" | "left" | "right";
+    size?: VariantProps<typeof tooltipContentVariants>["size"];
+    maxWidth?: number;
+    disabled?: boolean;
+    arrow?: boolean;
+}
+declare function TooltipComponent({ content, children, placement, size, maxWidth, disabled, arrow, }: TooltipProps): react_jsx_runtime.JSX.Element;
+
+declare const popoverContentVariants: (props?: ({
+    placement?: "left" | "right" | "bottom" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const popoverArrowVariants: (props?: ({
+    placement?: "left" | "right" | "bottom" | "top" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface PopoverProps {
+    trigger: React$1.ReactElement;
+    children: React$1.ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    placement?: "top" | "bottom" | "left" | "right";
+    arrow?: boolean;
+    maxWidth?: number;
+    className?: string;
+    showClose?: boolean;
+    title?: string;
+}
+declare function PopoverComponent({ trigger, children, open: controlledOpen, onOpenChange, placement, arrow, maxWidth, className, showClose, title, }: PopoverProps): react_jsx_runtime.JSX.Element;
+
+declare const bottomSheetVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const dragHandleVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | "full" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface BottomSheetProps extends VariantProps<typeof bottomSheetVariants> {
+    open: boolean;
+    onClose: () => void;
+    title?: React$1.ReactNode;
+    children: React$1.ReactNode;
+    footer?: React$1.ReactNode;
+    showHandle?: boolean;
+    /** Accessible name when no string `title` is provided. */
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * Bottom sheet built on Base UI's Dialog primitive, so it gets a real focus
+ * trap, focus restore, scroll lock, outside-press + Escape dismissal, portal,
+ * and aria-modal wiring. Drag-to-dismiss is bound to the grab handle only (the
+ * previous version bound drag to the whole sheet, so any mousedown inside the
+ * content started a drag).
+ */
+declare function BottomSheet({ open, onClose, title, children, footer, size, showHandle, ariaLabel, className, }: BottomSheetProps): react_jsx_runtime.JSX.Element;
+
+declare const menuContentVariants: (props?: ({
+    align?: "center" | "end" | "start" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const menuItemVariants: (props?: ({
+    variant?: "default" | "danger" | null | undefined;
+    disabled?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface MenuItemDef {
+    key: string;
+    label: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    divider?: boolean;
+    danger?: boolean;
+}
+interface MenuProps {
+    trigger: React$1.ReactElement;
+    items: MenuItemDef[];
+    onSelect?: (key: string) => void;
+    className?: string;
+    align?: "start" | "end" | "center";
+}
+declare function MenuComponent({ trigger, items, onSelect, className, align }: MenuProps): react_jsx_runtime.JSX.Element;
+
+interface PopupProps {
+    open: boolean;
+    onClose: () => void;
+    title?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+    size?: "sm" | "md" | "lg";
+    primaryAction?: {
+        label: string;
+        onClick: () => void;
+        variant?: "default" | "destructive";
+    };
+    secondaryAction?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Custom body content rendered between the description and the actions. */
+    children?: React$1.ReactNode;
+    /**
+     * Accessible name for the dialog. Required when no `title` is provided —
+     * without a title or this prop the modal has no accessible name.
+     */
+    ariaLabel?: string;
+    className?: string;
+}
+/**
+ * Modal dialog built on Base UI's Dialog primitive, so it gets a real focus
+ * trap, focus restore on close, scroll lock, outside-press + Escape dismissal,
+ * portalling, and aria-modal / aria-labelledby / aria-describedby wiring for
+ * free — none of which the previous hand-rolled implementation had.
+ */
+declare function Popup({ open, onClose, title, description, icon, size, primaryAction, secondaryAction, children, ariaLabel, className, }: PopupProps): react_jsx_runtime.JSX.Element;
+
+interface AutocompleteOption {
+    value: string;
+    label: string;
+    group?: string;
+}
+interface AutocompleteProps {
+    options: AutocompleteOption[];
+    value?: string;
+    placeholder?: string;
+    onSelect?: (value: string) => void;
+    onSearch?: (query: string) => void;
+    loading?: boolean;
+    className?: string;
+    debounce?: number;
+}
+declare function Autocomplete({ options, value, placeholder, onSelect, onSearch, loading, className, debounce, }: AutocompleteProps): react_jsx_runtime.JSX.Element;
+
+interface ScrollAreaProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    orientation?: "vertical" | "horizontal" | "both";
+    scrollbarSize?: "sm" | "md";
+}
+declare function ScrollArea({ className, children, orientation, scrollbarSize, ...props }: ScrollAreaProps): react_jsx_runtime.JSX.Element;
+
+declare const checkboxBoxVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface CheckboxProps extends Omit<React$1.ComponentProps<typeof Checkbox$1.Root>, "className">, VariantProps<typeof checkboxBoxVariants> {
+    label?: React$1.ReactNode;
+    error?: string;
+    className?: string;
+}
+declare const Checkbox: React$1.ForwardRefExoticComponent<Omit<CheckboxProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const radioBoxVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface RadioProps extends Omit<React$1.ComponentProps<typeof Radio$1.Root>, "className">, VariantProps<typeof radioBoxVariants> {
+    label?: React$1.ReactNode;
+    error?: string;
+    className?: string;
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+declare const Radio: React$1.ForwardRefExoticComponent<Omit<RadioProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+type RadioSize = "sm" | "md" | "lg";
+interface RadioGroupProps extends Omit<React$1.ComponentProps<typeof RadioGroup$1>, "className"> {
+    className?: string;
+    orientation?: "horizontal" | "vertical";
+}
+/**
+ * Proper mutually-exclusive radio group. Wrap `RadioGroupItem`s with this so a
+ * single value is shared across the group (unlike the standalone `Radio`, which
+ * manages its own isolated group).
+ */
+declare const RadioGroup: React$1.ForwardRefExoticComponent<Omit<RadioGroupProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+interface RadioGroupItemProps extends Omit<React$1.ComponentProps<typeof Radio$1.Root>, "className"> {
+    value: NonNullable<React$1.ComponentProps<typeof Radio$1.Root>["value"]>;
+    label?: React$1.ReactNode;
+    size?: RadioSize;
+    className?: string;
+}
+declare const RadioGroupItem: React$1.ForwardRefExoticComponent<Omit<RadioGroupItemProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare const switchTrackVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const switchThumbVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SwitchProps extends Omit<React$1.ComponentProps<typeof Switch$1.Root>, "className">, VariantProps<typeof switchTrackVariants> {
+    label?: React$1.ReactNode;
+    className?: string;
+}
+declare const Switch: React$1.ForwardRefExoticComponent<Omit<SwitchProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+
+declare function Input({ className, type, ...props }: React$1.ComponentProps<"input">): react_jsx_runtime.JSX.Element;
+
+declare const textareaVariants: (props?: ({
+    variant?: "default" | "error" | null | undefined;
+    resize?: "none" | "both" | "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TextAreaProps extends Omit<React$1.TextareaHTMLAttributes<HTMLTextAreaElement>, "className">, VariantProps<typeof textareaVariants> {
+    maxLength?: number;
+    showCount?: boolean;
+    label?: string;
+    error?: string;
+    helperText?: string;
+    autoResize?: boolean;
+    className?: string;
+}
+declare const TextArea: React$1.ForwardRefExoticComponent<TextAreaProps & React$1.RefAttributes<HTMLTextAreaElement>>;
+
+interface SelectOption$1 {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface SelectProps {
+    options: SelectOption$1[];
+    value?: string;
+    placeholder?: string;
+    onChange?: (value: string) => void;
+    searchable?: boolean;
+    disabled?: boolean;
+    className?: string;
+    label?: string;
+    error?: string;
+}
+declare function Select({ options, value, placeholder, onChange, searchable, disabled, className, label, error, }: SelectProps): react_jsx_runtime.JSX.Element;
+
+declare const containerVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const itemVariants: (props?: ({
+    size?: "sm" | "md" | null | undefined;
+    active?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SegmentedItem {
+    key: string;
+    label: React$1.ReactNode;
+    icon?: React$1.ReactNode;
+}
+interface SegmentedControlProps extends VariantProps<typeof containerVariants> {
+    items: SegmentedItem[];
+    activeKey: string;
+    onChange?: (key: string) => void;
+    className?: string;
+}
+declare function SegmentedControl({ items, activeKey, onChange, size, className, }: SegmentedControlProps): react_jsx_runtime.JSX.Element;
+
+declare const searchFieldVariants: (props?: ({
+    size?: "sm" | "lg" | "md" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface SearchFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "size" | "className">, VariantProps<typeof searchFieldVariants> {
+    value: string;
+    onChange: (value: string) => void;
+    onSearch?: (value: string) => void;
+    loading?: boolean;
+    debounceMs?: number;
+    className?: string;
+}
+declare function SearchField({ value, onChange, onSearch, loading, size, className, placeholder, debounceMs, ...props }: SearchFieldProps): react_jsx_runtime.JSX.Element;
+
+interface SliderProps {
+    value?: number | [number, number];
+    defaultValue?: number | [number, number];
+    min?: number;
+    max?: number;
+    step?: number;
+    onChange?: (value: number | [number, number]) => void;
+    className?: string;
+    disabled?: boolean;
+}
+declare function Slider({ value, defaultValue, min, max, step, onChange, className, disabled, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+interface FilterButtonProps {
+    selectedCount?: number;
+    onClick?: () => void;
+    onClear?: () => void;
+    className?: string;
+    label?: string;
+}
+declare function FilterButton({ selectedCount, onClick, onClear, className, label, }: FilterButtonProps): react_jsx_runtime.JSX.Element;
+
+interface DatePickerProps {
+    value?: Date | null;
+    onChange?: (date: Date | null) => void;
+    min?: Date;
+    max?: Date;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare function DatePicker({ value, onChange, min, max, placeholder, className, disabled, }: DatePickerProps): react_jsx_runtime.JSX.Element;
+
+interface TimePickerProps {
+    value?: string;
+    onChange?: (time: string) => void;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare function TimePicker({ value, onChange, placeholder, className, disabled, }: TimePickerProps): react_jsx_runtime.JSX.Element;
+
+interface CheckMarkProps {
+    checked?: boolean;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+}
+declare function CheckMark({ checked, size, className }: CheckMarkProps): react_jsx_runtime.JSX.Element;
+
+declare const framedStyleVariants: (props?: ({
+    variant?: "default" | "error" | "success" | "warning" | "highlight" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface FramedStyleProps extends React$1.HTMLAttributes<HTMLDivElement>, VariantProps<typeof framedStyleVariants> {
+}
+declare function FramedStyle({ className, variant, children, ...props }: FramedStyleProps): react_jsx_runtime.JSX.Element;
+
+interface LabelProps extends React$1.LabelHTMLAttributes<HTMLLabelElement> {
+    error?: string;
+    description?: string;
+    required?: boolean;
+}
+declare function Label({ className, children, error, description, required, ...props }: LabelProps): react_jsx_runtime.JSX.Element;
+
+interface StepperProps {
+    value: number;
+    onChange: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    size?: "sm" | "md";
+    disabled?: boolean;
+    className?: string;
+}
+declare function Stepper({ value, onChange, min, max, step, size, disabled, className, }: StepperProps): react_jsx_runtime.JSX.Element;
+
+interface PickerActionAreaProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement> {
+    label: string;
+    description?: string;
+    selected?: boolean;
+    disabled?: boolean;
+}
+declare function PickerActionArea({ className, label, description, selected, disabled, ...props }: PickerActionAreaProps): react_jsx_runtime.JSX.Element;
+
+interface DateCalendarProps {
+    value?: Date;
+    onChange?: (date: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+    className?: string;
+}
+declare function DateCalendar({ value, onChange, minDate, maxDate, className, }: DateCalendarProps): react_jsx_runtime.JSX.Element;
+
+interface DateRange {
+    start?: Date;
+    end?: Date;
+}
+interface DateRangeCalendarProps {
+    value?: DateRange;
+    onChange?: (range: DateRange) => void;
+    className?: string;
+}
+declare function DateRangeCalendar({ value, onChange, className, }: DateRangeCalendarProps): react_jsx_runtime.JSX.Element;
+
+interface DateRangePickerProps {
+    value?: DateRange;
+    onChange?: (range: DateRange) => void;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare function DateRangePicker({ value, onChange, placeholder, className, disabled, }: DateRangePickerProps): react_jsx_runtime.JSX.Element;
+
+interface RoundCheckboxProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+    className?: string;
+    ariaLabel?: string;
+}
+declare function RoundCheckbox({ checked, onCheckedChange, size, disabled, className, ariaLabel, }: RoundCheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface SelectOption {
+    value: string;
+    label: string;
+}
+interface SelectMultipleProps {
+    options: SelectOption[];
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function SelectMultiple({ options, value, onChange, placeholder, disabled, className, }: SelectMultipleProps): react_jsx_runtime.JSX.Element;
+
+interface FormContextValue {
+    errors: Record<string, string>;
+    setError: (name: string, message: string) => void;
+    clearError: (name: string) => void;
+}
+declare function useForm(): FormContextValue;
+interface FormProps extends React$1.FormHTMLAttributes<HTMLFormElement> {
+    onSubmit?: (e: React$1.FormEvent) => void;
+}
+declare function Form({ className, children, onSubmit, ...props }: FormProps): react_jsx_runtime.JSX.Element;
+interface FormFieldProps {
+    name: string;
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function FormField({ name, children, className }: FormFieldProps): react_jsx_runtime.JSX.Element;
+interface FormSubmitProps {
+    children: React$1.ReactNode;
+    className?: string;
+}
+declare function FormSubmit({ children, className }: FormSubmitProps): react_jsx_runtime.JSX.Element;
+
+interface DividerProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    orientation?: "horizontal" | "vertical";
+    variant?: "solid" | "dashed" | "dotted";
+    label?: React$1.ReactNode;
+    spacing?: "sm" | "md" | "lg";
+}
+declare function Divider({ className, orientation, variant, label, spacing, ...props }: DividerProps): react_jsx_runtime.JSX.Element;
+
+declare const typographyVariants: (props?: ({
+    variant?: "display-1" | "display-2" | "display-3" | "title-1" | "title-2" | "title-3" | "heading-1" | "heading-2" | "headline-1" | "headline-2" | "body-1" | "body-2" | "label-1" | "label-2" | "caption-1" | "caption-2" | null | undefined;
+    color?: "default" | "brand" | "muted" | "subtle" | "inverse" | null | undefined;
+    truncate?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+interface TypographyProps extends Omit<React$1.HTMLAttributes<HTMLElement>, "color" | "as">, VariantProps<typeof typographyVariants> {
+    as?: "p" | "span" | "div" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "label";
+    lines?: number;
+}
+declare function Typography({ className, variant, color, truncate, as, lines, children, ...props }: TypographyProps): react_jsx_runtime.JSX.Element;
+
+type SpacingValue = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16 | 20 | 24 | 32;
+type RadiusValue = "none" | "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+interface BoxProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    as?: React$1.ElementType;
+    p?: SpacingValue;
+    px?: SpacingValue;
+    py?: SpacingValue;
+    pt?: SpacingValue;
+    pr?: SpacingValue;
+    pb?: SpacingValue;
+    pl?: SpacingValue;
+    m?: SpacingValue;
+    mx?: SpacingValue;
+    my?: SpacingValue;
+    mt?: SpacingValue;
+    mr?: SpacingValue;
+    mb?: SpacingValue;
+    ml?: SpacingValue;
+    bg?: string;
+    border?: boolean;
+    borderColor?: string;
+    radius?: RadiusValue;
+    width?: string | number;
+    height?: string | number;
+}
+declare const Box: React$1.ForwardRefExoticComponent<BoxProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface FlexBoxProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    direction?: "row" | "column" | "row-reverse" | "column-reverse";
+    align?: "start" | "center" | "end" | "stretch" | "baseline";
+    justify?: "start" | "center" | "end" | "between" | "around" | "evenly";
+    gap?: 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16;
+    wrap?: "wrap" | "nowrap" | "wrap-reverse";
+    center?: boolean;
+    column?: boolean;
+    grow?: number;
+    shrink?: number;
+    basis?: string | number;
+}
+declare const FlexBox: React$1.ForwardRefExoticComponent<FlexBoxProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type GapValue = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 8 | 10 | 12 | 16;
+interface GridProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Number of equal columns, or an explicit grid-template-columns string. */
+    columns?: number | string;
+    /** Number of equal rows, or an explicit grid-template-rows string. */
+    rows?: number | string;
+    gap?: GapValue;
+    columnGap?: GapValue;
+    rowGap?: GapValue;
+    align?: "start" | "center" | "end" | "stretch";
+    justify?: "start" | "center" | "end" | "stretch" | "between" | "around" | "evenly";
+    inline?: boolean;
+    as?: React$1.ElementType;
+}
+declare const Grid: React$1.ForwardRefExoticComponent<GridProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface GridItemProps extends React$1.HTMLAttributes<HTMLDivElement> {
+    /** Number of columns to span, or "full" to span the whole row. */
+    colSpan?: number | "full";
+    /** Number of rows to span. */
+    rowSpan?: number | "full";
+    colStart?: number;
+    colEnd?: number;
+    rowStart?: number;
+    rowEnd?: number;
+    align?: "start" | "center" | "end" | "stretch";
+    justify?: "start" | "center" | "end" | "stretch";
+    as?: React$1.ElementType;
+}
+declare const GridItem: React$1.ForwardRefExoticComponent<GridItemProps & React$1.RefAttributes<HTMLDivElement>>;
+
+interface TimeViewProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+    value: Date | string;
+    format?: "24h" | "12h";
+    showSeconds?: boolean;
+    className?: string;
+}
+declare function TimeView({ value, format, showSeconds, className, ...props }: TimeViewProps): react_jsx_runtime.JSX.Element;
+
+declare const _default: {
+    blue: {
+        readonly 10: "#001536";
+        readonly 20: "#002966";
+        readonly 30: "#003E9C";
+        readonly 40: "#0054D1";
+        readonly 45: "#005EEB";
+        readonly 50: "#0066FF";
+        readonly 55: "#1A75FF";
+        readonly 60: "#3385FF";
+        readonly 65: "#4F95FF";
+        readonly 70: "#69A5FF";
+        readonly 80: "#9EC5FF";
+        readonly 90: "#C9DEFE";
+        readonly 95: "#EAF2FE";
+        readonly 99: "#F7FBFF";
+    };
+    common: {
+        readonly 0: "#000000";
+        readonly 100: "#ffffff";
+    };
+    coolNeutral: {
+        readonly 5: "#0F0F10";
+        readonly 7: "#141415";
+        readonly 10: "#171719";
+        readonly 15: "#1B1C1E";
+        readonly 17: "#212225";
+        readonly 20: "#292A2D";
+        readonly 22: "#2E2F33";
+        readonly 23: "#333438";
+        readonly 25: "#37383C";
+        readonly 30: "#46474C";
+        readonly 40: "#5A5C63";
+        readonly 50: "#70737C";
+        readonly 60: "#878A93";
+        readonly 70: "#989BA2";
+        readonly 80: "#AEB0B6";
+        readonly 90: "#C2C4C8";
+        readonly 95: "#DBDCDF";
+        readonly 96: "#E1E2E4";
+        readonly 97: "#EAEBEC";
+        readonly 98: "#F4F4F5";
+        readonly 99: "#F7F7F8";
+    };
+    cyan: {
+        readonly 10: "#00252B";
+        readonly 20: "#004854";
+        readonly 30: "#006F82";
+        readonly 40: "#0098B2";
+        readonly 50: "#00BDDE";
+        readonly 60: "#28D0ED";
+        readonly 70: "#57DFF7";
+        readonly 80: "#8AEDFF";
+        readonly 90: "#B5F4FF";
+        readonly 95: "#DEFAFF";
+        readonly 99: "#F7FEFF";
+    };
+    green: {
+        readonly 10: "#00240C";
+        readonly 20: "#004517";
+        readonly 30: "#006E25";
+        readonly 40: "#009632";
+        readonly 50: "#00BF40";
+        readonly 60: "#1ED45A";
+        readonly 70: "#49E57D";
+        readonly 80: "#7DF5A5";
+        readonly 90: "#ACFCC7";
+        readonly 95: "#D9FFE6";
+        readonly 99: "#F2FFF6";
+    };
+    lightBlue: {
+        readonly 10: "#002130";
+        readonly 20: "#004261";
+        readonly 30: "#006796";
+        readonly 40: "#008DCF";
+        readonly 50: "#00AEFF";
+        readonly 60: "#3DC2FF";
+        readonly 70: "#70D2FF";
+        readonly 80: "#A1E1FF";
+        readonly 90: "#C4ECFE";
+        readonly 95: "#E5F6FE";
+        readonly 99: "#F7FDFF";
+    };
+    lime: {
+        readonly 10: "#112900";
+        readonly 20: "#225200";
+        readonly 30: "#347D00";
+        readonly 37: "#429E00";
+        readonly 40: "#48AD00";
+        readonly 50: "#58CF04";
+        readonly 60: "#6BE016";
+        readonly 70: "#88F03E";
+        readonly 80: "#AEF779";
+        readonly 90: "#CCFCA9";
+        readonly 95: "#E6FFD4";
+        readonly 99: "#F8FFF2";
+    };
+    neutral: {
+        readonly 5: "#0F0F0F";
+        readonly 10: "#171717";
+        readonly 15: "#1C1C1C";
+        readonly 20: "#2A2A2A";
+        readonly 22: "#303030";
+        readonly 30: "#474747";
+        readonly 40: "#5C5C5C";
+        readonly 50: "#737373";
+        readonly 60: "#8A8A8A";
+        readonly 70: "#9B9B9B";
+        readonly 80: "#B0B0B0";
+        readonly 90: "#C4C4C4";
+        readonly 95: "#DCDCDC";
+        readonly 99: "#F7F7F7";
+    };
+    orange: {
+        readonly 10: "#361E00";
+        readonly 20: "#663A00";
+        readonly 30: "#9C5800";
+        readonly 39: "#D17600";
+        readonly 40: "#D47800";
+        readonly 50: "#FF9200";
+        readonly 60: "#FFA938";
+        readonly 70: "#FFC06E";
+        readonly 80: "#FFD49C";
+        readonly 90: "#FEE6C6";
+        readonly 95: "#FEF4E6";
+        readonly 99: "#FFFCF7";
+    };
+    pink: {
+        readonly 10: "#3D0133";
+        readonly 20: "#730560";
+        readonly 30: "#A81690";
+        readonly 40: "#D331B8";
+        readonly 46: "#E846CD";
+        readonly 50: "#F553DA";
+        readonly 60: "#FA73E3";
+        readonly 70: "#FF94ED";
+        readonly 80: "#FFB8F3";
+        readonly 90: "#FED3F7";
+        readonly 95: "#FEECFB";
+        readonly 99: "#FFFAFE";
+    };
+    purple: {
+        readonly 99: "#FEFBFF";
+        readonly 95: "#F9EDFF";
+        readonly 90: "#F2D6FF";
+        readonly 80: "#E9BAFF";
+        readonly 70: "#DE96FF";
+        readonly 60: "#D478FF";
+        readonly 50: "#CB59FF";
+        readonly 40: "#AD36E3";
+        readonly 30: "#861CB8";
+        readonly 20: "#580A7D";
+        readonly 10: "#290247";
+    };
+    red: {
+        readonly 10: "#3B0101";
+        readonly 20: "#730303";
+        readonly 30: "#B00C0C";
+        readonly 40: "#E52222";
+        readonly 50: "#FF4242";
+        readonly 60: "#FF6363";
+        readonly 70: "#FF8C8C";
+        readonly 80: "#FFB5B5";
+        readonly 90: "#FED5D5";
+        readonly 95: "#FEECEC";
+        readonly 99: "#FFFAFA";
+    };
+    violet: {
+        readonly 10: "#11024D";
+        readonly 20: "#23098F";
+        readonly 30: "#3A16C9";
+        readonly 40: "#4F29E5";
+        readonly 45: "#5B37ED";
+        readonly 50: "#6541F2";
+        readonly 60: "#7D5EF7";
+        readonly 70: "#9E86FC";
+        readonly 80: "#C0B0FF";
+        readonly 90: "#DBD3FE";
+        readonly 95: "#F0ECFE";
+        readonly 99: "#FBFAFF";
+    };
+    redOrange: {
+        readonly 10: "#290F00";
+        readonly 20: "#592100";
+        readonly 30: "#913500";
+        readonly 40: "#C94A00";
+        readonly 48: "#F55A00";
+        readonly 50: "#FF5E00";
+        readonly 60: "#FF7B2E";
+        readonly 70: "#FF9B61";
+        readonly 80: "#FFBD96";
+        readonly 90: "#FED9C4";
+        readonly 95: "#FEEEE5";
+        readonly 99: "#FFFAF7";
+    };
+};
+
+declare const lightTheme: {
+    atomic: typeof _default;
+    semantic: {
+        platform: {
+            ios: {
+                navigation: string;
+            };
+        };
+        static: {
+            white: "#ffffff";
+            black: "#000000";
+        };
+        primary: {
+            normal: "#0066FF";
+            strong: "#005EEB";
+            heavy: "#0054D1";
+        };
+        label: {
+            normal: "#171719";
+            strong: "#000000";
+            neutral: string;
+            alternative: string;
+            assistive: string;
+            disable: string;
+        };
+        background: {
+            normal: {
+                normal: "#ffffff";
+                alternative: "#F7F7F8";
+            };
+            elevated: {
+                normal: "#ffffff";
+                alternative: "#F7F7F8";
+            };
+            transparent: {
+                normal: string;
+                alternative: string;
+            };
+        };
+        interaction: {
+            inactive: "#989BA2";
+            disable: "#F4F4F5";
+        };
+        line: {
+            normal: {
+                normal: string;
+                neutral: string;
+                alternative: string;
+            };
+            solid: {
+                normal: "#E1E2E4";
+                neutral: "#EAEBEC";
+                alternative: "#F4F4F5";
+            };
+        };
+        status: {
+            positive: "#00BF40";
+            cautionary: "#FF9200";
+            negative: "#FF4242";
+        };
+        accent: {
+            background: {
+                redOrange: "#FF5E00";
+                lime: "#58CF04";
+                cyan: "#00BDDE";
+                lightBlue: "#00AEFF";
+                violet: "#6541F2";
+                purple: "#CB59FF";
+                pink: "#F553DA";
+            };
+            foreground: {
+                red: "#E52222";
+                redOrange: "#F55A00";
+                orange: "#D17600";
+                lime: "#429E00";
+                green: "#009632";
+                cyan: "#0098B2";
+                lightBlue: "#008DCF";
+                blue: "#005EEB";
+                violet: "#5B37ED";
+                purple: "#AD36E3";
+                pink: "#E846CD";
+            };
+        };
+        inverse: {
+            primary: "#3385FF";
+            background: "#1B1C1E";
+            label: "#F7F7F8";
+        };
+        fill: {
+            normal: string;
+            strong: string;
+            alternative: string;
+        };
+        material: {
+            dimmer: string;
+        };
+        elevation: {
+            shadow: {
+                normal: {
+                    xsmall: string;
+                    small: string;
+                    medium: string;
+                    large: string;
+                    xlarge: string;
+                };
+                drop: {
+                    xsmall: string;
+                    small: string;
+                    medium: string;
+                    large: string;
+                    xlarge: string;
+                };
+                spread: {
+                    small: string;
+                    medium: string;
+                };
+            };
+        };
+    };
+    opacity: {
+        readonly 0: 0;
+        readonly 5: 0.05;
+        readonly 8: 0.08;
+        readonly 12: 0.12;
+        readonly 16: 0.16;
+        readonly 22: 0.22;
+        readonly 28: 0.28;
+        readonly 35: 0.35;
+        readonly 43: 0.43;
+        readonly 52: 0.52;
+        readonly 61: 0.61;
+        readonly 74: 0.74;
+        readonly 88: 0.88;
+        readonly 97: 0.97;
+        readonly 100: 1;
+    };
+    breakpoint: {
+        readonly xl: "1600px";
+        readonly lg: "1200px";
+        readonly md: "992px";
+        readonly sm: "768px";
+        readonly xs: "0px";
+    };
+    spacing: {
+        readonly 0: "0px";
+        readonly 0.5: "0.5px";
+        readonly 1: "1px";
+        readonly 2: "2px";
+        readonly 4: "4px";
+        readonly 6: "6px";
+        readonly 8: "8px";
+        readonly 10: "10px";
+        readonly 12: "12px";
+        readonly 14: "14px";
+        readonly 16: "16px";
+        readonly 20: "20px";
+        readonly 24: "24px";
+        readonly 32: "32px";
+        readonly 40: "40px";
+        readonly 48: "48px";
+        readonly 56: "56px";
+        readonly 64: "64px";
+        readonly 72: "72px";
+        readonly 80: "80px";
+    };
+    zIndex: {
+        readonly modal: 1300;
+    };
+};
+declare const darkTheme: {
+    atomic: typeof _default;
+    semantic: {
+        platform: {
+            ios: {
+                navigation: string;
+            };
+        };
+        static: {
+            white: "#ffffff";
+            black: "#000000";
+        };
+        primary: {
+            normal: "#3385FF";
+            strong: "#1A75FF";
+            heavy: "#0066FF";
+        };
+        label: {
+            normal: "#F7F7F8";
+            strong: "#ffffff";
+            neutral: string;
+            alternative: string;
+            assistive: string;
+            disable: string;
+        };
+        background: {
+            normal: {
+                normal: "#1B1C1E";
+                alternative: "#0F0F10";
+            };
+            elevated: {
+                normal: "#212225";
+                alternative: "#141415";
+            };
+            transparent: {
+                normal: string;
+                alternative: string;
+            };
+        };
+        interaction: {
+            inactive: "#5A5C63";
+            disable: "#2E2F33";
+        };
+        line: {
+            normal: {
+                normal: string;
+                neutral: string;
+                alternative: string;
+            };
+            solid: {
+                normal: "#37383C";
+                neutral: "#333438";
+                alternative: "#2E2F33";
+            };
+        };
+        status: {
+            positive: "#1ED45A";
+            cautionary: "#FFA938";
+            negative: "#FF6363";
+        };
+        accent: {
+            background: {
+                redOrange: "#FF7B2E";
+                lime: "#6BE016";
+                cyan: "#28D0ED";
+                lightBlue: "#3DC2FF";
+                violet: "#7D5EF7";
+                purple: "#D478FF";
+                pink: "#FA73E3";
+            };
+            foreground: {
+                red: "#FF6363";
+                redOrange: "#FF7B2E";
+                orange: "#FF9200";
+                lime: "#58CF04";
+                green: "#1ED45A";
+                cyan: "#00BDDE";
+                lightBlue: "#00AEFF";
+                blue: "#4F95FF";
+                violet: "#9E86FC";
+                purple: "#D478FF";
+                pink: "#FA73E3";
+            };
+        };
+        inverse: {
+            primary: "#0066FF";
+            background: "#ffffff";
+            label: "#171719";
+        };
+        fill: {
+            normal: string;
+            strong: string;
+            alternative: string;
+        };
+        material: {
+            dimmer: string;
+        };
+        elevation: {
+            shadow: {
+                normal: {
+                    xsmall: string;
+                    small: string;
+                    medium: string;
+                    large: string;
+                    xlarge: string;
+                };
+                drop: {
+                    xsmall: string;
+                    small: string;
+                    medium: string;
+                    large: string;
+                    xlarge: string;
+                };
+                spread: {
+                    small: string;
+                    medium: string;
+                };
+            };
+        };
+    };
+    opacity: {
+        readonly 0: 0;
+        readonly 5: 0.05;
+        readonly 8: 0.08;
+        readonly 12: 0.12;
+        readonly 16: 0.16;
+        readonly 22: 0.22;
+        readonly 28: 0.28;
+        readonly 35: 0.35;
+        readonly 43: 0.43;
+        readonly 52: 0.52;
+        readonly 61: 0.61;
+        readonly 74: 0.74;
+        readonly 88: 0.88;
+        readonly 97: 0.97;
+        readonly 100: 1;
+    };
+    breakpoint: {
+        readonly xl: "1600px";
+        readonly lg: "1200px";
+        readonly md: "992px";
+        readonly sm: "768px";
+        readonly xs: "0px";
+    };
+    spacing: {
+        readonly 0: "0px";
+        readonly 0.5: "0.5px";
+        readonly 1: "1px";
+        readonly 2: "2px";
+        readonly 4: "4px";
+        readonly 6: "6px";
+        readonly 8: "8px";
+        readonly 10: "10px";
+        readonly 12: "12px";
+        readonly 14: "14px";
+        readonly 16: "16px";
+        readonly 20: "20px";
+        readonly 24: "24px";
+        readonly 32: "32px";
+        readonly 40: "40px";
+        readonly 48: "48px";
+        readonly 56: "56px";
+        readonly 64: "64px";
+        readonly 72: "72px";
+        readonly 80: "80px";
+    };
+    zIndex: {
+        readonly modal: 1300;
+    };
+};
+declare const theme: {
+    light: {
+        atomic: typeof _default;
+        semantic: {
+            platform: {
+                ios: {
+                    navigation: string;
+                };
+            };
+            static: {
+                white: "#ffffff";
+                black: "#000000";
+            };
+            primary: {
+                normal: "#0066FF";
+                strong: "#005EEB";
+                heavy: "#0054D1";
+            };
+            label: {
+                normal: "#171719";
+                strong: "#000000";
+                neutral: string;
+                alternative: string;
+                assistive: string;
+                disable: string;
+            };
+            background: {
+                normal: {
+                    normal: "#ffffff";
+                    alternative: "#F7F7F8";
+                };
+                elevated: {
+                    normal: "#ffffff";
+                    alternative: "#F7F7F8";
+                };
+                transparent: {
+                    normal: string;
+                    alternative: string;
+                };
+            };
+            interaction: {
+                inactive: "#989BA2";
+                disable: "#F4F4F5";
+            };
+            line: {
+                normal: {
+                    normal: string;
+                    neutral: string;
+                    alternative: string;
+                };
+                solid: {
+                    normal: "#E1E2E4";
+                    neutral: "#EAEBEC";
+                    alternative: "#F4F4F5";
+                };
+            };
+            status: {
+                positive: "#00BF40";
+                cautionary: "#FF9200";
+                negative: "#FF4242";
+            };
+            accent: {
+                background: {
+                    redOrange: "#FF5E00";
+                    lime: "#58CF04";
+                    cyan: "#00BDDE";
+                    lightBlue: "#00AEFF";
+                    violet: "#6541F2";
+                    purple: "#CB59FF";
+                    pink: "#F553DA";
+                };
+                foreground: {
+                    red: "#E52222";
+                    redOrange: "#F55A00";
+                    orange: "#D17600";
+                    lime: "#429E00";
+                    green: "#009632";
+                    cyan: "#0098B2";
+                    lightBlue: "#008DCF";
+                    blue: "#005EEB";
+                    violet: "#5B37ED";
+                    purple: "#AD36E3";
+                    pink: "#E846CD";
+                };
+            };
+            inverse: {
+                primary: "#3385FF";
+                background: "#1B1C1E";
+                label: "#F7F7F8";
+            };
+            fill: {
+                normal: string;
+                strong: string;
+                alternative: string;
+            };
+            material: {
+                dimmer: string;
+            };
+            elevation: {
+                shadow: {
+                    normal: {
+                        xsmall: string;
+                        small: string;
+                        medium: string;
+                        large: string;
+                        xlarge: string;
+                    };
+                    drop: {
+                        xsmall: string;
+                        small: string;
+                        medium: string;
+                        large: string;
+                        xlarge: string;
+                    };
+                    spread: {
+                        small: string;
+                        medium: string;
+                    };
+                };
+            };
+        };
+        opacity: {
+            readonly 0: 0;
+            readonly 5: 0.05;
+            readonly 8: 0.08;
+            readonly 12: 0.12;
+            readonly 16: 0.16;
+            readonly 22: 0.22;
+            readonly 28: 0.28;
+            readonly 35: 0.35;
+            readonly 43: 0.43;
+            readonly 52: 0.52;
+            readonly 61: 0.61;
+            readonly 74: 0.74;
+            readonly 88: 0.88;
+            readonly 97: 0.97;
+            readonly 100: 1;
+        };
+        breakpoint: {
+            readonly xl: "1600px";
+            readonly lg: "1200px";
+            readonly md: "992px";
+            readonly sm: "768px";
+            readonly xs: "0px";
+        };
+        spacing: {
+            readonly 0: "0px";
+            readonly 0.5: "0.5px";
+            readonly 1: "1px";
+            readonly 2: "2px";
+            readonly 4: "4px";
+            readonly 6: "6px";
+            readonly 8: "8px";
+            readonly 10: "10px";
+            readonly 12: "12px";
+            readonly 14: "14px";
+            readonly 16: "16px";
+            readonly 20: "20px";
+            readonly 24: "24px";
+            readonly 32: "32px";
+            readonly 40: "40px";
+            readonly 48: "48px";
+            readonly 56: "56px";
+            readonly 64: "64px";
+            readonly 72: "72px";
+            readonly 80: "80px";
+        };
+        zIndex: {
+            readonly modal: 1300;
+        };
+    };
+    dark: {
+        atomic: typeof _default;
+        semantic: {
+            platform: {
+                ios: {
+                    navigation: string;
+                };
+            };
+            static: {
+                white: "#ffffff";
+                black: "#000000";
+            };
+            primary: {
+                normal: "#3385FF";
+                strong: "#1A75FF";
+                heavy: "#0066FF";
+            };
+            label: {
+                normal: "#F7F7F8";
+                strong: "#ffffff";
+                neutral: string;
+                alternative: string;
+                assistive: string;
+                disable: string;
+            };
+            background: {
+                normal: {
+                    normal: "#1B1C1E";
+                    alternative: "#0F0F10";
+                };
+                elevated: {
+                    normal: "#212225";
+                    alternative: "#141415";
+                };
+                transparent: {
+                    normal: string;
+                    alternative: string;
+                };
+            };
+            interaction: {
+                inactive: "#5A5C63";
+                disable: "#2E2F33";
+            };
+            line: {
+                normal: {
+                    normal: string;
+                    neutral: string;
+                    alternative: string;
+                };
+                solid: {
+                    normal: "#37383C";
+                    neutral: "#333438";
+                    alternative: "#2E2F33";
+                };
+            };
+            status: {
+                positive: "#1ED45A";
+                cautionary: "#FFA938";
+                negative: "#FF6363";
+            };
+            accent: {
+                background: {
+                    redOrange: "#FF7B2E";
+                    lime: "#6BE016";
+                    cyan: "#28D0ED";
+                    lightBlue: "#3DC2FF";
+                    violet: "#7D5EF7";
+                    purple: "#D478FF";
+                    pink: "#FA73E3";
+                };
+                foreground: {
+                    red: "#FF6363";
+                    redOrange: "#FF7B2E";
+                    orange: "#FF9200";
+                    lime: "#58CF04";
+                    green: "#1ED45A";
+                    cyan: "#00BDDE";
+                    lightBlue: "#00AEFF";
+                    blue: "#4F95FF";
+                    violet: "#9E86FC";
+                    purple: "#D478FF";
+                    pink: "#FA73E3";
+                };
+            };
+            inverse: {
+                primary: "#0066FF";
+                background: "#ffffff";
+                label: "#171719";
+            };
+            fill: {
+                normal: string;
+                strong: string;
+                alternative: string;
+            };
+            material: {
+                dimmer: string;
+            };
+            elevation: {
+                shadow: {
+                    normal: {
+                        xsmall: string;
+                        small: string;
+                        medium: string;
+                        large: string;
+                        xlarge: string;
+                    };
+                    drop: {
+                        xsmall: string;
+                        small: string;
+                        medium: string;
+                        large: string;
+                        xlarge: string;
+                    };
+                    spread: {
+                        small: string;
+                        medium: string;
+                    };
+                };
+            };
+        };
+        opacity: {
+            readonly 0: 0;
+            readonly 5: 0.05;
+            readonly 8: 0.08;
+            readonly 12: 0.12;
+            readonly 16: 0.16;
+            readonly 22: 0.22;
+            readonly 28: 0.28;
+            readonly 35: 0.35;
+            readonly 43: 0.43;
+            readonly 52: 0.52;
+            readonly 61: 0.61;
+            readonly 74: 0.74;
+            readonly 88: 0.88;
+            readonly 97: 0.97;
+            readonly 100: 1;
+        };
+        breakpoint: {
+            readonly xl: "1600px";
+            readonly lg: "1200px";
+            readonly md: "992px";
+            readonly sm: "768px";
+            readonly xs: "0px";
+        };
+        spacing: {
+            readonly 0: "0px";
+            readonly 0.5: "0.5px";
+            readonly 1: "1px";
+            readonly 2: "2px";
+            readonly 4: "4px";
+            readonly 6: "6px";
+            readonly 8: "8px";
+            readonly 10: "10px";
+            readonly 12: "12px";
+            readonly 14: "14px";
+            readonly 16: "16px";
+            readonly 20: "20px";
+            readonly 24: "24px";
+            readonly 32: "32px";
+            readonly 40: "40px";
+            readonly 48: "48px";
+            readonly 56: "56px";
+            readonly 64: "64px";
+            readonly 72: "72px";
+            readonly 80: "80px";
+        };
+        zIndex: {
+            readonly modal: 1300;
+        };
+    };
+};
+
+type Theme = typeof lightTheme | typeof darkTheme;
+type BreakPoint = Theme['breakpoint'];
+type Spacing = Theme['spacing'];
+type MergeWithDot<T extends string> = T extends '' ? '' : `.${T}`;
+type ObjectToNestedKeys<T> = (T extends object ? {
+    [K in Exclude<keyof T, symbol>]: `${K}${MergeWithDot<ObjectToNestedKeys<T[K]>>}`;
+}[Exclude<keyof T, symbol>] : '') extends infer D ? Extract<D, string> : never;
+type ThemeToken = ObjectToNestedKeys<Theme>;
+type PickThemeShadowToken<T extends string> = T extends `semantic.elevation.shadow.${infer _}` ? T : never;
+type ThemeShadowToken = PickThemeShadowToken<ObjectToNestedKeys<Pick<Theme, 'semantic'>>>;
+type ThemeColorsToken = ObjectToNestedKeys<Pick<Theme, 'atomic'>> | Exclude<ObjectToNestedKeys<Pick<Theme, 'semantic'>>, 'semantic.platform.ios.navigation' | ThemeShadowToken>;
+type ThemeOpacityToken = ObjectToNestedKeys<Pick<Theme, 'opacity'>>;
+
+/**
+ * Type for the `sx` prop. Emotion-free — plain React.CSSProperties.
+ */
+type SxProp = React.CSSProperties;
+
+declare const getColorByToken: (theme: Theme, token: ThemeColorsToken) => string;
+declare const addHexOpacity: (hex: string, value: number) => string;
+
+declare const useSxProps: () => (sx: SxProp) => React$1.CSSProperties;
+
+declare const useTheme: () => Theme;
+
+type ThemeProviderProps = {
+    theme?: 'light' | 'dark';
+    children: ReactNode;
+    provider?: (props: {
+        theme: Theme;
+        children: ReactNode;
+    }) => JSX.Element;
+};
+
+declare const ThemeProvider: ({ theme: localTheme, children, provider, }: ThemeProviderProps) => react_jsx_runtime.JSX.Element;
+
+type ForceThemeProps = {
+    theme: 'light' | 'dark';
+    children?: ReactNode;
+};
+
+declare const ForceTheme: {
+    ({ theme: localTheme, children }: ForceThemeProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+type Props = {
+    styles: string | ((theme: Theme) => string);
+};
+declare const Global: ({ styles }: Props) => react_jsx_runtime.JSX.Element;
+
+export { Input as $, type ActionAreaProps as A, BottomNavigation as B, Card as C, Checkbox as D, Chip as E, ContentBadge as F, type ContentBadgeProps as G, type ContentBadgeVariant as H, DateCalendar as I, DatePicker as J, DateRangeCalendar as K, DateRangePicker as L, Divider as M, FallbackView as N, FilterButton as O, FlexBox as P, ForceTheme as Q, Form as R, FormField as S, FormSubmit as T, FramedStyle as U, Global as V, Grid as W, GridItem as X, type GridItemProps as Y, type GridProps as Z, IconButton as _, Accordion as a, ThemeProvider as a$, Label as a0, List as a1, ListCard as a2, ListCell as a3, type ListCellBaseProps as a4, ListCellChevron as a5, type ListCellProps as a6, ListItem as a7, Loading as a8, MenuComponent as a9, SectionMessage as aA, SegmentedControl as aB, type SegmentedControlProps as aC, type SegmentedItem as aD, Select as aE, SelectMultiple as aF, type SelectOption$1 as aG, type SelectProps as aH, Skeleton as aI, Slider as aJ, type SliderProps as aK, Snackbar as aL, type Spacing as aM, Stepper as aN, Switch as aO, Tab as aP, Table as aQ, TableBody as aR, TableCell as aS, TableHead as aT, TableHeader as aU, TableRow as aV, TextArea as aW, TextButton as aX, type Theme as aY, type ThemeColorsToken as aZ, type ThemeOpacityToken as a_, type MenuItemDef as aa, type MenuProps as ab, PageCounter as ac, Pagination as ad, PaginationDots as ae, PickerActionArea as af, PlayBadge as ag, PopoverComponent as ah, Popup as ai, ProgressIndicator as aj, type ProgressStep as ak, ProgressStepIndicator as al, type ProgressStepIndicatorProps as am, ProgressTracker as an, PushBadge as ao, Radio as ap, RadioGroup as aq, RadioGroupItem as ar, type RadioGroupItemProps as as, type RadioGroupProps as at, RoundCheckbox as au, ScrollArea as av, SearchField as aw, type SearchFieldProps as ax, SectionHeader as ay, type SectionHeaderProps as az, AccordionContent as b, type ThemeShadowToken as b0, type ThemeToken as b1, Thumbnail as b2, type ThumbnailProps as b3, type ThumbnailRatio as b4, TimePicker as b5, TimeView as b6, Toast as b7, type ToastItem as b8, ToggleIcon as b9, menuContentVariants as bA, menuItemVariants as bB, popoverArrowVariants as bC, popoverContentVariants as bD, radioBoxVariants as bE, ratioMap as bF, searchFieldVariants as bG, sectionHeaderVariants as bH, sectionMessageVariants as bI, sizeMap as bJ, snackbarVariants as bK, switchThumbVariants as bL, switchTrackVariants as bM, tabVariants as bN, textButtonVariants as bO, textareaVariants as bP, theme as bQ, thumbnailVariants as bR, toastVariants as bS, tooltipArrowVariants as bT, tooltipContentVariants as bU, topNavVariants as bV, typographyVariants as bW, useForm as bX, useSxProps as bY, useTheme as bZ, ActionArea as b_, TooltipComponent as ba, TooltipProvider as bb, TopNavigation as bc, Typography as bd, type TypographyProps as be, addHexOpacity as bf, alertVariants as bg, avatarGroupVariants as bh, avatarVariants as bi, bottomSheetVariants as bj, buttonVariants as bk, checkboxBoxVariants as bl, chipVariants as bm, containerVariants as bn, contentBadgeVariants as bo, darkTheme as bp, dotVariants as bq, dragHandleVariants as br, framedStyleVariants as bs, getBorderRadius as bt, getColorByToken as bu, getInitials as bv, iconButtonVariants as bw, itemVariants as bx, lightTheme as by, listCellVariants as bz, AccordionItem as c, AccordionTrigger as d, Alert as e, Autocomplete as f, Avatar as g, AvatarButton as h, AvatarGroup as i, type AvatarGroupItem as j, type AvatarGroupProps as k, type AvatarProps as l, type AvatarSize as m, type AvatarStatus as n, BottomSheet as o, Box as p, type BreakPoint as q, Button as r, CardContent as s, CardDescription as t, CardFooter as u, CardHeader as v, CardList as w, CardTitle as x, Category as y, CheckMark as z };