@blinkdotnew/mobile-ui 0.1.1 → 1.0.1

package/dist/index.d.mts

@@ -1,104 +1,20 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React, { ReactNode } from 'react';
-import { ViewStyle, TextStyle, ImageStyle, ImageSourcePropType, DimensionValue, PressableProps, EasingFunction, StyleProp } from 'react-native';
+import { vars } from 'nativewind';
+import { ClassValue } from 'clsx';
+import { PressableProps, ViewStyle, TextProps, ImageSourcePropType, TextInputProps, EasingFunction, ScrollViewProps, Animated } from 'react-native';
+import { ActionSheetRef } from 'react-native-actions-sheet';
+import { Ionicons } from '@expo/vector-icons';
 
-interface ColorPalette {
-    primary: string;
-    primaryDark: string;
-    primaryLight: string;
-    primaryTint: string;
-    accent: string;
-    background: string;
-    surface: string;
-    surfaceElevated: string;
-    card: string;
-    text: string;
-    textSecondary: string;
-    textMuted: string;
-    textInverse: string;
-    border: string;
-    borderLight: string;
-    error: string;
-    errorLight: string;
-    success: string;
-    successLight: string;
-    warning: string;
-    warningLight: string;
-    overlay: string;
-    highlight: string;
-}
-interface SpacingScale {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-    xxxl: number;
-}
-interface TypographyStyle {
-    fontSize: number;
-    lineHeight: number;
-    fontWeight: '400' | '500' | '600' | '700' | '800';
-    letterSpacing?: number;
-}
-interface TypographyScale {
-    display: TypographyStyle;
-    h1: TypographyStyle;
-    h2: TypographyStyle;
-    h3: TypographyStyle;
-    h4: TypographyStyle;
-    body: TypographyStyle;
-    bodySmall: TypographyStyle;
-    caption: TypographyStyle;
-    small: TypographyStyle;
-    tiny: TypographyStyle;
-}
-interface ShadowStyle {
-    shadowColor: string;
-    shadowOffset: {
-        width: number;
-        height: number;
-    };
-    shadowOpacity: number;
-    shadowRadius: number;
-    elevation: number;
-}
-interface ShadowScale {
-    none: ShadowStyle;
-    xs: ShadowStyle;
-    sm: ShadowStyle;
-    md: ShadowStyle;
-    lg: ShadowStyle;
-    xl: ShadowStyle;
-}
-interface BorderRadiusScale {
-    xs: number;
-    sm: number;
-    md: number;
-    lg: number;
-    xl: number;
-    xxl: number;
-    full: number;
-}
-interface ThemeTokens {
-    colors: ColorPalette;
-    dark: ColorPalette;
-    spacing: SpacingScale;
-    typography: TypographyScale;
-    shadows: ShadowScale;
-    borderRadius: BorderRadiusScale;
-    touchTargets: {
-        ios: number;
-        android: number;
-    };
-}
 type PaletteName = 'ocean' | 'coral' | 'violet' | 'midnight' | 'rose' | 'neon';
 type ColorScheme = 'light' | 'dark' | 'system';
