import React$1 from 'react';
import { PressableProps, ViewStyle, TextStyle, TextProps, TextInputProps, ViewProps, ImageSourcePropType } from 'react-native';

interface NovaColors {
    primary: string;
    primaryLight: string;
    primaryDark: string;
    secondary: string;
    secondaryLight: string;
    secondaryDark: string;
    success: string;
    successLight: string;
    successDark: string;
    warning: string;
    warningLight: string;
    warningDark: string;
    error: string;
    errorLight: string;
    errorDark: string;
    info: string;
    infoLight: string;
    infoDark: string;
    background: string;
    surface: string;
    surfaceVariant: string;
    text: string;
    textSecondary: string;
    textDisabled: string;
    textInverse: string;
    border: string;
    borderLight: string;
    overlay: string;
    transparent: string;
}
interface NovaSpacing {
    xs: number;
    sm: number;
    md: number;
    lg: number;
    xl: number;
    '2xl': number;
    '3xl': number;
}
interface NovaRadii {
    none: number;
    xs: number;
    sm: number;
    md: number;
    lg: number;
    xl: number;
    full: number;
}
interface NovaTypography {
    fontFamily: {
        regular: string;
        medium: string;
        semibold: string;
        bold: string;
    };
    fontSize: {
        xs: number;
        sm: number;
        md: number;
        lg: number;
        xl: number;
        '2xl': number;
        '3xl': number;
        '4xl': number;
    };
    lineHeight: {
        tight: number;
        normal: number;
        relaxed: number;
    };
}
interface NovaShadows {
    none: ShadowStyle;
    sm: ShadowStyle;
    md: ShadowStyle;
    lg: ShadowStyle;
    xl: ShadowStyle;
}
interface ShadowStyle {
    shadowColor: string;
    shadowOffset: {
        width: number;
        height: number;
    };
    shadowOpacity: number;
    shadowRadius: number;
    elevation: number;
}
interface NovaTheme {
    dark: boolean;
    colors: NovaColors;
    spacing: NovaSpacing;
    radii: NovaRadii;
    typography: NovaTypography;
    shadows: NovaShadows;
}
type NovaThemeOverride = {
    dark?: boolean;
    colors?: Partial<NovaColors>;
    spacing?: Partial<NovaSpacing>;
    radii?: Partial<NovaRadii>;
    typography?: Partial<NovaTypography>;
    shadows?: Partial<NovaShadows>;
};

interface ThemeProviderProps {
    theme?: NovaThemeOverride;
    darkMode?: boolean;
    children: React$1.ReactNode;
}
declare const ThemeProvider: React$1.FC<ThemeProviderProps>;

declare function useTheme(): NovaTheme;

declare const lightTheme: NovaTheme;
declare const darkTheme: NovaTheme;

type ButtonVariant = 'solid' | 'outline' | 'ghost' | 'soft';
type ButtonSize = 'sm' | 'md' | 'lg';
type ButtonColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
interface ButtonProps extends Omit<PressableProps, 'style'> {
    variant?: ButtonVariant;
    size?: ButtonSize;
    color?: ButtonColor;
    fullWidth?: boolean;
    loading?: boolean;
    disabled?: boolean;
    leftIcon?: React.ReactNode;
    rightIcon?: React.ReactNode;
    style?: ViewStyle;
    textStyle?: TextStyle;
    children: React.ReactNode;
}

declare const Button: React$1.FC<ButtonProps>;

type TextVariant = 'h1' | 'h2' | 'h3' | 'h4' | 'body' | 'bodySmall' | 'caption' | 'label' | 'overline';
type TextWeight = 'regular' | 'medium' | 'semibold' | 'bold';
type TextColor = 'default' | 'secondary' | 'disabled' | 'inverse' | 'primary' | 'success' | 'warning' | 'error' | 'info';
type TextAlign = 'auto' | 'left' | 'right' | 'center' | 'justify';
interface NovaTextProps extends TextProps {
    variant?: TextVariant;
    weight?: TextWeight;
    color?: TextColor;
    align?: TextAlign;
    italic?: boolean;
    underline?: boolean;
    strikethrough?: boolean;
    uppercase?: boolean;
    children: React.ReactNode;
}

