react-native-elements

const Accessory: any;

const AirbnbRating: any;

const Avatar: any;

const Badge: any;

const BottomSheet: any;

const Button: any;

const ButtonGroup: any;

const Card: any;

const CheckBox: any;

const Chip: any;

const colors: Colors;

const Dialog: any;

const Divider: any;

const FAB: any;

const Header: any;

const Icon: any;

const Image: any;

const Input: any;

const LinearProgress: any;

const ListItem: any;

const Overlay: any;

const PricingCard: any;

const Rating: any;

const SearchBar: any;

const Slider: any;

const SocialIcon: any;

const SpeedDial: any;

const Switch: any;

const Tab: any;

const TabView: TabView;

const Text: any;

const ThemeConsumer: React.Consumer<ThemeProps<{}>>;

const ThemeContext: React.Context<ThemeProps<{}>>;

const Tile: any;

const Tooltip: any;

getIconType: (type: IconType) => any;

makeStyles: <T extends unknown, V>(
    styles: T | ((theme: Partial<FullTheme>, props: V) => T)
) => (props?: V) => T;

normalize: (number: number, factor?: number) => number;

registerCustomIconType: (id: string, customIcon: any) => void;

useTheme: () => import('./ThemeProvider').ThemeProps<{}>;

withBadge: (
    value: any,
    options?: withBadgeOptions
) => (WrappedComponent: React.ComponentType<any>) => React.ComponentType;

withTheme: <P = {}, T = {}>(
    WrappedComponent: React.ComponentType<P & Partial<ThemeProps<T>>>,
    themeKey: string
) =>
    | React.FunctionComponent<Omit<P, keyof ThemeProps<T>>>
    | React.ForwardRefExoticComponent<P>;

type AccessoryProps = Partial<IconProps> &
    Partial<ImageProps> & {
        underlayColor?: ColorValue;
        style?: StyleProp<ViewStyle>;
    };

type AvatarProps = {
    Component?: typeof React.Component;
    onPress?(): void;
    onLongPress?(): void;
    containerStyle?: StyleProp<ViewStyle>;
    source?: ImageSourcePropType;
    avatarStyle?: ImageStyle;
    rounded?: boolean;
    title?: string;
    titleStyle?: StyleProp<TextStyle>;
    overlayContainerStyle?: StyleProp<TextStyle>;
    activeOpacity?: number;
    icon?: AvatarIcon;
    iconStyle?: StyleProp<TextStyle>;
    size?: ('small' | 'medium' | 'large' | 'xlarge') | number;
    placeholderStyle?: StyleProp<ViewStyle>;
    renderPlaceholderContent?: React.ReactElement<{}>;
    imageProps?: Partial<ImageProps>;
    ImageComponent?: React.ComponentClass;
};

type BadgeProps = {
    containerStyle?: StyleProp<ViewStyle>;
    badgeStyle?: StyleProp<ViewStyle>;
    textProps?: TextProps;
    textStyle?: StyleProp<TextStyle>;
    value?: React.ReactNode;
    onPress?: (...args: any[]) => any;
    Component?: typeof React.Component;
    status?: 'primary' | 'success' | 'warning' | 'error';
};

type BottomSheetProps = {
    containerStyle?: StyleProp<ViewStyle>;
    modalProps?: ModalProps;
    isVisible?: boolean;
};

type ButtonGroupProps = {
    button?: object;
    Component?: typeof React.Component;
    onPress?(...args: any[]): void;
    buttons?: (string | React.ReactElement<{}>)[];
    containerStyle?: StyleProp<ViewStyle>;
    textStyle?: StyleProp<TextStyle>;
    selectedTextStyle?: StyleProp<TextStyle>;
    selectedButtonStyle?: StyleProp<ViewStyle>;
    underlayColor?: string;
    selectedIndex?: number | null;
    selectedIndexes?: number[];
    activeOpacity?: number;
    onHideUnderlay?(): void;
    onShowUnderlay?(): void;
    setOpacityTo?: (value: number) => void;
    innerBorderStyle?: {
        color?: string;
        width?: number;
    };
    buttonStyle?: StyleProp<ViewStyle>;
    buttonContainerStyle?: StyleProp<ViewStyle>;
    selectMultiple?: boolean;
    disabled?: boolean | number[];
    disabledStyle?: StyleProp<ViewStyle>;
    disabledTextStyle?: StyleProp<TextStyle>;
    disabledSelectedStyle?: StyleProp<ViewStyle>;
    disabledSelectedTextStyle?: StyleProp<TextStyle>;
    vertical?: boolean;
};

