react-native-elements

  • Version 3.4.2
  • Published
  • 600 kB
  • 8 dependencies
  • MIT license

Install

npm i react-native-elements
yarn add react-native-elements
pnpm add react-native-elements

Overview

React Native Elements & UI Toolkit

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Variables

variable Accessory

const Accessory: any;

    variable AirbnbRating

    const AirbnbRating: any;

      variable Avatar

      const Avatar: any;

        variable Badge

        const Badge: any;

          variable BottomSheet

          const BottomSheet: any;

            variable Button

            const Button: any;

              variable ButtonGroup

              const ButtonGroup: any;

                variable Card

                const Card: any;

                  variable CheckBox

                  const CheckBox: any;

                    variable Chip

                    const Chip: any;

                      variable colors

                      const colors: Colors;

                        variable Dialog

                        const Dialog: any;

                          variable Divider

                          const Divider: any;

                            variable FAB

                            const FAB: any;
                              const Header: any;

                                variable Icon

                                const Icon: any;

                                  variable Image

                                  const Image: any;

                                    variable Input

                                    const Input: any;

                                      variable LinearProgress

                                      const LinearProgress: any;

                                        variable ListItem

                                        const ListItem: any;

                                          variable Overlay

                                          const Overlay: any;

                                            variable PricingCard

                                            const PricingCard: any;

                                              variable Rating

                                              const Rating: any;
                                                const SearchBar: any;

                                                  variable Slider

                                                  const Slider: any;

                                                    variable SocialIcon

                                                    const SocialIcon: any;

                                                      variable SpeedDial

                                                      const SpeedDial: any;

                                                        variable Switch

                                                        const Switch: any;

                                                          variable Tab

                                                          const Tab: any;

                                                            variable TabView

                                                            const TabView: TabView;

                                                              variable Text

                                                              const Text: any;

                                                                variable ThemeConsumer

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

                                                                  variable ThemeContext

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

                                                                    variable Tile

                                                                    const Tile: any;

                                                                      variable Tooltip

                                                                      const Tooltip: any;

                                                                        Functions

                                                                        function getIconType

                                                                        getIconType: (type: IconType) => any;

                                                                          function makeStyles

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

                                                                            function normalize

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

                                                                              function registerCustomIconType

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

                                                                                function useTheme

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

                                                                                  function withBadge

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

                                                                                    function withTheme

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

                                                                                      Classes

                                                                                      class ThemeProvider

                                                                                      class ThemeProvider extends React.Component<
                                                                                      ThemeProviderProps,
                                                                                      ThemeProviderState
                                                                                      > {}

                                                                                        constructor

                                                                                        constructor(props: { theme: Theme; useDark?: boolean });

                                                                                          property defaultProps

                                                                                          static defaultProps: { theme: {}; useDark: boolean };

                                                                                            property defaultTheme

                                                                                            defaultTheme: Partial<FullTheme>;

                                                                                              property getTheme

                                                                                              getTheme: () => Partial<FullTheme>;

                                                                                                property replaceTheme

                                                                                                replaceTheme: (theme: RecursivePartial<FullTheme>) => void;

                                                                                                  property updateTheme

                                                                                                  updateTheme: (updates: RecursivePartial<FullTheme>) => void;

                                                                                                    method getDerivedStateFromProps

                                                                                                    static getDerivedStateFromProps: (
                                                                                                    props: { theme: Theme; useDark?: boolean },
                                                                                                    state: ThemeProviderState
                                                                                                    ) => { theme: FullTheme; useDark: boolean };

                                                                                                      method render

                                                                                                      render: () => JSX.Element;

                                                                                                        Interfaces

                                                                                                        interface Colors

                                                                                                        interface Colors {}

                                                                                                          property black

                                                                                                          readonly black: string;

                                                                                                            property disabled

                                                                                                            readonly disabled: string;

                                                                                                              property divider

                                                                                                              readonly divider: string;

                                                                                                                property error

                                                                                                                readonly error: string;

                                                                                                                  property grey0

                                                                                                                  readonly grey0: string;

                                                                                                                    property grey1

                                                                                                                    readonly grey1: string;

                                                                                                                      property grey2

                                                                                                                      readonly grey2: string;

                                                                                                                        property grey3

                                                                                                                        readonly grey3: string;

                                                                                                                          property grey4

                                                                                                                          readonly grey4: string;

                                                                                                                            property grey5

                                                                                                                            readonly grey5: string;

                                                                                                                              property greyOutline

                                                                                                                              readonly greyOutline: string;

                                                                                                                                property platform

                                                                                                                                readonly platform: {
                                                                                                                                ios: PlatformColors;
                                                                                                                                android: PlatformColors;
                                                                                                                                web: PlatformColors;
                                                                                                                                default: PlatformColors;
                                                                                                                                };

                                                                                                                                  property primary

                                                                                                                                  readonly primary: string;

                                                                                                                                    property searchBg

                                                                                                                                    readonly searchBg: string;

                                                                                                                                      property secondary

                                                                                                                                      readonly secondary: string;

                                                                                                                                        property success

                                                                                                                                        readonly success: string;

                                                                                                                                          property warning

                                                                                                                                          readonly warning: string;

                                                                                                                                            property white

                                                                                                                                            readonly white: string;

                                                                                                                                              interface FullTheme

                                                                                                                                              interface FullTheme {}

                                                                                                                                                property AirbnbRating

                                                                                                                                                AirbnbRating: Partial<SwipeRatingProps>;

                                                                                                                                                  property Avatar

                                                                                                                                                  Avatar: Partial<AvatarProps>;

                                                                                                                                                    property AvatarAccessory

                                                                                                                                                    AvatarAccessory: Partial<AccessoryProps>;

                                                                                                                                                      property Badge

                                                                                                                                                      Badge: Partial<BadgeProps>;

                                                                                                                                                        property BottomSheet

                                                                                                                                                        BottomSheet: Partial<BottomSheetProps>;

                                                                                                                                                          property Button

                                                                                                                                                          Button: Partial<ButtonProps>;

                                                                                                                                                            property ButtonGroup

                                                                                                                                                            ButtonGroup: Partial<ButtonGroupProps>;

                                                                                                                                                              property Card

                                                                                                                                                              Card: Partial<CardProps>;

                                                                                                                                                                property CardDivider

                                                                                                                                                                CardDivider: Partial<DividerProps>;

                                                                                                                                                                  property CardFeaturedSubtitle

                                                                                                                                                                  CardFeaturedSubtitle: Partial<TextProps>;

                                                                                                                                                                    property CardFeaturedTitle

                                                                                                                                                                    CardFeaturedTitle: Partial<TextProps>;

                                                                                                                                                                      property CardImage

                                                                                                                                                                      CardImage: Partial<ImageProps>;

                                                                                                                                                                        property CardTitle

                                                                                                                                                                        CardTitle: Partial<TextProps>;

                                                                                                                                                                          property CheckBox

                                                                                                                                                                          CheckBox: Partial<CheckBoxProps>;

                                                                                                                                                                            property colors

                                                                                                                                                                            colors: RecursivePartial<Colors>;

                                                                                                                                                                              property Divider

                                                                                                                                                                              Divider: Partial<DividerProps>;

                                                                                                                                                                                property FAB

                                                                                                                                                                                FAB: Partial<FABProps>;

                                                                                                                                                                                  property Header

                                                                                                                                                                                  Header: Partial<HeaderProps>;

                                                                                                                                                                                    property Icon

                                                                                                                                                                                    Icon: Partial<IconProps>;

                                                                                                                                                                                      property Image

                                                                                                                                                                                      Image: Partial<ImageProps>;

                                                                                                                                                                                        property Input

                                                                                                                                                                                        Input: Partial<InputProps>;

                                                                                                                                                                                          property LinearProgress

                                                                                                                                                                                          LinearProgress: Partial<LinearProgressProps>;

                                                                                                                                                                                            property ListItem

                                                                                                                                                                                            ListItem: Partial<ListItemProps>;

                                                                                                                                                                                              property ListItemAccordion

                                                                                                                                                                                              ListItemAccordion: Partial<ListItemAccordionProps>;

                                                                                                                                                                                                property ListItemButtonGroup

                                                                                                                                                                                                ListItemButtonGroup: Partial<ButtonGroupProps>;

                                                                                                                                                                                                  property ListItemCheckBox

                                                                                                                                                                                                  ListItemCheckBox: Partial<CheckBoxProps>;

                                                                                                                                                                                                    property ListItemChevron

                                                                                                                                                                                                    ListItemChevron: Partial<IconProps>;

                                                                                                                                                                                                      property ListItemContent

                                                                                                                                                                                                      ListItemContent: Partial<ViewProps>;

                                                                                                                                                                                                        property ListItemInput

                                                                                                                                                                                                        ListItemInput: Partial<InputProps>;

                                                                                                                                                                                                          property ListItemSubtitle

                                                                                                                                                                                                          ListItemSubtitle: Partial<TextProps>;

                                                                                                                                                                                                            property ListItemTitle

                                                                                                                                                                                                            ListItemTitle: Partial<TextProps>;

                                                                                                                                                                                                              property Overlay

                                                                                                                                                                                                              Overlay: Partial<OverlayProps>;

                                                                                                                                                                                                                property PricingCard

                                                                                                                                                                                                                PricingCard: Partial<PricingCardProps>;

                                                                                                                                                                                                                  property Rating

                                                                                                                                                                                                                  Rating: Partial<TapRatingProps>;

                                                                                                                                                                                                                    property SearchBar

                                                                                                                                                                                                                    SearchBar: Partial<SearchBarProps>;

                                                                                                                                                                                                                      property Slider

                                                                                                                                                                                                                      Slider: Partial<SliderProps>;

                                                                                                                                                                                                                        property SocialIcon

                                                                                                                                                                                                                        SocialIcon: Partial<SocialIconProps>;

                                                                                                                                                                                                                          property SpeedDial

                                                                                                                                                                                                                          SpeedDial: Partial<SpeedDialProps>;

                                                                                                                                                                                                                            property SpeedDialAction

                                                                                                                                                                                                                            SpeedDialAction: Partial<SpeedDialActionProps>;

                                                                                                                                                                                                                              property Switch

                                                                                                                                                                                                                              Switch: Partial<SwitchProps>;

                                                                                                                                                                                                                                property Tab

                                                                                                                                                                                                                                Tab: Partial<TabProps>;

                                                                                                                                                                                                                                  property TabItem

                                                                                                                                                                                                                                  TabItem: Partial<TabItemProps>;

                                                                                                                                                                                                                                    property TabView

                                                                                                                                                                                                                                    TabView: Partial<TabViewProps>;

                                                                                                                                                                                                                                      property TabViewItem

                                                                                                                                                                                                                                      TabViewItem: Partial<ViewProps>;

                                                                                                                                                                                                                                        property Text

                                                                                                                                                                                                                                        Text: Partial<TextProps>;

                                                                                                                                                                                                                                          property Tile

                                                                                                                                                                                                                                          Tile: Partial<TileProps>;

                                                                                                                                                                                                                                            property Tooltip

                                                                                                                                                                                                                                            Tooltip: Partial<TooltipProps>;

                                                                                                                                                                                                                                              interface ThemeProps

                                                                                                                                                                                                                                              interface ThemeProps<T> {}

                                                                                                                                                                                                                                                property replaceTheme

                                                                                                                                                                                                                                                replaceTheme: (updates: RecursivePartial<FullTheme>) => void;

                                                                                                                                                                                                                                                  property theme

                                                                                                                                                                                                                                                  theme: Theme<T>;

                                                                                                                                                                                                                                                    property updateTheme

                                                                                                                                                                                                                                                    updateTheme: (updates: RecursivePartial<FullTheme>) => void;

                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                      type AccessoryProps

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

                                                                                                                                                                                                                                                        type AvatarProps

                                                                                                                                                                                                                                                        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

                                                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                                                              type ButtonGroupProps

                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                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

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

                                                                                                                                                                                                                                                                    type CheckBoxProps

                                                                                                                                                                                                                                                                    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

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

                                                                                                                                                                                                                                                                        type DialogLoadingProps

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

                                                                                                                                                                                                                                                                          type DialogProps

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

                                                                                                                                                                                                                                                                            type DialogTitleProps

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

                                                                                                                                                                                                                                                                              type DividerProps

                                                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                                                  type HeaderProps

                                                                                                                                                                                                                                                                                  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

                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                      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

                                                                                                                                                                                                                                                                                        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

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

                                                                                                                                                                                                                                                                                            type ListItemAccordionProps

                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                                                                  type OverlayProps

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

                                                                                                                                                                                                                                                                                                    type PricingCardProps

                                                                                                                                                                                                                                                                                                    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

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

                                                                                                                                                                                                                                                                                                        type SearchBarAndroidProps

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

                                                                                                                                                                                                                                                                                                          type SearchBarDefaultProps

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

                                                                                                                                                                                                                                                                                                            type SearchBarIosProps

                                                                                                                                                                                                                                                                                                            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

                                                                                                                                                                                                                                                                                                              type SearchBarProps = SearchBarBaseProps &
                                                                                                                                                                                                                                                                                                              SearchBarDefaultProps &
                                                                                                                                                                                                                                                                                                              SearchBarAndroidProps &
                                                                                                                                                                                                                                                                                                              SearchBarIosProps;

                                                                                                                                                                                                                                                                                                                type SliderProps

                                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                                  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

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

                                                                                                                                                                                                                                                                                                                      type SpeedDialProps

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

                                                                                                                                                                                                                                                                                                                        type SwitchProps

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

                                                                                                                                                                                                                                                                                                                          type TabItemProps

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

                                                                                                                                                                                                                                                                                                                            type TabProps

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

                                                                                                                                                                                                                                                                                                                              type TabViewProps

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

                                                                                                                                                                                                                                                                                                                                type TextProps

                                                                                                                                                                                                                                                                                                                                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

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

                                                                                                                                                                                                                                                                                                                                    type TileProps

                                                                                                                                                                                                                                                                                                                                    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

                                                                                                                                                                                                                                                                                                                                      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

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

                                                                                                                                                                                                                                                                                                                                          Package Files (48)

                                                                                                                                                                                                                                                                                                                                          Dependencies (8)

                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (29)

                                                                                                                                                                                                                                                                                                                                          Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                                          Badge

                                                                                                                                                                                                                                                                                                                                          To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                                          You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/react-native-elements.

                                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/react-native-elements)
                                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/react-native-elements"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>