declare const NovaText: React$1.FC<NovaTextProps>;

type InputVariant = 'outline' | 'filled' | 'underline';
type InputSize = 'sm' | 'md' | 'lg';
interface NovaInputProps extends Omit<TextInputProps, 'style'> {
    variant?: InputVariant;
    size?: InputSize;
    label?: string;
    helperText?: string;
    errorText?: string;
    leftIcon?: React.ReactNode;
    rightIcon?: React.ReactNode;
    disabled?: boolean;
    fullWidth?: boolean;
    containerStyle?: ViewStyle;
    inputStyle?: TextStyle;
    labelStyle?: TextStyle;
}

declare const Input: React$1.FC<NovaInputProps>;

type CardVariant = 'elevated' | 'outlined' | 'filled';
interface CardProps extends ViewProps {
    variant?: CardVariant;
    padding?: 'none' | 'sm' | 'md' | 'lg';
    rounded?: 'sm' | 'md' | 'lg' | 'xl';
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const Card: React$1.FC<CardProps>;

type DividerOrientation = 'horizontal' | 'vertical';
interface DividerProps {
    orientation?: DividerOrientation;
    thickness?: number;
    color?: string;
    spacing?: number;
    style?: ViewStyle;
}

declare const Divider: React$1.FC<DividerProps>;

type SpacingKey$1 = keyof NovaSpacing;
interface BoxProps extends ViewProps {
    padding?: SpacingKey$1;
    paddingX?: SpacingKey$1;
    paddingY?: SpacingKey$1;
    margin?: SpacingKey$1;
    marginX?: SpacingKey$1;
    marginY?: SpacingKey$1;
    gap?: SpacingKey$1;
    flex?: number;
    direction?: 'row' | 'column' | 'row-reverse' | 'column-reverse';
    align?: ViewStyle['alignItems'];
    justify?: ViewStyle['justifyContent'];
    wrap?: boolean;
    bg?: string;
    rounded?: 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
    shadow?: 'none' | 'sm' | 'md' | 'lg' | 'xl';
    style?: ViewStyle;
    children?: React.ReactNode;
}

declare const Box: React$1.FC<BoxProps>;

type SpacingKey = keyof NovaSpacing;
interface StackProps extends ViewProps {
    direction?: 'horizontal' | 'vertical';
    spacing?: SpacingKey;
    align?: ViewStyle['alignItems'];
    justify?: ViewStyle['justifyContent'];
    wrap?: boolean;
    style?: ViewStyle;
    children: React.ReactNode;
}
type HStackProps = Omit<StackProps, 'direction'>;
type VStackProps = Omit<StackProps, 'direction'>;

declare const Stack: React$1.FC<StackProps>;
declare const HStack: React$1.FC<HStackProps>;
declare const VStack: React$1.FC<VStackProps>;

type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
interface AvatarProps {
    source?: ImageSourcePropType;
    name?: string;
    size?: AvatarSize;
    rounded?: boolean;
    backgroundColor?: string;
    textColor?: string;
    style?: ViewStyle;
    textStyle?: TextStyle;
}

declare const Avatar: React$1.FC<AvatarProps>;

type BadgeVariant = 'solid' | 'outline' | 'soft';
type BadgeColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
type BadgeSize = 'sm' | 'md' | 'lg';
interface BadgeProps {
    variant?: BadgeVariant;
    color?: BadgeColor;
    size?: BadgeSize;
    label: string;
    rounded?: boolean;
    style?: ViewStyle;
    textStyle?: TextStyle;
}
interface BadgeDotProps {
    color?: BadgeColor;
    size?: number;
    style?: ViewStyle;
}

declare const Badge: React$1.FC<BadgeProps>;
declare const BadgeDot: React$1.FC<BadgeDotProps>;

type ChipVariant = 'solid' | 'outline' | 'soft';
type ChipColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
interface ChipProps {
    variant?: ChipVariant;
    color?: ChipColor;
    label: string;
    selected?: boolean;
    disabled?: boolean;
    leftIcon?: React.ReactNode;
    onPress?: () => void;
    onClose?: () => void;
    style?: ViewStyle;
    textStyle?: TextStyle;
}

declare const Chip: React$1.FC<ChipProps>;

type SkeletonVariant = 'rectangular' | 'circular' | 'text';
interface SkeletonProps {
    variant?: SkeletonVariant;
    width?: number | string;
    height?: number;
    radius?: number;
    style?: ViewStyle;
}

declare const Skeleton: React$1.FC<SkeletonProps>;

type SpinnerSize = 'sm' | 'md' | 'lg';
type SpinnerColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
interface SpinnerProps {
    size?: SpinnerSize;
    color?: SpinnerColor;
    label?: string;
    style?: ViewStyle;
}

declare const Spinner: React$1.FC<SpinnerProps>;

type SwitchColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error';
type SwitchSize = 'sm' | 'md' | 'lg';
interface NovaSwitchProps {
    value: boolean;
    onValueChange: (value: boolean) => void;
    color?: SwitchColor;
    size?: SwitchSize;
    disabled?: boolean;
    label?: string;
    style?: ViewStyle;
}

declare const NovaSwitch: React$1.FC<NovaSwitchProps>;

type CheckboxColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error';
type CheckboxSize = 'sm' | 'md' | 'lg';
interface CheckboxProps {
    checked: boolean;
    onCheckedChange: (checked: boolean) => void;
    color?: CheckboxColor;
    size?: CheckboxSize;
    label?: string;
    disabled?: boolean;
    style?: ViewStyle;
    labelStyle?: TextStyle;
}

declare const Checkbox: React$1.FC<CheckboxProps>;

type RadioColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error';
type RadioSize = 'sm' | 'md' | 'lg';
interface RadioOption<T extends string = string> {
    value: T;
    label: string;
    disabled?: boolean;
}
interface RadioGroupProps<T extends string = string> {
    options: RadioOption<T>[];
    value: T;
    onValueChange: (value: T) => void;
    color?: RadioColor;
    size?: RadioSize;
    direction?: 'horizontal' | 'vertical';
    spacing?: number;
    disabled?: boolean;
    style?: ViewStyle;
    labelStyle?: TextStyle;
}

declare function RadioGroup<T extends string = string>({ options, value, onValueChange, color, size, direction, spacing, disabled, style, labelStyle, }: RadioGroupProps<T>): React$1.JSX.Element;

interface OTPInputProps {
    length?: number;
    value: string;
    onValueChange: (value: string) => void;
    onComplete?: (value: string) => void;
    secureEntry?: boolean;
    disabled?: boolean;
    error?: boolean;
    autoFocus?: boolean;
    style?: ViewStyle;
    cellStyle?: ViewStyle;
    textStyle?: TextStyle;
}

declare const OTPInput: React$1.FC<OTPInputProps>;

type ProgressVariant = 'linear' | 'circular';
type ProgressColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
type ProgressSize = 'sm' | 'md' | 'lg';
interface ProgressProps {
    value: number;
    variant?: ProgressVariant;
    color?: ProgressColor;
    size?: ProgressSize;
    showValue?: boolean;
    animated?: boolean;
    indeterminate?: boolean;
    style?: ViewStyle;
}

declare const Progress: React$1.FC<ProgressProps>;

type SliderColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error';
interface SliderProps {
    value: number;
    onValueChange: (value: number) => void;
    onSlidingComplete?: (value: number) => void;
    min?: number;
    max?: number;
    step?: number;
    disabled?: boolean;
    color?: SliderColor;
    showValue?: boolean;
    style?: ViewStyle;
}

declare const Slider: React$1.FC<SliderProps>;

interface TabItem {
    key: string;
    label: string;
    icon?: React.ReactNode;
}
type TabVariant = 'underline' | 'pill' | 'soft';
type TabSize = 'sm' | 'md' | 'lg';
interface TabsProps {
    tabs: TabItem[];
    activeTab: string;
    onTabChange: (key: string) => void;
    variant?: TabVariant;
    size?: TabSize;
    fullWidth?: boolean;
    style?: ViewStyle;
    tabStyle?: ViewStyle;
    labelStyle?: TextStyle;
}

declare const Tabs: React$1.FC<TabsProps>;

interface SearchBarProps extends Omit<TextInputProps, 'style'> {
    value: string;
    onChangeText: (text: string) => void;
    onClear?: () => void;
    onSubmit?: () => void;
    placeholder?: string;
    loading?: boolean;
    disabled?: boolean;
    style?: ViewStyle;
}

declare const SearchBar: React$1.FC<SearchBarProps>;

interface AccordionItem {
    key: string;
    title: string;
    content: React.ReactNode;
}
interface AccordionProps {
    items: AccordionItem[];
    allowMultiple?: boolean;
    defaultExpandedKeys?: string[];
    style?: ViewStyle;
}

declare const Accordion: React$1.FC<AccordionProps>;

type IconButtonVariant = 'solid' | 'outline' | 'ghost' | 'soft';
type IconButtonSize = 'sm' | 'md' | 'lg';
type IconButtonColor = 'primary' | 'secondary' | 'success' | 'warning' | 'error' | 'info';
interface IconButtonProps extends Omit<PressableProps, 'style'> {
    variant?: IconButtonVariant;
    size?: IconButtonSize;
    color?: IconButtonColor;
    rounded?: boolean;
    disabled?: boolean;
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const IconButton: React$1.FC<IconButtonProps>;

type FABSize = 'sm' | 'md' | 'lg';
type FABPosition = 'bottom-right' | 'bottom-left' | 'bottom-center';
type FABColor = 'primary' | 'secondary' | 'success' | 'error';
interface FABProps extends Omit<PressableProps, 'style'> {
    size?: FABSize;
    color?: FABColor;
    position?: FABPosition;
    label?: string;
    icon: React.ReactNode;
    style?: ViewStyle;
}

declare const FAB: React$1.FC<FABProps>;

type ModalSize = 'sm' | 'md' | 'lg' | 'full';
interface NovaModalProps {
    visible: boolean;
    onClose: () => void;
    size?: ModalSize;
    title?: string;
    closeOnBackdrop?: boolean;
    showCloseButton?: boolean;
    animationType?: 'fade' | 'slide' | 'none';
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const NovaModal: React$1.FC<NovaModalProps>;

type BottomSheetHeight = 'auto' | 'half' | 'full';
interface BottomSheetProps {
    visible: boolean;
    onClose: () => void;
    height?: BottomSheetHeight;
    showHandle?: boolean;
    closeOnBackdrop?: boolean;
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const BottomSheet: React$1.FC<BottomSheetProps>;

type ToastType = 'success' | 'error' | 'warning' | 'info';
type ToastPosition = 'top' | 'bottom';
interface ToastConfig {
    id?: string;
    type?: ToastType;
    title: string;
    description?: string;
    duration?: number;
    position?: ToastPosition;
    onPress?: () => void;
}
interface ToastContextType {
    show: (config: ToastConfig) => void;
    hide: (id: string) => void;
    hideAll: () => void;
}

interface ToastProviderProps {
    children: React$1.ReactNode;
    maxVisible?: number;
}
declare const ToastProvider: React$1.FC<ToastProviderProps>;

declare function useToast(): ToastContextType;

type GlowColor = 'primary' | 'secondary' | 'success' | 'error' | 'rainbow';
interface GlowCardProps {
    glowColor?: GlowColor;
    intensity?: 'subtle' | 'medium' | 'strong';
    animated?: boolean;
    padding?: 'sm' | 'md' | 'lg';
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const GlowCard: React$1.FC<GlowCardProps>;

interface AnimatedNumberProps {
    value: number;
    duration?: number;
    prefix?: string;
    suffix?: string;
    decimals?: number;
    style?: TextStyle;
}

declare const AnimatedNumber: React$1.FC<AnimatedNumberProps>;

type MarqueeDirection = 'left' | 'right';
interface MarqueeProps {
    speed?: number;
    direction?: MarqueeDirection;
    pauseOnPress?: boolean;
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const Marquee: React$1.FC<MarqueeProps>;

type ShimmerButtonColor = 'primary' | 'secondary' | 'success' | 'error';
interface ShimmerButtonProps extends Omit<PressableProps, 'style'> {
    color?: ShimmerButtonColor;
    size?: 'sm' | 'md' | 'lg';
    style?: ViewStyle;
    textStyle?: TextStyle;
    children: React.ReactNode;
}

declare const ShimmerButton: React$1.FC<ShimmerButtonProps>;

interface GradientTextProps {
    colors?: string[];
    animated?: boolean;
    speed?: number;
    style?: TextStyle;
    children: string;
}

declare const GradientText: React$1.FC<GradientTextProps>;

type StaggerAnimation = 'fadeUp' | 'fadeLeft' | 'scaleIn' | 'fadeIn';
interface StaggeredListProps {
    animation?: StaggerAnimation;
    staggerDelay?: number;
    duration?: number;
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const StaggeredList: React$1.FC<StaggeredListProps>;

interface RippleProps extends Omit<PressableProps, 'style'> {
    rippleColor?: string;
    rippleOpacity?: number;
    rippleDuration?: number;
    style?: ViewStyle;
    children: React.ReactNode;
}

declare const Ripple: React$1.FC<RippleProps>;

/**
 * Adjusts the opacity of a hex color.
 */
declare function withOpacity(hex: string, opacity: number): string;
/**
 * Lightens a hex color by a given percentage (0 to 1).
 */
declare function lighten(hex: string, amount: number): string;
/**
 * Darkens a hex color by a given percentage (0 to 1).
 */
declare function darken(hex: string, amount: number): string;
/**
 * Determines if a color is considered "light" or "dark" based on luminance.
 */
declare function isLightColor(hex: string): boolean;

/**
 * Creates consistent spacing values from theme spacing.
 */
declare function createSpacing(spacing: NovaSpacing): {
    padding: (key: keyof NovaSpacing) => number;
    margin: (key: keyof NovaSpacing) => number;
    gap: (key: keyof NovaSpacing) => number;
    multiply: (key: keyof NovaSpacing, factor: number) => number;
};

export { Accordion, type AccordionItem, type AccordionProps, AnimatedNumber, type AnimatedNumberProps, Avatar, type AvatarProps, type AvatarSize, Badge, type BadgeColor, BadgeDot, type BadgeDotProps, type BadgeProps, type BadgeSize, type BadgeVariant, BottomSheet, type BottomSheetHeight, type BottomSheetProps, Box, type BoxProps, Button, type ButtonColor, type ButtonProps, type ButtonSize, type ButtonVariant, Card, type CardProps, type CardVariant, Checkbox, type CheckboxColor, type CheckboxProps, type CheckboxSize, Chip, type ChipColor, type ChipProps, type ChipVariant, Divider, type DividerOrientation, type DividerProps, FAB, type FABColor, type FABPosition, type FABProps, type FABSize, GlowCard, type GlowCardProps, type GlowColor, GradientText, type GradientTextProps, HStack, type HStackProps, IconButton, type IconButtonColor, type IconButtonProps, type IconButtonSize, type IconButtonVariant, Input, type InputSize, type InputVariant, Marquee, type MarqueeDirection, type MarqueeProps, type ModalSize, type NovaColors, type NovaInputProps, NovaModal, type NovaModalProps, type NovaRadii, type NovaShadows, type NovaSpacing, NovaSwitch, type NovaSwitchProps, NovaText, type NovaTextProps, type NovaTheme, type NovaThemeOverride, type NovaTypography, OTPInput, type OTPInputProps, Progress, type ProgressColor, type ProgressProps, type ProgressSize, type ProgressVariant, type RadioColor, RadioGroup, type RadioGroupProps, type RadioOption, type RadioSize, Ripple, type RippleProps, SearchBar, type SearchBarProps, type ShadowStyle, ShimmerButton, type ShimmerButtonColor, type ShimmerButtonProps, Skeleton, type SkeletonProps, type SkeletonVariant, Slider, type SliderColor, type SliderProps, Spinner, type SpinnerColor, type SpinnerProps, type SpinnerSize, Stack, type StackProps, type StaggerAnimation, StaggeredList, type StaggeredListProps, type SwitchColor, type SwitchSize, type TabItem, type TabSize, type TabVariant, Tabs, type TabsProps, type TextAlign, type TextColor, type TextVariant, type TextWeight, ThemeProvider, type ThemeProviderProps, type ToastConfig, type ToastContextType, type ToastPosition, ToastProvider, type ToastType, VStack, type VStackProps, createSpacing, darkTheme, darken, isLightColor, lightTheme, lighten, useTheme, useToast, withOpacity };