@masumdev/rn-ui 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1593 @@
+import React, { ReactNode } from 'react';
+import { TextStyle, ViewStyle, ImageStyle, StyleProp, ModalProps, ViewProps, View, ImageProps, PressableProps, TextProps as TextProps$1, TextInputProps, TextInput, KeyboardAvoidingViewProps, ScrollViewProps, GestureResponderEvent } from 'react-native';
+import { Calendar as Calendar$1 } from 'react-native-calendars';
+import { BottomSheetProps as BottomSheetProps$1, BottomSheetBackdrop } from '@gorhom/bottom-sheet';
+export { BottomSheetBackdropProps, BottomSheetFlatList, BottomSheetModal, BottomSheetModalProps, BottomSheetModalProvider, BottomSheetScrollView, BottomSheetSectionList, BottomSheetTextInput, BottomSheetView, BottomSheetProps as GorhomBottomSheetProps, BottomSheetView as SheetContent, useBottomSheet, useBottomSheetModal } from '@gorhom/bottom-sheet';
+import { BottomSheetMethods } from '@gorhom/bottom-sheet/lib/typescript/types';
+export { BottomSheetMethods } from '@gorhom/bottom-sheet/lib/typescript/types';
+import { SharedValue } from 'react-native-reanimated';
+
+type ThemeMode = "light" | "dark";
+type ColorSchemePreference = ThemeMode | "system";
+type ThemeStyle = ViewStyle | TextStyle | ImageStyle;
+type ThemeNamedStyles<T> = {
+    [P in keyof T]: ThemeStyle;
+};
+type ThemeStyleFactory<T extends ThemeNamedStyles<T>> = (theme: Theme) => T;
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+interface ThemeColors {
+    background: string;
+    backgroundMuted: string;
+    backgroundSubtle: string;
+    surface: string;
+    surfaceRaised: string;
+    surfaceMuted: string;
+    text: string;
+    textMuted: string;
+    textSubtle: string;
+    textInverse: string;
+    primary: string;
+    primarySoft: string;
+    primaryStrong: string;
+    onPrimary: string;
+    secondary: string;
+    secondarySoft: string;
+    onSecondary: string;
+    accent: string;
+    accentSoft: string;
+    onAccent: string;
+    success: string;
+    successSoft: string;
+    onSuccess: string;
+    warning: string;
+    warningSoft: string;
+    onWarning: string;
+    danger: string;
+    dangerSoft: string;
+    onDanger: string;
+    info: string;
+    infoSoft: string;
+    onInfo: string;
+    border: string;
+    borderMuted: string;
+    divider: string;
+    input: string;
+    placeholder: string;
+    disabled: string;
+    disabledText: string;
+    overlay: string;
+    transparent: string;
+}
+interface TypographyVariant {
+    fontFamily?: string;
+    fontSize: number;
+    lineHeight: number;
+    fontWeight?: TextStyle["fontWeight"];
+    letterSpacing?: number;
+}
+interface ThemeTypography {
+    display: TypographyVariant;
+    h1: TypographyVariant;
+    h2: TypographyVariant;
+    h3: TypographyVariant;
+    title: TypographyVariant;
+    subtitle: TypographyVariant;
+    body: TypographyVariant;
+    bodySmall: TypographyVariant;
+    label: TypographyVariant;
+    labelSmall: TypographyVariant;
+    caption: TypographyVariant;
+}
+interface ThemeFonts {
+    regular?: string;
+    medium?: string;
+    semibold?: string;
+    bold?: string;
+    mono?: string;
+}
+interface ThemeSpacing {
+    none: number;
+    xxs: number;
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    xxl: number;
+    xxxl: number;
+}
+interface ThemeRadii {
+    none: number;
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+    xl: number;
+    xxl: number;
+    full: number;
+}
+interface ThemeShadow {
+    shadowColor: string;
+    shadowOffset: {
+        width: number;
+        height: number;
+    };
+    shadowOpacity: number;
+    shadowRadius: number;
+    elevation: number;
+}
+interface ThemeShadows {
+    none: ThemeShadow;
+    sm: ThemeShadow;
+    md: ThemeShadow;
+    lg: ThemeShadow;
+}
+interface ThemeComponents {
+    borderWidth: {
+        default: number;
+        strong: number;
+        focus: number;
+        ring: number;
+        hairline: number;
+    };
+    button: {
+        height: Record<"xs" | "sm" | "md" | "lg" | "xl", number>;
+        paddingX: Record<"xs" | "sm" | "md" | "lg" | "xl", number>;
+        iconSize: Record<"xs" | "sm" | "md" | "lg" | "xl", number>;
+    };
+    iconButton: {
+        size: Record<"sm" | "md" | "lg", number>;
+        iconSize: Record<"sm" | "md" | "lg", number>;
+        badge: {
+            size: number;
+            minWidth: number;
+            offset: number;
+            paddingX: number;
+            borderWidth: number;
+            fontSize: number;
+            lineHeight: number;
+        };
+    };
+    timeline: {
+        indicatorSize: number;
+        connectorWidth: number;
+        connectorMinHeight: number;
+    };
+    table: {
+        minColumnWidth: number;
+    };
+    metricCard: {
+        iconSize: number;
+    };
+    floatingActionButton: {
+        size: Record<"sm" | "md" | "lg", number>;
+        iconSize: Record<"sm" | "md" | "lg", number>;
+        paddingX: Record<"sm" | "md" | "lg", number>;
+    };
+    switch: {
+        width: Record<"sm" | "md" | "lg", number>;
+        height: Record<"sm" | "md" | "lg", number>;
+        thumbSize: Record<"sm" | "md" | "lg", number>;
+        iconSize: Record<"sm" | "md" | "lg", number>;
+    };
+    slider: {
+        height: number;
+        trackHeight: number;
+        thumbSize: number;
+        activeThumbSize: number;
+        hitSlop: number;
+    };
+}
+interface Theme {
+    mode: ThemeMode;
+    dark: boolean;
+    colors: ThemeColors;
+    fonts: ThemeFonts;
+    typography: ThemeTypography;
+    spacing: ThemeSpacing;
+    radii: ThemeRadii;
+    shadows: ThemeShadows;
+    components: ThemeComponents;
+}
+type ThemeInput = DeepPartial<Omit<Theme, "mode" | "dark">>;
+interface ThemeStorage {
+    getItem: (key: string) => string | null | Promise<string | null>;
+    setItem: (key: string, value: string) => void | Promise<void>;
+}
+interface ThemeProviderProps {
+    children: ReactNode;
+    colorScheme?: ColorSchemePreference;
+    defaultColorScheme?: ColorSchemePreference;
+    themes?: Partial<Record<ThemeMode, ThemeInput>>;
+    storage?: ThemeStorage;
+    storageKey?: string;
+    waitForStorage?: boolean;
+    fallback?: ReactNode;
+    onColorSchemeChange?: (scheme: ColorSchemePreference) => void;
+}
+interface ThemeContextValue {
+    theme: Theme;
+    colors: ThemeColors;
+    fonts: ThemeFonts;
+    typography: ThemeTypography;
+    spacing: ThemeSpacing;
+    radii: ThemeRadii;
+    shadows: ThemeShadows;
+    components: ThemeComponents;
+    colorScheme: ColorSchemePreference;
+    resolvedColorScheme: ThemeMode;
+    isDark: boolean;
+    isHydrated: boolean;
+    setColorScheme: (scheme: ColorSchemePreference) => void;
+    toggleColorScheme: () => void;
+}
+
+declare function ThemeProvider({ children, colorScheme, defaultColorScheme, themes, storage, storageKey, waitForStorage, fallback, onColorSchemeChange, }: ThemeProviderProps): React.JSX.Element;
+
+declare function mergeTheme<T extends object>(base: T, override?: DeepPartial<T>): T;
+declare function createTheme(mode: ThemeMode, override?: ThemeInput): Theme;
+
+declare function useTheme(): ThemeContextValue;
+
+declare function useThemeStyles<T extends ThemeNamedStyles<T>>(factory: ThemeStyleFactory<T>): T;
+
+declare const fonts: ThemeFonts;
+declare const spacing: ThemeSpacing;
+declare const radii: ThemeRadii;
+declare const typography: ThemeTypography;
+declare const lightTheme: Theme;
+declare const darkTheme: Theme;
+declare const defaultThemes: {
+    readonly light: Theme;
+    readonly dark: Theme;
+};
+
+type ThemeColorName = keyof ThemeColors;
+type RenderIcon = ReactNode | ((props: {
+    color: string;
+    size: number;
+}) => ReactNode);
+
+interface AccordionItem {
+    id: string;
+    title: React.ReactNode;
+    content: React.ReactNode;
+    subtitle?: React.ReactNode;
+    icon?: RenderIcon;
+    disabled?: boolean;
+}
+interface AccordionIndicatorProps {
+    expanded: boolean;
+    color: string;
+    size: number;
+}
+interface AccordionAnimatedContentProps {
+    expanded: boolean;
+    children: React.ReactNode;
+    duration: number;
+    style?: StyleProp<ViewStyle>;
+}
+interface AccordionAnimatedIndicatorProps {
+    expanded: boolean;
+    children: React.ReactNode;
+    duration: number;
+    style?: StyleProp<ViewStyle>;
+}
+interface AccordionAnimationComponents {
+    Content?: React.ComponentType<AccordionAnimatedContentProps>;
+    Indicator?: React.ComponentType<AccordionAnimatedIndicatorProps>;
+}
+type AccordionIndicator = React.ReactNode | ((props: AccordionIndicatorProps) => React.ReactNode);
+interface AccordionProps {
+    items: AccordionItem[];
+    allowMultiple?: boolean;
+    defaultOpenIds?: string[];
+    openIds?: string[];
+    onOpenChange?: (openIds: string[]) => void;
+    disabled?: boolean;
+    animated?: boolean;
+    animationDuration?: number;
+    animationComponents?: AccordionAnimationComponents;
+    indicator?: AccordionIndicator;
+    itemStyle?: StyleProp<ViewStyle>;
+    headerStyle?: StyleProp<ViewStyle>;
+    titleStyle?: StyleProp<TextStyle>;
+    subtitleStyle?: StyleProp<TextStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Accordion({ items, allowMultiple, defaultOpenIds, openIds, onOpenChange, disabled, animated, animationDuration, animationComponents, indicator, itemStyle, headerStyle, titleStyle, subtitleStyle, contentStyle, style, }: AccordionProps): React.JSX.Element;
+
+type AlertTone = "primary" | "success" | "warning" | "danger" | "info" | "secondary";
+type AlertVariant = "soft" | "outline" | "solid";
+interface AlertAction {
+    label: string;
+    onPress: () => void;
+    icon?: RenderIcon;
+}
+interface AlertProps {
+    title?: React.ReactNode;
+    children?: React.ReactNode;
+    tone?: AlertTone;
+    variant?: AlertVariant;
+    icon?: RenderIcon;
+    action?: AlertAction;
+    dismissible?: boolean;
+    animated?: boolean;
+    animationDuration?: number;
+    onClose?: () => void;
+    closeIcon?: RenderIcon;
+    style?: StyleProp<ViewStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    titleStyle?: StyleProp<TextStyle>;
+    textStyle?: StyleProp<TextStyle>;
+}
+declare function Alert({ title, children, tone, variant, icon, action, dismissible, animated, animationDuration, onClose, closeIcon, style, contentStyle, titleStyle, textStyle, }: AlertProps): React.JSX.Element | null;
+
+type AlertDialogTone = "primary" | "success" | "warning" | "danger" | "info" | "secondary";
+interface AlertDialogProps {
+    visible: boolean;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    children?: React.ReactNode;
+    tone?: AlertDialogTone;
+    icon?: RenderIcon;
+    closeIcon?: RenderIcon;
+    confirmText?: string;
+    cancelText?: string;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+    onClose?: () => void;
+    confirmLoading?: boolean;
+    confirmDisabled?: boolean;
+    cancelDisabled?: boolean;
+    dismissOnBackdropPress?: boolean;
+    animated?: boolean;
+    animationDuration?: number;
+    modalProps?: Omit<ModalProps, "visible" | "transparent" | "animationType" | "onRequestClose">;
+    overlayStyle?: StyleProp<ViewStyle>;
+    style?: StyleProp<ViewStyle>;
+    contentStyle?: StyleProp<ViewStyle>;
+    titleStyle?: StyleProp<TextStyle>;
+    descriptionStyle?: StyleProp<TextStyle>;
+}
+declare function AlertDialog({ visible, title, description, children, tone, icon, closeIcon, confirmText, cancelText, onConfirm, onCancel, onClose, confirmLoading, confirmDisabled, cancelDisabled, dismissOnBackdropPress, animated, animationDuration, modalProps, overlayStyle, style, contentStyle, titleStyle, descriptionStyle, }: AlertDialogProps): React.JSX.Element | null;
+
+interface AspectRatioProps extends ViewProps {
+    /**
+     * The aspect ratio of the container, e.g., 16/9, 4/3, 1.
+     * Defaults to 1.
+     */
+    ratio?: number;
+    /**
+     * The border radius token from the theme.
+     */
+    radius?: keyof ReturnType<typeof useTheme>["radii"];
+    /**
+     * The content to render inside the AspectRatio container.
+     */
+    children?: React.ReactNode;
+}
+declare function AspectRatio({ ratio, radius, children, style, ...props }: AspectRatioProps): React.JSX.Element;
+
+type AttachmentLayout = "card" | "row";
+type AttachmentDescriptionTone = "default" | "info" | "success" | "warning" | "danger";
+interface AttachmentProps {
+    /**
+     * Layout style of the attachment.
+     * - 'card': A square card layout, ideal for grid-like previews of images.
+     * - 'row': A full-width horizontal row, ideal for document/file listings.
+     * Defaults to 'row'.
+     */
+    layout?: AttachmentLayout;
+    /**
+     * Name of the file, e.g., 'workspace.png'.
+     */
+    name: string;
+    /**
+     * Description or metadata, e.g., 'PNG • 820 KB' or 'Uploading • 64%'.
+     */
+    description?: string;
+    /**
+     * Pluggable icon/thumbnail for the attachment.
+     * Can be a URI string (rendered as Image), a ReactNode, or a RenderIcon function.
+     */
+    thumbnail?: string | RenderIcon;
+    /**
+     * Pluggable fallback file icon when no thumbnail is provided.
+     */
+    fileIcon?: RenderIcon;
+    /**
+     * Tone for the description text. Use this instead of deriving visual state from copy.
+     */
+    descriptionTone?: AttachmentDescriptionTone;
+    /**
+     * If true, shows a loading spinner in the thumbnail slot.
+     */
+    loading?: boolean;
+    /**
+     * Callback triggered when the remove button is pressed.
+     * Shows a close button on the right side if defined.
+     */
+    onRemove?: () => void;
+    /**
+     * Pluggable close/remove icon.
+     */
+    closeIcon?: RenderIcon;
+    /**
+     * Callback triggered when pressing the entire attachment card/row.
+     */
+    onPress?: () => void;
+    /**
+     * Style overrides for the root container.
+     */
+    style?: StyleProp<ViewStyle>;
+    /**
+     * Style overrides for the name text.
+     */
+    nameStyle?: StyleProp<TextStyle>;
+    /**
+     * Style overrides for the description text.
+     */
+    descriptionStyle?: StyleProp<TextStyle>;
+}
+declare function Attachment({ layout, name, description, thumbnail, loading, onRemove, closeIcon, fileIcon, descriptionTone, onPress, style, nameStyle, descriptionStyle, ...props }: AttachmentProps): React.JSX.Element;
+
+type AvatarSize = "default" | "sm" | "lg";
+interface AvatarProps extends React.ComponentPropsWithoutRef<typeof View> {
+    size?: AvatarSize;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function Avatar({ size, style, children, ...props }: AvatarProps): React.JSX.Element;
+interface AvatarImageProps extends Omit<ImageProps, "style"> {
+    style?: StyleProp<ImageStyle>;
+}
+declare function AvatarImage({ source, style, onLoad, onError, ...props }: AvatarImageProps): React.JSX.Element | null;
+interface AvatarFallbackProps extends React.ComponentPropsWithoutRef<typeof View> {
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    children?: React.ReactNode;
+}
+declare function AvatarFallback({ style, textStyle, children, ...props }: AvatarFallbackProps): React.JSX.Element | null;
+interface AvatarBadgeProps extends React.ComponentPropsWithoutRef<typeof View> {
+    style?: StyleProp<ViewStyle>;
+    bg?: string;
+}
+declare function AvatarBadge({ style, bg, ...props }: AvatarBadgeProps): React.JSX.Element;
+interface AvatarGroupProps extends React.ComponentPropsWithoutRef<typeof View> {
+    size?: AvatarSize;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function AvatarGroup({ size, style, children, ...props }: AvatarGroupProps): React.JSX.Element;
+interface AvatarGroupCountProps extends React.ComponentPropsWithoutRef<typeof View> {
+    count: number;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+}
+declare function AvatarGroupCount({ count, style, textStyle, ...props }: AvatarGroupCountProps): React.JSX.Element;
+
+type BubbleVariant = "default" | "secondary" | "muted" | "tinted" | "outline" | "ghost" | "destructive";
+type BubbleAlign = "start" | "end";
+interface BubbleGroupProps extends React.ComponentPropsWithoutRef<typeof View> {
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function BubbleGroup({ style, children, ...props }: BubbleGroupProps): React.JSX.Element;
+interface BubbleProps extends React.ComponentPropsWithoutRef<typeof View> {
+    variant?: BubbleVariant;
+    align?: BubbleAlign;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function Bubble({ variant, align, style, children, ...props }: BubbleProps): React.JSX.Element;
+interface BubbleContentProps extends Omit<PressableProps, "style"> {
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    onPress?: () => void;
+    children?: React.ReactNode;
+}
+declare function BubbleContent({ style, textStyle, onPress, children, ...props }: BubbleContentProps): React.JSX.Element;
+interface BubbleReactionsProps extends React.ComponentPropsWithoutRef<typeof View> {
+    side?: "top" | "bottom";
+    align?: "start" | "end";
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function BubbleReactions({ side, align, style, children, ...props }: BubbleReactionsProps): React.JSX.Element;
+
+type ButtonGroupOrientation = "horizontal" | "vertical";
+interface ButtonGroupProps extends ViewProps {
+    orientation?: ButtonGroupOrientation;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function ButtonGroup({ orientation, style, children, ...props }: ButtonGroupProps): React.JSX.Element;
+interface ButtonGroupTextProps extends React.ComponentPropsWithoutRef<typeof View> {
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+    children?: React.ReactNode;
+}
+declare function ButtonGroupText({ style, textStyle, children, ...props }: ButtonGroupTextProps): React.JSX.Element;
+interface ButtonGroupSeparatorProps extends React.ComponentPropsWithoutRef<typeof View> {
+    orientation?: ButtonGroupOrientation;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ButtonGroupSeparator({ orientation, style, ...props }: ButtonGroupSeparatorProps): React.JSX.Element;
+
+interface CalendarDayData {
+    year: number;
+    month: number;
+    day: number;
+    timestamp: number;
+    dateString: string;
+}
+interface CalendarDayMarking {
+    selected?: boolean;
+    startingDay?: boolean;
+    endingDay?: boolean;
+    color?: string;
+    textColor?: string;
+    disabled?: boolean;
+    isMiddle?: boolean;
+}
+interface CalendarProps extends Omit<React.ComponentProps<typeof Calendar$1>, "current"> {
+    style?: StyleProp<ViewStyle>;
+    current?: string;
+    enableYearMonthPicker?: boolean;
+}
+declare function Calendar({ style, theme, markingType, markedDates, current, enableYearMonthPicker, ...props }: CalendarProps): React.JSX.Element;
+
+type BadgeTone = "primary" | "secondary" | "accent" | "success" | "warning" | "danger" | "info";
+type BadgeVariant = "solid" | "soft" | "outline";
+type BadgeSize = "sm" | "md" | "lg";
+interface BadgeProps {
+    children: string;
+    tone?: BadgeTone;
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    icon?: RenderIcon;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Badge({ children, tone, variant, size, icon, style, }: BadgeProps): React.JSX.Element;
+
+type Space$1 = keyof ReturnType<typeof useTheme>["spacing"];
+interface BoxProps extends ViewProps {
+    bg?: ThemeColorName;
+    borderColor?: ThemeColorName;
+    radius?: keyof ReturnType<typeof useTheme>["radii"];
+    p?: Space$1;
+    px?: Space$1;
+    py?: Space$1;
+    m?: Space$1;
+    mx?: Space$1;
+    my?: Space$1;
+    flex?: number;
+    row?: boolean;
+    center?: boolean;
+    gap?: Space$1;
+}
+declare function Box({ bg, borderColor, radius, p, px, py, m, mx, my, flex, row, center, gap, style, ...props }: BoxProps): React.JSX.Element;
+
+interface BreadcrumbProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function Breadcrumb({ style, ...props }: BreadcrumbProps): React.JSX.Element;
+interface BreadcrumbItemProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function BreadcrumbItem({ style, ...props }: BreadcrumbItemProps): React.JSX.Element;
+interface BreadcrumbLinkProps extends PressableProps {
+    children?: React.ReactNode;
+}
+interface BreadcrumbPageProps {
+    children?: React.ReactNode;
+}
+interface BreadcrumbSeparatorProps {
+    children?: React.ReactNode;
+}
+declare function BreadcrumbLink({ children, disabled, ...props }: BreadcrumbLinkProps): React.JSX.Element;
+declare function BreadcrumbPage({ children }: BreadcrumbPageProps): React.JSX.Element;
+declare function BreadcrumbSeparator({ children, }: BreadcrumbSeparatorProps): React.JSX.Element;
+
+type GorhomBackdropComponentProps = React.ComponentProps<typeof BottomSheetBackdrop>;
+interface BottomSheetProps extends BottomSheetProps$1 {
+    withBackdrop?: boolean;
+    backdropOpacity?: number;
+    backdropAppearsOnIndex?: number;
+    backdropDisappearsOnIndex?: number;
+    backdropPressBehavior?: GorhomBackdropComponentProps["pressBehavior"];
+    backdropStyle?: StyleProp<ViewStyle>;
+}
+declare const BottomSheet: React.ForwardRefExoticComponent<BottomSheetProps & React.RefAttributes<BottomSheetMethods>>;
+
+type ButtonVariant = "filled" | "outline" | "ghost" | "soft" | "danger";
+type ButtonSize = "xs" | "sm" | "md" | "lg" | "xl";
+type ButtonTone = "primary" | "secondary" | "accent" | "success" | "warning" | "danger" | "info";
+type ButtonShape = "rounded" | "pill" | "square";
+interface ButtonProps extends Omit<PressableProps, "children" | "style"> {
+    children: React.ReactNode;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    tone?: ButtonTone;
+    shape?: ButtonShape;
+    leftIcon?: RenderIcon;
+    rightIcon?: RenderIcon;
+    loading?: boolean;
+    fullWidth?: boolean;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+}
+declare function Button({ children, variant, size, tone, shape, leftIcon, rightIcon, loading, fullWidth, disabled, style, textStyle, ...props }: ButtonProps): React.JSX.Element;
+
+interface CardProps extends ViewProps {
+    padded?: boolean;
+    elevated?: boolean;
+    outlined?: boolean;
+}
+declare function Card({ padded, elevated, outlined, style, ...props }: CardProps): React.JSX.Element;
+
+interface CommandItem {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: RenderIcon;
+    disabled?: boolean;
+}
+interface CommandProps {
+    visible: boolean;
+    items: CommandItem[];
+    title?: string;
+    placeholder?: string;
+    emptyText?: string;
+    onClose: () => void;
+    onSelect?: (value: string, item: CommandItem) => void;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Command({ visible, items, title, placeholder, emptyText, onClose, onSelect, style, }: CommandProps): React.JSX.Element;
+
+interface DataListProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+interface DataListItemProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+interface DataListLabelProps {
+    children?: React.ReactNode;
+}
+interface DataListValueProps {
+    children?: React.ReactNode;
+}
+declare function DataList({ style, ...props }: DataListProps): React.JSX.Element;
+declare function DataListItem({ style, ...props }: DataListItemProps): React.JSX.Element;
+declare function DataListLabel({ children }: DataListLabelProps): React.JSX.Element;
+declare function DataListValue({ children }: DataListValueProps): React.JSX.Element;
+
+interface DividerProps {
+    inset?: number;
+    vertical?: boolean;
+    style?: ViewStyle;
+}
+declare function Divider({ inset, vertical, style }: DividerProps): React.JSX.Element;
+
+type EmptyMediaVariant = "default" | "icon";
+interface EmptyProps extends ViewProps {
+    bordered?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Empty({ bordered, style, ...props }: EmptyProps): React.JSX.Element;
+interface EmptyHeaderProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function EmptyHeader({ style, ...props }: EmptyHeaderProps): React.JSX.Element;
+interface EmptyMediaProps extends ViewProps {
+    variant?: EmptyMediaVariant;
+    style?: StyleProp<ViewStyle>;
+}
+declare function EmptyMedia({ variant, style, ...props }: EmptyMediaProps): React.JSX.Element;
+interface EmptyTitleProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function EmptyTitle({ children, style }: EmptyTitleProps): React.JSX.Element;
+interface EmptyDescriptionProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function EmptyDescription({ children, style }: EmptyDescriptionProps): React.JSX.Element;
+interface EmptyContentProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function EmptyContent({ style, ...props }: EmptyContentProps): React.JSX.Element;
+
+type DropdownMenuAlign = "start" | "end";
+type DropdownMenuItemVariant = "default" | "destructive";
+interface DropdownMenuTriggerLayout {
+    pageX: number;
+    pageY: number;
+    width: number;
+    height: number;
+}
+interface DropdownMenuContextProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    triggerLayout: DropdownMenuTriggerLayout;
+    setTriggerLayout: (layout: DropdownMenuTriggerLayout) => void;
+    colors: ThemeColors;
+}
+declare function useDropdownMenu(): DropdownMenuContextProps;
+interface DropdownMenuProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+declare function DropdownMenu({ open: controlledOpen, defaultOpen, onOpenChange, children, }: DropdownMenuProps): React.JSX.Element;
+interface DropdownMenuTriggerProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    disabled?: boolean;
+}
+declare function DropdownMenuTrigger({ children, style, disabled, }: DropdownMenuTriggerProps): React.JSX.Element;
+interface DropdownMenuContentProps {
+    children?: React.ReactNode;
+    align?: DropdownMenuAlign;
+    width?: number;
+    maxHeight?: number;
+    sideOffset?: number;
+    style?: StyleProp<ViewStyle>;
+    overlayStyle?: StyleProp<ViewStyle>;
+    modalProps?: Omit<ModalProps, "visible" | "transparent" | "animationType" | "onRequestClose">;
+}
+declare function DropdownMenuContent({ children, align, width, maxHeight, sideOffset, style, overlayStyle, modalProps, }: DropdownMenuContentProps): React.JSX.Element | null;
+interface DropdownMenuItemProps {
+    onPress?: () => void;
+    children?: React.ReactNode;
+    variant?: DropdownMenuItemVariant;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function DropdownMenuItem({ onPress, children, variant, disabled, style, }: DropdownMenuItemProps): React.JSX.Element;
+interface DropdownMenuCheckboxItemProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    children?: React.ReactNode;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+    checkIcon?: RenderIcon;
+}
+declare function DropdownMenuCheckboxItem({ checked, onCheckedChange, children, disabled, style, checkIcon, }: DropdownMenuCheckboxItemProps): React.JSX.Element;
+interface DropdownMenuSeparatorProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function DropdownMenuSeparator({ style }: DropdownMenuSeparatorProps): React.JSX.Element;
+interface DropdownMenuLabelProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function DropdownMenuLabel({ children, style }: DropdownMenuLabelProps): React.JSX.Element;
+interface DropdownMenuShortcutProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function DropdownMenuShortcut({ children, style, }: DropdownMenuShortcutProps): React.JSX.Element;
+
+type IconButtonVariant = "filled" | "outline" | "ghost" | "soft";
+type IconButtonSize = "sm" | "md" | "lg";
+type IconButtonTone = "primary" | "secondary" | "accent" | "success" | "warning" | "danger" | "info";
+interface IconButtonProps extends Omit<PressableProps, "children" | "style"> {
+    icon: RenderIcon;
+    variant?: IconButtonVariant;
+    size?: IconButtonSize;
+    tone?: IconButtonTone;
+    color?: ThemeColorName | string;
+    loading?: boolean;
+    badge?: number;
+    style?: StyleProp<ViewStyle>;
+}
+declare function IconButton({ icon, variant, size, tone, color, loading, disabled, badge, style, ...props }: IconButtonProps): React.JSX.Element;
+
+interface LabelProps extends TextProps$1 {
+    required?: boolean;
+    requiredIndicator?: React.ReactNode;
+    requiredIndicatorStyle?: StyleProp<TextStyle>;
+    disabled?: boolean;
+    invalid?: boolean;
+    style?: StyleProp<TextStyle>;
+}
+declare function Label({ required, requiredIndicator, requiredIndicatorStyle, disabled, invalid, style, children, ...props }: LabelProps): React.JSX.Element;
+
+type HoverCardAlign = "start" | "center" | "end";
+type HoverCardTriggerMode = "longPress" | "press" | "manual";
+interface HoverCardTriggerLayout {
+    pageX: number;
+    pageY: number;
+    width: number;
+    height: number;
+}
+interface HoverCardContextProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    triggerLayout: HoverCardTriggerLayout;
+    setTriggerLayout: (layout: HoverCardTriggerLayout) => void;
+    openDelay: number;
+    closeDelay: number;
+    triggerMode: HoverCardTriggerMode;
+    colors: ThemeColors;
+}
+declare function useHoverCard(): HoverCardContextProps;
+interface HoverCardProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    openDelay?: number;
+    closeDelay?: number;
+    triggerMode?: HoverCardTriggerMode;
+    children?: React.ReactNode;
+}
+declare function HoverCard({ open: controlledOpen, defaultOpen, onOpenChange, openDelay, closeDelay, triggerMode, children, }: HoverCardProps): React.JSX.Element;
+interface HoverCardTriggerProps {
+    children?: React.ReactNode;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function HoverCardTrigger({ children, disabled, style, }: HoverCardTriggerProps): React.JSX.Element;
+interface HoverCardContentProps {
+    children?: React.ReactNode;
+    align?: HoverCardAlign;
+    width?: number;
+    maxHeight?: number;
+    sideOffset?: number;
+    style?: StyleProp<ViewStyle>;
+    overlayStyle?: StyleProp<ViewStyle>;
+    modalProps?: Omit<ModalProps, "visible" | "transparent" | "animationType" | "onRequestClose">;
+}
+declare function HoverCardContent({ children, align, width, maxHeight, sideOffset, style, overlayStyle, modalProps, }: HoverCardContentProps): React.JSX.Element | null;
+
+type InputSize = "sm" | "md" | "lg";
+type InputType = "text" | "email" | "number" | "password" | "tel" | "url";
+interface InputProps extends Omit<TextInputProps, "style"> {
+    type?: InputType;
+    size?: InputSize;
+    invalid?: boolean;
+    disabled?: boolean;
+    fullWidth?: boolean;
+    style?: StyleProp<TextStyle>;
+}
+declare const Input: React.ForwardRefExoticComponent<InputProps & React.RefAttributes<TextInput>>;
+
+type InputGroupAddonAlign = "inline-start" | "inline-end" | "block-start" | "block-end";
+type InputGroupButtonSize = "xs" | "sm" | "icon-xs" | "icon-sm";
+type InputGroupOrientation = "inline" | "block";
+interface InputGroupProps extends ViewProps {
+    orientation?: InputGroupOrientation;
+    invalid?: boolean;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function InputGroup({ orientation, invalid, disabled, style, children, ...props }: InputGroupProps): React.JSX.Element;
+interface InputGroupAddonProps extends ViewProps {
+    align?: InputGroupAddonAlign;
+    style?: StyleProp<ViewStyle>;
+}
+declare function InputGroupAddon({ align, style, children, ...props }: InputGroupAddonProps): React.JSX.Element;
+interface InputGroupButtonProps extends Omit<ButtonProps, "size" | "children"> {
+    size?: InputGroupButtonSize;
+    variant?: ButtonVariant;
+    children?: React.ReactNode;
+}
+declare function InputGroupButton({ size, variant, shape, children, style, ...props }: InputGroupButtonProps): React.JSX.Element;
+interface InputGroupTextProps extends ViewProps {
+    textStyle?: StyleProp<TextStyle>;
+}
+declare function InputGroupText({ style, textStyle, children, ...props }: InputGroupTextProps): React.JSX.Element;
+interface InputGroupInputProps extends InputProps {
+}
+declare const InputGroupInput: React.ForwardRefExoticComponent<InputGroupInputProps & React.RefAttributes<TextInput>>;
+interface InputGroupTextareaProps extends Omit<InputGroupInputProps, "multiline"> {
+}
+declare const InputGroupTextarea: React.ForwardRefExoticComponent<InputGroupTextareaProps & React.RefAttributes<TextInput>>;
+
+interface InputOTPSlotState {
+    char: string;
+    hasFakeCaret: boolean;
+    isActive: boolean;
+}
+interface InputOTPContextValue {
+    slots: InputOTPSlotState[];
+    disabled: boolean;
+    invalid: boolean;
+    focused: boolean;
+    focus: () => void;
+}
+declare const InputOTPContext: React.Context<InputOTPContextValue | null>;
+interface InputOTPProps extends Omit<PressableProps, "children" | "style"> {
+    children: React.ReactNode;
+    value?: string;
+    defaultValue?: string;
+    onChangeText?: (value: string) => void;
+    maxLength?: number;
+    disabled?: boolean;
+    invalid?: boolean;
+    autoFocus?: boolean;
+    textInputProps?: Omit<TextInputProps, "value" | "defaultValue" | "onChangeText" | "maxLength" | "editable">;
+    style?: StyleProp<ViewStyle>;
+}
+declare function InputOTP({ children, value, defaultValue, onChangeText, maxLength, disabled, invalid, autoFocus, textInputProps, style, onPress, ...props }: InputOTPProps): React.JSX.Element;
+interface InputOTPGroupProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function InputOTPGroup({ style, ...props }: InputOTPGroupProps): React.JSX.Element;
+interface InputOTPSlotProps extends ViewProps {
+    index: number;
+    style?: StyleProp<ViewStyle>;
+}
+declare function InputOTPSlot({ index, style, ...props }: InputOTPSlotProps): React.JSX.Element;
+interface InputOTPSeparatorProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function InputOTPSeparator({ style, children, ...props }: InputOTPSeparatorProps): React.JSX.Element;
+
+type ItemVariant = "default" | "outline" | "muted";
+type ItemSize = "default" | "sm" | "xs";
+type ItemMediaVariant = "default" | "icon" | "image";
+interface ItemGroupProps extends ViewProps {
+    size?: ItemSize;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemGroup({ size, style, ...props }: ItemGroupProps): React.JSX.Element;
+interface ItemSeparatorProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemSeparator({ style, ...props }: ItemSeparatorProps): React.JSX.Element;
+interface ItemProps extends Omit<PressableProps, "style"> {
+    variant?: ItemVariant;
+    size?: ItemSize;
+    style?: StyleProp<ViewStyle> | ((state: {
+        pressed: boolean;
+    }) => StyleProp<ViewStyle>);
+}
+declare function Item({ variant, size, disabled, style, ...props }: ItemProps): React.JSX.Element;
+interface ItemMediaProps extends ViewProps {
+    variant?: ItemMediaVariant;
+    size?: ItemSize;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemMedia({ variant, size, style, ...props }: ItemMediaProps): React.JSX.Element;
+interface ItemContentProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemContent({ style, ...props }: ItemContentProps): React.JSX.Element;
+interface ItemTitleProps extends TextProps$1 {
+    style?: StyleProp<TextStyle>;
+}
+declare function ItemTitle({ style, ...props }: ItemTitleProps): React.JSX.Element;
+interface ItemDescriptionProps extends TextProps$1 {
+    style?: StyleProp<TextStyle>;
+}
+declare function ItemDescription({ style, ...props }: ItemDescriptionProps): React.JSX.Element;
+interface ItemActionsProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemActions({ style, ...props }: ItemActionsProps): React.JSX.Element;
+interface ItemHeaderProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemHeader({ style, ...props }: ItemHeaderProps): React.JSX.Element;
+interface ItemFooterProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ItemFooter({ style, ...props }: ItemFooterProps): React.JSX.Element;
+
+type Space = keyof ReturnType<typeof useTheme>["spacing"];
+interface KeyboardAvoidingProps extends Omit<KeyboardAvoidingViewProps, "style"> {
+    bg?: ThemeColorName;
+    p?: Space;
+    px?: Space;
+    py?: Space;
+    gap?: Space;
+    scroll?: boolean;
+    fullHeight?: boolean;
+    contentContainerStyle?: StyleProp<ViewStyle>;
+    scrollViewProps?: ScrollViewProps;
+    style?: StyleProp<ViewStyle>;
+}
+declare function KeyboardAvoiding({ bg, p, px, py, gap, scroll, fullHeight, behavior, keyboardVerticalOffset, enabled, contentContainerStyle, scrollViewProps, style, children, ...props }: KeyboardAvoidingProps): React.JSX.Element;
+
+interface MetricCardProps extends ViewProps {
+    label: React.ReactNode;
+    value: React.ReactNode;
+    delta?: React.ReactNode;
+    icon?: RenderIcon;
+    style?: StyleProp<ViewStyle>;
+}
+declare function MetricCard({ label, value, delta, icon, style, ...props }: MetricCardProps): React.JSX.Element;
+
+interface PaginationProps extends ViewProps {
+    page: number;
+    pageCount: number;
+    onPageChange?: (page: number) => void;
+    previousLabel?: string;
+    nextLabel?: string;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Pagination({ page, pageCount, onPageChange, previousLabel, nextLabel, style, ...props }: PaginationProps): React.JSX.Element;
+
+interface PopoverProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+}
+declare function Popover({ open, defaultOpen, onOpenChange, children, }: PopoverProps): React.JSX.Element;
+interface PopoverTriggerProps extends PressableProps {
+    triggerMode?: "press" | "longPress";
+}
+declare function PopoverTrigger({ triggerMode, onPress, onLongPress, ...props }: PopoverTriggerProps): React.JSX.Element;
+interface PopoverContentProps {
+    children?: React.ReactNode;
+    width?: number;
+    style?: StyleProp<ViewStyle>;
+}
+declare function PopoverContent({ children, width, style, }: PopoverContentProps): React.JSX.Element | null;
+
+interface ProgressProps extends ViewProps {
+    value?: number;
+    max?: number;
+    animated?: boolean;
+    style?: StyleProp<ViewStyle>;
+    indicatorStyle?: StyleProp<ViewStyle>;
+}
+declare function Progress({ value, max, animated, style, indicatorStyle, ...props }: ProgressProps): React.JSX.Element;
+
+interface RadioGroupContextValue {
+    value?: string;
+    disabled: boolean;
+    onValueChange?: (value: string) => void;
+}
+interface RadioGroupProps extends ViewProps {
+    value?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    onValueChange?: (value: string) => void;
+    style?: StyleProp<ViewStyle>;
+}
+declare function RadioGroup({ value, defaultValue, disabled, onValueChange, style, ...props }: RadioGroupProps): React.JSX.Element;
+interface RadioGroupItemProps extends Omit<PressableProps, "style"> {
+    value: string;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function RadioGroupItem({ value, label, description, disabled, style, ...props }: RadioGroupItemProps): React.JSX.Element;
+
+declare const Sheet: React.ForwardRefExoticComponent<BottomSheetProps & React.RefAttributes<BottomSheetMethods>>;
+
+interface SheetHeaderProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function SheetHeader({ style, ...props }: SheetHeaderProps): React.JSX.Element;
+interface SheetTitleProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function SheetTitle({ children, style }: SheetTitleProps): React.JSX.Element;
+interface SheetDescriptionProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function SheetDescription({ children, style }: SheetDescriptionProps): React.JSX.Element;
+interface SheetFooterProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function SheetFooter({ style, ...props }: SheetFooterProps): React.JSX.Element;
+
+interface SkeletonProps extends ViewProps {
+    animated?: boolean;
+    radius?: keyof ReturnType<typeof useTheme>["radii"];
+    style?: StyleProp<ViewStyle>;
+}
+declare function Skeleton({ animated, radius, style, ...props }: SkeletonProps): React.JSX.Element;
+
+type SliderTone = "primary" | "secondary" | "accent" | "success" | "warning" | "danger" | "info";
+interface SliderProps extends Omit<ViewProps, "style"> {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    tone?: SliderTone;
+    onValueChange?: (value: number) => void;
+    onSlidingStart?: (value: number) => void;
+    onSlidingComplete?: (value: number) => void;
+    style?: StyleProp<ViewStyle>;
+    trackStyle?: StyleProp<ViewStyle>;
+    activeTrackStyle?: StyleProp<ViewStyle>;
+    thumbStyle?: StyleProp<ViewStyle>;
+}
+declare function Slider({ value, defaultValue, min, max, step, disabled, tone, onValueChange, onSlidingStart, onSlidingComplete, style, trackStyle, activeTrackStyle, thumbStyle, onLayout, ...props }: SliderProps): React.JSX.Element;
+
+interface StepperProps extends ViewProps {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    onValueChange?: (value: number) => void;
+    decrementIcon?: RenderIcon;
+    incrementIcon?: RenderIcon;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Stepper({ value, defaultValue, min, max, step, disabled, onValueChange, decrementIcon, incrementIcon, style, ...props }: StepperProps): React.JSX.Element;
+
+type SwitchSize = "sm" | "md" | "lg";
+type SwitchTone = "primary" | "secondary" | "accent" | "success" | "warning" | "danger" | "info";
+interface SwitchRenderThumbParams {
+    checked: boolean;
+    disabled: boolean;
+    invalid: boolean;
+    color: string;
+    size: number;
+}
+type SwitchThumbContent = React.ReactNode | ((params: SwitchRenderThumbParams) => React.ReactNode);
+interface SwitchProps extends Omit<PressableProps, "onPress" | "style" | "children"> {
+    value?: boolean;
+    defaultValue?: boolean;
+    onValueChange?: (value: boolean) => void;
+    disabled?: boolean;
+    invalid?: boolean;
+    size?: SwitchSize;
+    tone?: SwitchTone;
+    style?: StyleProp<ViewStyle>;
+    trackStyle?: StyleProp<ViewStyle>;
+    thumbStyle?: StyleProp<ViewStyle>;
+    activeIcon?: RenderIcon;
+    inactiveIcon?: RenderIcon;
+    thumbContent?: SwitchThumbContent;
+    activeThumbContent?: SwitchThumbContent;
+    inactiveThumbContent?: SwitchThumbContent;
+    renderThumb?: (params: SwitchRenderThumbParams) => React.ReactNode;
+    onPress?: (event: GestureResponderEvent) => void;
+}
+declare function Switch({ value, defaultValue, onValueChange, disabled, invalid, size, tone, style, trackStyle, thumbStyle, activeIcon, inactiveIcon, thumbContent, activeThumbContent, inactiveThumbContent, renderThumb, onPress, onPressIn, onPressOut, accessibilityLabel, ...props }: SwitchProps): React.JSX.Element;
+
+interface TabsContextValue {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface TabsProps extends ViewProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Tabs({ value, defaultValue, onValueChange, style, ...props }: TabsProps): React.JSX.Element;
+interface TabsListProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function TabsList({ style, ...props }: TabsListProps): React.JSX.Element;
+interface TabsTriggerProps extends Omit<PressableProps, "style"> {
+    value: string;
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function TabsTrigger({ value, children, style, disabled, ...props }: TabsTriggerProps): React.JSX.Element;
+interface TabsContentProps extends ViewProps {
+    value: string;
+    forceMount?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function TabsContent({ value, forceMount, style, ...props }: TabsContentProps): React.JSX.Element | null;
+
+interface TextProps extends TextProps$1 {
+    variant?: keyof ReturnType<typeof useTheme>["typography"];
+    color?: ThemeColorName;
+    align?: TextStyle["textAlign"];
+    weight?: TextStyle["fontWeight"];
+}
+declare function Text({ variant, color, align, weight, style, ...props }: TextProps): React.JSX.Element;
+
+interface TextareaProps extends Omit<InputProps, "multiline"> {
+    minRows?: number;
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<TextInput>>;
+
+interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+interface SelectProps {
+    value?: string;
+    defaultValue?: string;
+    options: SelectOption[];
+    placeholder?: string;
+    disabled?: boolean;
+    title?: string;
+    onValueChange?: (value: string) => void;
+    chevronIcon?: RenderIcon;
+    checkIcon?: RenderIcon;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Select({ value, defaultValue, options, placeholder, disabled, title, onValueChange, chevronIcon, checkIcon, style, }: SelectProps): React.JSX.Element;
+
+interface TableProps extends ViewProps {
+    horizontal?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+interface TableRowProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+interface TableHeadProps extends ViewProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+interface TableCellProps extends ViewProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Table({ horizontal, style, children, ...props }: TableProps): React.JSX.Element;
+declare function TableRow({ style, ...props }: TableRowProps): React.JSX.Element;
+declare function TableHead({ children, style, ...props }: TableHeadProps): React.JSX.Element;
+declare function TableCell({ children, style, ...props }: TableCellProps): React.JSX.Element;
+
+interface TimelineProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+interface TimelineItemProps extends ViewProps {
+    active?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+interface TimelineTitleProps {
+    children?: React.ReactNode;
+}
+interface TimelineDescriptionProps {
+    children?: React.ReactNode;
+}
+declare function Timeline({ style, ...props }: TimelineProps): React.JSX.Element;
+declare function TimelineItem({ active, style, children, ...props }: TimelineItemProps): React.JSX.Element;
+declare function TimelineTitle({ children }: TimelineTitleProps): React.JSX.Element;
+declare function TimelineDescription({ children }: TimelineDescriptionProps): React.JSX.Element;
+
+interface FormFieldContextValue {
+    invalid: boolean;
+    disabled: boolean;
+    required: boolean;
+}
+declare function useFormField(): FormFieldContextValue | null;
+interface FormFieldProps extends ViewProps {
+    invalid?: boolean;
+    disabled?: boolean;
+    required?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function FormField({ invalid, disabled, required, style, ...props }: FormFieldProps): React.JSX.Element;
+interface FormLabelProps extends LabelProps {
+}
+declare function FormLabel(props: FormLabelProps): React.JSX.Element;
+interface FormControlProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function FormControl({ style, ...props }: FormControlProps): React.JSX.Element;
+interface FormDescriptionProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function FormDescription({ children, style }: FormDescriptionProps): React.JSX.Element;
+interface FormMessageProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function FormMessage({ children, style }: FormMessageProps): React.JSX.Element | null;
+
+type FloatingActionButtonSize = "sm" | "md" | "lg";
+type FloatingActionButtonPlacement = "none" | "bottom-end" | "bottom-start" | "top-end" | "top-start";
+interface FloatingActionButtonProps extends Omit<PressableProps, "children" | "style"> {
+    icon?: RenderIcon;
+    label?: React.ReactNode;
+    extended?: boolean;
+    size?: FloatingActionButtonSize;
+    tone?: ButtonTone;
+    variant?: Exclude<ButtonVariant, "danger">;
+    placement?: FloatingActionButtonPlacement;
+    offset?: number;
+    visible?: boolean;
+    animated?: boolean;
+    loading?: boolean;
+    fullWidth?: boolean;
+    style?: StyleProp<ViewStyle>;
+    textStyle?: StyleProp<TextStyle>;
+}
+declare function FloatingActionButton({ icon, label, extended, size, tone, variant, placement, offset, visible, animated, loading, disabled, fullWidth, style, textStyle, onPressIn, onPressOut, ...props }: FloatingActionButtonProps): React.JSX.Element | null;
+
+type ToastTone = "default" | "success" | "warning" | "danger" | "info";
+type ToastPlacement = "top" | "bottom";
+interface ToastOptions {
+    id?: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    tone?: ToastTone;
+    icon?: RenderIcon;
+    closeIcon?: RenderIcon;
+    action?: ToastAction;
+    duration?: number;
+}
+interface ToastRecord extends Required<Pick<ToastOptions, "id">> {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    tone: ToastTone;
+    icon?: RenderIcon;
+    closeIcon?: RenderIcon;
+    action?: ToastAction;
+    duration: number;
+    open: boolean;
+}
+interface ToastContextValue {
+    show: (options: ToastOptions) => string;
+    dismiss: (id?: string) => void;
+    update: (id: string, options: Omit<ToastOptions, "id">) => void;
+}
+declare const ToastContext: React.Context<ToastContextValue | null>;
+interface ToastProviderProps {
+    children: React.ReactNode;
+    placement?: ToastPlacement;
+    offset?: number;
+    duration?: number;
+    maxToasts?: number;
+    swipeToDismiss?: boolean;
+    renderToast?: (toast: ToastRecord, controls: ToastContextValue) => React.ReactNode;
+    viewportStyle?: StyleProp<ViewStyle>;
+}
+declare function ToastProvider({ children, placement, offset, duration, maxToasts, swipeToDismiss, renderToast, viewportStyle, }: ToastProviderProps): React.JSX.Element;
+declare function useToast(): ToastContextValue;
+interface ToastViewportProps extends ViewProps {
+    placement?: ToastPlacement;
+    offset?: number;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ToastViewport({ placement, offset, style, ...props }: ToastViewportProps): React.JSX.Element;
+interface ToastProps extends ViewProps {
+    toast: ToastRecord;
+    placement?: ToastPlacement;
+    swipeToDismiss?: boolean;
+    onDismiss?: () => void;
+    onCloseComplete?: () => void;
+    style?: StyleProp<ViewStyle>;
+}
+declare function Toast({ toast, placement, swipeToDismiss, onDismiss, onCloseComplete, style, ...props }: ToastProps): React.JSX.Element;
+interface ToastContentProps extends ViewProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ToastContent({ style, ...props }: ToastContentProps): React.JSX.Element;
+interface ToastTitleProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function ToastTitle({ children, style }: ToastTitleProps): React.JSX.Element;
+interface ToastDescriptionProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function ToastDescription({ children, style }: ToastDescriptionProps): React.JSX.Element;
+interface ToastActionProps {
+    label: string;
+    onPress?: () => void;
+}
+interface ToastAction {
+    label: string;
+    onPress: () => void;
+}
+declare function ToastAction({ label, onPress }: ToastActionProps): React.JSX.Element;
+interface ToastCloseProps {
+    onPress?: () => void;
+    icon?: RenderIcon;
+}
+declare function ToastClose({ onPress, icon }: ToastCloseProps): React.JSX.Element;
+
+interface CarouselProps {
+    itemWidth?: number;
+    onIndexChange?: (index: number) => void;
+    showPagination?: boolean;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+interface CarouselContextProps {
+    scrollX: SharedValue<number>;
+    itemWidth: number;
+    activeIndex: number;
+    totalItems: number;
+    setTotalItems: React.Dispatch<React.SetStateAction<number>>;
+    scrollPrev: () => void;
+    scrollNext: () => void;
+    canScrollPrev: boolean;
+    canScrollNext: boolean;
+    scrollViewRef: React.RefObject<any>;
+    setActiveIndex: React.Dispatch<React.SetStateAction<number>>;
+}
+declare function useCarousel(): CarouselContextProps;
+declare function Carousel({ itemWidth, onIndexChange, showPagination, style, children, ...props }: CarouselProps): React.JSX.Element;
+interface CarouselContentProps {
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function CarouselContent({ style, children }: CarouselContentProps): React.JSX.Element;
+interface CarouselItemProps {
+    index?: number;
+    style?: StyleProp<ViewStyle>;
+    children?: React.ReactNode;
+}
+declare function CarouselItem({ index, style, children, ...props }: CarouselItemProps): React.JSX.Element;
+interface CarouselButtonProps {
+    style?: StyleProp<ViewStyle>;
+    icon?: RenderIcon;
+}
+declare function CarouselPrevious({ style, icon }: CarouselButtonProps): React.JSX.Element | null;
+declare function CarouselNext({ style, icon }: CarouselButtonProps): React.JSX.Element | null;
+
+interface CheckboxProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    invalid?: boolean;
+    style?: StyleProp<ViewStyle>;
+    icon?: RenderIcon;
+}
+declare function Checkbox({ checked, onCheckedChange, disabled, invalid, style, icon, ...props }: CheckboxProps): React.JSX.Element;
+
+interface CollapsibleProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+interface CollapsibleContextProps {
+    open: boolean;
+    toggle: () => void;
+}
+declare function useCollapsible(): CollapsibleContextProps;
+declare function Collapsible({ open: controlledOpen, defaultOpen, onOpenChange, children, style, ...props }: CollapsibleProps): React.JSX.Element;
+interface CollapsibleTriggerProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function CollapsibleTrigger({ children, style, ...props }: CollapsibleTriggerProps): React.JSX.Element;
+interface CollapsibleContentProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function CollapsibleContent({ children, style, ...props }: CollapsibleContentProps): React.JSX.Element;
+
+interface ComboboxProps {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children?: React.ReactNode;
+}
+interface ComboboxContextProps {
+    value: string;
+    onValueChange: (value: string) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    inputValue: string;
+    setInputValue: (val: string) => void;
+    triggerRef: React.RefObject<any>;
+    triggerLayout: {
+        pageX: number;
+        pageY: number;
+        width: number;
+        height: number;
+    };
+    measureTrigger: () => void;
+    colors: ThemeColors;
+}
+declare function useCombobox(): ComboboxContextProps;
+declare function Combobox({ value: controlledValue, onValueChange, open: controlledOpen, onOpenChange, children, }: ComboboxProps): React.JSX.Element;
+interface ComboboxInputProps {
+    placeholder?: string;
+    style?: StyleProp<ViewStyle>;
+    inputStyle?: StyleProp<TextStyle>;
+    disabled?: boolean;
+    chevronIcon?: RenderIcon;
+}
+declare function ComboboxInput({ placeholder, style, inputStyle, disabled, chevronIcon, }: ComboboxInputProps): React.JSX.Element;
+interface ComboboxContentProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    overlayStyle?: StyleProp<ViewStyle>;
+    modalProps?: Omit<ModalProps, "visible" | "transparent" | "animationType" | "onRequestClose">;
+}
+declare function ComboboxContent({ children, style, overlayStyle, modalProps, }: ComboboxContentProps): React.JSX.Element | null;
+interface ComboboxListProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ComboboxList({ children, style }: ComboboxListProps): React.JSX.Element;
+interface ComboboxItemProps {
+    value: string;
+    label: string;
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    checkIcon?: RenderIcon;
+}
+declare function ComboboxItem({ value, label, children, style, checkIcon, }: ComboboxItemProps): React.JSX.Element | null;
+interface ComboboxEmptyProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ComboboxEmpty({ children, style, }: ComboboxEmptyProps): React.JSX.Element;
+
+interface ContextMenuProps {
+    children?: React.ReactNode;
+}
+interface ContextMenuContextProps {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    triggerLayout: {
+        pageX: number;
+        pageY: number;
+        width: number;
+        height: number;
+    };
+    setTriggerLayout: (layout: any) => void;
+    colors: ThemeColors;
+}
+declare function useContextMenu(): ContextMenuContextProps;
+declare function ContextMenu({ children }: ContextMenuProps): React.JSX.Element;
+interface ContextMenuTriggerProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    disabled?: boolean;
+}
+declare function ContextMenuTrigger({ children, style, disabled, }: ContextMenuTriggerProps): React.JSX.Element;
+interface ContextMenuContentProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+    overlayStyle?: StyleProp<ViewStyle>;
+    modalProps?: Omit<ModalProps, "visible" | "transparent" | "animationType" | "onRequestClose">;
+    width?: number;
+}
+declare function ContextMenuContent({ children, style, overlayStyle, modalProps, width, }: ContextMenuContentProps): React.JSX.Element | null;
+interface ContextMenuItemProps {
+    onPress?: () => void;
+    children?: React.ReactNode;
+    variant?: "default" | "destructive";
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ContextMenuItem({ onPress, children, variant, disabled, style, }: ContextMenuItemProps): React.JSX.Element;
+interface ContextMenuSeparatorProps {
+    style?: StyleProp<ViewStyle>;
+}
+declare function ContextMenuSeparator({ style }: ContextMenuSeparatorProps): React.JSX.Element;
+interface ContextMenuLabelProps {
+    children?: React.ReactNode;
+    style?: StyleProp<ViewStyle>;
+}
+declare function ContextMenuLabel({ children, style }: ContextMenuLabelProps): React.JSX.Element;
+interface ContextMenuCheckboxItemProps {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    children?: React.ReactNode;
+    disabled?: boolean;
+    style?: StyleProp<ViewStyle>;
+    checkIcon?: RenderIcon;
+}
+declare function ContextMenuCheckboxItem({ checked, onCheckedChange, children, disabled, style, checkIcon, }: ContextMenuCheckboxItemProps): React.JSX.Element;
+interface ContextMenuShortcutProps {
+    children?: React.ReactNode;
+    style?: StyleProp<TextStyle>;
+}
+declare function ContextMenuShortcut({ children, style, }: ContextMenuShortcutProps): React.JSX.Element;
+
+declare function withAlpha(color: string, alpha: number): string;
+
+export { Accordion, type AccordionAnimatedContentProps, type AccordionAnimatedIndicatorProps, type AccordionAnimationComponents, type AccordionIndicator, type AccordionIndicatorProps, type AccordionItem, type AccordionProps, Alert, type AlertAction, AlertDialog, type AlertDialogProps, type AlertDialogTone, type AlertProps, type AlertTone, type AlertVariant, AspectRatio, type AspectRatioProps, Attachment, type AttachmentDescriptionTone, type AttachmentLayout, type AttachmentProps, Avatar, AvatarBadge, type AvatarBadgeProps, AvatarFallback, type AvatarFallbackProps, AvatarGroup, AvatarGroupCount, type AvatarGroupCountProps, type AvatarGroupProps, AvatarImage, type AvatarImageProps, type AvatarProps, type AvatarSize, Badge, type BadgeProps, type BadgeSize, type BadgeTone, type BadgeVariant, BottomSheet, type BottomSheetProps, Box, type BoxProps, Breadcrumb, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbPage, type BreadcrumbPageProps, type BreadcrumbProps, BreadcrumbSeparator, type BreadcrumbSeparatorProps, Bubble, type BubbleAlign, BubbleContent, type BubbleContentProps, BubbleGroup, type BubbleGroupProps, type BubbleProps, BubbleReactions, type BubbleReactionsProps, type BubbleVariant, Button, ButtonGroup, type ButtonGroupOrientation, type ButtonGroupProps, ButtonGroupSeparator, type ButtonGroupSeparatorProps, ButtonGroupText, type ButtonGroupTextProps, type ButtonProps, type ButtonShape, type ButtonSize, type ButtonTone, type ButtonVariant, Calendar, type CalendarDayData, type CalendarDayMarking, type CalendarProps, Card, type CardProps, Carousel, type CarouselButtonProps, CarouselContent, type CarouselContentProps, CarouselItem, type CarouselItemProps, CarouselNext, CarouselPrevious, type CarouselProps, Checkbox, type CheckboxProps, Collapsible, CollapsibleContent, type CollapsibleContentProps, type CollapsibleProps, CollapsibleTrigger, type CollapsibleTriggerProps, type ColorSchemePreference, Combobox, ComboboxContent, type ComboboxContentProps, ComboboxEmpty, type ComboboxEmptyProps, ComboboxInput, type ComboboxInputProps, ComboboxItem, type ComboboxItemProps, ComboboxList, type ComboboxListProps, type ComboboxProps, Command, type CommandItem, type CommandProps, ContextMenu, ContextMenuCheckboxItem, type ContextMenuCheckboxItemProps, ContextMenuContent, type ContextMenuContentProps, ContextMenuItem, type ContextMenuItemProps, ContextMenuLabel, type ContextMenuLabelProps, type ContextMenuProps, ContextMenuSeparator, type ContextMenuSeparatorProps, ContextMenuShortcut, type ContextMenuShortcutProps, ContextMenuTrigger, type ContextMenuTriggerProps, DataList, DataListItem, type DataListItemProps, DataListLabel, type DataListLabelProps, type DataListProps, DataListValue, type DataListValueProps, type DeepPartial, Divider, type DividerProps, DropdownMenu, type DropdownMenuAlign, DropdownMenuCheckboxItem, type DropdownMenuCheckboxItemProps, DropdownMenuContent, type DropdownMenuContentProps, DropdownMenuItem, type DropdownMenuItemProps, type DropdownMenuItemVariant, DropdownMenuLabel, type DropdownMenuLabelProps, type DropdownMenuProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, DropdownMenuShortcut, type DropdownMenuShortcutProps, DropdownMenuTrigger, type DropdownMenuTriggerProps, Empty, EmptyContent, type EmptyContentProps, EmptyDescription, type EmptyDescriptionProps, EmptyHeader, type EmptyHeaderProps, EmptyMedia, type EmptyMediaProps, type EmptyMediaVariant, type EmptyProps, EmptyTitle, type EmptyTitleProps, FloatingActionButton, type FloatingActionButtonPlacement, type FloatingActionButtonProps, type FloatingActionButtonSize, FormControl, type FormControlProps, FormDescription, type FormDescriptionProps, FormField, type FormFieldContextValue, type FormFieldProps, FormLabel, type FormLabelProps, FormMessage, type FormMessageProps, HoverCard, type HoverCardAlign, HoverCardContent, type HoverCardContentProps, type HoverCardProps, HoverCardTrigger, type HoverCardTriggerMode, type HoverCardTriggerProps, IconButton, type IconButtonProps, type IconButtonSize, type IconButtonTone, type IconButtonVariant, Input, InputGroup, InputGroupAddon, type InputGroupAddonAlign, type InputGroupAddonProps, InputGroupButton, type InputGroupButtonProps, type InputGroupButtonSize, InputGroupInput, type InputGroupInputProps, type InputGroupOrientation, type InputGroupProps, InputGroupText, type InputGroupTextProps, InputGroupTextarea, type InputGroupTextareaProps, InputOTP, InputOTPContext, type InputOTPContextValue, InputOTPGroup, type InputOTPGroupProps, type InputOTPProps, InputOTPSeparator, type InputOTPSeparatorProps, InputOTPSlot, type InputOTPSlotProps, type InputOTPSlotState, type InputProps, type InputSize, type InputType, Item, ItemActions, type ItemActionsProps, ItemContent, type ItemContentProps, ItemDescription, type ItemDescriptionProps, ItemFooter, type ItemFooterProps, ItemGroup, type ItemGroupProps, ItemHeader, type ItemHeaderProps, ItemMedia, type ItemMediaProps, type ItemMediaVariant, type ItemProps, ItemSeparator, type ItemSeparatorProps, type ItemSize, ItemTitle, type ItemTitleProps, type ItemVariant, KeyboardAvoiding, type KeyboardAvoidingProps, Label, type LabelProps, MetricCard, type MetricCardProps, Pagination, type PaginationProps, Popover, PopoverContent, type PopoverContentProps, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Progress, type ProgressProps, RadioGroup, type RadioGroupContextValue, RadioGroupItem, type RadioGroupItemProps, type RadioGroupProps, type RenderIcon, Select, type SelectOption, type SelectProps, Sheet, SheetDescription, type SheetDescriptionProps, SheetFooter, type SheetFooterProps, SheetHeader, type SheetHeaderProps, SheetTitle, type SheetTitleProps, Skeleton, type SkeletonProps, Slider, type SliderProps, type SliderTone, Stepper, type StepperProps, Switch, type SwitchProps, Table, TableCell, type TableCellProps, TableHead, type TableHeadProps, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, type TabsContentProps, type TabsContextValue, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Text, type TextProps, Textarea, type TextareaProps, type Theme, type ThemeColorName, type ThemeColors, type ThemeComponents, type ThemeContextValue, type ThemeFonts, type ThemeInput, type ThemeMode, type ThemeNamedStyles, ThemeProvider, type ThemeProviderProps, type ThemeRadii, type ThemeShadow, type ThemeShadows, type ThemeSpacing, type ThemeStorage, type ThemeStyleFactory, Timeline, TimelineDescription, type TimelineDescriptionProps, TimelineItem, type TimelineItemProps, type TimelineProps, TimelineTitle, type TimelineTitleProps, Toast, ToastAction, ToastAction as ToastActionConfig, type ToastActionProps, ToastClose, type ToastCloseProps, ToastContent, type ToastContentProps, ToastContext, type ToastContextValue, ToastDescription, type ToastDescriptionProps, type ToastOptions, type ToastPlacement, type ToastProps, ToastProvider, type ToastProviderProps, type ToastRecord, ToastTitle, type ToastTitleProps, type ToastTone, ToastViewport, type ToastViewportProps, type TypographyVariant, createTheme, darkTheme, defaultThemes, fonts, lightTheme, mergeTheme, radii, spacing, typography, useCarousel, useCollapsible, useCombobox, useContextMenu, useDropdownMenu, useFormField, useHoverCard, useTheme, useThemeStyles, useToast, withAlpha };