+interface PaletteSet {
+    light: ReturnType<typeof vars>;
+    dark: ReturnType<typeof vars>;
+}
+declare const palettes: Record<PaletteName, PaletteSet>;
 
 interface BlinkMobileUIContextValue {
-    tokens: ThemeTokens;
-    colors: ColorPalette;
     palette: PaletteName;
     colorScheme: ColorScheme;
     isDark: boolean;
@@ -106,361 +22,786 @@ interface BlinkMobileUIContextValue {
     setColorScheme: (s: ColorScheme) => void;
 }
 declare function useBlinkMobileUI(): BlinkMobileUIContextValue;
-declare function useThemeColors(): ColorPalette;
-interface Props {
+interface BlinkMobileUIProviderProps {
     children: React.ReactNode;
     palette?: PaletteName;
     colorScheme?: ColorScheme;
 }
-declare function BlinkMobileUIProvider({ children, palette: initialPalette, colorScheme: initialScheme, }: Props): react_jsx_runtime.JSX.Element;
+declare function BlinkMobileUIProvider({ children, palette: initPalette, colorScheme: initScheme, }: BlinkMobileUIProviderProps): react_jsx_runtime.JSX.Element;
 
-declare const palettes: Record<string, ThemeTokens>;
-declare const defaultPalette: ThemeTokens;
+declare function cn(...inputs: ClassValue[]): string;
 
-type Style = ViewStyle | TextStyle | ImageStyle;
-declare function mergeStyles(...styles: (Style | Style[] | undefined | null | false)[]): Style;
-
-declare function applyShadow(shadow: ShadowStyle): object;
-declare const shadowPresets: {
-    card: (isDark?: boolean) => object;
-    elevated: (isDark?: boolean) => object;
+declare function useAnimColors(): {
+    text: string;
+    placeholder: string;
+    bg: string;
+    border: string;
+    primary: string;
+    highlight: string;
+    error: string;
+    secondary: string;
+    icon: string;
 };
 
-declare const isIOS: boolean;
-declare const isAndroid: boolean;
-declare const isWeb: boolean;
-declare const SCREEN_WIDTH: number;
-declare const SCREEN_HEIGHT: number;
-declare const platformTouchTarget: number;
-declare function platformValue<T>(ios: T, android: T, web?: T): T;
-declare const hapticAvailable: boolean;
-
-type VariantKey = 'display' | 'h1' | 'h2' | 'h3' | 'h4' | 'body' | 'bodySmall' | 'caption' | 'small' | 'tiny';
-interface TextProps {
-    variant?: VariantKey;
-    color?: string;
-    weight?: '400' | '500' | '600' | '700' | '800';
-    center?: boolean;
-    muted?: boolean;
-    inverse?: boolean;
-    numberOfLines?: number;
-    children?: React.ReactNode;
-    style?: TextStyle;
-    onPress?: () => void;
+interface BlinkPressableProps extends Omit<PressableProps, 'style'> {
+    className?: string;
+    activeClassName?: string;
+    style?: ViewStyle;
+}
+declare function BlinkPressable({ className, activeClassName, style, children, ...props }: BlinkPressableProps): react_jsx_runtime.JSX.Element;
+
+type TextVariant = 'body' | 'heading' | 'subheading' | 'caption' | 'label' | 'title';
+type TextWeight = 'normal' | 'medium' | 'semibold' | 'bold';
+interface BlinkTextProps extends TextProps {
+    variant?: TextVariant;
+    weight?: TextWeight;
+    className?: string;
+    children: React.ReactNode;
 }
-declare function Text({ variant, color, weight, center, muted, inverse, numberOfLines, children, style, onPress, }: TextProps): react_jsx_runtime.JSX.Element;
+declare function BlinkText({ variant, weight, className, children, ...props }: BlinkTextProps): react_jsx_runtime.JSX.Element;
 
 type ButtonVariant = 'primary' | 'secondary' | 'outline' | 'ghost' | 'destructive';
 type ButtonSize = 'sm' | 'md' | 'lg';
+type ButtonRounded = 'none' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
 interface ButtonProps {
+    title?: string;
+    onPress?: () => void;
+    loading?: boolean;
     variant?: ButtonVariant;
     size?: ButtonSize;
-    loading?: boolean;
+    rounded?: ButtonRounded;
+    className?: string;
+    textClassName?: string;
     disabled?: boolean;
-    iconLeft?: React.ReactNode;
-    iconRight?: React.ReactNode;
-    fullWidth?: boolean;
+    iconStart?: React.ReactNode;
+    iconEnd?: React.ReactNode;
     children?: React.ReactNode;
-    onPress?: () => void;
-    style?: ViewStyle;
-}
-declare function Button({ variant, size, loading, disabled, iconLeft, iconRight, fullWidth, children, onPress, style, }: ButtonProps): react_jsx_runtime.JSX.Element;
-
-type IconButtonVariant = 'primary' | 'secondary' | 'ghost';
-type IconButtonSize = 'sm' | 'md' | 'lg';
-interface IconButtonProps {
-    variant?: IconButtonVariant;
-    size?: IconButtonSize;
-    disabled?: boolean;
-    onPress?: () => void;
-    style?: ViewStyle;
-    children: React.ReactNode;
 }
-declare function IconButton({ variant, size, disabled, onPress, style, children, }: IconButtonProps): react_jsx_runtime.JSX.Element;
+declare function Button({ title, onPress, loading, variant, size, rounded, className, textClassName, disabled, iconStart, iconEnd, children, }: ButtonProps): react_jsx_runtime.JSX.Element;
 
-type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
-type StatusDot = 'online' | 'offline' | 'busy' | 'away';
+type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
 interface AvatarProps {
-    uri?: string;
-    initials?: string;
+    src?: string;
+    name?: string;
     size?: AvatarSize;
-    badge?: StatusDot;
+    className?: string;
+}
+declare function Avatar({ src, name, size, className }: AvatarProps): react_jsx_runtime.JSX.Element;
+
+type CardVariant = 'elevated' | 'outlined' | 'filled' | 'ghost';
+interface CardProps {
+    variant?: CardVariant;
+    className?: string;
     style?: ViewStyle;
+    onPress?: () => void;
+    children?: React.ReactNode;
+}
+declare function Card({ variant, className, style, onPress, children }: CardProps): react_jsx_runtime.JSX.Element;
+declare namespace Card {
+    var Header: typeof CardHeader;
+    var Body: typeof CardBody;
+    var Footer: typeof CardFooter;
+    var Image: typeof CardImage;
+    var Title: typeof CardTitle;
+    var Description: typeof CardDescription;
+}
+interface CardHeaderProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function CardHeader({ className, children }: CardHeaderProps): react_jsx_runtime.JSX.Element;
+interface CardBodyProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function CardBody({ className, children }: CardBodyProps): react_jsx_runtime.JSX.Element;
+interface CardFooterProps {
+    className?: string;
+    children: React.ReactNode;
+}
+declare function CardFooter({ className, children }: CardFooterProps): react_jsx_runtime.JSX.Element;
+interface CardImageProps {
+    source: string | ImageSourcePropType;
+    height?: number;
+    className?: string;
+}
+declare function CardImage({ source, height, className }: CardImageProps): react_jsx_runtime.JSX.Element;
+interface CardTitleProps {
+    className?: string;
+    children: React.ReactNode;
 }
-declare function Avatar({ uri, initials, size, badge, style }: AvatarProps): react_jsx_runtime.JSX.Element;
+declare function CardTitle({ className, children }: CardTitleProps): react_jsx_runtime.JSX.Element;
+interface CardDescriptionProps {
+    className?: string;
+    numberOfLines?: number;
+    children: React.ReactNode;
+}
+declare function CardDescription({ className, numberOfLines, children }: CardDescriptionProps): react_jsx_runtime.JSX.Element;
 
-type ChipVariant = 'default' | 'primary' | 'secondary';
+type ChipVariant = 'filled' | 'outlined' | 'tinted';
+type ChipSize = 'sm' | 'md';
 interface ChipProps {
     label: string;
-    selected?: boolean;
     variant?: ChipVariant;
-    icon?: React.ReactNode;
+    size?: ChipSize;
+    selected?: boolean;
     onPress?: () => void;
-    onRemove?: () => void;
-    disabled?: boolean;
-    style?: ViewStyle;
+    iconStart?: React.ReactNode;
+    iconEnd?: React.ReactNode;
+    className?: string;
 }
-declare function Chip({ label, selected, variant, icon, onPress, onRemove, disabled, style, }: ChipProps): react_jsx_runtime.JSX.Element;
+declare function Chip({ label, variant, size, selected, onPress, iconStart, iconEnd, className, }: ChipProps): react_jsx_runtime.JSX.Element;
 
-type BadgeVariant = 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info';
+type BadgeVariant = 'default' | 'primary' | 'success' | 'error' | 'warning';
 type BadgeSize = 'sm' | 'md';
 interface BadgeProps {
-    label?: string;
+    label: string;
     variant?: BadgeVariant;
     size?: BadgeSize;
-    dot?: boolean;
-    style?: ViewStyle;
+    className?: string;
 }
-declare function Badge({ label, variant, size, dot, style }: BadgeProps): react_jsx_runtime.JSX.Element;
+declare function Badge({ label, variant, size, className }: BadgeProps): react_jsx_runtime.JSX.Element;
 
-type CardVariant = 'flat' | 'elevated' | 'outlined';
-interface CardProps {
-    variant?: CardVariant;
-    onPress?: () => void;
-    style?: ViewStyle;
-    children?: React.ReactNode;
-}
-interface CardImageProps {
-    source: ImageSourcePropType;
-    height?: number;
-    style?: ImageStyle;
-}
-interface SubViewProps {
-    children?: React.ReactNode;
-    style?: ViewStyle;
-}
-declare function CardImage({ source, height, style }: CardImageProps): react_jsx_runtime.JSX.Element;
-declare function CardHeader({ children, style }: SubViewProps): react_jsx_runtime.JSX.Element;
-declare function CardContent({ children, style }: SubViewProps): react_jsx_runtime.JSX.Element;
-declare function CardFooter({ children, style }: SubViewProps): react_jsx_runtime.JSX.Element;
-declare function Card({ variant, onPress, style, children }: CardProps): react_jsx_runtime.JSX.Element;
-declare namespace Card {
-    var Image: typeof CardImage;
-    var Header: typeof CardHeader;
-    var Content: typeof CardContent;
-    var Footer: typeof CardFooter;
+type IconContainerVariant = 'plain' | 'bordered' | 'contained';
+type IconContainerSize = 'sm' | 'md' | 'lg';
+interface IconContainerProps {
+    variant?: IconContainerVariant;
+    size?: IconContainerSize;
+    className?: string;
+    children: React.ReactNode;
 }
+declare function IconContainer({ variant, size, className, children, }: IconContainerProps): react_jsx_runtime.JSX.Element;
 
+type DividerOrientation = 'horizontal' | 'vertical';
 interface DividerProps {
-    orientation?: 'horizontal' | 'vertical';
-    spacing?: number;
+    orientation?: DividerOrientation;
     label?: string;
-    style?: ViewStyle;
-}
-declare function Divider({ orientation, spacing, label, style }: DividerProps): react_jsx_runtime.JSX.Element;
-
-interface IconProps {
-    name: string;
-    size?: number;
-    color?: string;
-    strokeWidth?: number;
+    className?: string;
 }
-declare function Icon({ name, size, color, strokeWidth }: IconProps): react_jsx_runtime.JSX.Element | null;
+declare function Divider({ orientation, label, className }: DividerProps): react_jsx_runtime.JSX.Element;
 
 type SkeletonVariant = 'rect' | 'circle' | 'text';
 interface SkeletonProps {
     variant?: SkeletonVariant;
-    width?: DimensionValue;
-    height?: number;
-    borderRadius?: number;
-    style?: ViewStyle;
-    lines?: number;
+    width?: number | string;
+    height?: number | string;
+    className?: string;
 }
-declare function Skeleton({ variant, width, height, borderRadius, style, lines, }: SkeletonProps): react_jsx_runtime.JSX.Element;
+declare function Skeleton({ variant, width, height, className }: SkeletonProps): react_jsx_runtime.JSX.Element;
 
+type ProgressBarSize = 'sm' | 'md' | 'lg';
+type ProgressBarVariant = 'primary' | 'success' | 'warning' | 'error';
 interface ProgressBarProps {
-    value?: number;
-    indeterminate?: boolean;
-    height?: number;
-    color?: string;
-    trackColor?: string;
-    borderRadius?: number;
-    style?: ViewStyle;
+    progress: number;
+    variant?: ProgressBarVariant;
+    size?: ProgressBarSize;
+    className?: string;
 }
-declare function ProgressBar({ value, indeterminate, height, color, trackColor, borderRadius, style, }: ProgressBarProps): react_jsx_runtime.JSX.Element;
+declare function ProgressBar({ progress, variant, size, className, }: ProgressBarProps): react_jsx_runtime.JSX.Element;
 
+type ToggleSize = 'sm' | 'md';
 interface ToggleProps {
     value: boolean;
     onValueChange: (value: boolean) => void;
-    label?: string;
+    size?: ToggleSize;
     disabled?: boolean;
-    style?: ViewStyle;
+    className?: string;
 }
-declare function Toggle({ value, onValueChange, label, disabled, style }: ToggleProps): react_jsx_runtime.JSX.Element;
+declare function Toggle({ value, onValueChange, size, disabled, className, }: ToggleProps): react_jsx_runtime.JSX.Element;
 
-type TagColor = 'default' | 'primary' | 'success' | 'warning' | 'error' | 'info' | 'purple';
+type TagVariant = 'filled' | 'outlined' | 'tinted';
 interface TagProps {
     label: string;
-    color?: TagColor;
-    style?: ViewStyle;
+    variant?: TagVariant;
+    onRemove?: () => void;
+    className?: string;
 }
-declare function Tag({ label, color, style }: TagProps): react_jsx_runtime.JSX.Element;
+declare function Tag({ label, variant, onRemove, className }: TagProps): react_jsx_runtime.JSX.Element;
 
-interface BlinkPressableProps extends Omit<PressableProps, 'style'> {
-    activeScale?: number;
-    haptic?: boolean;
-    style?: ViewStyle | ViewStyle[];
-    children?: React.ReactNode;
+type IconButtonVariant = 'primary' | 'secondary' | 'ghost' | 'outline';
+type IconButtonSize = 'sm' | 'md' | 'lg';
+interface IconButtonProps {
+    onPress?: () => void;
+    variant?: IconButtonVariant;
+    size?: IconButtonSize;
+    rounded?: 'md' | 'lg' | 'full';
+    disabled?: boolean;
+    className?: string;
+    children: React.ReactNode;
 }
-declare function BlinkPressable({ activeScale, haptic, style, children, onPress, ...rest }: BlinkPressableProps): react_jsx_runtime.JSX.Element;
+declare function IconButton({ onPress, variant, size, rounded, disabled, className, children, }: IconButtonProps): react_jsx_runtime.JSX.Element;
 
 interface SafeWrapperProps {
-    children?: React.ReactNode;
-    avoidKeyboard?: boolean;
+    children: React.ReactNode;
+    className?: string;
     style?: ViewStyle;
+    edges?: ('top' | 'bottom' | 'left' | 'right')[];
 }
-declare function SafeWrapper({ children, avoidKeyboard, style }: SafeWrapperProps): react_jsx_runtime.JSX.Element;
+declare function SafeWrapper({ children, className, style, edges }: SafeWrapperProps): react_jsx_runtime.JSX.Element;
 
-type AnimationType = 'fadeIn' | 'scaleIn' | 'slideInBottom' | 'slideInRight' | 'slideInLeft' | 'slideInTop' | 'bounceIn' | 'flipInX' | 'zoomInRotate' | 'rotateIn' | 'slideOutBottom' | 'slideOutRight' | 'slideOutLeft' | 'slideOutTop' | 'scaleOut';
-interface AnimatedViewProps {
-    children?: React.ReactNode;
-    animation: AnimationType;
-    duration?: number;
-    delay?: number;
-    easing?: EasingFunction;
-    style?: StyleProp<ViewStyle>;
+interface ContainerProps {
+    children: React.ReactNode;
+    scrollable?: boolean;
+    padded?: boolean;
     className?: string;
-    playOnlyOnce?: boolean;
-    triggerOnVisible?: boolean;
-    visibilityThreshold?: number;
-    shouldResetAnimation?: boolean;
+    style?: ViewStyle;
 }
-declare function AnimatedViewComponent({ children, animation, duration, delay, easing, style, className, playOnlyOnce, triggerOnVisible, visibilityThreshold, shouldResetAnimation, }: AnimatedViewProps): react_jsx_runtime.JSX.Element;
-declare const AnimatedView: React.MemoExoticComponent<typeof AnimatedViewComponent>;
+declare function Container({ children, scrollable, padded, className, style, }: ContainerProps): react_jsx_runtime.JSX.Element;
 
-interface FabAction {
-    icon: React.ReactNode;
-    label: string;
-    onPress: () => void;
-}
-interface AnimatedFabProps {
-    icon: React.ReactNode;
-    label?: string;
-    onPress?: () => void;
-    expanded?: boolean;
-    actions?: FabAction[];
-    style?: ViewStyle;
+interface ThemeScrollerProps$1 {
+    selected: PaletteName;
+    onSelect: (palette: PaletteName) => void;
+    className?: string;
 }
-declare function AnimatedFab({ icon, label, onPress, expanded, actions, style }: AnimatedFabProps): react_jsx_runtime.JSX.Element;
 
-interface StepProps {
+type SectionPadding = 'none' | 'sm' | 'md' | 'lg' | 'xl';
+type TitleSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+interface SectionProps {
+    children?: React.ReactNode;
     title?: string;
-    children: ReactNode;
+    subtitle?: string;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    padding?: SectionPadding;
+    titleSize?: TitleSize;
+    link?: string;
+    linkText?: string;
+    onLinkPress?: () => void;
+    className?: string;
 }
-interface MultiStepProps {
-    children: ReactNode;
-    onComplete?: () => void;
-    showProgress?: boolean;
-    showSkip?: boolean;
-    nextLabel?: string;
-    completeLabel?: string;
+declare function Section({ children, title, subtitle, header, footer, padding, titleSize, link, linkText, onLinkPress, className, }: SectionProps): react_jsx_runtime.JSX.Element;
+
+type StackAlign = 'start' | 'center' | 'end' | 'stretch';
+type StackJustify = 'start' | 'center' | 'end' | 'between' | 'around';
+interface StackProps {
+    children: React.ReactNode;
+    gap?: number;
+    align?: StackAlign;
+    justify?: StackJustify;
+    className?: string;
     style?: ViewStyle;
 }
-declare function MultiStep({ children, onComplete, showProgress, showSkip, nextLabel, completeLabel, style, }: MultiStepProps): react_jsx_runtime.JSX.Element | null;
-declare namespace MultiStep {
-    var Step: any;
+declare function VStack({ children, gap, align, justify, className, style }: StackProps): react_jsx_runtime.JSX.Element;
+declare function HStack({ children, gap, align, justify, className, style }: StackProps): react_jsx_runtime.JSX.Element;
+interface FlexStackProps extends StackProps {
+    direction?: 'vertical' | 'horizontal';
 }
+declare function Stack({ children, direction, ...props }: FlexStackProps): react_jsx_runtime.JSX.Element;
 
-interface TransitionProps {
+interface GridProps {
     children: React.ReactNode;
-    duration?: number;
-    delay?: number;
+    columns?: 2 | 3 | 4;
+    gap?: number;
+    className?: string;
     style?: ViewStyle;
 }
-declare const FadeIn: React.FC<TransitionProps>;
-declare const SlideUp: React.FC<TransitionProps>;
-interface SlideInProps extends TransitionProps {
-    from?: 'left' | 'right' | 'bottom' | 'top';
-}
-declare const SlideIn: React.FC<SlideInProps>;
-declare const ScaleIn: React.FC<TransitionProps>;
+declare function Grid({ children, columns, gap, className, style }: GridProps): react_jsx_runtime.JSX.Element;
 
-interface PlanOption {
-    id: string;
-    period: 'monthly' | 'annual' | 'weekly' | 'lifetime';
-    price: string;
-    priceSubtext?: string;
-    badge?: string;
-    trialDays?: number;
-}
-interface PlanCardProps {
-    plan: PlanOption;
-    selected: boolean;
-    onSelect: () => void;
+interface ListProps<T> {
+    data: T[];
+    renderItem: (item: T, index: number) => React.ReactNode;
+    keyExtractor?: (item: T, index: number) => string;
+    separator?: boolean;
+    className?: string;
+    style?: ViewStyle;
 }
-declare function PlanCard({ plan, selected, onSelect }: PlanCardProps): react_jsx_runtime.JSX.Element;
+declare function List<T>({ data, renderItem, keyExtractor, separator, className, style, }: ListProps<T>): react_jsx_runtime.JSX.Element;
 
-interface FeatureItem {
-    label: string;
-    free?: boolean;
-    pro: boolean;
-}
-interface PaywallScreenProps {
-    appName: string;
-    tagline?: string;
-    features: FeatureItem[];
-    plans: PlanOption[];
-    onSubscribe: (planId: string) => void | Promise<void>;
-    onDismiss?: () => void;
-    loading?: boolean;
-    selectedPlan?: string;
+interface ListItemProps {
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+    onPress?: () => void;
+    disabled?: boolean;
+    className?: string;
     style?: ViewStyle;
 }
-declare function PaywallScreen({ appName, tagline, features, plans, onSubscribe, onDismiss, loading, selectedPlan: controlledPlan, style, }: PaywallScreenProps): react_jsx_runtime.JSX.Element;
-
-type PaywallSoftProps = Omit<PaywallScreenProps, 'onDismiss'> & {
-    visible: boolean;
-    onDismiss: () => void;
-};
-declare function PaywallSoft({ visible, onDismiss, ...rest }: PaywallSoftProps): react_jsx_runtime.JSX.Element;
+declare function ListItem({ title, subtitle, leading, trailing, onPress, disabled, className, style, }: ListItemProps): react_jsx_runtime.JSX.Element;
 
-type PaywallHardProps = Omit<PaywallScreenProps, 'onDismiss'> & {
-    visible: boolean;
-};
-declare function PaywallHard({ visible, ...rest }: PaywallHardProps): react_jsx_runtime.JSX.Element;
+type SpacerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+interface SpacerProps {
+    size?: SpacerSize;
+    flex?: boolean;
+    className?: string;
+}
+declare function Spacer({ size, flex, className }: SpacerProps): react_jsx_runtime.JSX.Element;
 
-interface ComparisonFeature {
-    label: string;
-    free?: boolean;
-    pro: boolean;
-    enterprise?: boolean;
+type InputVariant = 'animated' | 'classic' | 'underlined';
+interface InputProps extends Omit<TextInputProps, 'className'> {
+    label?: string;
+    error?: string;
+    hint?: string;
+    variant?: InputVariant;
+    left?: React.ReactNode;
+    right?: React.ReactNode;
+    clearable?: boolean;
+    disabled?: boolean;
+    className?: string;
 }
-interface PlanComparisonProps {
-    features: ComparisonFeature[];
-    plans?: string[];
+declare function Input({ label, placeholder, value, onChangeText, error, hint, secureTextEntry, variant, left, right, clearable, multiline, disabled, className, ...props }: InputProps): react_jsx_runtime.JSX.Element;
+
+interface TextAreaProps extends Omit<InputProps, 'multiline'> {
 }
-declare function PlanComparison({ features, plans }: PlanComparisonProps): react_jsx_runtime.JSX.Element;
+declare function TextArea({ className, ...props }: TextAreaProps): react_jsx_runtime.JSX.Element;
 
-interface FeatureRowProps {
+interface SearchInputProps {
+    value: string;
+    onChangeText: (text: string) => void;
+    placeholder?: string;
+    onClear?: () => void;
+    autoFocus?: boolean;
+    className?: string;
+}
+declare function SearchInput({ value, onChangeText, placeholder, onClear, autoFocus, className, }: SearchInputProps): react_jsx_runtime.JSX.Element;
+
+interface SearchPillProps {
+    placeholder?: string;
+    onPress?: () => void;
+    className?: string;
+}
+declare function SearchPill({ placeholder, onPress, className, }: SearchPillProps): react_jsx_runtime.JSX.Element;
+
+interface CheckboxProps {
+    checked?: boolean;
+    onToggle?: (checked: boolean) => void;
+    label?: string;
+    disabled?: boolean;
+    error?: string;
+    className?: string;
+}
+declare function Checkbox({ checked, onToggle, label, disabled, error, className, }: CheckboxProps): react_jsx_runtime.JSX.Element;
+
+interface RadioOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface RadioGroupProps {
+    options: RadioOption[];
+    value: string;
+    onChange: (value: string) => void;
+    direction?: 'vertical' | 'horizontal';
+    className?: string;
+}
+declare function RadioGroup({ options, value, onChange, direction, className, }: RadioGroupProps): react_jsx_runtime.JSX.Element;
+
+interface BlinkSwitchProps {
+    value?: boolean;
+    onValueChange?: (value: boolean) => void;
+    label?: string;
+    description?: string;
+    disabled?: boolean;
+    className?: string;
+}
+declare function BlinkSwitch({ value, onValueChange, label, description, disabled, className, }: BlinkSwitchProps): react_jsx_runtime.JSX.Element;
+
+interface SliderProps {
+    value: number;
+    onValueChange: (v: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    showValue?: boolean;
+    className?: string;
+}
+declare function Slider({ value, onValueChange, min, max, step, showValue, className, }: SliderProps): react_jsx_runtime.JSX.Element;
+
+interface SelectOption {
+    label: string;
+    value: string;
+}
+interface SelectProps {
+    options: SelectOption[];
+    value?: string;
+    onChange: (value: string) => void;
+    label?: string;
+    placeholder?: string;
+    error?: string;
+    variant?: InputVariant;
+    className?: string;
+}
+declare function Select({ options, value, onChange, label, placeholder, error, variant, className, }: SelectProps): react_jsx_runtime.JSX.Element;
+
+interface CounterProps {
+    value?: number;
+    onChange?: (value: number) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    label?: string;
+    className?: string;
+}
+declare function Counter({ value: controlledValue, onChange, min, max, step, label, className, }: CounterProps): react_jsx_runtime.JSX.Element;
+
+type HeaderVariant = 'default' | 'blurred' | 'transparent' | 'collapsible';
+interface HeaderProps {
+    title?: string;
+    subtitle?: string;
+    left?: React.ReactNode;
+    right?: React.ReactNode;
+    variant?: HeaderVariant;
+    large?: boolean;
+    showBackButton?: boolean;
+    onBackPress?: () => void;
+    visible?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+}
+declare function Header({ title, subtitle, left, right, variant, large, showBackButton, onBackPress, visible, children, className, }: HeaderProps): react_jsx_runtime.JSX.Element;
+
+interface HeaderIconProps {
+    onPress?: () => void;
+    badge?: boolean;
+    children: React.ReactNode;
+    className?: string;
+}
+declare function HeaderIcon({ onPress, badge, children, className, }: HeaderIconProps): react_jsx_runtime.JSX.Element;
+
+interface TabItem {
+    key: string;
+    label: string;
+    icon: React.ReactNode;
+    activeIcon?: React.ReactNode;
+    badge?: number;
+}
+interface TabBarProps {
+    tabs: TabItem[];
+    activeKey: string;
+    onChange: (key: string) => void;
+    className?: string;
+}
+declare function TabBar({ tabs, activeKey, onChange, className }: TabBarProps): react_jsx_runtime.JSX.Element;
+
+interface TabButtonProps {
+    icon: React.ReactNode;
+    label: string;
+    active: boolean;
+    badge?: number;
+    onPress: () => void;
+    className?: string;
+}
+declare function TabButton({ icon, label, active, badge, onPress, className, }: TabButtonProps): react_jsx_runtime.JSX.Element;
+
+interface Segment {
+    value: string;
+    label: string;
+}
+interface SegmentedControlProps {
+    segments: Segment[];
+    value: string;
+    onChange: (value: string) => void;
+    className?: string;
+}
+declare function SegmentedControl({ segments, value, onChange, className, }: SegmentedControlProps): react_jsx_runtime.JSX.Element;
+
+interface BottomSheetProps {
+    children: React.ReactNode;
+    title?: string;
+    className?: string;
+}
+declare const BottomSheet: React.ForwardRefExoticComponent<BottomSheetProps & React.RefAttributes<ActionSheetRef>>;
+
+interface BlinkModalProps {
+    visible: boolean;
+    onClose: () => void;
+    title?: string;
+    description?: string;
+    children?: React.ReactNode;
+    showCloseButton?: boolean;
+    className?: string;
+}
+declare function BlinkModal({ visible, onClose, title, description, children, showCloseButton, className, }: BlinkModalProps): react_jsx_runtime.JSX.Element;
+
+interface ConfirmationSheetProps {
+    title: string;
+    message?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+    destructive?: boolean;
+    className?: string;
+}
+declare function ConfirmationSheet({ title, message, confirmLabel, cancelLabel, onConfirm, onCancel, destructive, className, }: ConfirmationSheetProps): react_jsx_runtime.JSX.Element;
+declare function useConfirmationSheet(): {
+    show: (p: ConfirmationSheetProps) => void;
+    Sheet: react_jsx_runtime.JSX.Element | null;
+};
+
+interface ActionItem {
+    label: string;
+    icon?: React.ReactNode;
+    onPress: () => void;
+    destructive?: boolean;
+    disabled?: boolean;
+}
+interface BlinkActionSheetProps {
+    title?: string;
+    items: ActionItem[];
+    cancelLabel?: string;
+    onClose?: () => void;
+    className?: string;
+}
+declare function BlinkActionSheet({ title, items, cancelLabel, onClose, className, }: BlinkActionSheetProps): react_jsx_runtime.JSX.Element;
+declare function useActionSheet(): {
+    show: (p: BlinkActionSheetProps) => void;
+    Sheet: react_jsx_runtime.JSX.Element | null;
+};
+
+type ToastType = 'success' | 'error' | 'info' | 'warning';
+type ToastPosition = 'top' | 'bottom';
+interface ToastOptions {
+    message: string;
+    type?: ToastType;
+    duration?: number;
+    position?: ToastPosition;
+}
+declare const Toast: React.FC<{
+    className?: string;
+}>;
+declare const toast: {
+    show: (opts: ToastOptions) => void | undefined;
+    success: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
+    error: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
+    info: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
+    warning: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
+};
+
+interface PageLoaderProps {
+    message?: string;
+    transparent?: boolean;
+    className?: string;
+}
+declare function PageLoader({ message, transparent, className, }: PageLoaderProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    icon?: React.ReactNode;
+    title: string;
+    description?: string;
+    action?: {
+        label: string;
+        onPress: () => void;
+    };
+    className?: string;
+}
+declare function EmptyState({ icon, title, description, action, className, }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface PlaceholderProps {
+    width?: number | string;
+    height?: number;
+    className?: string;
+}
+declare function Placeholder({ width, height, className, }: PlaceholderProps): react_jsx_runtime.JSX.Element;
+
+interface TextSkeletonProps {
+    lines?: number;
+    className?: string;
+}
+declare function TextSkeleton({ lines, className }: TextSkeletonProps): react_jsx_runtime.JSX.Element;
+interface CardSkeletonProps {
+    className?: string;
+}
+declare function CardSkeleton({ className }: CardSkeletonProps): react_jsx_runtime.JSX.Element;
+interface ListSkeletonProps {
+    rows?: number;
+    className?: string;
+}
+declare function ListSkeleton({ rows, className }: ListSkeletonProps): react_jsx_runtime.JSX.Element;
+interface ChatSkeletonProps {
+    className?: string;
+}
+declare function ChatSkeleton({ className }: ChatSkeletonProps): react_jsx_runtime.JSX.Element;
+interface ArticleSkeletonProps {
+    className?: string;
+}
+declare function ArticleSkeleton({ className }: ArticleSkeletonProps): react_jsx_runtime.JSX.Element;
+interface GridSkeletonProps {
+    columns?: number;
+    count?: number;
+    className?: string;
+}
+declare function GridSkeleton({ columns, count, className }: GridSkeletonProps): react_jsx_runtime.JSX.Element;
+declare const SkeletonLoader: {
+    Text: typeof TextSkeleton;
+    Card: typeof CardSkeleton;
+    List: typeof ListSkeleton;
+    Chat: typeof ChatSkeleton;
+    Article: typeof ArticleSkeleton;
+    Grid: typeof GridSkeleton;
+};
+
+type AnimationType = 'fadeIn' | 'scaleIn' | 'slideInBottom' | 'slideInRight' | 'slideInLeft' | 'slideInTop' | 'bounceIn' | 'flipInX' | 'zoomInRotate' | 'rotateIn' | 'slideOutBottom' | 'slideOutRight' | 'slideOutLeft' | 'slideOutTop' | 'scaleOut';
+interface AnimatedViewProps {
+    children?: React.ReactNode;
+    animation: AnimationType;
+    duration?: number;
+    delay?: number;
+    easing?: EasingFunction;
+    className?: string;
+    playOnlyOnce?: boolean;
+    triggerOnVisible?: boolean;
+    visibilityThreshold?: number;
+    shouldResetAnimation?: boolean;
+}
+declare function AnimatedViewComponent({ children, animation, duration, delay, easing, className, playOnlyOnce, triggerOnVisible, visibilityThreshold, shouldResetAnimation, }: AnimatedViewProps): react_jsx_runtime.JSX.Element;
+declare const AnimatedView: React.MemoExoticComponent<typeof AnimatedViewComponent>;
+
+interface FabAction {
+    icon: React.ReactNode;
+    label: string;
+    onPress: () => void;
+}
+interface AnimatedFabProps {
+    icon: React.ReactNode;
+    actions?: FabAction[];
+    onPress?: () => void;
+    className?: string;
+}
+declare function AnimatedFab({ icon, actions, onPress, className, }: AnimatedFabProps): react_jsx_runtime.JSX.Element;
+
+interface StepProps {
+    title?: string;
+    children: ReactNode;
+}
+declare function Step({ children }: StepProps): react_jsx_runtime.JSX.Element;
+interface MultiStepProps {
+    children: ReactNode;
+    onComplete?: () => void;
+    showProgress?: boolean;
+    showSkip?: boolean;
+    nextLabel?: string;
+    completeLabel?: string;
+    className?: string;
+}
+declare function MultiStepRoot({ children, onComplete, showProgress, showSkip, nextLabel, completeLabel, className, }: MultiStepProps): react_jsx_runtime.JSX.Element | null;
+declare const MultiStep: typeof MultiStepRoot & {
+    Step: typeof Step;
+};
+
+interface TransitionProps {
+    children: React.ReactNode;
+    duration?: number;
+    delay?: number;
+    className?: string;
+}
+declare const FadeIn: React.FC<TransitionProps>;
+declare const SlideUp: React.FC<TransitionProps>;
+interface SlideInProps extends TransitionProps {
+    from?: 'left' | 'right' | 'bottom' | 'top';
+}
+declare const SlideIn: React.FC<SlideInProps>;
+declare const ScaleIn: React.FC<TransitionProps>;
+
+interface ThemeScrollerProps extends ScrollViewProps {
+    children: React.ReactNode;
+    topOffset?: number;
+    className?: string;
+}
+declare function ThemeScroller({ children, topOffset, className, contentContainerStyle, ...props }: ThemeScrollerProps): react_jsx_runtime.JSX.Element;
+
+interface CardScrollerProps {
+    children: React.ReactNode;
+    cardWidth?: number;
+    gap?: number;
+    snapEnabled?: boolean;
+    className?: string;
+}
+declare function CardScroller({ children, cardWidth, gap, snapEnabled, className, }: CardScrollerProps): react_jsx_runtime.JSX.Element;
+
+interface ImageCarouselProps {
+    images: string[];
+    height?: number;
+    borderRadius?: number;
+    onIndexChange?: (index: number) => void;
+    className?: string;
+}
+declare function ImageCarousel({ images, height, borderRadius, onIndexChange, className, }: ImageCarouselProps): react_jsx_runtime.JSX.Element;
+
+interface PlanOption {
+    id: string;
+    label: string;
+    price: string;
+    period: string;
+    badge?: string;
+    savings?: string;
+}
+interface PlanCardProps {
+    plan: PlanOption;
+    selected: boolean;
+    onSelect: (plan: PlanOption) => void;
+    className?: string;
+}
+declare function PlanCard({ plan, selected, onSelect, className }: PlanCardProps): react_jsx_runtime.JSX.Element;
+
+interface PaywallFeature {
+    label: string;
+    free?: boolean;
+    pro: boolean;
+}
+interface PaywallScreenProps {
+    appName: string;
+    tagline?: string;
+    features: PaywallFeature[];
+    plans: PlanOption[];
+    selectedPlan: string;
+    onSubscribe: (planId: string) => void;
+    onSelectPlan?: (plan: PlanOption) => void;
+    onDismiss?: () => void;
+    loading?: boolean;
+    ctaLabel?: string;
+    disclaimer?: string;
+    className?: string;
+}
+declare function PaywallScreen({ appName, tagline, features, plans, selectedPlan, onSubscribe, onSelectPlan, onDismiss, loading, ctaLabel, disclaimer, className, }: PaywallScreenProps): react_jsx_runtime.JSX.Element;
+
+type PaywallSoftProps = Omit<PaywallScreenProps, 'onDismiss'> & {
+    onDismiss: () => void;
+    className?: string;
+};
+declare function PaywallSoft({ className, ...props }: PaywallSoftProps): react_jsx_runtime.JSX.Element;
+
+type PaywallHardProps = Omit<PaywallScreenProps, 'onDismiss'> & {
+    className?: string;
+};
+declare function PaywallHard({ className, ...props }: PaywallHardProps): react_jsx_runtime.JSX.Element;
+
+interface FeatureRowProps {
     label: string;
-    available?: boolean;
-    highlighted?: boolean;
+    free?: boolean;
+    pro?: boolean;
+    className?: string;
+}
+declare function FeatureRow({ label, free, pro, className }: FeatureRowProps): react_jsx_runtime.JSX.Element;
+
+interface PlanComparisonProps {
+    features: Omit<FeatureRowProps, 'className'>[];
+    freeLabel?: string;
+    proLabel?: string;
+    className?: string;
 }
-declare function FeatureRow({ label, available, highlighted }: FeatureRowProps): react_jsx_runtime.JSX.Element;
+declare function PlanComparison({ features, freeLabel, proLabel, className, }: PlanComparisonProps): react_jsx_runtime.JSX.Element;
 
 interface TrialBannerProps {
     days: number;
-    onClaim?: () => void;
-    dismissible?: boolean;
-    style?: ViewStyle;
+    message?: string;
+    className?: string;
 }
-declare function TrialBanner({ days, onClaim, dismissible, style }: TrialBannerProps): react_jsx_runtime.JSX.Element | null;
+declare function TrialBanner({ days, message, className }: TrialBannerProps): react_jsx_runtime.JSX.Element;
 
 interface SocialProofBarProps {
     userCount?: string;
     rating?: number;
     reviewCount?: string;
-    logos?: React.ReactNode[];
-    style?: ViewStyle;
+    className?: string;
 }
-declare function SocialProofBar({ userCount, rating, reviewCount, logos, style }: SocialProofBarProps): react_jsx_runtime.JSX.Element;
+declare function SocialProofBar({ userCount, rating, reviewCount, className, }: SocialProofBarProps): react_jsx_runtime.JSX.Element;
 
 interface OnboardingSlide {
     id: string;
     title: string;
-    description?: string;
-    image?: React.ReactNode;
-    backgroundColor?: string;
+    description: string;
+    visual?: React.ReactNode;
 }
 interface OnboardingCarouselProps {
     slides: OnboardingSlide[];
@@ -470,633 +811,479 @@ interface OnboardingCarouselProps {
     showDots?: boolean;
     nextLabel?: string;
     completeLabel?: string;
-    autoPlay?: boolean;
-    autoPlayInterval?: number;
-    style?: ViewStyle;
+    className?: string;
 }
-declare function OnboardingCarousel({ slides, onComplete, onSkip, showSkip, showDots, nextLabel, completeLabel, autoPlay, autoPlayInterval, style, }: OnboardingCarouselProps): react_jsx_runtime.JSX.Element;
+declare function OnboardingCarousel({ slides, onComplete, onSkip, showSkip, showDots, nextLabel, completeLabel, className, }: OnboardingCarouselProps): react_jsx_runtime.JSX.Element;
 
-interface SocialButton {
-    icon: React.ReactNode;
-    label: string;
-    onPress: () => void;
+interface ParallaxLayer {
+    content: React.ReactNode;
+    speed?: number;
+}
+interface ParallaxSlide {
+    id: string;
+    title: string;
+    description: string;
+    layers: ParallaxLayer[];
+}
+interface OnboardingParallaxProps {
+    slides: ParallaxSlide[];
+    onComplete: () => void;
+    onSkip?: () => void;
+    showSkip?: boolean;
+    completeLabel?: string;
+    nextLabel?: string;
+    className?: string;
 }
+declare function OnboardingParallax({ slides, onComplete, onSkip, showSkip, completeLabel, nextLabel, className, }: OnboardingParallaxProps): react_jsx_runtime.JSX.Element;
+
 interface OnboardingHeroProps {
     title: string;
-    subtitle?: string;
-    description?: string;
+    description: string;
     visual?: React.ReactNode;
     ctaLabel?: string;
-    onCta?: () => void;
+    onCta: () => void;
     secondaryLabel?: string;
     onSecondary?: () => void;
-    socialButtons?: SocialButton[];
-    style?: ViewStyle;
+    className?: string;
 }
-declare function OnboardingHero({ title, subtitle, description, visual, ctaLabel, onCta, secondaryLabel, onSecondary, socialButtons, style, }: OnboardingHeroProps): react_jsx_runtime.JSX.Element;
+declare function OnboardingHero({ title, description, visual, ctaLabel, onCta, secondaryLabel, onSecondary, className, }: OnboardingHeroProps): react_jsx_runtime.JSX.Element;
 
 interface PermissionStepProps {
-    icon?: React.ReactNode;
+    icon: React.ReactNode;
     title: string;
     description: string;
     allowLabel?: string;
     skipLabel?: string;
-    onAllow: () => void | Promise<void>;
-    onSkip?: () => void;
-    loading?: boolean;
-    style?: ViewStyle;
+    onAllow: () => void;
+    onSkip: () => void;
+    className?: string;
 }
-declare function PermissionStep({ icon, title, description, allowLabel, skipLabel, onAllow, onSkip, loading: externalLoading, style, }: PermissionStepProps): react_jsx_runtime.JSX.Element;
+declare function PermissionStep({ icon, title, description, allowLabel, skipLabel, onAllow, onSkip, className, }: PermissionStepProps): react_jsx_runtime.JSX.Element;
 
 interface QuizOption {
-    value: string;
+    id: string;
     label: string;
     icon?: React.ReactNode;
-    description?: string;
 }
 interface QuizStepProps {
-    question: string;
-    subtitle?: string;
+    title: string;
+    description?: string;
     options: QuizOption[];
-    value?: string | string[];
-    onChange: (v: string | string[]) => void;
     multiSelect?: boolean;
-    minSelect?: number;
-    maxSelect?: number;
-    style?: ViewStyle;
+    onSubmit: (selected: string[]) => void;
+    submitLabel?: string;
+    className?: string;
 }
-declare function QuizStep({ question, subtitle, options, value, onChange, multiSelect, maxSelect, style, }: QuizStepProps): react_jsx_runtime.JSX.Element;
+declare function QuizStep({ title, description, options, multiSelect, onSubmit, submitLabel, className, }: QuizStepProps): react_jsx_runtime.JSX.Element;
 
-interface OnboardingStep {
+interface OnboardingFlowStep {
     id: string;
     component: React.ReactNode;
 }
 interface OnboardingFlowProps {
-    steps: OnboardingStep[];
+    steps: OnboardingFlowStep[];
     onComplete: () => void;
     showProgress?: boolean;
-    style?: ViewStyle;
+    className?: string;
+}
+declare function OnboardingFlow({ steps, onComplete, showProgress, className, }: OnboardingFlowProps): react_jsx_runtime.JSX.Element;
+
+interface AuthProvider {
+    id: 'google' | 'apple' | 'email' | string;
+    label?: string;
+    icon?: React.ReactNode;
+}
+interface AuthButtonsProps {
+    providers?: AuthProvider[];
+    onAuth: (providerId: string) => void;
+    className?: string;
 }
-declare function OnboardingFlow({ steps, onComplete, showProgress, style }: OnboardingFlowProps): react_jsx_runtime.JSX.Element;
+declare function AuthButtons({ providers, onAuth, className, }: AuthButtonsProps): react_jsx_runtime.JSX.Element;
 
+type SwipeDirection = 'left' | 'right' | 'up';
 interface SwipeDeckProps<T> {
     data: T[];
     renderCard: (item: T, index: number) => React.ReactNode;
     onSwipeLeft?: (item: T) => void;
     onSwipeRight?: (item: T) => void;
     onSwipeUp?: (item: T) => void;
-    onEmpty?: () => void;
+    onEmpty?: () => React.ReactNode;
     swipeThreshold?: number;
     rotationFactor?: number;
     stackDepth?: number;
-    style?: ViewStyle;
+    className?: string;
 }
-declare function SwipeDeck<T>(props: SwipeDeckProps<T>): react_jsx_runtime.JSX.Element;
+declare function SwipeDeck<T>({ data, renderCard, onSwipeLeft, onSwipeRight, onSwipeUp, onEmpty, swipeThreshold, rotationFactor, stackDepth, className, }: SwipeDeckProps<T>): react_jsx_runtime.JSX.Element;
 
 interface SwipeCardProps {
     children: React.ReactNode;
-    likeLabel?: string;
-    nopeLabel?: string;
-    superLabel?: string;
-    swipeDirection?: 'left' | 'right' | 'up' | null;
-    swipeIntensity?: number;
-    style?: ViewStyle;
+    className?: string;
 }
-declare function SwipeCard({ children, swipeDirection, swipeIntensity, style, }: SwipeCardProps): react_jsx_runtime.JSX.Element;
+declare function SwipeCard({ children, className }: SwipeCardProps): react_jsx_runtime.JSX.Element;
 
 interface SwipeActionsProps {
     onNope?: () => void;
-    onLike?: () => void;
     onSuperLike?: () => void;
-    onRewind?: () => void;
-    style?: ViewStyle;
+    onLike?: () => void;
+    className?: string;
 }
-declare function SwipeActions({ onNope, onLike, onSuperLike, onRewind, style }: SwipeActionsProps): react_jsx_runtime.JSX.Element;
+declare function SwipeActions({ onNope, onSuperLike, onLike, className }: SwipeActionsProps): react_jsx_runtime.JSX.Element;
 
 interface SwipeOverlayProps {
-    direction: 'left' | 'right' | 'up' | null;
-    intensity: number;
+    position: Animated.ValueXY;
+    swipeThreshold: number;
+    className?: string;
 }
-declare function SwipeOverlay({ direction, intensity }: SwipeOverlayProps): react_jsx_runtime.JSX.Element | null;
+declare function SwipeOverlay({ position, swipeThreshold }: SwipeOverlayProps): react_jsx_runtime.JSX.Element;
 
 interface VerticalReelProps<T> {
     data: T[];
     renderItem: (item: T, index: number, isActive: boolean) => React.ReactNode;
     onActiveChange?: (index: number) => void;
-    preloadCount?: number;
-    style?: ViewStyle;
+    keyExtractor: (item: T, index: number) => string;
+    className?: string;
 }
-declare function VerticalReel<T extends {
-    id?: string | number;
-}>({ data, renderItem, onActiveChange, preloadCount, style, }: VerticalReelProps<T>): react_jsx_runtime.JSX.Element;
+declare function VerticalReel<T>({ data, renderItem, onActiveChange, keyExtractor, className, }: VerticalReelProps<T>): react_jsx_runtime.JSX.Element;
 
 interface ReelItemProps {
-    background?: React.ReactNode;
-    children?: React.ReactNode;
-    style?: ViewStyle;
-}
-declare function ReelItem({ background, children, style }: ReelItemProps): react_jsx_runtime.JSX.Element;
-
-interface ReelOverlayProps {
-    username?: string;
-    avatar?: string;
-    description?: string;
-    rightActions?: React.ReactNode;
-    bottomContent?: React.ReactNode;
-    style?: ViewStyle;
-}
-declare function ReelOverlay({ username, avatar, description, rightActions, bottomContent, style, }: ReelOverlayProps): react_jsx_runtime.JSX.Element;
-
-interface GlassViewProps {
-    children?: React.ReactNode;
-    intensity?: number;
-    tint?: 'light' | 'dark' | 'default' | 'extraLight' | 'systemUltraThinMaterial' | 'systemThinMaterial' | 'systemMaterial';
-    borderRadius?: number;
-    borderWidth?: number;
-    borderColor?: string;
-    style?: StyleProp<ViewStyle>;
-}
-declare function GlassView({ children, intensity, tint, borderRadius, borderWidth, borderColor, style, }: GlassViewProps): react_jsx_runtime.JSX.Element;
-
-interface GlassCardProps {
-    children?: React.ReactNode;
-    onPress?: () => void;
-    intensity?: number;
-    padding?: number;
-    style?: StyleProp<ViewStyle>;
-}
-declare function GlassCard({ children, onPress, intensity, padding, style, }: GlassCardProps): react_jsx_runtime.JSX.Element;
-
-interface GlassHeaderProps {
-    title?: string;
-    left?: React.ReactNode;
-    right?: React.ReactNode;
-    intensity?: number;
-    style?: StyleProp<ViewStyle>;
-}
-declare function GlassHeader({ title, left, right, intensity, style }: GlassHeaderProps): react_jsx_runtime.JSX.Element;
-
-interface GlassSheetProps {
-    children: React.ReactNode;
-    visible: boolean;
-    onClose: () => void;
-    title?: string;
-    intensity?: number;
-    snapPoints?: number[];
-    style?: StyleProp<ViewStyle>;
-}
-declare function GlassSheet({ children, visible, onClose, title, intensity, style, }: GlassSheetProps): react_jsx_runtime.JSX.Element;
-
-interface TabItem$1 {
-    key: string;
-    label: string;
-    icon: React.ReactNode;
-    badge?: number;
-}
-interface GlassTabBarProps {
-    tabs: TabItem$1[];
-    activeKey: string;
-    onChange: (key: string) => void;
-    intensity?: number;
-    style?: StyleProp<ViewStyle>;
-}
-declare function GlassTabBar({ tabs, activeKey, onChange, intensity, style }: GlassTabBarProps): react_jsx_runtime.JSX.Element;
-
-interface ChatBubbleProps {
-    message: string;
-    type: 'sent' | 'received';
-    timestamp?: string;
-    status?: 'sending' | 'sent' | 'delivered' | 'read';
-    avatar?: string;
-    style?: ViewStyle;
-}
-declare function ChatBubble({ message, type, timestamp, status, avatar, style }: ChatBubbleProps): react_jsx_runtime.JSX.Element;
-
-interface ChatInputProps {
-    value: string;
-    onChangeText: (t: string) => void;
-    onSend: () => void;
-    onAttach?: () => void;
-    onVoice?: () => void;
-    placeholder?: string;
-    disabled?: boolean;
-    style?: ViewStyle;
-}
-declare function ChatInput({ value, onChangeText, onSend, onAttach, onVoice, placeholder, disabled, style, }: ChatInputProps): react_jsx_runtime.JSX.Element;
-
-interface ChatMessage {
-    id: string;
-    message: string;
-    type: 'sent' | 'received';
-    timestamp?: string;
-    status?: 'sending' | 'sent' | 'delivered' | 'read';
-    avatar?: string;
-}
-interface ChatListProps {
-    messages: ChatMessage[];
-    style?: ViewStyle;
-}
-declare function ChatList({ messages, style }: ChatListProps): react_jsx_runtime.JSX.Element;
-
-declare function TypingIndicator(): react_jsx_runtime.JSX.Element;
-
-interface ContainerProps {
-    children: React.ReactNode;
-    padded?: boolean;
-    paddingHorizontal?: number;
-    style?: ViewStyle;
-}
-declare const Container: React.FC<ContainerProps>;
-
-interface ScreenContentProps {
-    children: React.ReactNode;
-    onRefresh?: () => void;
-    refreshing?: boolean;
-    padded?: boolean;
-    scrollEnabled?: boolean;
-    style?: ViewStyle;
-    contentStyle?: ViewStyle;
-}
-declare const ScreenContent: React.FC<ScreenContentProps>;
-
-interface SectionProps {
-    title?: string;
-    subtitle?: string;
-    right?: React.ReactNode;
-    children: React.ReactNode;
-    spacing?: boolean;
-    style?: ViewStyle;
-}
-declare const Section: React.FC<SectionProps>;
-
-type Align = 'start' | 'center' | 'end' | 'stretch';
-type Justify = 'start' | 'center' | 'end' | 'between' | 'around';
-interface StackProps {
-    children: React.ReactNode;
-    gap?: number;
-    align?: Align;
-    justify?: Justify;
-    wrap?: boolean;
-    style?: ViewStyle;
-}
-declare const VStack: React.FC<StackProps>;
-declare const HStack: React.FC<StackProps>;
-declare const Stack: React.FC<StackProps>;
-
-interface GridProps {
-    children: React.ReactNode;
-    columns?: number;
-    gap?: number;
-    style?: ViewStyle;
-}
-declare const Grid: React.FC<GridProps>;
-
-interface ListProps<T> {
-    data: T[];
-    renderItem: (item: T, index: number) => React.ReactNode;
-    keyExtractor?: (item: T, index: number) => string;
-    onRefresh?: () => void;
-    refreshing?: boolean;
-    emptyText?: string;
-    emptyComponent?: React.ReactNode;
-    style?: ViewStyle;
-    contentStyle?: ViewStyle;
-    separator?: boolean;
-}
-declare function List<T>({ data, renderItem, keyExtractor, onRefresh, refreshing, emptyText, emptyComponent, style, contentStyle, separator, }: ListProps<T>): react_jsx_runtime.JSX.Element;
-
-interface ListItemProps {
-    title: string;
-    subtitle?: string;
-    left?: React.ReactNode;
-    right?: React.ReactNode;
-    onPress?: () => void;
-    destructive?: boolean;
-    style?: ViewStyle;
-}
-declare const ListItem: React.FC<ListItemProps>;
-
-interface SpacerProps {
-    height?: number;
-    width?: number;
-    flex?: boolean;
-}
-declare const Spacer: React.FC<SpacerProps>;
-
-interface InputProps {
-    label?: string;
-    placeholder?: string;
-    value?: string;
-    onChangeText?: (text: string) => void;
-    error?: string;
-    hint?: string;
-    left?: React.ReactNode;
-    right?: React.ReactNode;
-    clearable?: boolean;
-    secureTextEntry?: boolean;
-    multiline?: boolean;
-    numberOfLines?: number;
-    variant?: 'default' | 'filled' | 'underline';
-    disabled?: boolean;
-    style?: ViewStyle;
-    inputStyle?: TextStyle;
-}
-declare const Input: React.FC<InputProps>;
-
-interface TextAreaProps extends Omit<InputProps, 'multiline' | 'numberOfLines'> {
-    minHeight?: number;
-    maxHeight?: number;
-    style?: ViewStyle;
-    inputStyle?: TextStyle;
-}
-declare const TextArea: React.FC<TextAreaProps>;
-
-interface SearchInputProps {
-    value: string;
-    onChangeText: (text: string) => void;
-    placeholder?: string;
-    onClear?: () => void;
-    style?: ViewStyle;
-}
-declare const SearchInput: React.FC<SearchInputProps>;
-
-interface CheckboxProps {
-    checked: boolean;
-    onToggle: (v: boolean) => void;
-    label?: string;
-    disabled?: boolean;
-}
-declare const Checkbox: React.FC<CheckboxProps>;
-
-interface RadioOption {
-    value: string;
-    label: string;
-    disabled?: boolean;
-}
-interface RadioGroupProps {
-    options: RadioOption[];
-    value: string;
-    onChange: (v: string) => void;
-    direction?: 'vertical' | 'horizontal';
-}
-declare const RadioGroup: React.FC<RadioGroupProps>;
-
-interface BlinkSwitchProps {
-    value: boolean;
-    onValueChange: (v: boolean) => void;
-    label?: string;
-    disabled?: boolean;
-}
-declare const BlinkSwitch: React.FC<BlinkSwitchProps>;
-
-interface SliderProps {
-    value: number;
-    onValueChange: (v: number) => void;
-    min?: number;
-    max?: number;
-    step?: number;
-    showValue?: boolean;
-    style?: ViewStyle;
+    backgroundSource?: string | ImageSourcePropType;
+    backgroundColor?: string;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const Slider: React.FC<SliderProps>;
+declare function ReelItem({ backgroundSource, backgroundColor, children, className, }: ReelItemProps): react_jsx_runtime.JSX.Element;
 
-interface SelectOption {
-    label: string;
-    value: string;
+interface ReelAction {
+    key: string;
+    icon: React.ReactNode;
+    label?: string;
+    count?: number;
+    onPress?: () => void;
 }
-interface SelectProps {
-    options: SelectOption[];
-    value?: string;
-    onChange: (value: string) => void;
-    placeholder?: string;
-    style?: ViewStyle;
+interface ReelOverlayProps {
+    username: string;
+    description?: string;
+    actions?: ReelAction[];
+    avatar?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const Select: React.FC<SelectProps>;
+declare function ReelOverlay({ username, description, actions, avatar, children, className, }: ReelOverlayProps): react_jsx_runtime.JSX.Element;
 
-interface DatePickerProps {
-    value?: Date;
-    onChange: (date: Date) => void;
-    placeholder?: string;
-    mode?: 'date' | 'time' | 'datetime';
-    style?: ViewStyle;
+type GlassTint = 'light' | 'dark' | 'default' | 'extraLight' | 'prominent' | 'systemMaterial';
+interface GlassViewProps {
+    intensity?: number;
+    tint?: GlassTint;
+    borderRadius?: number;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const DatePicker: React.FC<DatePickerProps>;
+declare function GlassView({ intensity, tint, borderRadius, children, className, }: GlassViewProps): react_jsx_runtime.JSX.Element;
 
-interface CounterProps {
-    value: number;
-    onChange: (v: number) => void;
-    min?: number;
-    max?: number;
-    step?: number;
+interface GlassCardProps {
+    intensity?: number;
+    tint?: GlassTint;
+    onPress?: () => void;
+    style?: ViewStyle;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const Counter: React.FC<CounterProps>;
+declare function GlassCard({ intensity, tint, onPress, style, children, className, }: GlassCardProps): react_jsx_runtime.JSX.Element;
 
-interface HeaderProps {
+interface GlassHeaderProps {
     title?: string;
     subtitle?: string;
     left?: React.ReactNode;
     right?: React.ReactNode;
-    variant?: 'default' | 'blurred' | 'transparent' | 'collapsible';
-    large?: boolean;
-    style?: ViewStyle;
+    intensity?: number;
+    tint?: GlassTint;
+    showBackButton?: boolean;
+    onBackPress?: () => void;
+    backIcon?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const Header: React.FC<HeaderProps>;
+declare function GlassHeader({ title, subtitle, left, right, intensity, tint, showBackButton, onBackPress, backIcon, children, className, }: GlassHeaderProps): react_jsx_runtime.JSX.Element;
 
-interface HeaderIconProps {
-    icon: React.ReactNode;
-    onPress?: () => void;
-    label?: string;
+interface GlassSheetProps {
+    visible: boolean;
+    onClose: () => void;
+    title?: string;
+    height?: number;
+    intensity?: number;
+    tint?: GlassTint;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const HeaderIcon: React.FC<HeaderIconProps>;
+declare function GlassSheet({ visible, onClose, title, height, intensity, tint, children, className, }: GlassSheetProps): react_jsx_runtime.JSX.Element;
 
-interface TabItem {
+interface GlassTab {
     key: string;
     label: string;
     icon: React.ReactNode;
     activeIcon?: React.ReactNode;
+    badge?: number;
 }
-interface TabBarProps {
-    tabs: TabItem[];
+interface GlassTabBarProps {
+    tabs: GlassTab[];
     activeKey: string;
     onChange: (key: string) => void;
-    style?: ViewStyle;
+    intensity?: number;
+    tint?: GlassTint;
+    className?: string;
 }
-declare const TabBar: React.FC<TabBarProps>;
+declare function GlassTabBar({ tabs, activeKey, onChange, intensity, tint, className, }: GlassTabBarProps): react_jsx_runtime.JSX.Element;
 
-interface TabButtonProps {
-    icon: React.ReactNode;
-    label: string;
-    active: boolean;
-    onPress: () => void;
+type BubbleStatus = 'sending' | 'sent' | 'delivered' | 'read';
+interface ChatBubbleProps {
+    content: string;
+    variant: 'sent' | 'received';
+    timestamp?: string;
+    status?: BubbleStatus;
+    renderMarkdown?: (content: string) => React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
 }
-declare const TabButton: React.FC<TabButtonProps>;
+declare function ChatBubble({ content, variant, timestamp, status, renderMarkdown, children, className, }: ChatBubbleProps): react_jsx_runtime.JSX.Element;
 
-interface Segment {
-    value: string;
-    label: string;
+interface ChatInputProps {
+    onSend?: (text: string) => void;
+    placeholder?: string;
+    attachButton?: React.ReactNode;
+    voiceButton?: React.ReactNode;
+    onAttach?: () => void;
+    onVoice?: () => void;
+    disabled?: boolean;
+    className?: string;
 }
-interface SegmentedControlProps {
-    segments: Segment[];
-    value: string;
-    onChange: (v: string) => void;
-    style?: ViewStyle;
+declare function ChatInput({ onSend, placeholder, attachButton, voiceButton, onAttach, onVoice, disabled, className, }: ChatInputProps): react_jsx_runtime.JSX.Element;
+
+interface ChatMessage {
+    id: string;
+    type: 'sent' | 'received' | 'system';
+    date?: string;
+}
+interface ChatListProps<T extends ChatMessage> {
+    messages: T[];
+    renderMessage: (item: T, index: number) => React.ReactNode;
+    renderDateSeparator?: (date: string) => React.ReactNode;
+    className?: string;
 }
-declare const SegmentedControl: React.FC<SegmentedControlProps>;
+declare function ChatList<T extends ChatMessage>({ messages, renderMessage, renderDateSeparator, className, }: ChatListProps<T>): react_jsx_runtime.JSX.Element;
 
-type BottomSheetRef = {
-    show: () => void;
-    hide: () => void;
-};
-interface BottomSheetProps {
-    children: React.ReactNode;
-    title?: string;
-    snapPoints?: number[];
-    style?: ViewStyle;
+interface TypingIndicatorProps {
+    label?: React.ReactNode;
+    className?: string;
 }
-declare const BottomSheet: React.ForwardRefExoticComponent<BottomSheetProps & React.RefAttributes<BottomSheetRef>>;
-declare function useBottomSheet(): {
-    ref: React.RefObject<BottomSheetRef>;
-    show: () => void | undefined;
-    hide: () => void | undefined;
-};
+declare function TypingIndicator({ label, className }: TypingIndicatorProps): react_jsx_runtime.JSX.Element;
 
-interface BlinkModalProps {
-    visible: boolean;
-    onClose: () => void;
-    title?: string;
-    description?: string;
-    children?: React.ReactNode;
-    showCloseButton?: boolean;
-    style?: ViewStyle;
+interface ListingCardProps {
+    image: ImageSourcePropType | string;
+    title: string;
+    subtitle?: string;
+    price: string;
+    priceSuffix?: string;
+    rating?: number;
+    favorite?: boolean;
+    badge?: string;
+    imageHeight?: number;
+    onPress?: () => void;
+    onFavorite?: () => void;
+    className?: string;
 }
-declare const BlinkModal: React.FC<BlinkModalProps>;
+declare function ListingCard({ image, title, subtitle, price, priceSuffix, rating, favorite, badge, imageHeight, onPress, onFavorite, className, }: ListingCardProps): react_jsx_runtime.JSX.Element;
 
-interface ConfirmationSheetProps {
+interface ProductCardProps {
+    image: ImageSourcePropType | string;
     title: string;
-    message?: string;
-    confirmLabel?: string;
-    cancelLabel?: string;
-    onConfirm: () => void;
-    onCancel: () => void;
-    destructive?: boolean;
+    price: string;
+    originalPrice?: string;
+    badge?: string;
+    favorite?: boolean;
+    onPress?: () => void;
+    onFavorite?: () => void;
+    className?: string;
 }
-declare const ConfirmationSheet: React.FC<ConfirmationSheetProps>;
-declare function useConfirmationSheet(): {
-    show: (p: ConfirmationSheetProps) => void;
-    Sheet: react_jsx_runtime.JSX.Element | null;
-};
+declare function ProductCard({ image, title, price, originalPrice, badge, favorite, onPress, onFavorite, className, }: ProductCardProps): react_jsx_runtime.JSX.Element;
 
-interface ActionItem {
-    label: string;
-    icon?: React.ReactNode;
-    onPress: () => void;
-    destructive?: boolean;
-    disabled?: boolean;
+interface CartItemProps {
+    image: ImageSourcePropType | string;
+    title: string;
+    subtitle?: string;
+    price: string;
+    quantity: number;
+    onIncrement?: () => void;
+    onDecrement?: () => void;
+    onRemove?: () => void;
+    className?: string;
 }
-interface BlinkActionSheetProps {
-    title?: string;
-    items: ActionItem[];
-    cancelLabel?: string;
-    onClose?: () => void;
+declare function CartItem({ image, title, subtitle, price, quantity, onIncrement, onDecrement, onRemove, className, }: CartItemProps): react_jsx_runtime.JSX.Element;
+
+interface PriceTagProps {
+    price: string;
+    originalPrice?: string;
+    suffix?: string;
+    className?: string;
 }
-declare const BlinkActionSheet: React.FC<BlinkActionSheetProps>;
-declare function useActionSheet(): {
-    show: (p: BlinkActionSheetProps) => void;
-    Sheet: react_jsx_runtime.JSX.Element | null;
-};
+declare function PriceTag({ price, originalPrice, suffix, className }: PriceTagProps): react_jsx_runtime.JSX.Element;
 
-type ToastType = 'success' | 'error' | 'info' | 'warning';
-type ToastPosition = 'top' | 'bottom';
-interface ToastOptions {
-    message: string;
-    type?: ToastType;
-    duration?: number;
-    position?: ToastPosition;
+interface RatingStarsProps {
+    rating: number;
+    maxStars?: number;
+    count?: number;
+    size?: number;
+    className?: string;
 }
-declare const Toast: React.FC;
-declare const toast: {
-    show: (opts: ToastOptions) => void | undefined;
-    success: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
-    error: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
-    info: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
-    warning: (message: string, opts?: Partial<ToastOptions>) => void | undefined;
-};
+declare function RatingStars({ rating, maxStars, count, size, className, }: RatingStarsProps): react_jsx_runtime.JSX.Element;
 
-interface PageLoaderProps {
-    message?: string;
-    transparent?: boolean;
+interface CategoryTileProps {
+    icon: keyof typeof Ionicons.glyphMap;
+    label: string;
+    iconColor?: string;
+    onPress?: () => void;
+    className?: string;
 }
-declare const PageLoader: React.FC<PageLoaderProps>;
+declare function CategoryTile({ icon, label, iconColor, onPress, className, }: CategoryTileProps): react_jsx_runtime.JSX.Element;
 
-interface EmptyStateProps {
-    icon?: React.ReactNode;
+interface BalanceDisplayProps {
+    label?: string;
+    amount: string;
+    currency?: string;
+    changePercent?: number;
+    className?: string;
+}
+declare function BalanceDisplay({ label, amount, currency, changePercent, className, }: BalanceDisplayProps): react_jsx_runtime.JSX.Element;
+
+interface CardPreviewProps {
+    cardNumber?: string;
+    expiryDate?: string;
+    brand?: string;
+    gradientColors?: [string, string];
+    className?: string;
+}
+declare function CardPreview({ cardNumber, expiryDate, brand, gradientColors, className, }: CardPreviewProps): react_jsx_runtime.JSX.Element;
+
+interface TransactionItemProps {
     title: string;
-    description?: string;
-    action?: {
-        label: string;
-        onPress: () => void;
-    };
-    style?: ViewStyle;
+    amount: string;
+    time: string;
+    method?: string;
+    isIncome?: boolean;
+    icon?: keyof typeof Ionicons.glyphMap;
+    avatar?: ImageSourcePropType | string;
+    onPress?: () => void;
+    className?: string;
 }
-declare const EmptyState: React.FC<EmptyStateProps>;
+declare function TransactionItem({ title, amount, time, method, isIncome, icon, avatar, onPress, className, }: TransactionItemProps): react_jsx_runtime.JSX.Element;
 
-interface PlaceholderProps {
-    width?: number | string;
-    height?: number;
-    borderRadius?: number;
-    style?: ViewStyle;
+interface StoryCircleProps {
+    image: ImageSourcePropType | string;
+    size?: number;
+    seen?: boolean;
+    gradientColors?: string[];
+    onPress?: () => void;
+    className?: string;
+}
+declare function StoryCircle({ image, size, seen, gradientColors, onPress, className, }: StoryCircleProps): react_jsx_runtime.JSX.Element;
+
+interface FeedCardProps {
+    userName: string;
+    userAvatar: ImageSourcePropType | string;
+    timeAgo: string;
+    content?: string;
+    image?: ImageSourcePropType | string;
+    liked?: boolean;
+    likeCount?: number;
+    commentCount?: number;
+    bookmarked?: boolean;
+    onLike?: () => void;
+    onComment?: () => void;
+    onShare?: () => void;
+    onBookmark?: () => void;
+    onMore?: () => void;
+    onUserPress?: () => void;
+    className?: string;
 }
-declare const Placeholder: React.FC<PlaceholderProps>;
+declare function FeedCard({ userName, userAvatar, timeAgo, content, image, liked, likeCount, commentCount, bookmarked, onLike, onComment, onShare, onBookmark, onMore, onUserPress, className, }: FeedCardProps): react_jsx_runtime.JSX.Element;
 
-interface TextSkeletonProps {
-    lines?: number;
-    style?: ViewStyle;
+interface ProviderCardProps {
+    heroImage: ImageSourcePropType | string;
+    avatar: ImageSourcePropType | string;
+    name: string;
+    rating?: number;
+    location?: string;
+    description?: string;
+    onPress?: () => void;
+    className?: string;
 }
-interface CardSkeletonProps {
-    style?: ViewStyle;
+declare function ProviderCard({ heroImage, avatar, name, rating, location, description, onPress, className, }: ProviderCardProps): react_jsx_runtime.JSX.Element;
+
+interface Reaction {
+    emoji: string;
+    count: number;
+    active?: boolean;
 }
-interface ListSkeletonProps {
-    rows?: number;
-    style?: ViewStyle;
+interface ReactionBarProps {
+    reactions: Reaction[];
+    onReact?: (emoji: string) => void;
+    className?: string;
 }
-interface AvatarSkeletonProps {
-    size?: number;
-    style?: ViewStyle;
+declare function ReactionBar({ reactions, onReact, className }: ReactionBarProps): react_jsx_runtime.JSX.Element;
+
+interface SearchBarProps {
+    placeholder?: string;
+    value?: string;
+    onChangeText?: (text: string) => void;
+    onSubmit?: (text: string) => void;
+    autoFocus?: boolean;
+    /** When true, renders as a pressable pill that opens full-screen overlay */
+    asTrigger?: boolean;
+    className?: string;
 }
-declare const SkeletonLoader: {
-    Text: React.FC<TextSkeletonProps>;
-    Card: React.FC<CardSkeletonProps>;
-    List: React.FC<ListSkeletonProps>;
-    Avatar: React.FC<AvatarSkeletonProps>;
-};
+declare function SearchBar({ placeholder, value: controlledValue, onChangeText, onSubmit, autoFocus, asTrigger, className, }: SearchBarProps): react_jsx_runtime.JSX.Element;
 
-interface HorizontalScrollerProps {
-    children: React.ReactNode;
-    snap?: boolean;
-    snapInterval?: number;
-    paddingHorizontal?: number;
-    gap?: number;
-    style?: ViewStyle;
+interface FilterChip {
+    id: string;
+    label: string;
+}
+interface FilterChipRowProps {
+    chips: FilterChip[];
+    activeId?: string;
+    onSelect?: (id: string) => void;
+    className?: string;
 }
-declare const HorizontalScroller: React.FC<HorizontalScrollerProps>;
+declare function FilterChipRow({ chips, activeId, onSelect, className, }: FilterChipRowProps): react_jsx_runtime.JSX.Element;
 
-interface CardScrollerProps {
-    children: React.ReactNode;
-    cardWidth?: number;
-    gap?: number;
-    snapEnabled?: boolean;
-    paddingHorizontal?: number;
-    style?: ViewStyle;
+type SectionTitleSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+interface SectionHeaderProps {
+    title: string;
+    titleSize?: SectionTitleSize;
+    linkText?: string;
+    onLinkPress?: () => void;
+    className?: string;
 }
-declare const CardScroller: React.FC<CardScrollerProps>;
+declare function SectionHeader({ title, titleSize, linkText, onLinkPress, className, }: SectionHeaderProps): react_jsx_runtime.JSX.Element;
 
-interface ImageCarouselProps {
-    images: string[];
-    height?: number;
-    borderRadius?: number;
-    onIndexChange?: (index: number) => void;
-    style?: ViewStyle;
+interface CheckoutStep {
+    key: string;
+    label: string;
+    content: React.ReactNode;
+}
+interface CheckoutFlowProps {
+    steps: CheckoutStep[];
+    onComplete?: () => void;
+    nextLabel?: string;
+    completeLabel?: string;
+    className?: string;
+}
+declare function CheckoutFlow({ steps, onComplete, nextLabel, completeLabel, className, }: CheckoutFlowProps): react_jsx_runtime.JSX.Element;
+
+interface DateRangePickerProps {
+    startDate?: Date;
+    endDate?: Date;
+    onSelect?: (start: Date, end: Date | null) => void;
+    className?: string;
 }
-declare const ImageCarousel: React.FC<ImageCarouselProps>;
+declare function DateRangePicker({ startDate: initialStart, endDate: initialEnd, onSelect, className, }: DateRangePickerProps): react_jsx_runtime.JSX.Element;
 
-export { type ActionItem, AnimatedFab, AnimatedView, AnimatedView as AnimatedViewNamed, type AnimationType, Avatar, type AvatarProps, Badge, type BadgeProps, BlinkActionSheet, type BlinkActionSheetProps, BlinkMobileUIProvider, BlinkModal, type BlinkModalProps, BlinkPressable, type BlinkPressableProps, BlinkSwitch, type BlinkSwitchProps, type BorderRadiusScale, BottomSheet, type BottomSheetProps, type BottomSheetRef, Button, type ButtonProps, Card, type CardProps, CardScroller, type CardScrollerProps, ChatBubble, ChatInput, ChatList, Checkbox, type CheckboxProps, Chip, type ChipProps, type ColorPalette, type ColorScheme, ConfirmationSheet, type ConfirmationSheetProps, Container, type ContainerProps, Counter, type CounterProps, DatePicker, type DatePickerProps, Divider, type DividerProps, EmptyState, type EmptyStateProps, FadeIn, FeatureRow, GlassCard, GlassHeader, GlassSheet, GlassTabBar, GlassView, Grid, type GridProps, HStack, Header, HeaderIcon, type HeaderIconProps, type HeaderProps, HorizontalScroller, type HorizontalScrollerProps, Icon, IconButton, type IconButtonProps, type IconProps, ImageCarousel, type ImageCarouselProps, Input, type InputProps, List, ListItem, type ListItemProps, type ListProps, MultiStep, type MultiStepProps, OnboardingCarousel, type OnboardingCarouselProps, OnboardingFlow, OnboardingHero, type OnboardingSlide, PageLoader, type PageLoaderProps, type PaletteName, PaywallHard, PaywallScreen, type PaywallScreenProps, PaywallSoft, PermissionStep, Placeholder, type PlaceholderProps, PlanCard, PlanComparison, type PlanOption, ProgressBar, type ProgressBarProps, type QuizOption, QuizStep, type QuizStepProps, RadioGroup, type RadioGroupProps, ReelItem, ReelOverlay, SCREEN_HEIGHT, SCREEN_WIDTH, SafeWrapper, type SafeWrapperProps, ScaleIn, ScreenContent, type ScreenContentProps, SearchInput, type SearchInputProps, Section, type SectionProps, SegmentedControl, type SegmentedControlProps, Select, type SelectProps, type ShadowScale, Skeleton, SkeletonLoader, type SkeletonProps, SlideIn, SlideUp, Slider, SocialProofBar, Spacer, type SpacerProps, type SpacingScale, Stack, type StackProps, type StepProps, SwipeActions, SwipeCard, SwipeDeck, SwipeOverlay, TabBar, type TabBarProps, TabButton, type TabButtonProps, Tag, type TagProps, Text, TextArea, type TextProps, type ThemeTokens, Toast, Toggle, type ToggleProps, TrialBanner, TypingIndicator, type TypographyScale, VStack, VerticalReel, applyShadow, mergeStyles as cn, defaultPalette, hapticAvailable, isAndroid, isIOS, isWeb, mergeStyles, palettes, platformTouchTarget, platformValue, shadowPresets, toast, useActionSheet, useBlinkMobileUI, useBottomSheet, useConfirmationSheet, useThemeColors };
+export { type ActionItem, AnimatedFab, AnimatedView, type AnimationType, AuthButtons, type AuthButtonsProps, type AuthProvider, Avatar, type AvatarProps, Badge, type BadgeProps, BalanceDisplay, type BalanceDisplayProps, BlinkActionSheet, type BlinkActionSheetProps, BlinkMobileUIProvider, BlinkModal, BlinkPressable, type BlinkPressableProps, BlinkSwitch, type BlinkSwitchProps, BlinkText, type BlinkTextProps, BottomSheet, Button, type ButtonProps, Card, type CardBodyProps, type CardDescriptionProps, type CardFooterProps, type CardHeaderProps, type CardImageProps, CardPreview, type CardPreviewProps, type CardProps, CardScroller, type CardTitleProps, CartItem, type CartItemProps, CategoryTile, type CategoryTileProps, ChatBubble, type ChatBubbleProps, ChatInput, type ChatInputProps, ChatList, type ChatListProps, type ChatMessage, Checkbox, type CheckboxProps, CheckoutFlow, type CheckoutFlowProps, type CheckoutStep, Chip, type ChipProps, type ColorScheme, ConfirmationSheet, type ConfirmationSheetProps, Container, type ContainerProps, Counter, type CounterProps, DateRangePicker, type DateRangePickerProps, Divider, type DividerProps, EmptyState, FadeIn, FeatureRow, type FeatureRowProps, FeedCard, type FeedCardProps, type FilterChip, FilterChipRow, type FilterChipRowProps, type FlexStackProps, GlassCard, type GlassCardProps, GlassHeader, type GlassHeaderProps, GlassSheet, type GlassSheetProps, type GlassTab, GlassTabBar, type GlassTabBarProps, type GlassTint, GlassView, type GlassViewProps, Grid, type GridProps, HStack, Header, HeaderIcon, type HeaderIconProps, type HeaderProps, type HeaderVariant, IconButton, type IconButtonProps, IconContainer, type IconContainerProps, ImageCarousel, Input, type InputProps, type InputVariant, List, ListItem, type ListItemProps, type ListProps, ListingCard, type ListingCardProps, MultiStep, OnboardingCarousel, type OnboardingCarouselProps, OnboardingFlow, type OnboardingFlowProps, type OnboardingFlowStep, OnboardingHero, type OnboardingHeroProps, OnboardingParallax, type OnboardingParallaxProps, type OnboardingSlide, PageLoader, type PaletteName, type ParallaxLayer, type ParallaxSlide, type PaywallFeature, PaywallHard, type PaywallHardProps, PaywallScreen, type PaywallScreenProps, PaywallSoft, type PaywallSoftProps, PermissionStep, type PermissionStepProps, Placeholder, PlanCard, type PlanCardProps, PlanComparison, type PlanComparisonProps, type PlanOption, PriceTag, type PriceTagProps, ProductCard, type ProductCardProps, ProgressBar, type ProgressBarProps, ProviderCard, type ProviderCardProps, type QuizOption, QuizStep, type QuizStepProps, RadioGroup, type RadioGroupProps, type RadioOption, RatingStars, type RatingStarsProps, type Reaction, ReactionBar, type ReactionBarProps, type ReelAction, ReelItem, type ReelItemProps, ReelOverlay, type ReelOverlayProps, SafeWrapper, type SafeWrapperProps, ScaleIn, SearchBar, type SearchBarProps, SearchInput, type SearchInputProps, SearchPill, type SearchPillProps, Section, SectionHeader, type SectionHeaderProps, type SectionProps, type SectionTitleSize, type Segment, SegmentedControl, type SegmentedControlProps, Select, type SelectOption, type SelectProps, Skeleton, SkeletonLoader, type SkeletonProps, SlideIn, SlideUp, Slider, type SliderProps, SocialProofBar, type SocialProofBarProps, Spacer, type SpacerProps, Stack, type StackProps, StoryCircle, type StoryCircleProps, SwipeActions, type SwipeActionsProps, SwipeCard, type SwipeCardProps, SwipeDeck, type SwipeDeckProps, type SwipeDirection, SwipeOverlay, type SwipeOverlayProps, TabBar, type TabBarProps, TabButton, type TabButtonProps, type TabItem, Tag, type TagProps, TextArea, type TextAreaProps, ThemeScroller, type ThemeScrollerProps$1 as ThemeScrollerProps, Toast, Toggle, type ToggleProps, TransactionItem, type TransactionItemProps, TrialBanner, type TrialBannerProps, TypingIndicator, type TypingIndicatorProps, VStack, VerticalReel, type VerticalReelProps, cn, palettes, toast, useActionSheet, useAnimColors, useBlinkMobileUI, useConfirmationSheet };