import React, { ReactNode, FC } from 'react';
import { ViewStyle, TextStyle, NativeSyntheticEvent, NativeScrollEvent, TextInputProps, TextProps, StyleProp, ViewProps, ScrollView, View, TextInput } from 'react-native';

type ThemeTypes = "dark" | "light";
type ThemeModes = "dark" | "light" | "default";
type colorTypes = "primary" | "secondary" | "light" | "dark" | "info" | "warning" | "error" | "success" | "blue" | "textSecondary";
type extraColorTypes = {
    dark?: {
        [key: string]: {
            main?: string;
            light?: string;
            dark?: string;
            text?: string;
            [key: number]: string;
        };
    };
    light?: {
        [key: string]: {
            main?: string;
            light?: string;
            dark?: string;
            text?: string;
            [key: number]: string;
        };
    };
};
interface ThemeActionTypes {
    type: ThemeModes;
    payload?: ThemeTypes;
}
interface ThemeState {
    value: ThemeTypes;
    mode: ThemeModes;
}
interface ThemeContext {
    themeState: ThemeState;
    themeDispatch?: (action: ThemeActionTypes) => void;
}
interface ThemeProviderProps {
    children: ReactNode;
}
interface AlertXProps {
    type: "info" | "warning" | "success" | "error";
    variant?: "contained" | "outlined";
    title?: string;
    gutterBottom?: number;
    body: string;
    style?: ViewStyle;
}
interface AvatarProps {
    color?: colorTypes;
    label?: string;
    variant?: "outlined" | "contained";
    source?: any;
    size?: number;
    style?: ViewStyle;
    icon?: ReactNode;
}
interface ButtonProps {
    color?: colorTypes;
    variant?: "text" | "outlined" | "contained" | "translucent";
    gutterBottom?: number;
    elevation?: number;
    onPress?: () => void;
    disabled?: boolean;
    title?: string;
    loading?: boolean;
    size?: "large" | "normal" | "small";
    rounded?: boolean;
    style?: ViewStyle;
    fullWidth?: boolean;
    translucent?: "dark" | undefined;
    start?: ReactNode;
    end?: ReactNode;
}
interface CheckboxProps {
    color?: colorTypes;
    label?: ReactNode;
    size?: number;
    checked?: boolean;
    style?: ViewStyle;
    onChange?: () => void;
}
interface FlashMessageProps {
    message: string;
    title?: string;
    actions?: Array<{
        title: string;
        onPress?: () => void;
    }>;
    duration?: number;
    type?: "success" | "warning" | "error" | "info" | "default";
}
interface LinkButtonProps {
    title: string;
    style?: TextStyle & ViewStyle;
    color?: colorTypes;
    fontSize?: number;
    fontWeight?: 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
    disabled?: boolean;
    onPress?: () => void;
}
interface IconButtonProps {
    style?: TextStyle;
    color?: colorTypes;
    fontSize?: number;
    disabled?: boolean;
    onPress?: () => void;
    icon: any;
    elevation?: number;
    bg?: boolean;
    size?: number;
    containerStyles?: ViewStyle;
    iconType?: "material" | "ion";
}
type locatorLocation = {
    description: string;
    formatted_address?: string;
    longitude: number;
    latitude: number;
};
type LocatorInputProps = {
    onBlur?: () => void;
    onFocus?: () => void;
    clear?: () => void;
    locateMe?: () => void;
    value?: string;
    onChangeText: (text: string) => void;
};
interface LocatorProps {
    variant?: "contained" | "outlined";
    onLocationSelected: (location: locatorLocation | null, formatted_address?: string) => void;
    label?: string;
    error?: string;
    float?: boolean;
    location?: locatorLocation | null;
    gutterBottom?: number;
    helperText?: string;
    renderInput?: (props: LocatorInputProps) => ReactNode;
    country?: string;
}
interface ListProps {
    style?: ViewStyle;
    children: ReactNode;
}
interface ListItemTextProps {
    primary: string;
    divider?: boolean;
    primaryProps?: TypographyProps;
    secondaryProps?: TypographyProps;
    secondary?: string;
    style?: ViewStyle;
}
interface ListItemProps {
    link?: boolean;
    divider?: boolean;
    onPress?: () => void;
    index?: number;
    style?: ViewStyle;
    children: ReactNode;
}
interface FormWrapperProps {
    children: ReactNode;
    behavior?: "position" | "height" | "padding";
    contentContainerStyle?: ViewStyle;
    mode?: "scroll" | "static";
    keyboardVerticalOffset?: number;
    style?: ViewStyle;
    onScroll?: (event: NativeSyntheticEvent<NativeScrollEvent>) => void;
}
interface GridItemProps {
    children: ReactNode;
    col?: number;
    alignItems?: "center" | "flex-start" | "flex-end";
    spacing?: number;
    style?: ViewStyle;
}
interface GridProps {
    children: ReactNode;
    spacing?: number;
    style?: ViewStyle;
}
interface PopupProps {
    title?: string;
    keyboardVerticalOffset?: number;
    sheet?: number | boolean;
    bare?: boolean;
    children: ReactNode;
    open: boolean;
    onClose?: () => void;
    style?: ViewStyle;
    disableAutoKeyboardManagement?: boolean;
    onModalShow?: () => void;
    onModalHide?: () => void;
}
interface SpinnerProps {
    label?: string;
    size?: "large" | "small";
    color?: colorTypes;
    fullscreen?: boolean;
    style?: ViewStyle;
}
interface TextFieldProps extends TextInputProps {
    label?: string;
    labelProps?: TypographyProps;
    variant?: "outlined" | "text" | "contained";
    color?: colorTypes;
    size?: "small" | "normal" | "large";
    type?: "email" | "tel" | "password" | "text" | "number" | "search" | "date";
    helperText?: string;
    value: any;
    start?: ReactNode;
    rounded?: boolean;
    error?: string | string[];
    disabled?: boolean;
    style?: ViewStyle;
    inputStyles?: any;
    gutterBottom?: number;
    end?: ReactNode;
    options?: {
        start?: ReactNode;
        secondary?: string;
        value: string | number;
        label: string;
    }[];
    onFocus?: () => void;
    onBlur?: () => void;
    selectMenuProps?: Partial<SelectMenuProps>;
    labelAlwaysOpen?: boolean;
}
interface TypographyProps extends TextProps {
    children: ReactNode;
    color?: colorTypes | (string & {});
    style?: StyleProp<TextStyle | ViewStyle>;
    textCase?: "capitalize" | "uppercase" | "lowercase" | undefined;
    lineHeight?: number;
    variant?: "caption" | "body1" | "body2" | "h6" | "h5" | "h4" | "h3" | "h2" | "h1";
    align?: "center" | "left" | "right";
    gutterBottom?: number;
    numberOfLines?: number;
    adjustsFontSizeToFit?: boolean;
    fontFamily?: string;
    fontSize?: number;
    fontWeight?: 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
}
interface SafeAreaViewProps extends ViewProps {
    children: ReactNode;
}
interface SelectMenuProps {
    open: boolean;
    onClose: () => void;
    value: any;
    options: {
        secondary?: string;
        value: any;
        label: string;
    }[];
    onChange: (value: string) => void;
    disableAutoClose?: boolean;
    label?: string;
    secondary?: string;
    helperText?: string;
    searchEnabled?: boolean;
    searchPlaceholder?: string;
}
interface OTPInputProps {
    length?: number;
    onChange: (value: string) => void;
    value: string;
    variant?: "outlined" | "text" | "contained";
    spacing?: number;
    size?: number;
}
interface RatingStarsProps {
    rating: number;
    size: number;
    color?: colorTypes | (string & {});
    inactiveColor?: colorTypes | (string & {});
}
interface RatingInputProps {
    rating?: number;
    noReview?: boolean;
    size?: number;
    onSubmit?: (data: {
        rating: number;
        review: string;
    }) => Promise<void>;
    color?: colorTypes | (string & {});
}
interface DividerProps {
    color?: colorTypes;
    gutterBottom?: number;
    style?: ViewStyle;
    height?: number;
}
type AnimationType = "fade" | "grow" | "slide" | "blink" | "float" | "roll" | "thrownup";
interface BaseAnimatorProps {
    children: ReactNode;
    duration?: number;
    delay?: number;
    closeAfter?: number | null;
    style?: ViewStyle;
}
type AnimatorProps = (BaseAnimatorProps & {
    type: "fade";
}) | (BaseAnimatorProps & {
    type: "grow";
    initialScale?: number;
}) | (BaseAnimatorProps & {
    type: "slide";
    direction?: "up" | "down" | "left" | "right";
    initialValue?: number;
}) | (BaseAnimatorProps & {
    type: "blink";
    blinkDuration?: number;
    minOpacity?: number;
    maxOpacity?: number;
}) | (BaseAnimatorProps & {
    type: "float";
    closeDuration?: number;
    floatDistance?: number;
    floatDuration?: number;
}) | (BaseAnimatorProps & {
    type: "roll";
    initialTranslateY?: number;
    initialRotate?: string;
}) | (BaseAnimatorProps & {
    type: "thrownup";
});