type ButtonProps = TouchableOpacityProps &
    TouchableNativeFeedbackProps & {
        title?: string | React.ReactElement<{}>;
        titleStyle?: StyleProp<TextStyle>;
        titleProps?: TextProps;
        buttonStyle?: StyleProp<ViewStyle>;
        type?: 'solid' | 'clear' | 'outline';
        loading?: boolean;
        loadingStyle?: StyleProp<ViewStyle>;
        loadingProps?: ActivityIndicatorProps;
        containerStyle?: StyleProp<ViewStyle>;
        icon?: IconNode;
        iconContainerStyle?: StyleProp<ViewStyle>;
        iconRight?: boolean;
        linearGradientProps?: object;
        TouchableComponent?: typeof React.Component;
        ViewComponent?: typeof React.Component;
        disabled?: boolean;
        disabledStyle?: StyleProp<ViewStyle>;
        disabledTitleStyle?: StyleProp<TextStyle>;
        raised?: boolean;
        iconPosition?: 'left' | 'right' | 'top' | 'bottom';
    };

type CardProps = {
    containerStyle?: StyleProp<ViewStyle>;
    wrapperStyle?: StyleProp<ViewStyle>;
};

type CheckBoxProps = TouchableOpacityProps &
    CheckBoxIconProps & {
        Component?: typeof React.Component;
        iconRight?: boolean;
        title?: string | React.ReactElement<{}>;
        titleProps?: TextProps;
        center?: boolean;
        right?: boolean;
        containerStyle?: StyleProp<ViewStyle>;
        wrapperStyle?: StyleProp<ViewStyle>;
        textStyle?: StyleProp<TextStyle>;
        checkedTitle?: string;
        fontFamily?: string;
    };

type ChipProps = Omit<ButtonProps, 'loading' | 'loadingStyle' | 'loadingProps'> & {
    type?: 'solid' | 'outline';
};

type DialogLoadingProps = {
    loadingStyle?: StyleProp<ViewStyle>;
    loadingProps?: ActivityIndicatorProps;
    theme?: Theme;
};

type DialogProps = Omit<OverlayProps, 'fullScreen'> & {
    theme?: Theme;
    children?: any;
};

type DialogTitleProps = {
    title?: string;
    titleStyle?: StyleProp<TextStyle>;
    titleProps?: TextProps;
};

type DividerProps = ViewProps & {
    color?: string;
    inset?: boolean;
    insetType?: 'left' | 'right' | 'middle';
    style?: StyleProp<ViewStyle>;
    subHeader?: string;
    subHeaderStyle?: StyleProp<TextStyle>;
    orientation?: 'horizontal' | 'vertical';
    width?: number;
};

type FABProps = ButtonProps & {
    color?: string;
    size?: 'large' | 'small';
    placement?: 'left' | 'right';
    visible?: boolean;
    upperCase?: boolean;
};

type HeaderProps = ViewProps & {
    ViewComponent?: typeof React.Component;
    linearGradientProps?: Object;
    statusBarProps?: StatusBarProps;
    barStyle?: StatusBarStyle;
    leftComponent?: HeaderSubComponent;
    centerComponent?: HeaderSubComponent;
    rightComponent?: HeaderSubComponent;
    backgroundColor?: string;
    backgroundImage?: ImageSourcePropType;
    backgroundImageStyle?: ImageStyle;
    placement?: 'left' | 'center' | 'right';
    containerStyle?: StyleProp<ViewStyle>;
    centerContainerStyle?: StyleProp<ViewStyle>;
    leftContainerStyle?: StyleProp<ViewStyle>;
    rightContainerStyle?: StyleProp<ViewStyle>;
    children?: JSX.Element[];
    elevated?: boolean;
};

type IconProps = IconButtonProps & {
    type?: IconType;
    Component?: typeof React.Component;
    reverse?: boolean;
    raised?: boolean;
    containerStyle?: StyleProp<ViewStyle>;
    iconProps?: VectorIconProps;
    reverseColor?: string;
    disabled?: boolean;
    disabledStyle?: StyleProp<ViewStyle>;
    solid?: boolean;
    brand?: boolean;
};

type ImageProps = RNImageProps & {
    Component?: typeof React.Component;
    onPress?(): void;
    onLongPress?(): void;
    ImageComponent?: React.ComponentType<any>;
    PlaceholderContent?: React.ReactElement<any>;
    containerStyle?: StyleProp<ViewStyle>;
    childrenContainerStyle?: StyleProp<ViewStyle>;
    placeholderStyle?: StyleProp<ViewStyle>;
    transition?: boolean;
    transitionDuration?: number;
};