type TypographyVariant = "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "body1" | "body2" | "caption";
/**
 * Configuration options for the Hoddy UI library
 *
 * @example
 * ```typescript
 * initialize({
 *   googleMapApiKey: "AIzaSyBxxxxxxxxxxxxxxxxxxxxxx",
 *   edgeToEdge: true,
 *   colors: {
 *     primary: "#007AFF",
 *     secondary: "#34C759"
 *   },
 *   typography: {
 *     fontFamily: "Inter",
 *     fontWeights: {
 *       400: "Inter-Regular",
 *       500: "Inter-Medium",
 *       600: "Inter-SemiBold",
 *       700: "Inter-Bold"
 *     },
 *     fontSizes: {
 *       h1: 48,
 *       h2: 40,
 *       body1: 16,
 *       caption: 12
 *     }
 *   }
 * });
 * ```
 */
type configProps = {
    /** Google Maps API key for map components */
    googleMapApiKey?: string;
    /** Custom color palette overrides */
    colors?: extraColorTypes;
    /** Enable edge-to-edge display mode */
    edgeToEdge?: boolean;
    /** Typography settings */
    typography?: {
        /** Primary font family */
        fontFamily?: string;
        /** Font family mappings for each weight (Android support) */
        fontWeights?: {
            [K in 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900]?: string;
        };
        /** Custom font sizes for each typography variant (values in pixels, will be scaled with ms()) */
        fontSizes?: {
            [K in TypographyVariant]?: number;
        };
    };
};
declare function initialize(config: configProps): void;

declare const AdaptiveStatusBar: ({ translucent }: {
    translucent?: boolean | undefined;
}) => React.JSX.Element;

declare const AlertX: React.FC<AlertXProps>;

declare const Avatar: React.FC<AvatarProps>;

declare const LinkButton: React.FC<LinkButtonProps>;
declare const IconButton: React.FC<IconButtonProps>;
declare const Button: React.FC<ButtonProps>;

declare const CheckBox: FC<CheckboxProps>;

declare const showFlashMessage: (msg: FlashMessageProps) => void;

declare const FormWrapper: React.ForwardRefExoticComponent<FormWrapperProps & React.RefAttributes<ScrollView>>;

declare const RatingInput: FC<RatingInputProps>;
declare const RatingStars: FC<RatingStarsProps>;

declare const GridItem: React.FC<GridItemProps>;
declare const Grid: React.FC<GridProps>;

type predictionType = {
    id: string;
    description: string;
    types: string[];
};
declare const getPredictionsFromCoords: (coords: {
    latitude: number;
    longitude: number;
}) => Promise<{
    description: any;
    id: any;
    types: any;
    latLng: {
        lst: number;
        lng: number;
    };
}[]>;
declare const getPredictionsFromQuery: (query: string, country: string) => Promise<{
    description: any;
    id: any;
    types: any;
}[]>;
declare const getLocationFromPlaceId: (place_id: string) => Promise<{
    formatted_address: string;
    geometry: {
        location: {
            lat: number;
            lng: number;
        };
    };
}>;
declare const Locator: React.FC<LocatorProps>;