type InputProps = React.ComponentPropsWithRef<typeof TextInput> & {
    containerStyle?: StyleProp<ViewStyle>;
    disabled?: boolean;
    disabledInputStyle?: StyleProp<TextStyle>;
    inputContainerStyle?: StyleProp<ViewStyle>;
    leftIcon?: IconNode;
    leftIconContainerStyle?: StyleProp<ViewStyle>;
    rightIcon?: IconNode;
    rightIconContainerStyle?: StyleProp<ViewStyle>;
    inputStyle?: StyleProp<TextStyle>;
    InputComponent?: typeof React.Component;
    errorProps?: object;
    errorStyle?: StyleProp<TextStyle>;
    errorMessage?: string;
    label?: string | React.ReactNode;
    labelStyle?: StyleProp<TextStyle>;
    labelProps?: object;
    renderErrorMessage?: boolean;
};

type LinearProgressProps = {
    value?: number;
    variant?: 'determinate' | 'indeterminate';
    color?: 'primary' | 'secondary' | string;
    trackColor?: string;
    style?: StyleProp<ViewStyle>;
} & ViewProps;

type ListItemAccordionProps = ListItemProps & {
    isExpanded?: boolean;
    icon?: IconNode;
    expandIcon?: IconNode;
    content?: React.ReactNode;
    noRotation?: boolean;
    noIcon?: boolean;
    animation?:
        | {
              type?: 'timing' | 'spring';
              duration?: number;
          }
        | boolean;
};

type ListItemProps = TouchableHighlightProps & {
    containerStyle?: StyleProp<ViewStyle>;
    disabledStyle?: StyleProp<ViewStyle>;
    topDivider?: boolean;
    bottomDivider?: boolean;
    pad?: number;
    Component?: typeof React.Component;
    ViewComponent?: typeof React.Component;
    linearGradientProps?: any;
    children?: any;
};

type ListItemSwipeableProps = ListItemProps & {
    leftContent?: React.ReactNode;
    rightContent?: React.ReactNode;
    leftStyle?: StyleProp<ViewStyle>;
    rightStyle?: StyleProp<ViewStyle>;
    leftWidth?: number;
    rightWidth?: number;
};

type OverlayProps = ModalProps & {
    isVisible: boolean;
    backdropStyle?: StyleProp<ViewStyle>;
    overlayStyle?: StyleProp<ViewStyle>;
    onBackdropPress?(): void;
    fullScreen?: boolean;
    ModalComponent?: typeof React.Component;
};

type PricingCardProps = {
    containerStyle?: StyleProp<ViewStyle>;
    wrapperStyle?: StyleProp<ViewStyle>;
    title?: string;
    price?: string | number;
    info?: string[];
    button?: ButtonProps | ButtonInformation;
    color?: string;
    onButtonPress?(): void;
    titleStyle?: StyleProp<TextStyle>;
    pricingStyle?: StyleProp<TextStyle>;
    infoStyle?: StyleProp<TextStyle>;
};

type ReplaceTheme = (updates: RecursivePartial<FullTheme>) => void;

type SearchBarAndroidProps = InputProps &
    SearchBarBaseProps &
    typeof SearchBar.defaultProps & {
        cancelIcon?: IconNode;
    };

type SearchBarDefaultProps = typeof SearchBar.defaultProps &
    SearchBarBaseProps &
    TextInputProps;

type SearchBarIosProps = InputProps &
    SearchBarBaseProps &
    typeof SearchBar.defaultProps & {
        cancelButtonProps?: Partial<TouchableOpacityProps> & {
            buttonStyle?: StyleProp<ViewStyle>;
            buttonTextStyle?: StyleProp<TextStyle>;
            color?: string;
            buttonDisabledStyle?: StyleProp<ViewStyle>;
            buttonDisabledTextStyle?: StyleProp<ViewStyle>;
        };
        cancelButtonTitle?: string;
        showCancel?: boolean;
    };

type SearchBarProps = SearchBarBaseProps &
    SearchBarDefaultProps &
    SearchBarAndroidProps &
    SearchBarIosProps;