declare const Popup: React.FC<PopupProps>;

declare const SafeAreaView: React.ForwardRefExoticComponent<SafeAreaViewProps & React.RefAttributes<View>>;

declare const Divider: FC<DividerProps>;

declare const SelectMenu: React.FC<SelectMenuProps>;

declare const Spinner: React.FC<SpinnerProps>;

type TextFieldLabelVariant = "floating" | "external";
interface TextFieldBaseProps extends TextFieldProps {
    labelVariant: TextFieldLabelVariant;
}
declare const TextFieldBase: React.ForwardRefExoticComponent<TextFieldBaseProps & React.RefAttributes<TextInput>>;
declare const TextField: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<TextInput>>;
declare const TextField2: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<TextInput>>;

declare const Typography: React.FC<TypographyProps>;

declare const OTPInput: FC<OTPInputProps>;

declare const useColors: () => Record<string, {
    [key: number]: string;
    main?: string;
    light?: string;
    dark?: string;
    text?: string;
}> & {
    white: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    black: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    primary: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    secondary: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    light: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    dark: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    textSecondary: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    blue: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    info: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    success: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    warning: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
    error: {
        [key: number]: string;
        main?: string;
        light?: string;
        dark?: string;
        text?: string;
    };
};
declare const useTheme: () => ThemeTypes;
declare const useThemeContext: () => {
    theme: ThemeState;
    setTheme: (theme: ThemeModes) => void;
};
declare const useNavScreenOptions: (type: "stack" | "tab" | "drawer") => any;

declare const UIThemeContext: React.Context<ThemeContext>;
declare const UIThemeProvider: ({ children }: ThemeProviderProps) => React.JSX.Element;

declare const useAppState: () => {
    isActive: boolean;
};

interface UseBlinkAnimationProps {
    delay?: number;
    blinkDuration?: number;
    minOpacity?: number;
    maxOpacity?: number;
}
declare const useBlinkAnimation: ({ delay, blinkDuration, minOpacity, maxOpacity, }?: UseBlinkAnimationProps) => {
    animatedStyle: {
        opacity: number;
    };
};

interface UseFadeAnimationProps {
    duration?: number;
    delay?: number;
    closeAfter?: number | null;
}
declare const useFadeAnimation: ({ duration, delay, closeAfter, }?: UseFadeAnimationProps) => {
    animatedStyle: {
        opacity: number;
    };
};

interface UseFloatAnimationProps {
    duration?: number;
    delay?: number;
    closeAfter?: number | null;
    closeDuration?: number;
    floatDistance?: number;
    floatDuration?: number;
}
declare const useFloatAnimation: ({ duration, delay, closeAfter, closeDuration, floatDistance, floatDuration, }?: UseFloatAnimationProps) => {
    animatedStyle: {
        opacity: number;
        transform: {
            translateY: number;
        }[];
    };
};

interface UseGrowAnimationProps {
    duration?: number;
    delay?: number;
    closeAfter?: number | null;
    initialScale?: number;
}
declare const useGrowAnimation: ({ duration, delay, closeAfter, initialScale, }?: UseGrowAnimationProps) => {
    animatedStyle: {
        transform: {
            scale: number;
        }[];
    };
};

interface UseRollAnimationProps {
    duration?: number;
    delay?: number;
    closeAfter?: number | null;
    initialTranslateY?: number;
    initialRotate?: string;
}
declare const useRollAnimation: ({ duration, delay, closeAfter, initialTranslateY, initialRotate, }?: UseRollAnimationProps) => {
    animatedStyle: {
        transform: ({
            translateY: number;
            rotate?: undefined;
        } | {
            rotate: string;
            translateY?: undefined;
        })[];
    };
};