type SliderProps = {
    value?: number;
    disabled?: boolean;
    minimumValue?: number;
    maximumValue?: number;
    step?: number;
    minimumTrackTintColor?: string;
    maximumTrackTintColor?: string;
    allowTouchTrack?: boolean;
    thumbTintColor?: string;
    thumbTouchSize?: Sizable;
    onValueChange?(value: number): void;
    onSlidingStart?(value: number): void;
    onSlidingComplete?(value: number): void;
    style?: StyleProp<ViewStyle>;
    trackStyle?: StyleProp<ViewStyle>;
    thumbStyle?: StyleProp<ViewStyle>;
    thumbProps?: any;
    debugTouchArea?: boolean;
    animateTransitions?: boolean;
    animationType?: 'spring' | 'timing';
    orientation?: 'horizontal' | 'vertical';
    animationConfig?:
        | Animated.TimingAnimationConfig
        | Animated.SpringAnimationConfig;
    containerStyle?: typeof styles;
};

type SocialIconProps = {
    Component?: typeof React.Component;
    type?: SocialMediaType;
    button?: boolean;
    onPress?(): void;
    onLongPress?(): void;
    iconType?: string;
    iconStyle?: StyleProp<ViewStyle>;
    style?: StyleProp<ViewStyle>;
    iconColor?: string;
    underlayColor?: string;
    title?: string;
    raised?: boolean;
    disabled?: boolean;
    loading?: boolean;
    activityIndicatorStyle?: StyleProp<ViewStyle>;
    small?: string;
    iconSize?: number;
    light?: boolean;
    fontWeight?: string;
    fontStyle?: StyleProp<TextStyle>;
    fontFamily?: string;
};

type SpeedDialActionProps = Omit<FABProps, 'size'>;

type SpeedDialProps = {
    isOpen: boolean;
    onOpen: () => void;
    onClose: () => void;
    openIcon?: IconNode;
    overlayColor?: string;
    children?: React.ReactChild[];
    transitionDuration?: number;
} & FABProps;

type SwitchProps = NativeSwitchProps & {
    color?: string;
};

type TabItemProps = ButtonProps & {
    active?: boolean;
    variant?: 'primary' | 'default';
};

type TabProps = ViewProps & {
    value?: number;
    onChange?: (value: number) => void;
    disableIndicator?: boolean;
    indicatorStyle?: StyleProp<ViewStyle>;
    variant?: 'primary' | 'default';
};

type TabViewProps = {
    value?: number;
    onChange?: (value: number) => any;
    animationType?: 'spring' | 'timing';
    animationConfig?: Omit<
        Animated.SpringAnimationConfig & Animated.TimingAnimationConfig,
        'toValue'
    >;
};

type TextProps = TextProperties & {
    style?: StyleProp<TextStyle>;
    h1?: boolean;
    h2?: boolean;
    h3?: boolean;
    h4?: boolean;
    h1Style?: StyleProp<TextStyle>;
    h2Style?: StyleProp<TextStyle>;
    h3Style?: StyleProp<TextStyle>;
    h4Style?: StyleProp<TextStyle>;
};

type Theme<T = {}> = Partial<FullTheme> & T;

type TileProps = TouchableOpacityProps &
    TouchableNativeFeedbackProps & {
        title?: string;
        icon?: IconObject & IconProps;
        caption?: React.ReactNode;
        imageSrc?: ImageSourcePropType | string | number;
        activeOpacity?: number;
        containerStyle?: StyleProp<ViewStyle>;
        imageContainerStyle?: StyleProp<ViewStyle>;
        iconContainerStyle?: StyleProp<ViewStyle>;
        overlayContainerStyle?: StyleProp<ViewStyle>;
        titleStyle?: StyleProp<TextStyle>;
        captionStyle?: StyleProp<TextStyle>;
        width?: number;
        height?: number;
        featured?: boolean;
        contentContainerStyle?: StyleProp<ViewStyle>;
        titleNumberOfLines?: number;
        imageProps?: Partial<ImageProps>;
        ImageComponent?: typeof React.Component;
    };

type TooltipProps = {
    withPointer?: boolean;
    popover?: React.ReactElement<{}>;
    toggleOnPress?: boolean;
    toggleAction?: string | 'onPress' | 'onLongPress';
    height?: FlexStyle['height'];
    width?: FlexStyle['width'];
    containerStyle?: StyleProp<ViewStyle>;
    pointerColor?: ColorValue;
    onClose?(): void;
    onOpen?(): void;
    overlayColor?: ColorValue;
    withOverlay?: boolean;
    backgroundColor?: ColorValue;
    highlightColor?: ColorValue;
    skipAndroidStatusBar?: boolean;
    ModalComponent?: typeof React.Component;
    closeOnlyOnBackdropPress?: boolean;
} & typeof defaultProps;

type UpdateTheme = (updates: RecursivePartial<FullTheme>) => void;