interface UseSlideAnimationProps {
    duration?: number;
    delay?: number;
    direction?: "up" | "down" | "left" | "right";
    closeAfter?: number | null;
    initialValue?: number;
}
declare const useSlideAnimation: ({ duration, delay, direction, closeAfter, initialValue, }?: UseSlideAnimationProps) => {
    animatedStyle: {
        transform: {
            translateY: number;
        }[];
    } | {
        transform: {
            translateX: number;
        }[];
    };
};

interface UseThrownUpAnimationProps {
    delay?: number;
    closeAfter?: number | null;
}
declare const useThrownUpAnimation: ({ delay, closeAfter, }?: UseThrownUpAnimationProps) => {
    animatedStyle: {
        transform: {
            translateY: number;
        }[];
        opacity: number;
    };
};

/**
 * Unified Animator component that handles multiple animation types with type-safe props.
 *
 * Each animation type only accepts its relevant props, ensuring type safety and better developer experience.
 *
 * @example
 * // Fade animation - only accepts base props
 * <Animator type="fade" duration={1000} closeAfter={3000}>
 *   <Text>This will fade in and out</Text>
 * </Animator>
 *
 * @example
 * // Slide animation - only accepts direction and initialValue props
 * <Animator type="slide" direction="up" duration={800} closeAfter={2000}>
 *   <View>This will slide up from bottom</View>
 * </Animator>
 *
 * @example
 * // Grow animation - only accepts initialScale prop
 * <Animator type="grow" initialScale={0.5} duration={600}>
 *   <Button>This will grow from 50% scale</Button>
 * </Animator>
 *
 * @example
 * // Blink animation - only accepts blink-specific props
 * <Animator type="blink" blinkDuration={1000} minOpacity={0.3}>
 *   <Icon>This will blink continuously</Icon>
 * </Animator>
 *
 * @example
 * // TypeScript will show errors for invalid prop combinations:
 * // ❌ This will cause a TypeScript error:
 * // <Animator type="fade" direction="up"> // direction is not valid for fade
 * //
 * // ✅ This is correct:
 * // <Animator type="slide" direction="up">
 */
declare const Animator: FC<AnimatorProps>;

declare const HoddyUI: {
    initialize: typeof initialize;
};

export { AdaptiveStatusBar, AlertX, type AlertXProps, type AnimationType, Animator, type AnimatorProps, Avatar, type AvatarProps, Button, type ButtonProps, CheckBox, type CheckboxProps, Divider, type DividerProps, type FlashMessageProps, FormWrapper, type FormWrapperProps, Grid, GridItem, type GridItemProps, type GridProps, IconButton, type IconButtonProps, LinkButton, type LinkButtonProps, type ListItemProps, type ListItemTextProps, type ListProps, Locator, type LocatorInputProps, type LocatorProps, OTPInput, type OTPInputProps, Popup, type PopupProps, RatingInput, type RatingInputProps, RatingStars, type RatingStarsProps, SafeAreaView, type SafeAreaViewProps, SelectMenu, type SelectMenuProps, Spinner, type SpinnerProps, TextField, TextField2, TextFieldBase, type TextFieldBaseProps, type TextFieldLabelVariant, type TextFieldProps, type ThemeActionTypes, type ThemeContext, type ThemeModes, type ThemeProviderProps, type ThemeState, type ThemeTypes, Typography, type TypographyProps, UIThemeContext, UIThemeProvider, type colorTypes, HoddyUI as default, type extraColorTypes, getLocationFromPlaceId, getPredictionsFromCoords, getPredictionsFromQuery, type locatorLocation, type predictionType, showFlashMessage, useAppState, useBlinkAnimation, useColors, useFadeAnimation, useFloatAnimation, useGrowAnimation, useNavScreenOptions, useRollAnimation, useSlideAnimation, useTheme, useThemeContext, useThrownUpAnimation };