@types/react-native

  • Version 0.65.3
  • Published
  • 389 kB
  • 1 dependency
  • MIT license

Install

npm i @types/react-native
yarn add @types/react-native
pnpm add @types/react-native

Overview

TypeScript definitions for react-native

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable AccessibilityInfo

const AccessibilityInfo: AccessibilityInfoStatic;

    variable ActionSheetIOS

    const ActionSheetIOS: ActionSheetIOSStatic;

      variable ActivityIndicatorBase

      const ActivityIndicatorBase: Constructor<NativeMethods> &
      typeof ActivityIndicatorComponent;

        variable Alert

        const Alert: AlertStatic;

          variable AppState

          const AppState: AppStateStatic;

            variable AsyncStorage

            const AsyncStorage: AsyncStorageStatic;
            • AsyncStorage has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/async-storage instead of 'react-native'.

              See Also

              • https://github.com/react-native-community/async-storage

              Deprecated

            variable BackHandler

            const BackHandler: BackHandlerStatic;

              variable CameraRoll

              const CameraRoll: CameraRollStatic;
              • CameraRoll has been removed from React Native. It can now be installed and imported from @react-native-community/cameraroll instead of 'react-native'.

                See Also

                • https://github.com/react-native-community/react-native-cameraroll

                Deprecated

              variable Clipboard

              const Clipboard: ClipboardStatic;
              • Clipboard has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/clipboard instead of 'react-native'.

                See Also

                • https://github.com/react-native-community/clipboard

                Deprecated

              variable ColorPropType

              const ColorPropType: any;

                variable DatePickerAndroid

                const DatePickerAndroid: DatePickerAndroidStatic;
                • DatePickerAndroid has been merged with DatePickerIOS and will be removed in a future release. It can now be installed and imported from @react-native-community/datetimepicker instead of 'react-native'.

                  See Also

                  • https://github.com/react-native-community/datetimepicker

                  Deprecated

                variable DatePickerIOSBase

                const DatePickerIOSBase: Constructor<NativeMethods> & typeof DatePickerIOSComponent;

                  variable DeviceEventEmitter

                  const DeviceEventEmitter: DeviceEventEmitterStatic;

                    variable DevSettings

                    const DevSettings: DevSettingsStatic;

                      variable Dimensions

                      const Dimensions: Dimensions;

                        variable DrawerLayoutAndroidBase

                        const DrawerLayoutAndroidBase: Constructor<NativeMethods> &
                        typeof DrawerLayoutAndroidComponent;

                          variable Easing

                          const Easing: EasingStatic;

                            variable EdgeInsetsPropType

                            const EdgeInsetsPropType: any;

                              variable I18nManager

                              const I18nManager: I18nManagerStatic;
                              • https://reactnative.dev/blog/2016/08/19/right-to-left-support-for-react-native-apps

                              variable ImageBackgroundBase

                              const ImageBackgroundBase: Constructor<NativeMethods> &
                              typeof ImageBackgroundComponent;

                                variable ImageBase

                                const ImageBase: Constructor<NativeMethods> & typeof ImageComponent;

                                  variable ImageEditor

                                  const ImageEditor: ImageEditorStatic;
                                  • ImageEditor has been removed from React Native. It can now be installed and imported from @react-native-community/image-editor instead of 'react-native'.

                                    See Also

                                    • https://github.com/react-native-community/react-native-image-editor

                                    Deprecated

                                  variable ImagePickerIOS

                                  const ImagePickerIOS: ImagePickerIOSStatic;
                                  • ImagePickerIOS has been extracted from react-native core and will be removed in a future release. Please upgrade to use either @react-native-community/react-native-image-picker or 'expo-image-picker'. If you cannot upgrade to a different library, please install the deprecated @react-native-community/image-picker-ios package.

                                    See Also

                                    • https://github.com/react-native-community/react-native-image-picker-ios

                                    Deprecated

                                  variable ImagePropTypes

                                  const ImagePropTypes: any;

                                    variable ImageStore

                                    const ImageStore: ImageStoreStatic;
                                    • ImageStore has been removed from React Native. To get a base64-encoded string from a local image use either of the following third-party libraries: * expo-file-system: readAsStringAsync(filepath, 'base64') * react-native-fs: readFile(filepath, 'base64')

                                      Deprecated

                                    variable InteractionManager

                                    const InteractionManager: InteractionManagerStatic;

                                      variable Keyboard

                                      const Keyboard: KeyboardStatic;

                                        variable KeyboardAvoidingViewBase

                                        const KeyboardAvoidingViewBase: Constructor<TimerMixin> &
                                        typeof KeyboardAvoidingViewComponent;

                                          variable LayoutAnimation

                                          const LayoutAnimation: LayoutAnimationStatic;

                                            variable Linking

                                            const Linking: LinkingStatic;

                                              variable ListViewBase

                                              const ListViewBase: Constructor<ScrollResponderMixin> &
                                              Constructor<TimerMixin> &
                                              typeof ListViewComponent;

                                                variable LogBox

                                                const LogBox: LogBoxStatic;

                                                  variable MaskedViewBase

                                                  const MaskedViewBase: Constructor<NativeMethods> & typeof MaskedViewComponent;

                                                    variable NativeAppEventEmitter

                                                    const NativeAppEventEmitter: DeviceEventEmitterStatic;
                                                    • Deprecated - subclass NativeEventEmitter to create granular event modules instead of adding all event listeners directly to RCTNativeAppEventEmitter.

                                                    variable NativeModules

                                                    const NativeModules: NativeModulesStatic;
                                                    • Native Modules written in ObjectiveC/Swift/Java exposed via the RCTBridge Define lazy getters for each module. These will return the module if already loaded, or load it if not. See https://reactnative.dev/docs/native-modules-ios Use: const MyModule = NativeModules.ModuleName

                                                    variable PanResponder

                                                    const PanResponder: PanResponderStatic;

                                                      variable PermissionsAndroid

                                                      const PermissionsAndroid: PermissionsAndroidStatic;

                                                        variable PickerIOSBase

                                                        const PickerIOSBase: Constructor<NativeMethods> & typeof PickerIOSComponent;

                                                          variable PixelRatio

                                                          const PixelRatio: PixelRatioStatic;

                                                            variable Platform

                                                            const Platform:
                                                            | PlatformIOSStatic
                                                            | PlatformAndroidStatic
                                                            | PlatformWindowsOSStatic
                                                            | PlatformMacOSStatic
                                                            | PlatformWebStatic;

                                                              variable PointPropType

                                                              const PointPropType: any;

                                                                variable Pressable

                                                                const Pressable: any;

                                                                  variable ProgressBarAndroidBase

                                                                  const ProgressBarAndroidBase: Constructor<NativeMethods> &
                                                                  typeof ProgressBarAndroidComponent;

                                                                    variable ProgressViewIOSBase

                                                                    const ProgressViewIOSBase: Constructor<NativeMethods> &
                                                                    typeof ProgressViewIOSComponent;

                                                                      variable PushNotificationIOS

                                                                      const PushNotificationIOS: PushNotificationIOSStatic;
                                                                      • PushNotificationIOS has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/push-notification-ios instead of 'react-native'.

                                                                        See Also

                                                                        • https://github.com/react-native-community/react-native-push-notification-ios

                                                                        Deprecated

                                                                      variable RecyclerViewBackedScrollViewBase

                                                                      const RecyclerViewBackedScrollViewBase: Constructor<ScrollResponderMixin> &
                                                                      typeof RecyclerViewBackedScrollViewComponent;

                                                                        variable RefreshControlBase

                                                                        const RefreshControlBase: Constructor<NativeMethods> &
                                                                        typeof RefreshControlComponent;

                                                                          variable SafeAreaViewBase

                                                                          const SafeAreaViewBase: Constructor<NativeMethods> & typeof SafeAreaViewComponent;

                                                                            variable ScrollViewBase

                                                                            const ScrollViewBase: Constructor<ScrollResponderMixin> & typeof ScrollViewComponent;

                                                                              variable SegmentedControlIOSBase

                                                                              const SegmentedControlIOSBase: Constructor<NativeMethods> &
                                                                              typeof SegmentedControlIOSComponent;

                                                                                variable Settings

                                                                                const Settings: SettingsStatic;

                                                                                  variable ShadowPropTypesIOS

                                                                                  const ShadowPropTypesIOS: ShadowPropTypesIOSStatic;

                                                                                    variable Share

                                                                                    const Share: ShareStatic;

                                                                                      variable SliderBase

                                                                                      const SliderBase: Constructor<NativeMethods> & typeof SliderComponent;

                                                                                        variable SnapshotViewIOSBase

                                                                                        const SnapshotViewIOSBase: Constructor<NativeMethods> &
                                                                                        typeof SnapshotViewIOSComponent;

                                                                                          variable StatusBarIOS

                                                                                          const StatusBarIOS: StatusBarIOSStatic;
                                                                                          • Deprecated

                                                                                            Use StatusBar instead

                                                                                          variable SwitchBase

                                                                                          const SwitchBase: Constructor<NativeMethods> & typeof SwitchComponent;

                                                                                            variable Systrace

                                                                                            const Systrace: SystraceStatic;

                                                                                              variable TextBase

                                                                                              const TextBase: Constructor<NativeMethods> & typeof TextComponent;

                                                                                                variable TextInputBase

                                                                                                const TextInputBase: Constructor<NativeMethods> &
                                                                                                Constructor<TimerMixin> &
                                                                                                typeof TextInputComponent;

                                                                                                  variable TextPropTypes

                                                                                                  const TextPropTypes: any;

                                                                                                    variable TimePickerAndroid

                                                                                                    const TimePickerAndroid: TimePickerAndroidStatic;
                                                                                                    • TimePickerAndroid has been removed from React Native. It can now be installed and imported from @react-native-community/datetimepicker instead of 'react-native'.

                                                                                                      See Also

                                                                                                      • https://github.com/react-native-community/datetimepicker

                                                                                                      Deprecated

                                                                                                    variable ToastAndroid

                                                                                                    const ToastAndroid: ToastAndroidStatic;

                                                                                                      variable ToolbarAndroidBase

                                                                                                      const ToolbarAndroidBase: Constructor<NativeMethods> &
                                                                                                      typeof ToolbarAndroidComponent;

                                                                                                        variable Touchable

                                                                                                        const Touchable: {
                                                                                                        TOUCH_TARGET_DEBUG: boolean;
                                                                                                        renderDebugView: (config: {
                                                                                                        color: string | number;
                                                                                                        hitSlop?: Insets | undefined;
                                                                                                        }) => React.ReactElement | null;
                                                                                                        };

                                                                                                          variable TouchableHighlightBase

                                                                                                          const TouchableHighlightBase: Constructor<NativeMethods> &
                                                                                                          Constructor<TimerMixin> &
                                                                                                          Constructor<TouchableMixin> &
                                                                                                          typeof TouchableHighlightComponent;

                                                                                                            variable TouchableNativeFeedbackBase

                                                                                                            const TouchableNativeFeedbackBase: Constructor<TouchableMixin> &
                                                                                                            typeof TouchableNativeFeedbackComponent;

                                                                                                              variable TouchableOpacityBase

                                                                                                              const TouchableOpacityBase: Constructor<TimerMixin> &
                                                                                                              Constructor<TouchableMixin> &
                                                                                                              Constructor<NativeMethods> &
                                                                                                              typeof TouchableOpacityComponent;

                                                                                                                variable TouchableWithoutFeedbackBase

                                                                                                                const TouchableWithoutFeedbackBase: Constructor<TimerMixin> &
                                                                                                                Constructor<TouchableMixin> &
                                                                                                                typeof TouchableWithoutFeedbackComponent;

                                                                                                                  variable UIManager

                                                                                                                  const UIManager: UIManagerStatic;

                                                                                                                    variable Vibration

                                                                                                                    const Vibration: VibrationStatic;

                                                                                                                      variable ViewBase

                                                                                                                      const ViewBase: Constructor<NativeMethods> & typeof ViewComponent;

                                                                                                                        variable ViewPagerAndroidBase

                                                                                                                        const ViewPagerAndroidBase: Constructor<NativeMethods> &
                                                                                                                        typeof ViewPagerAndroidComponent;

                                                                                                                          variable ViewPropTypes

                                                                                                                          const ViewPropTypes: any;

                                                                                                                            variable YellowBox

                                                                                                                            const YellowBox: any;
                                                                                                                            • YellowBox has been replaced with LogBox.

                                                                                                                              See Also

                                                                                                                              • LogBox

                                                                                                                              Deprecated

                                                                                                                            Functions

                                                                                                                            function createElement

                                                                                                                            createElement: <P>(type: any, props?: P, ...children: React.ReactNode[]) => any;

                                                                                                                              function DynamicColorIOS

                                                                                                                              DynamicColorIOS: (tuple: DynamicColorIOSTuple) => OpaqueColorValue;
                                                                                                                              • Specify color to display depending on the current system appearance settings

                                                                                                                                Parameter tuple

                                                                                                                                Colors you want to use for "light mode" and "dark mode" ios

                                                                                                                              function findNodeHandle

                                                                                                                              findNodeHandle: (
                                                                                                                              componentOrHandle:
                                                                                                                              | null
                                                                                                                              | number
                                                                                                                              | React.Component<any, any>
                                                                                                                              | React.ComponentClass<any>
                                                                                                                              ) => null | number;

                                                                                                                                function PlatformColor

                                                                                                                                PlatformColor: (...colors: string[]) => OpaqueColorValue;
                                                                                                                                • Select native platform color The color must match the string that exists on the native platform

                                                                                                                                  See Also

                                                                                                                                  • https://reactnative.dev/docs/platformcolor#example

                                                                                                                                function processColor

                                                                                                                                processColor: (
                                                                                                                                color?: number | ColorValue
                                                                                                                                ) => ProcessedColorValue | null | undefined;

                                                                                                                                  function requireNativeComponent

                                                                                                                                  requireNativeComponent: <T>(viewName: string) => HostComponent<T>;
                                                                                                                                  • Creates values that can be used like React components which represent native view managers. You should create JavaScript modules that wrap these values so that the results are memoized. Example:

                                                                                                                                    const View = requireNativeComponent('RCTView');

                                                                                                                                    The concrete return type of requireNativeComponent is a string, but the declared type is HostComponent because TypeScript assumes anonymous JSX intrinsics (e.g. a string) not to have any props.

                                                                                                                                  function unstable_batchedUpdates

                                                                                                                                  unstable_batchedUpdates: {
                                                                                                                                  <A, B>(callback: (a: A, b: B) => any, a: A, b: B): void;
                                                                                                                                  <A>(callback: (a: A) => any, a: A): void;
                                                                                                                                  (callback: () => any): void;
                                                                                                                                  };
                                                                                                                                  • React Native also implements unstable_batchedUpdates

                                                                                                                                  function unstable_enableLogBox

                                                                                                                                  unstable_enableLogBox: () => void;
                                                                                                                                  • LogBox is enabled by default so there is no need to call unstable_enableLogBox() anymore. This is a no op and will be removed in the next version.

                                                                                                                                    Deprecated

                                                                                                                                  function useColorScheme

                                                                                                                                  useColorScheme: () => ColorSchemeName;
                                                                                                                                  • A new useColorScheme hook is provided as the preferred way of accessing the user's preferred color scheme (aka Dark Mode).

                                                                                                                                  function useWindowDimensions

                                                                                                                                  useWindowDimensions: () => ScaledSize;

                                                                                                                                    Classes

                                                                                                                                    class ActivityIndicator

                                                                                                                                    class ActivityIndicator extends ActivityIndicatorBase {}

                                                                                                                                      class ActivityIndicatorComponent

                                                                                                                                      class ActivityIndicatorComponent extends React.Component<ActivityIndicatorProps> {}

                                                                                                                                        class Button

                                                                                                                                        class Button extends React.Component<ButtonProps> {}

                                                                                                                                          class DatePickerIOS

                                                                                                                                          class DatePickerIOS extends DatePickerIOSBase {}
                                                                                                                                          • DatePickerIOS has been merged with DatePickerAndroid and will be removed in a future release. It can now be installed and imported from @react-native-community/datetimepicker instead of 'react-native'.

                                                                                                                                            See Also

                                                                                                                                            • https://github.com/react-native-community/datetimepicker

                                                                                                                                            Deprecated

                                                                                                                                          class DatePickerIOSComponent

                                                                                                                                          class DatePickerIOSComponent extends React.Component<DatePickerIOSProps> {}

                                                                                                                                            class DrawerLayoutAndroid

                                                                                                                                            class DrawerLayoutAndroid extends DrawerLayoutAndroidBase {}

                                                                                                                                              property positions

                                                                                                                                              positions: DrawerPosition;
                                                                                                                                              • drawer's positions.

                                                                                                                                              method closeDrawer

                                                                                                                                              closeDrawer: () => void;
                                                                                                                                              • Closes the drawer.

                                                                                                                                              method openDrawer

                                                                                                                                              openDrawer: () => void;
                                                                                                                                              • Opens the drawer.

                                                                                                                                              class DrawerLayoutAndroidComponent

                                                                                                                                              class DrawerLayoutAndroidComponent extends React.Component<DrawerLayoutAndroidProps> {}

                                                                                                                                                class EventEmitter

                                                                                                                                                class EventEmitter {}

                                                                                                                                                  constructor

                                                                                                                                                  constructor(subscriber?: EventSubscriptionVendor);
                                                                                                                                                  • Parameter subscriber

                                                                                                                                                    Optional subscriber instance to use. If omitted, a new subscriber will be created for the emitter.

                                                                                                                                                  method addListener

                                                                                                                                                  addListener: (
                                                                                                                                                  eventType: string,
                                                                                                                                                  listener: (...args: any[]) => any,
                                                                                                                                                  context?: any
                                                                                                                                                  ) => EmitterSubscription;
                                                                                                                                                  • Adds a listener to be invoked when events of the specified type are emitted. An optional calling context may be provided. The data arguments emitted will be passed to the listener function.

                                                                                                                                                    Parameter eventType

                                                                                                                                                    Name of the event to listen to

                                                                                                                                                    Parameter listener

                                                                                                                                                    Function to invoke when the specified event is emitted

                                                                                                                                                    Parameter context

                                                                                                                                                    Optional context object to use when invoking the listener

                                                                                                                                                  method emit

                                                                                                                                                  emit: (eventType: string, ...params: any[]) => void;
                                                                                                                                                  • Emits an event of the given type with the given data. All handlers of that particular type will be notified.

                                                                                                                                                    Parameter eventType

                                                                                                                                                    Name of the event to emit

                                                                                                                                                    Parameter Arbitrary

                                                                                                                                                    arguments to be passed to each registered listener

                                                                                                                                                    Example 1

                                                                                                                                                    emitter.addListener('someEvent', function(message) { console.log(message); });

                                                                                                                                                    emitter.emit('someEvent', 'abc'); // logs 'abc'

                                                                                                                                                  method listenerCount

                                                                                                                                                  listenerCount: (eventType: string) => number;
                                                                                                                                                  • Returns the number of listeners that are currently registered for the given event.

                                                                                                                                                    Parameter eventType

                                                                                                                                                    Name of the event to query

                                                                                                                                                  method removeAllListeners

                                                                                                                                                  removeAllListeners: (eventType?: string) => void;
                                                                                                                                                  • Removes all of the registered listeners, including those registered as listener maps.

                                                                                                                                                    Parameter eventType

                                                                                                                                                    Optional name of the event whose registered listeners to remove

                                                                                                                                                  method removeListener

                                                                                                                                                  removeListener: (eventType: string, listener: (...args: any[]) => any) => void;
                                                                                                                                                  • Removes the given listener for event of specific type.

                                                                                                                                                    Parameter eventType

                                                                                                                                                    Name of the event to emit

                                                                                                                                                    Parameter listener

                                                                                                                                                    Function to invoke when the specified event is emitted

                                                                                                                                                    Example 1

                                                                                                                                                    emitter.removeListener('someEvent', function(message) { console.log(message); }); // removes the listener if already registered

                                                                                                                                                    Deprecated

                                                                                                                                                    Use remove on the EventSubscription from addListener.

                                                                                                                                                  method removeSubscription

                                                                                                                                                  removeSubscription: (subscription: EmitterSubscription) => void;
                                                                                                                                                  • Removes a specific subscription. Called by the remove() method of the subscription itself to ensure any necessary cleanup is performed.

                                                                                                                                                    Deprecated

                                                                                                                                                    Use remove on the EventSubscription from addListener.

                                                                                                                                                  class EventSubscriptionVendor

                                                                                                                                                  class EventSubscriptionVendor {}
                                                                                                                                                  • EventSubscriptionVendor stores a set of EventSubscriptions that are subscribed to a particular event type.

                                                                                                                                                  constructor

                                                                                                                                                  constructor();

                                                                                                                                                    method addSubscription

                                                                                                                                                    addSubscription: (
                                                                                                                                                    eventType: string,
                                                                                                                                                    subscription: EventSubscription
                                                                                                                                                    ) => EventSubscription;
                                                                                                                                                    • Adds a subscription keyed by an event type.

                                                                                                                                                    method getSubscriptionsForType

                                                                                                                                                    getSubscriptionsForType: (eventType: string) => EventSubscription[];
                                                                                                                                                    • Returns the array of subscriptions that are currently registered for the given event type.

                                                                                                                                                      Note: This array can be potentially sparse as subscriptions are deleted from it when they are removed.

                                                                                                                                                    method removeAllSubscriptions

                                                                                                                                                    removeAllSubscriptions: (eventType?: string) => void;
                                                                                                                                                    • Removes a bulk set of the subscriptions.

                                                                                                                                                      Parameter eventType

                                                                                                                                                      Optional name of the event type whose registered supscriptions to remove, if null remove all subscriptions.

                                                                                                                                                    method removeSubscription

                                                                                                                                                    removeSubscription: (subscription: any) => void;
                                                                                                                                                    • Removes a specific subscription. Instead of calling this function, call subscription.remove() directly.

                                                                                                                                                    class FlatList

                                                                                                                                                    class FlatList<ItemT = any> extends React.Component<FlatListProps<ItemT>> {}

                                                                                                                                                      property flashScrollIndicators

                                                                                                                                                      flashScrollIndicators: () => void;
                                                                                                                                                      • Displays the scroll indicators momentarily.

                                                                                                                                                      property getNativeScrollRef

                                                                                                                                                      getNativeScrollRef: () =>
                                                                                                                                                      | React.RefObject<View>
                                                                                                                                                      | React.RefObject<ScrollViewComponent>
                                                                                                                                                      | null
                                                                                                                                                      | undefined;
                                                                                                                                                      • Provides a reference to the underlying host component

                                                                                                                                                      property getScrollableNode

                                                                                                                                                      getScrollableNode: () => any;

                                                                                                                                                        property getScrollResponder

                                                                                                                                                        getScrollResponder: () => JSX.Element | null | undefined;
                                                                                                                                                        • Provides a handle to the underlying scroll responder.

                                                                                                                                                        property recordInteraction

                                                                                                                                                        recordInteraction: () => void;
                                                                                                                                                        • Tells the list an interaction has occurred, which should trigger viewability calculations, e.g. if waitForInteractions is true and the user has not scrolled. This is typically called by taps on items or by navigation actions.

                                                                                                                                                        property scrollToEnd

                                                                                                                                                        scrollToEnd: (params?: { animated?: boolean | null | undefined }) => void;
                                                                                                                                                        • Scrolls to the end of the content. May be janky without getItemLayout prop.

                                                                                                                                                        property scrollToIndex

                                                                                                                                                        scrollToIndex: (params: {
                                                                                                                                                        animated?: boolean | null | undefined;
                                                                                                                                                        index: number;
                                                                                                                                                        viewOffset?: number | undefined;
                                                                                                                                                        viewPosition?: number | undefined;
                                                                                                                                                        }) => void;
                                                                                                                                                        • Scrolls to the item at the specified index such that it is positioned in the viewable area such that viewPosition 0 places it at the top, 1 at the bottom, and 0.5 centered in the middle. Cannot scroll to locations outside the render window without specifying the getItemLayout prop.

                                                                                                                                                        property scrollToItem

                                                                                                                                                        scrollToItem: (params: {
                                                                                                                                                        animated?: boolean | null | undefined;
                                                                                                                                                        item: ItemT;
                                                                                                                                                        viewPosition?: number | undefined;
                                                                                                                                                        }) => void;
                                                                                                                                                        • Requires linear scan through data - use scrollToIndex instead if possible. May be janky without getItemLayout prop.

                                                                                                                                                        property scrollToOffset

                                                                                                                                                        scrollToOffset: (params: {
                                                                                                                                                        animated?: boolean | null | undefined;
                                                                                                                                                        offset: number;
                                                                                                                                                        }) => void;
                                                                                                                                                        • Scroll to a specific content pixel offset, like a normal ScrollView.

                                                                                                                                                        property setNativeProps

                                                                                                                                                        setNativeProps: (props: { [key: string]: any }) => void;

                                                                                                                                                          class Image

                                                                                                                                                          class Image extends ImageBase {}

                                                                                                                                                            method abortPrefetch

                                                                                                                                                            static abortPrefetch: (requestId: number) => void;

                                                                                                                                                              method getSize

                                                                                                                                                              static getSize: (
                                                                                                                                                              uri: string,
                                                                                                                                                              success: (width: number, height: number) => void,
                                                                                                                                                              failure?: (error: any) => void
                                                                                                                                                              ) => any;

                                                                                                                                                                method getSizeWithHeaders

                                                                                                                                                                static getSizeWithHeaders: (
                                                                                                                                                                uri: string,
                                                                                                                                                                headers: { [index: string]: string },
                                                                                                                                                                success: (width: number, height: number) => void,
                                                                                                                                                                failure?: (error: any) => void
                                                                                                                                                                ) => any;

                                                                                                                                                                  method prefetch

                                                                                                                                                                  static prefetch: (url: string) => Promise<boolean>;

                                                                                                                                                                    method prefetchWithMetadata

                                                                                                                                                                    static prefetchWithMetadata: (
                                                                                                                                                                    url: string,
                                                                                                                                                                    queryRootName: string,
                                                                                                                                                                    rootTag?: number
                                                                                                                                                                    ) => Promise<boolean>;

                                                                                                                                                                      method queryCache

                                                                                                                                                                      static queryCache: (
                                                                                                                                                                      urls: string[]
                                                                                                                                                                      ) => Promise<{ [url: string]: 'memory' | 'disk' | 'disk/memory' }>;

                                                                                                                                                                        method resolveAssetSource

                                                                                                                                                                        static resolveAssetSource: (
                                                                                                                                                                        source: ImageSourcePropType
                                                                                                                                                                        ) => ImageResolvedAssetSource;
                                                                                                                                                                        • See Also

                                                                                                                                                                          • https://reactnative.dev/docs/image#resolveassetsource

                                                                                                                                                                        class ImageBackground

                                                                                                                                                                        class ImageBackground extends ImageBackgroundBase {}

                                                                                                                                                                          property resizeMode

                                                                                                                                                                          resizeMode: ImageResizeMode;

                                                                                                                                                                            method abortPrefetch

                                                                                                                                                                            abortPrefetch: (requestId: number) => void;

                                                                                                                                                                              method getSize

                                                                                                                                                                              getSize: (
                                                                                                                                                                              uri: string,
                                                                                                                                                                              success: (width: number, height: number) => void,
                                                                                                                                                                              failure: (error: any) => void
                                                                                                                                                                              ) => any;

                                                                                                                                                                                method prefetch

                                                                                                                                                                                prefetch: (url: string) => any;

                                                                                                                                                                                  method queryCache

                                                                                                                                                                                  queryCache: (
                                                                                                                                                                                  urls: string[]
                                                                                                                                                                                  ) => Promise<{ [url: string]: 'memory' | 'disk' | 'disk/memory' }>;

                                                                                                                                                                                    class ImageBackgroundComponent

                                                                                                                                                                                    class ImageBackgroundComponent extends React.Component<ImageBackgroundProps> {}

                                                                                                                                                                                      class ImageComponent

                                                                                                                                                                                      class ImageComponent extends React.Component<ImageProps> {}

                                                                                                                                                                                        class InputAccessoryView

                                                                                                                                                                                        class InputAccessoryView extends React.Component<InputAccessoryViewProps> {}
                                                                                                                                                                                        • A component which enables customization of the keyboard input accessory view on iOS. The input accessory view is displayed above the keyboard whenever a TextInput has focus. This component can be used to create custom toolbars.

                                                                                                                                                                                          To use this component wrap your custom toolbar with the InputAccessoryView component, and set a nativeID. Then, pass that nativeID as the inputAccessoryViewID of whatever TextInput you desire.

                                                                                                                                                                                        class KeyboardAvoidingView

                                                                                                                                                                                        class KeyboardAvoidingView extends KeyboardAvoidingViewBase {}

                                                                                                                                                                                          class KeyboardAvoidingViewComponent

                                                                                                                                                                                          class KeyboardAvoidingViewComponent extends React.Component<KeyboardAvoidingViewProps> {}
                                                                                                                                                                                          • It is a component to solve the common problem of views that need to move out of the way of the virtual keyboard. It can automatically adjust either its position or bottom padding based on the position of the keyboard.

                                                                                                                                                                                          class ListView

                                                                                                                                                                                          class ListView extends ListViewBase {}
                                                                                                                                                                                          • See Also

                                                                                                                                                                                            • https://fb.me/nolistview

                                                                                                                                                                                            Deprecated

                                                                                                                                                                                            See Flatlist or SectionList or use deprecated-react-native-listview

                                                                                                                                                                                          property DataSource

                                                                                                                                                                                          static DataSource: ListViewDataSource;

                                                                                                                                                                                            property getMetrics

                                                                                                                                                                                            getMetrics: () => {
                                                                                                                                                                                            contentLength: number;
                                                                                                                                                                                            totalRows: number;
                                                                                                                                                                                            renderedRows: number;
                                                                                                                                                                                            visibleRows: number;
                                                                                                                                                                                            };
                                                                                                                                                                                            • Exports some data, e.g. for perf investigations or analytics.

                                                                                                                                                                                            property getScrollResponder

                                                                                                                                                                                            getScrollResponder: () => any;
                                                                                                                                                                                            • Provides a handle to the underlying scroll responder.

                                                                                                                                                                                            property scrollTo

                                                                                                                                                                                            scrollTo: (
                                                                                                                                                                                            y?:
                                                                                                                                                                                            | number
                                                                                                                                                                                            | {
                                                                                                                                                                                            x?: number | undefined;
                                                                                                                                                                                            y?: number | undefined;
                                                                                                                                                                                            animated?: boolean | undefined;
                                                                                                                                                                                            },
                                                                                                                                                                                            x?: number,
                                                                                                                                                                                            animated?: boolean
                                                                                                                                                                                            ) => void;
                                                                                                                                                                                            • Scrolls to a given x, y offset, either immediately or with a smooth animation.

                                                                                                                                                                                              See ScrollView#scrollTo.

                                                                                                                                                                                            class ListViewComponent

                                                                                                                                                                                            class ListViewComponent extends React.Component<ListViewProps> {}

                                                                                                                                                                                              class MaskedViewComponent

                                                                                                                                                                                              class MaskedViewComponent extends React.Component<MaskedViewIOSProps> {}
                                                                                                                                                                                              • See Also

                                                                                                                                                                                                • https://reactnative.dev/docs/maskedviewios

                                                                                                                                                                                              class MaskedViewIOS

                                                                                                                                                                                              class MaskedViewIOS extends MaskedViewBase {}
                                                                                                                                                                                              • MaskedViewIOS has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/masked-view instead of 'react-native'.

                                                                                                                                                                                                See Also

                                                                                                                                                                                                • https://github.com/react-native-community/react-native-masked-view

                                                                                                                                                                                                Deprecated

                                                                                                                                                                                              class Modal extends React.Component<ModalProps> {}

                                                                                                                                                                                                class NativeEventEmitter

                                                                                                                                                                                                class NativeEventEmitter extends EventEmitter {}
                                                                                                                                                                                                • Abstract base class for implementing event-emitting modules. This implements a subset of the standard EventEmitter node module API.

                                                                                                                                                                                                constructor

                                                                                                                                                                                                constructor(nativeModule?: NativeModule);
                                                                                                                                                                                                • Parameter nativeModule

                                                                                                                                                                                                  the NativeModule implementation. This is required on IOS and will throw an invariant error if undefined.

                                                                                                                                                                                                method addListener

                                                                                                                                                                                                addListener: (
                                                                                                                                                                                                eventType: string,
                                                                                                                                                                                                listener: (event: any) => void,
                                                                                                                                                                                                context?: Object
                                                                                                                                                                                                ) => EmitterSubscription;
                                                                                                                                                                                                • Add the specified listener, this call passes through to the NativeModule addListener

                                                                                                                                                                                                  Parameter eventType

                                                                                                                                                                                                  name of the event for which we are registering listener

                                                                                                                                                                                                  Parameter listener

                                                                                                                                                                                                  the listener function

                                                                                                                                                                                                  Parameter context

                                                                                                                                                                                                  context of the listener

                                                                                                                                                                                                method removeAllListeners

                                                                                                                                                                                                removeAllListeners: (eventType: string) => void;
                                                                                                                                                                                                • Parameter eventType

                                                                                                                                                                                                  name of the event whose registered listeners to remove

                                                                                                                                                                                                method removeSubscription

                                                                                                                                                                                                removeSubscription: (subscription: EmitterSubscription) => void;
                                                                                                                                                                                                • Removes a subscription created by the addListener, the EventSubscription#remove() function actually calls through to this.

                                                                                                                                                                                                class NavigatorIOS extends React.Component<NavigatorIOSProps> {}
                                                                                                                                                                                                • A navigator is an object of navigation functions that a view can call. It is passed as a prop to any component rendered by NavigatorIOS.

                                                                                                                                                                                                  Navigator functions are also available on the NavigatorIOS component:

                                                                                                                                                                                                  See Also

                                                                                                                                                                                                  • https://reactnative.dev/docs/navigatorios#navigator

                                                                                                                                                                                                pop: () => void;
                                                                                                                                                                                                • Go back one page

                                                                                                                                                                                                popN: (n: number) => void;
                                                                                                                                                                                                • Go back N pages at once. When N=1, behavior matches pop()

                                                                                                                                                                                                push: (route: Route) => void;
                                                                                                                                                                                                • Navigate forward to a new route

                                                                                                                                                                                                replace: (route: Route) => void;
                                                                                                                                                                                                • Replace the route for the current page and immediately load the view for the new route

                                                                                                                                                                                                replacePrevious: (route: Route) => void;
                                                                                                                                                                                                • Replace the route/view for the previous page

                                                                                                                                                                                                replacePreviousAndPop: (route: Route) => void;
                                                                                                                                                                                                • Replaces the previous route/view and transitions back to it

                                                                                                                                                                                                resetTo: (route: Route) => void;
                                                                                                                                                                                                • Replaces the top item and popToTop

                                                                                                                                                                                                popToRoute: (route: Route) => void;
                                                                                                                                                                                                • Go back to the item for a particular route object

                                                                                                                                                                                                popToTop: () => void;
                                                                                                                                                                                                • Go back to the top item

                                                                                                                                                                                                class Picker

                                                                                                                                                                                                class Picker extends React.Component<PickerProps> {}
                                                                                                                                                                                                • Picker has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/picker instead of 'react-native'.

                                                                                                                                                                                                  See Also

                                                                                                                                                                                                  • https://github.com/react-native-community/react-native-picker

                                                                                                                                                                                                  Deprecated

                                                                                                                                                                                                property Item

                                                                                                                                                                                                static Item: any;

                                                                                                                                                                                                  property MODE_DIALOG

                                                                                                                                                                                                  static MODE_DIALOG: string;
                                                                                                                                                                                                  • On Android, display the options in a dialog.

                                                                                                                                                                                                  property MODE_DROPDOWN

                                                                                                                                                                                                  static MODE_DROPDOWN: string;
                                                                                                                                                                                                  • On Android, display the options in a dropdown (this is the default).

                                                                                                                                                                                                  class PickerIOS

                                                                                                                                                                                                  class PickerIOS extends PickerIOSBase {}
                                                                                                                                                                                                  • PickerIOS has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/picker instead of 'react-native'.

                                                                                                                                                                                                    See Also

                                                                                                                                                                                                    • https://github.com/react-native-community/react-native-picker

                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                  property Item

                                                                                                                                                                                                  static Item: typeof PickerIOSItem;

                                                                                                                                                                                                    class PickerIOSComponent

                                                                                                                                                                                                    class PickerIOSComponent extends React.Component<PickerIOSProps> {}
                                                                                                                                                                                                    • See Also

                                                                                                                                                                                                      • https://reactnative.dev/docs/pickerios

                                                                                                                                                                                                      • PickerIOS.ios.js

                                                                                                                                                                                                    class PickerIOSItem

                                                                                                                                                                                                    class PickerIOSItem extends React.Component<PickerIOSItemProps> {}
                                                                                                                                                                                                    • See Also

                                                                                                                                                                                                      • PickerIOS.ios.js

                                                                                                                                                                                                    class ProgressBarAndroid

                                                                                                                                                                                                    class ProgressBarAndroid extends ProgressBarAndroidBase {}
                                                                                                                                                                                                    • ProgressBarAndroid has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/progress-bar-android instead of 'react-native'.

                                                                                                                                                                                                      See Also

                                                                                                                                                                                                      • https://github.com/react-native-progress-view/progress-bar-android

                                                                                                                                                                                                      Deprecated

                                                                                                                                                                                                    class ProgressBarAndroidComponent

                                                                                                                                                                                                    class ProgressBarAndroidComponent extends React.Component<ProgressBarAndroidProps> {}
                                                                                                                                                                                                    • React component that wraps the Android-only ProgressBar. This component is used to indicate that the app is loading or there is some activity in the app.

                                                                                                                                                                                                    class ProgressViewIOS

                                                                                                                                                                                                    class ProgressViewIOS extends ProgressViewIOSBase {}
                                                                                                                                                                                                    • ProgressViewIOS has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/progress-view instead of 'react-native'.

                                                                                                                                                                                                      See Also

                                                                                                                                                                                                      • https://github.com/react-native-community/progress-view

                                                                                                                                                                                                      Deprecated

                                                                                                                                                                                                    class ProgressViewIOSComponent

                                                                                                                                                                                                    class ProgressViewIOSComponent extends React.Component<ProgressViewIOSProps> {}

                                                                                                                                                                                                      class RecyclerViewBackedScrollView

                                                                                                                                                                                                      class RecyclerViewBackedScrollView extends RecyclerViewBackedScrollViewBase {}

                                                                                                                                                                                                        method getScrollResponder

                                                                                                                                                                                                        getScrollResponder: () => any;
                                                                                                                                                                                                        • Returns a reference to the underlying scroll responder, which supports operations like scrollTo. All ScrollView-like components should implement this method so that they can be composed while providing access to the underlying scroll responder's methods.

                                                                                                                                                                                                        method scrollTo

                                                                                                                                                                                                        scrollTo: (
                                                                                                                                                                                                        y?:
                                                                                                                                                                                                        | number
                                                                                                                                                                                                        | {
                                                                                                                                                                                                        x?: number | undefined;
                                                                                                                                                                                                        y?: number | undefined;
                                                                                                                                                                                                        animated?: boolean | undefined;
                                                                                                                                                                                                        },
                                                                                                                                                                                                        x?: number,
                                                                                                                                                                                                        animated?: boolean
                                                                                                                                                                                                        ) => void;
                                                                                                                                                                                                        • A helper function to scroll to a specific point in the scrollview. This is currently used to help focus on child textviews, but can also be used to quickly scroll to any element we want to focus. Syntax:

                                                                                                                                                                                                          scrollResponderScrollTo(options: {x: number = 0; y: number = 0; animated: boolean = true})

                                                                                                                                                                                                          Note: The weird argument signature is due to the fact that, for historical reasons, the function also accepts separate arguments as an alternative to the options object. This is deprecated due to ambiguity (y before x), and SHOULD NOT BE USED.

                                                                                                                                                                                                        class RecyclerViewBackedScrollViewComponent

                                                                                                                                                                                                        class RecyclerViewBackedScrollViewComponent extends React.Component<RecyclerViewBackedScrollViewProps> {}
                                                                                                                                                                                                        • Wrapper around android native recycler view.

                                                                                                                                                                                                          It simply renders rows passed as children in a separate recycler view cells similarly to how ScrollView is doing it. Thanks to the fact that it uses native RecyclerView though, rows that are out of sight are going to be automatically detached (similarly on how this would work with removeClippedSubviews = true on a ScrollView.js).

                                                                                                                                                                                                          CAUTION: This is an experimental component and should only be used together with javascript implementation of list view (see ListView.js). In order to use it pass this component as renderScrollComponent to the list view. For now only horizontal scrolling is supported.

                                                                                                                                                                                                        class RefreshControl

                                                                                                                                                                                                        class RefreshControl extends RefreshControlBase {}

                                                                                                                                                                                                          property SIZE

                                                                                                                                                                                                          static SIZE: Object;

                                                                                                                                                                                                            class RefreshControlComponent

                                                                                                                                                                                                            class RefreshControlComponent extends React.Component<RefreshControlProps> {}
                                                                                                                                                                                                            • This component is used inside a ScrollView or ListView to add pull to refresh functionality. When the ScrollView is at scrollY: 0, swiping down triggers an onRefresh event.

                                                                                                                                                                                                              __Note:__ refreshing is a controlled prop, this is why it needs to be set to true in the onRefresh function otherwise the refresh indicator will stop immediately.

                                                                                                                                                                                                            class SafeAreaView

                                                                                                                                                                                                            class SafeAreaView extends SafeAreaViewBase {}

                                                                                                                                                                                                              class SafeAreaViewComponent

                                                                                                                                                                                                              class SafeAreaViewComponent extends React.Component<ViewProps> {}
                                                                                                                                                                                                              • Renders nested content and automatically applies paddings reflect the portion of the view that is not covered by navigation bars, tab bars, toolbars, and other ancestor views. Moreover, and most importantly, Safe Area's paddings reflect physical limitation of the screen, such as rounded corners or camera notches (aka sensor housing area on iPhone X).

                                                                                                                                                                                                              class ScrollView

                                                                                                                                                                                                              class ScrollView extends ScrollViewBase {}

                                                                                                                                                                                                                property scrollWithoutAnimationTo

                                                                                                                                                                                                                scrollWithoutAnimationTo?: (y: number, x: number) => void;
                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                  Use scrollTo instead

                                                                                                                                                                                                                method flashScrollIndicators

                                                                                                                                                                                                                flashScrollIndicators: () => void;
                                                                                                                                                                                                                • Displays the scroll indicators momentarily.

                                                                                                                                                                                                                method getInnerViewNode

                                                                                                                                                                                                                getInnerViewNode: () => any;

                                                                                                                                                                                                                  method getScrollableNode

                                                                                                                                                                                                                  getScrollableNode: () => any;

                                                                                                                                                                                                                    method getScrollResponder

                                                                                                                                                                                                                    getScrollResponder: () => ScrollResponderMixin;
                                                                                                                                                                                                                    • Returns a reference to the underlying scroll responder, which supports operations like scrollTo. All ScrollView-like components should implement this method so that they can be composed while providing access to the underlying scroll responder's methods.

                                                                                                                                                                                                                    method scrollTo

                                                                                                                                                                                                                    scrollTo: (
                                                                                                                                                                                                                    y?:
                                                                                                                                                                                                                    | number
                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                    x?: number | undefined;
                                                                                                                                                                                                                    y?: number | undefined;
                                                                                                                                                                                                                    animated?: boolean | undefined;
                                                                                                                                                                                                                    },
                                                                                                                                                                                                                    x?: number,
                                                                                                                                                                                                                    animated?: boolean
                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                    • Scrolls to a given x, y offset, either immediately or with a smooth animation. Syntax:

                                                                                                                                                                                                                      scrollTo(options: {x: number = 0; y: number = 0; animated: boolean = true})

                                                                                                                                                                                                                      Note: The weird argument signature is due to the fact that, for historical reasons, the function also accepts separate arguments as an alternative to the options object. This is deprecated due to ambiguity (y before x), and SHOULD NOT BE USED.

                                                                                                                                                                                                                    method scrollToEnd

                                                                                                                                                                                                                    scrollToEnd: (options?: { animated: boolean }) => void;
                                                                                                                                                                                                                    • A helper function that scrolls to the end of the scrollview; If this is a vertical ScrollView, it scrolls to the bottom. If this is a horizontal ScrollView scrolls to the right.

                                                                                                                                                                                                                      The options object has an animated prop, that enables the scrolling animation or not. The animated prop defaults to true

                                                                                                                                                                                                                    method setNativeProps

                                                                                                                                                                                                                    setNativeProps: (nativeProps: object) => void;
                                                                                                                                                                                                                    • This function sends props straight to native. They will not participate in future diff process - this means that if you do not include them in the next render, they will remain active (see [Direct Manipulation](https://reactnative.dev/docs/direct-manipulation)).

                                                                                                                                                                                                                    class ScrollViewComponent

                                                                                                                                                                                                                    class ScrollViewComponent extends React.Component<ScrollViewProps> {}

                                                                                                                                                                                                                      class SectionList

                                                                                                                                                                                                                      class SectionList<ItemT = any, SectionT = DefaultSectionT> extends React.Component<
                                                                                                                                                                                                                      SectionListProps<ItemT, SectionT>
                                                                                                                                                                                                                      > {}

                                                                                                                                                                                                                        method flashScrollIndicators

                                                                                                                                                                                                                        flashScrollIndicators: () => void;
                                                                                                                                                                                                                        • Displays the scroll indicators momentarily.

                                                                                                                                                                                                                          ios

                                                                                                                                                                                                                        method getScrollableNode

                                                                                                                                                                                                                        getScrollableNode: () => NodeHandle | undefined;
                                                                                                                                                                                                                        • Provides a handle to the underlying scroll node.

                                                                                                                                                                                                                        method getScrollResponder

                                                                                                                                                                                                                        getScrollResponder: () => ScrollView | undefined;
                                                                                                                                                                                                                        • Provides a handle to the underlying scroll responder.

                                                                                                                                                                                                                        method recordInteraction

                                                                                                                                                                                                                        recordInteraction: () => void;
                                                                                                                                                                                                                        • Tells the list an interaction has occurred, which should trigger viewability calculations, e.g. if waitForInteractions is true and the user has not scrolled. This is typically called by taps on items or by navigation actions.

                                                                                                                                                                                                                        method scrollToLocation

                                                                                                                                                                                                                        scrollToLocation: (params: SectionListScrollParams) => void;
                                                                                                                                                                                                                        • Scrolls to the item at the specified sectionIndex and itemIndex (within the section) positioned in the viewable area such that viewPosition 0 places it at the top (and may be covered by a sticky header), 1 at the bottom, and 0.5 centered in the middle.

                                                                                                                                                                                                                        class SegmentedControlIOS

                                                                                                                                                                                                                        class SegmentedControlIOS extends SegmentedControlIOSBase {}
                                                                                                                                                                                                                        • SegmentedControlIOS has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/segmented-control instead of 'react-native'.

                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                          • https://github.com/react-native-community/segmented-control

                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                        class SegmentedControlIOSComponent

                                                                                                                                                                                                                        class SegmentedControlIOSComponent extends React.Component<SegmentedControlIOSProps> {}
                                                                                                                                                                                                                        • Use SegmentedControlIOS to render a UISegmentedControl iOS.

                                                                                                                                                                                                                          #### Programmatically changing selected index

                                                                                                                                                                                                                          The selected index can be changed on the fly by assigning the selectIndex prop to a state variable, then changing that variable. Note that the state variable would need to be updated as the user selects a value and changes the index, as shown in the example below.

                                                                                                                                                                                                                          ```` <SegmentedControlIOS values={['One', 'Two']} selectedIndex={this.state.selectedIndex} onChange={(event) => { this.setState({selectedIndex: event.nativeEvent.selectedSegmentIndex}); }} /> ````

                                                                                                                                                                                                                        class Slider

                                                                                                                                                                                                                        class Slider extends SliderBase {}
                                                                                                                                                                                                                        • Slider has been extracted from react-native core and will be removed in a future release. It can now be installed and imported from @react-native-community/slider instead of 'react-native'.

                                                                                                                                                                                                                          See Also

                                                                                                                                                                                                                          • https://github.com/callstack/react-native-slider

                                                                                                                                                                                                                          Deprecated

                                                                                                                                                                                                                        class SliderComponent

                                                                                                                                                                                                                        class SliderComponent extends React.Component<SliderProps> {}
                                                                                                                                                                                                                        • A component used to select a single value from a range of values.

                                                                                                                                                                                                                        class SnapshotViewIOS

                                                                                                                                                                                                                        class SnapshotViewIOS extends SnapshotViewIOSBase {}

                                                                                                                                                                                                                          class SnapshotViewIOSComponent

                                                                                                                                                                                                                          class SnapshotViewIOSComponent extends React.Component<SnapshotViewIOSProps> {}

                                                                                                                                                                                                                            class StatusBar

                                                                                                                                                                                                                            class StatusBar extends React.Component<StatusBarProps> {}

                                                                                                                                                                                                                              property currentHeight

                                                                                                                                                                                                                              static currentHeight?: number;
                                                                                                                                                                                                                              • The current height of the status bar on the device. android

                                                                                                                                                                                                                              property popStackEntry

                                                                                                                                                                                                                              static popStackEntry: (entry: StatusBarProps) => void;
                                                                                                                                                                                                                              • Pop a StatusBar entry from the stack.

                                                                                                                                                                                                                                Parameter entry

                                                                                                                                                                                                                                Entry returned from pushStackEntry.

                                                                                                                                                                                                                              property pushStackEntry

                                                                                                                                                                                                                              static pushStackEntry: (props: StatusBarProps) => StatusBarProps;
                                                                                                                                                                                                                              • Push a StatusBar entry onto the stack. The return value should be passed to popStackEntry when complete.

                                                                                                                                                                                                                                Parameter props

                                                                                                                                                                                                                                Object containing the StatusBar props to use in the stack entry.

                                                                                                                                                                                                                              property replaceStackEntry

                                                                                                                                                                                                                              static replaceStackEntry: (
                                                                                                                                                                                                                              entry: StatusBarProps,
                                                                                                                                                                                                                              props: StatusBarProps
                                                                                                                                                                                                                              ) => StatusBarProps;
                                                                                                                                                                                                                              • Replace an existing StatusBar stack entry with new props.

                                                                                                                                                                                                                                Parameter entry

                                                                                                                                                                                                                                Entry returned from pushStackEntry to replace.

                                                                                                                                                                                                                                Parameter props

                                                                                                                                                                                                                                Object containing the StatusBar props to use in the replacement stack entry.

                                                                                                                                                                                                                              property setBackgroundColor

                                                                                                                                                                                                                              static setBackgroundColor: (color: ColorValue, animated?: boolean) => void;
                                                                                                                                                                                                                              • Set the background color for the status bar

                                                                                                                                                                                                                                Parameter color

                                                                                                                                                                                                                                Background color.

                                                                                                                                                                                                                                Parameter animated

                                                                                                                                                                                                                                Animate the style change.

                                                                                                                                                                                                                              property setBarStyle

                                                                                                                                                                                                                              static setBarStyle: (style: StatusBarStyle, animated?: boolean) => void;
                                                                                                                                                                                                                              • Set the status bar style

                                                                                                                                                                                                                                Parameter style

                                                                                                                                                                                                                                Status bar style to set

                                                                                                                                                                                                                                Parameter animated

                                                                                                                                                                                                                                Animate the style change.

                                                                                                                                                                                                                              property setHidden

                                                                                                                                                                                                                              static setHidden: (hidden: boolean, animation?: StatusBarAnimation) => void;
                                                                                                                                                                                                                              • Show or hide the status bar

                                                                                                                                                                                                                                Parameter hidden

                                                                                                                                                                                                                                The dialog's title.

                                                                                                                                                                                                                                Parameter animation

                                                                                                                                                                                                                                Optional animation when changing the status bar hidden property.

                                                                                                                                                                                                                              property setNetworkActivityIndicatorVisible

                                                                                                                                                                                                                              static setNetworkActivityIndicatorVisible: (visible: boolean) => void;
                                                                                                                                                                                                                              • Control the visibility of the network activity indicator

                                                                                                                                                                                                                                Parameter visible

                                                                                                                                                                                                                                Show the indicator.

                                                                                                                                                                                                                              property setTranslucent

                                                                                                                                                                                                                              static setTranslucent: (translucent: boolean) => void;
                                                                                                                                                                                                                              • Control the translucency of the status bar

                                                                                                                                                                                                                                Parameter translucent

                                                                                                                                                                                                                                Set as translucent.

                                                                                                                                                                                                                              class SwipeableListView

                                                                                                                                                                                                                              class SwipeableListView extends React.Component<SwipeableListViewProps> {}
                                                                                                                                                                                                                              • SwipeableListView has been removed from React Native. See https://fb.me/nolistview for more information or use deprecated-react-native-swipeable-listview.

                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                              method getNewDataSource

                                                                                                                                                                                                                              static getNewDataSource: () => SwipeableListViewDataSource;

                                                                                                                                                                                                                                class Switch

                                                                                                                                                                                                                                class Switch extends SwitchBase {}

                                                                                                                                                                                                                                  class SwitchComponent

                                                                                                                                                                                                                                  class SwitchComponent extends React.Component<SwitchProps> {}
                                                                                                                                                                                                                                  • Renders a boolean input.

                                                                                                                                                                                                                                    This is a controlled component that requires an onValueChange callback that updates the value prop in order for the component to reflect user actions. If the value prop is not updated, the component will continue to render the supplied value prop instead of the expected result of any user actions.

                                                                                                                                                                                                                                  class SwitchIOS

                                                                                                                                                                                                                                  class SwitchIOS extends React.Component<SwitchIOSProps> {}
                                                                                                                                                                                                                                  • SwitchIOS component has been removed from react-native in favor of Switch component https://github.com/facebook/react-native/pull/9891/files

                                                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                                                    see Switch

                                                                                                                                                                                                                                  class TabBarIOS

                                                                                                                                                                                                                                  class TabBarIOS extends React.Component<TabBarIOSProps> {}
                                                                                                                                                                                                                                  • TabBarIOS has been removed from react-native

                                                                                                                                                                                                                                    Deprecated

                                                                                                                                                                                                                                  property Item

                                                                                                                                                                                                                                  static Item: typeof TabBarIOSItem;

                                                                                                                                                                                                                                    class TabBarIOSItem

                                                                                                                                                                                                                                    class TabBarIOSItem extends React.Component<TabBarIOSItemProps> {}

                                                                                                                                                                                                                                      class Text

                                                                                                                                                                                                                                      class Text extends TextBase {}

                                                                                                                                                                                                                                        class TextComponent

                                                                                                                                                                                                                                        class TextComponent extends React.Component<TextProps> {}
                                                                                                                                                                                                                                        • A React component for displaying text which supports nesting, styling, and touch handling.

                                                                                                                                                                                                                                        class TextInput

                                                                                                                                                                                                                                        class TextInput extends TextInputBase {}

                                                                                                                                                                                                                                          property clear

                                                                                                                                                                                                                                          clear: () => void;
                                                                                                                                                                                                                                          • Removes all text from the input.

                                                                                                                                                                                                                                          property isFocused

                                                                                                                                                                                                                                          isFocused: () => boolean;
                                                                                                                                                                                                                                          • Returns if the input is currently focused.

                                                                                                                                                                                                                                          property State

                                                                                                                                                                                                                                          static State: TextInputState;
                                                                                                                                                                                                                                          • Access the current focus state.

                                                                                                                                                                                                                                          class TextInputComponent

                                                                                                                                                                                                                                          class TextInputComponent extends React.Component<TextInputProps> {}
                                                                                                                                                                                                                                          • See Also

                                                                                                                                                                                                                                            • https://reactnative.dev/docs/textinput#methods

                                                                                                                                                                                                                                          class ToolbarAndroid

                                                                                                                                                                                                                                          class ToolbarAndroid extends ToolbarAndroidBase {}
                                                                                                                                                                                                                                          • ToolbarAndroid has been deprecated and removed from the package since React Native v0.61.0. It can now be installed and imported from @react-native-community/datetimepicker instead of 'react-native'.

                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                            • https://github.com/react-native-community/toolbar-android

                                                                                                                                                                                                                                            Deprecated

                                                                                                                                                                                                                                          class ToolbarAndroidComponent

                                                                                                                                                                                                                                          class ToolbarAndroidComponent extends React.Component<ToolbarAndroidProps> {}
                                                                                                                                                                                                                                          • React component that wraps the Android-only [Toolbar widget][0]. A Toolbar can display a logo, navigation icon (e.g. hamburger menu), a title & subtitle and a list of actions. The title and subtitle are expanded so the logo and navigation icons are displayed on the left, title and subtitle in the middle and the actions on the right.

                                                                                                                                                                                                                                            If the toolbar has an only child, it will be displayed between the title and actions.

                                                                                                                                                                                                                                            Although the Toolbar supports remote images for the logo, navigation and action icons, this should only be used in DEV mode where require('./some_icon.png') translates into a packager URL. In release mode you should always use a drawable resource for these icons. Using require('./some_icon.png') will do this automatically for you, so as long as you don't explicitly use e.g. {uri: 'http://...'}, you will be good.

                                                                                                                                                                                                                                            [0]: https://developer.android.com/reference/android/support/v7/widget/Toolbar.html

                                                                                                                                                                                                                                          class TouchableHighlight

                                                                                                                                                                                                                                          class TouchableHighlight extends TouchableHighlightBase {}

                                                                                                                                                                                                                                            class TouchableHighlightComponent

                                                                                                                                                                                                                                            class TouchableHighlightComponent extends React.Component<TouchableHighlightProps> {}
                                                                                                                                                                                                                                            • A wrapper for making views respond properly to touches. On press down, the opacity of the wrapped view is decreased, which allows the underlay color to show through, darkening or tinting the view. The underlay comes from adding a view to the view hierarchy, which can sometimes cause unwanted visual artifacts if not used correctly, for example if the backgroundColor of the wrapped view isn't explicitly set to an opaque color.

                                                                                                                                                                                                                                              NOTE: TouchableHighlight supports only one child If you wish to have several child components, wrap them in a View.

                                                                                                                                                                                                                                              See Also

                                                                                                                                                                                                                                              • https://reactnative.dev/docs/touchablehighlight

                                                                                                                                                                                                                                            class TouchableNativeFeedback

                                                                                                                                                                                                                                            class TouchableNativeFeedback extends TouchableNativeFeedbackBase {}

                                                                                                                                                                                                                                              method canUseNativeForeground

                                                                                                                                                                                                                                              static canUseNativeForeground: () => boolean;

                                                                                                                                                                                                                                                method Ripple

                                                                                                                                                                                                                                                static Ripple: (
                                                                                                                                                                                                                                                color: ColorValue,
                                                                                                                                                                                                                                                borderless: boolean,
                                                                                                                                                                                                                                                rippleRadius?: number | null
                                                                                                                                                                                                                                                ) => RippleBackgroundPropType;
                                                                                                                                                                                                                                                • Creates an object that represents ripple drawable with specified color (as a string). If property borderless evaluates to true the ripple will render outside of the view bounds (see native actionbar buttons as an example of that behavior). This background type is available on Android API level 21+.

                                                                                                                                                                                                                                                  Parameter color

                                                                                                                                                                                                                                                  The ripple color

                                                                                                                                                                                                                                                  Parameter borderless

                                                                                                                                                                                                                                                  If the ripple can render outside it's bounds

                                                                                                                                                                                                                                                  Parameter rippleRadius

                                                                                                                                                                                                                                                  The radius of ripple effect

                                                                                                                                                                                                                                                method SelectableBackground

                                                                                                                                                                                                                                                static SelectableBackground: (
                                                                                                                                                                                                                                                rippleRadius?: number | null
                                                                                                                                                                                                                                                ) => ThemeAttributeBackgroundPropType;
                                                                                                                                                                                                                                                • Creates an object that represents android theme's default background for selectable elements (?android:attr/selectableItemBackground).

                                                                                                                                                                                                                                                  Parameter rippleRadius

                                                                                                                                                                                                                                                  The radius of ripple effect

                                                                                                                                                                                                                                                method SelectableBackgroundBorderless

                                                                                                                                                                                                                                                static SelectableBackgroundBorderless: (
                                                                                                                                                                                                                                                rippleRadius?: number | null
                                                                                                                                                                                                                                                ) => ThemeAttributeBackgroundPropType;
                                                                                                                                                                                                                                                • Creates an object that represent android theme's default background for borderless selectable elements (?android:attr/selectableItemBackgroundBorderless). Available on android API level 21+.

                                                                                                                                                                                                                                                  Parameter rippleRadius

                                                                                                                                                                                                                                                  The radius of ripple effect

                                                                                                                                                                                                                                                class TouchableNativeFeedbackComponent

                                                                                                                                                                                                                                                class TouchableNativeFeedbackComponent extends React.Component<TouchableNativeFeedbackProps> {}
                                                                                                                                                                                                                                                • A wrapper for making views respond properly to touches (Android only). On Android this component uses native state drawable to display touch feedback. At the moment it only supports having a single View instance as a child node, as it's implemented by replacing that View with another instance of RCTView node with some additional properties set.

                                                                                                                                                                                                                                                  Background drawable of native feedback touchable can be customized with background property.

                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                  • https://reactnative.dev/docs/touchablenativefeedback#content

                                                                                                                                                                                                                                                class TouchableOpacity

                                                                                                                                                                                                                                                class TouchableOpacity extends TouchableOpacityBase {}

                                                                                                                                                                                                                                                  property setOpacityTo

                                                                                                                                                                                                                                                  setOpacityTo: (value: number) => void;
                                                                                                                                                                                                                                                  • Animate the touchable to a new opacity.

                                                                                                                                                                                                                                                  class TouchableOpacityComponent

                                                                                                                                                                                                                                                  class TouchableOpacityComponent extends React.Component<TouchableOpacityProps> {}
                                                                                                                                                                                                                                                  • A wrapper for making views respond properly to touches. On press down, the opacity of the wrapped view is decreased, dimming it. This is done without actually changing the view hierarchy, and in general is easy to add to an app without weird side-effects.

                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                    • https://reactnative.dev/docs/touchableopacity

                                                                                                                                                                                                                                                  class TouchableWithoutFeedback

                                                                                                                                                                                                                                                  class TouchableWithoutFeedback extends TouchableWithoutFeedbackBase {}

                                                                                                                                                                                                                                                    class TouchableWithoutFeedbackComponent

                                                                                                                                                                                                                                                    class TouchableWithoutFeedbackComponent extends React.Component<TouchableWithoutFeedbackProps> {}
                                                                                                                                                                                                                                                    • Do not use unless you have a very good reason. All the elements that respond to press should have a visual feedback when touched. This is one of the primary reason a "web" app doesn't feel "native".

                                                                                                                                                                                                                                                      See Also

                                                                                                                                                                                                                                                      • https://reactnative.dev/docs/touchablewithoutfeedback

                                                                                                                                                                                                                                                    class View

                                                                                                                                                                                                                                                    class View extends ViewBase {}

                                                                                                                                                                                                                                                      property forceTouchAvailable

                                                                                                                                                                                                                                                      static forceTouchAvailable: boolean;
                                                                                                                                                                                                                                                      • Is 3D Touch / Force Touch available (i.e. will touch events include force) ios

                                                                                                                                                                                                                                                      class ViewComponent

                                                                                                                                                                                                                                                      class ViewComponent extends React.Component<ViewProps> {}
                                                                                                                                                                                                                                                      • The most fundamental component for building UI, View is a container that supports layout with flexbox, style, some touch handling, and accessibility controls, and is designed to be nested inside other views and to have 0 to many children of any type. View maps directly to the native view equivalent on whatever platform React is running on, whether that is a UIView, , android.view, etc.

                                                                                                                                                                                                                                                      class ViewPagerAndroid

                                                                                                                                                                                                                                                      class ViewPagerAndroid extends ViewPagerAndroidBase {}
                                                                                                                                                                                                                                                      • ViewPagerAndroid has been removed from React Native. It can now be installed and imported from @react-native-community/viewpager instead of 'react-native'.

                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                        • https://github.com/react-native-community/react-native-viewpager

                                                                                                                                                                                                                                                        Deprecated

                                                                                                                                                                                                                                                      method setPage

                                                                                                                                                                                                                                                      setPage: (selectedPage: number) => void;
                                                                                                                                                                                                                                                      • A helper function to scroll to a specific page in the ViewPager. The transition between pages will be animated.

                                                                                                                                                                                                                                                      method setPageWithoutAnimation

                                                                                                                                                                                                                                                      setPageWithoutAnimation: (selectedPage: number) => void;
                                                                                                                                                                                                                                                      • A helper function to scroll to a specific page in the ViewPager. The transition between pages will *not* be animated.

                                                                                                                                                                                                                                                      class ViewPagerAndroidComponent

                                                                                                                                                                                                                                                      class ViewPagerAndroidComponent extends React.Component<ViewPagerAndroidProps> {}

                                                                                                                                                                                                                                                        class VirtualizedList

                                                                                                                                                                                                                                                        class VirtualizedList<ItemT> extends React.Component<VirtualizedListProps<ItemT>> {}
                                                                                                                                                                                                                                                        • See Also

                                                                                                                                                                                                                                                          • https://reactnative.dev/docs/virtualizedlist

                                                                                                                                                                                                                                                        property recordInteraction

                                                                                                                                                                                                                                                        recordInteraction: () => void;

                                                                                                                                                                                                                                                          property scrollToEnd

                                                                                                                                                                                                                                                          scrollToEnd: (params?: { animated?: boolean | undefined }) => void;

                                                                                                                                                                                                                                                            property scrollToIndex

                                                                                                                                                                                                                                                            scrollToIndex: (params: {
                                                                                                                                                                                                                                                            animated?: boolean | undefined;
                                                                                                                                                                                                                                                            index: number;
                                                                                                                                                                                                                                                            viewOffset?: number | undefined;
                                                                                                                                                                                                                                                            viewPosition?: number | undefined;
                                                                                                                                                                                                                                                            }) => void;

                                                                                                                                                                                                                                                              property scrollToItem

                                                                                                                                                                                                                                                              scrollToItem: (params: {
                                                                                                                                                                                                                                                              animated?: boolean | undefined;
                                                                                                                                                                                                                                                              item: ItemT;
                                                                                                                                                                                                                                                              viewPosition?: number | undefined;
                                                                                                                                                                                                                                                              }) => void;

                                                                                                                                                                                                                                                                property scrollToOffset

                                                                                                                                                                                                                                                                scrollToOffset: (params: {
                                                                                                                                                                                                                                                                animated?: boolean | undefined;
                                                                                                                                                                                                                                                                offset: number;
                                                                                                                                                                                                                                                                }) => void;
                                                                                                                                                                                                                                                                • Scroll to a specific content pixel offset in the list. Param offset expects the offset to scroll to. In case of horizontal is true, the offset is the x-value, in any other case the offset is the y-value. Param animated (true by default) defines whether the list should do an animation while scrolling.

                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                interface AccessibilityInfoStatic

                                                                                                                                                                                                                                                                interface AccessibilityInfoStatic {}
                                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                                  • https://reactnative.dev/docs/accessibilityinfo

                                                                                                                                                                                                                                                                property announceForAccessibility

                                                                                                                                                                                                                                                                announceForAccessibility: (announcement: string) => void;
                                                                                                                                                                                                                                                                • Post a string to be announced by the screen reader.

                                                                                                                                                                                                                                                                property isBoldTextEnabled

                                                                                                                                                                                                                                                                isBoldTextEnabled: () => Promise<boolean>;
                                                                                                                                                                                                                                                                • Query whether bold text is currently enabled.

                                                                                                                                                                                                                                                                  ios

                                                                                                                                                                                                                                                                property isGrayscaleEnabled

                                                                                                                                                                                                                                                                isGrayscaleEnabled: () => Promise<boolean>;
                                                                                                                                                                                                                                                                • Query whether grayscale is currently enabled.

                                                                                                                                                                                                                                                                  ios

                                                                                                                                                                                                                                                                property isInvertColorsEnabled

                                                                                                                                                                                                                                                                isInvertColorsEnabled: () => Promise<boolean>;
                                                                                                                                                                                                                                                                • Query whether invert colors is currently enabled.

                                                                                                                                                                                                                                                                  ios

                                                                                                                                                                                                                                                                property isReduceMotionEnabled

                                                                                                                                                                                                                                                                isReduceMotionEnabled: () => Promise<boolean>;
                                                                                                                                                                                                                                                                • Query whether reduce motion is currently enabled.

                                                                                                                                                                                                                                                                property isReduceTransparencyEnabled

                                                                                                                                                                                                                                                                isReduceTransparencyEnabled: () => Promise<boolean>;
                                                                                                                                                                                                                                                                • Query whether reduce transparency is currently enabled.

                                                                                                                                                                                                                                                                  ios

                                                                                                                                                                                                                                                                property isScreenReaderEnabled

                                                                                                                                                                                                                                                                isScreenReaderEnabled: () => Promise<boolean>;
                                                                                                                                                                                                                                                                • Query whether a screen reader is currently enabled.

                                                                                                                                                                                                                                                                property setAccessibilityFocus

                                                                                                                                                                                                                                                                setAccessibilityFocus: (reactTag: number) => void;
                                                                                                                                                                                                                                                                • Set accessibility focus to a react component.

                                                                                                                                                                                                                                                                method addEventListener

                                                                                                                                                                                                                                                                addEventListener: {
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                eventName: AccessibilityChangeEventName,
                                                                                                                                                                                                                                                                handler: AccessibilityChangeEventHandler
                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                eventName: 'announcementFinished',
                                                                                                                                                                                                                                                                handler: AccessibilityAnnouncementFinishedEventHandler
                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                • Add an event handler. Supported events: - announcementFinished: iOS-only event. Fires when the screen reader has finished making an announcement. The argument to the event handler is a dictionary with these keys: - announcement: The string announced by the screen reader. - success: A boolean indicating whether the announcement was successfully made. - AccessibilityEventName constants other than announcementFinished: Fires on accessibility feature change. The argument to the event handler is a boolean. The boolean is true when the related event's feature is enabled and false otherwise.

                                                                                                                                                                                                                                                                method removeEventListener

                                                                                                                                                                                                                                                                removeEventListener: {
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                eventName: AccessibilityChangeEventName,
                                                                                                                                                                                                                                                                handler: AccessibilityChangeEventHandler
                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                eventName: 'announcementFinished',
                                                                                                                                                                                                                                                                handler: AccessibilityAnnouncementFinishedEventHandler
                                                                                                                                                                                                                                                                ): void;
                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                • Remove an event handler.

                                                                                                                                                                                                                                                                interface AccessibilityProps

                                                                                                                                                                                                                                                                interface AccessibilityProps
                                                                                                                                                                                                                                                                extends AccessibilityPropsAndroid,
                                                                                                                                                                                                                                                                AccessibilityPropsIOS {}
                                                                                                                                                                                                                                                                • See Also

                                                                                                                                                                                                                                                                  • https://reactnative.dev/docs/accessibility#accessibility-properties

                                                                                                                                                                                                                                                                property accessibilityActions

                                                                                                                                                                                                                                                                accessibilityActions?: ReadonlyArray<AccessibilityActionInfo> | undefined;
                                                                                                                                                                                                                                                                • Provides an array of custom actions available for accessibility.

                                                                                                                                                                                                                                                                property accessibilityHint

                                                                                                                                                                                                                                                                accessibilityHint?: string | undefined;
                                                                                                                                                                                                                                                                • An accessibility hint helps users understand what will happen when they perform an action on the accessibility element when that result is not obvious from the accessibility label.

                                                                                                                                                                                                                                                                property accessibilityLabel

                                                                                                                                                                                                                                                                accessibilityLabel?: string | undefined;
                                                                                                                                                                                                                                                                • Overrides the text that's read by the screen reader when the user interacts with the element. By default, the label is constructed by traversing all the children and accumulating all the Text nodes separated by space.

                                                                                                                                                                                                                                                                property accessibilityRole

                                                                                                                                                                                                                                                                accessibilityRole?: AccessibilityRole | undefined;
                                                                                                                                                                                                                                                                • Accessibility Role tells a person using either VoiceOver on iOS or TalkBack on Android the type of element that is focused on.

                                                                                                                                                                                                                                                                property accessibilityState

                                                                                                                                                                                                                                                                accessibilityState?: AccessibilityState | undefined;
                                                                                                                                                                                                                                                                • Accessibility State tells a person using either VoiceOver on iOS or TalkBack on Android the state of the element currently focused on.

                                                                                                                                                                                                                                                                property accessibilityValue

                                                                                                                                                                                                                                                                accessibilityValue?: AccessibilityValue | undefined;
                                                                                                                                                                                                                                                                • Represents the current value of a component. It can be a textual description of a component's value, or for range-based components, such as sliders and progress bars, it contains range information (minimum, current, and maximum).

                                                                                                                                                                                                                                                                property accessible

                                                                                                                                                                                                                                                                accessible?: boolean | undefined;
                                                                                                                                                                                                                                                                • When true, indicates that the view is an accessibility element. By default, all the touchable elements are accessible.

                                                                                                                                                                                                                                                                property onAccessibilityAction

                                                                                                                                                                                                                                                                onAccessibilityAction?: ((event: AccessibilityActionEvent) => void) | undefined;
                                                                                                                                                                                                                                                                • When accessible is true, the system will try to invoke this function when the user performs an accessibility custom action.

                                                                                                                                                                                                                                                                interface AccessibilityPropsAndroid

                                                                                                                                                                                                                                                                interface AccessibilityPropsAndroid {}

                                                                                                                                                                                                                                                                  property accessibilityLiveRegion

                                                                                                                                                                                                                                                                  accessibilityLiveRegion?: 'none' | 'polite' | 'assertive' | undefined;
                                                                                                                                                                                                                                                                  • Indicates to accessibility services whether the user should be notified when this view changes. Works for Android API >= 19 only. See http://developer.android.com/reference/android/view/View.html#attr_android:accessibilityLiveRegion for references. android

                                                                                                                                                                                                                                                                  property importantForAccessibility

                                                                                                                                                                                                                                                                  importantForAccessibility?:
                                                                                                                                                                                                                                                                  | 'auto'
                                                                                                                                                                                                                                                                  | 'yes'
                                                                                                                                                                                                                                                                  | 'no'
                                                                                                                                                                                                                                                                  | 'no-hide-descendants'
                                                                                                                                                                                                                                                                  | undefined;
                                                                                                                                                                                                                                                                  • Controls how view is important for accessibility which is if it fires accessibility events and if it is reported to accessibility services that query the screen. Works for Android only. See http://developer.android.com/reference/android/R.attr.html#importantForAccessibility for references.

                                                                                                                                                                                                                                                                    Possible values: 'auto' - The system determines whether the view is important for accessibility - default (recommended). 'yes' - The view is important for accessibility. 'no' - The view is not important for accessibility. 'no-hide-descendants' - The view is not important for accessibility, nor are any of its descendant views.

                                                                                                                                                                                                                                                                  interface AccessibilityPropsIOS

                                                                                                                                                                                                                                                                  interface AccessibilityPropsIOS {}

                                                                                                                                                                                                                                                                    property accessibilityElementsHidden

                                                                                                                                                                                                                                                                    accessibilityElementsHidden?: boolean | undefined;
                                                                                                                                                                                                                                                                    • A Boolean value indicating whether the accessibility elements contained within this accessibility element are hidden to the screen reader. ios

                                                                                                                                                                                                                                                                    property accessibilityIgnoresInvertColors

                                                                                                                                                                                                                                                                    accessibilityIgnoresInvertColors?: boolean | undefined;
                                                                                                                                                                                                                                                                    • https://reactnative.dev/docs/accessibility#accessibilityignoresinvertcolorsios ios

                                                                                                                                                                                                                                                                    property accessibilityViewIsModal

                                                                                                                                                                                                                                                                    accessibilityViewIsModal?: boolean | undefined;
                                                                                                                                                                                                                                                                    • A Boolean value indicating whether VoiceOver should ignore the elements within views that are siblings of the receiver. ios

                                                                                                                                                                                                                                                                    property onAccessibilityEscape

                                                                                                                                                                                                                                                                    onAccessibilityEscape?: (() => void) | undefined;
                                                                                                                                                                                                                                                                    • When accessibile is true, the system will invoke this function when the user performs the escape gesture (scrub with two fingers). ios

                                                                                                                                                                                                                                                                    property onAccessibilityTap

                                                                                                                                                                                                                                                                    onAccessibilityTap?: (() => void) | undefined;
                                                                                                                                                                                                                                                                    • When accessible is true, the system will try to invoke this function when the user performs accessibility tap gesture. ios

                                                                                                                                                                                                                                                                    property onMagicTap

                                                                                                                                                                                                                                                                    onMagicTap?: (() => void) | undefined;
                                                                                                                                                                                                                                                                    • When accessible is true, the system will invoke this function when the user performs the magic tap gesture. ios

                                                                                                                                                                                                                                                                    interface AccessibilityState

                                                                                                                                                                                                                                                                    interface AccessibilityState {}

                                                                                                                                                                                                                                                                      property busy

                                                                                                                                                                                                                                                                      busy?: boolean | undefined;
                                                                                                                                                                                                                                                                      • When present, informs accessible tools if the element is busy

                                                                                                                                                                                                                                                                      property checked

                                                                                                                                                                                                                                                                      checked?: boolean | 'mixed' | undefined;
                                                                                                                                                                                                                                                                      • For items like Checkboxes and Toggle switches, reports their state to accessible tools

                                                                                                                                                                                                                                                                      property disabled

                                                                                                                                                                                                                                                                      disabled?: boolean | undefined;
                                                                                                                                                                                                                                                                      • When true, informs accessible tools if the element is disabled

                                                                                                                                                                                                                                                                      property expanded

                                                                                                                                                                                                                                                                      expanded?: boolean | undefined;
                                                                                                                                                                                                                                                                      • When present, informs accessible tools the element is expanded or collapsed

                                                                                                                                                                                                                                                                      property selected

                                                                                                                                                                                                                                                                      selected?: boolean | undefined;
                                                                                                                                                                                                                                                                      • When true, informs accessible tools if the element is selected

                                                                                                                                                                                                                                                                      interface AccessibilityValue

                                                                                                                                                                                                                                                                      interface AccessibilityValue {}

                                                                                                                                                                                                                                                                        property max

                                                                                                                                                                                                                                                                        max?: number | undefined;
                                                                                                                                                                                                                                                                        • The maximum value of this component's range. (should be an integer)

                                                                                                                                                                                                                                                                        property min

                                                                                                                                                                                                                                                                        min?: number | undefined;
                                                                                                                                                                                                                                                                        • The minimum value of this component's range. (should be an integer)

                                                                                                                                                                                                                                                                        property now

                                                                                                                                                                                                                                                                        now?: number | undefined;
                                                                                                                                                                                                                                                                        • The current value of this component's range. (should be an integer)

                                                                                                                                                                                                                                                                        property text

                                                                                                                                                                                                                                                                        text?: string | undefined;
                                                                                                                                                                                                                                                                        • A textual description of this component's value. (will override minimum, current, and maximum if set)

                                                                                                                                                                                                                                                                        interface ActionSheetIOSOptions

                                                                                                                                                                                                                                                                        interface ActionSheetIOSOptions {}
                                                                                                                                                                                                                                                                        • @see: https://reactnative.dev/docs/actionsheetios#content

                                                                                                                                                                                                                                                                        property anchor

                                                                                                                                                                                                                                                                        anchor?: number | undefined;

                                                                                                                                                                                                                                                                          property cancelButtonIndex

                                                                                                                                                                                                                                                                          cancelButtonIndex?: number | undefined;

                                                                                                                                                                                                                                                                            property destructiveButtonIndex

                                                                                                                                                                                                                                                                            destructiveButtonIndex?: number | undefined;

                                                                                                                                                                                                                                                                              property disabledButtonIndices

                                                                                                                                                                                                                                                                              disabledButtonIndices?: number[] | undefined;

                                                                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                                                                message?: string | undefined;

                                                                                                                                                                                                                                                                                  property options

                                                                                                                                                                                                                                                                                  options: string[];

                                                                                                                                                                                                                                                                                    property tintColor

                                                                                                                                                                                                                                                                                    tintColor?: ColorValue | ProcessedColorValue | undefined;

                                                                                                                                                                                                                                                                                      property title

                                                                                                                                                                                                                                                                                      title?: string | undefined;

                                                                                                                                                                                                                                                                                        property userInterfaceStyle

                                                                                                                                                                                                                                                                                        userInterfaceStyle?: string | undefined;

                                                                                                                                                                                                                                                                                          interface ActionSheetIOSStatic

                                                                                                                                                                                                                                                                                          interface ActionSheetIOSStatic {}
                                                                                                                                                                                                                                                                                          • See Also

                                                                                                                                                                                                                                                                                            • https://reactnative.dev/docs/actionsheetios#content

                                                                                                                                                                                                                                                                                          property showActionSheetWithOptions

                                                                                                                                                                                                                                                                                          showActionSheetWithOptions: (
                                                                                                                                                                                                                                                                                          options: ActionSheetIOSOptions,
                                                                                                                                                                                                                                                                                          callback: (buttonIndex: number) => void
                                                                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                                                                          • Display an iOS action sheet. The options object must contain one or more of: - options (array of strings) - a list of button titles (required) - cancelButtonIndex (int) - index of cancel button in options - destructiveButtonIndex (int) - index of destructive button in options - title (string) - a title to show above the action sheet - message (string) - a message to show below the title

                                                                                                                                                                                                                                                                                          property showShareActionSheetWithOptions

                                                                                                                                                                                                                                                                                          showShareActionSheetWithOptions: (
                                                                                                                                                                                                                                                                                          options: ShareActionSheetIOSOptions,
                                                                                                                                                                                                                                                                                          failureCallback: (error: Error) => void,
                                                                                                                                                                                                                                                                                          successCallback: (success: boolean, method: string) => void
                                                                                                                                                                                                                                                                                          ) => void;
                                                                                                                                                                                                                                                                                          • Display the iOS share sheet. The options object should contain one or both of message and url and can additionally have a subject or excludedActivityTypes:

                                                                                                                                                                                                                                                                                            - url (string) - a URL to share - message (string) - a message to share - subject (string) - a subject for the message - excludedActivityTypes (array) - the activities to exclude from the ActionSheet

                                                                                                                                                                                                                                                                                            NOTE: if url points to a local file, or is a base64-encoded uri, the file it points to will be loaded and shared directly. In this way, you can share images, videos, PDF files, etc.

                                                                                                                                                                                                                                                                                          interface ActivityIndicatorIOSProps

                                                                                                                                                                                                                                                                                          interface ActivityIndicatorIOSProps extends ViewProps {}
                                                                                                                                                                                                                                                                                          • See Also

                                                                                                                                                                                                                                                                                            • https://reactnative.dev/docs/activityindicatorios#props

                                                                                                                                                                                                                                                                                          property animating

                                                                                                                                                                                                                                                                                          animating?: boolean | undefined;
                                                                                                                                                                                                                                                                                          • Whether to show the indicator (true, the default) or hide it (false).

                                                                                                                                                                                                                                                                                          property color

                                                                                                                                                                                                                                                                                          color?: ColorValue | undefined;
                                                                                                                                                                                                                                                                                          • The foreground color of the spinner (default is gray).

                                                                                                                                                                                                                                                                                          property hidesWhenStopped

                                                                                                                                                                                                                                                                                          hidesWhenStopped?: boolean | undefined;
                                                                                                                                                                                                                                                                                          • Whether the indicator should hide when not animating (true by default).

                                                                                                                                                                                                                                                                                          property onLayout

                                                                                                                                                                                                                                                                                          onLayout?: ((event: LayoutChangeEvent) => void) | undefined;
                                                                                                                                                                                                                                                                                          • Invoked on mount and layout changes with

                                                                                                                                                                                                                                                                                          property size

                                                                                                                                                                                                                                                                                          size?: 'small' | 'large' | undefined;
                                                                                                                                                                                                                                                                                          • Size of the indicator. Small has a height of 20, large has a height of 36.

                                                                                                                                                                                                                                                                                            enum('small', 'large')

                                                                                                                                                                                                                                                                                          property style

                                                                                                                                                                                                                                                                                          style?: StyleProp<ViewStyle> | undefined;

                                                                                                                                                                                                                                                                                            interface ActivityIndicatorProps

                                                                                                                                                                                                                                                                                            interface ActivityIndicatorProps extends ViewProps {}
                                                                                                                                                                                                                                                                                            • See Also

                                                                                                                                                                                                                                                                                              • https://reactnative.dev/docs/activityindicator#props

                                                                                                                                                                                                                                                                                            property animating

                                                                                                                                                                                                                                                                                            animating?: boolean | undefined;
                                                                                                                                                                                                                                                                                            • Whether to show the indicator (true, the default) or hide it (false).

                                                                                                                                                                                                                                                                                            property color

                                                                                                                                                                                                                                                                                            color?: ColorValue | undefined;
                                                                                                                                                                                                                                                                                            • The foreground color of the spinner (default is gray).

                                                                                                                                                                                                                                                                                            property hidesWhenStopped

                                                                                                                                                                                                                                                                                            hidesWhenStopped?: boolean | undefined;
                                                                                                                                                                                                                                                                                            • Whether the indicator should hide when not animating (true by default).

                                                                                                                                                                                                                                                                                            property size

                                                                                                                                                                                                                                                                                            size?: number | 'small' | 'large' | undefined;
                                                                                                                                                                                                                                                                                            • Size of the indicator. Small has a height of 20, large has a height of 36.

                                                                                                                                                                                                                                                                                              enum('small', 'large')

                                                                                                                                                                                                                                                                                            property style

                                                                                                                                                                                                                                                                                            style?: StyleProp<ViewStyle> | undefined;

                                                                                                                                                                                                                                                                                              interface AlertButton

                                                                                                                                                                                                                                                                                              interface AlertButton {}
                                                                                                                                                                                                                                                                                              • See Also

                                                                                                                                                                                                                                                                                                • https://reactnative.dev/docs/alert#content

                                                                                                                                                                                                                                                                                              property onPress

                                                                                                                                                                                                                                                                                              onPress?: ((value?: string) => void) | undefined;

                                                                                                                                                                                                                                                                                                property style

                                                                                                                                                                                                                                                                                                style?: 'default' | 'cancel' | 'destructive' | undefined;

                                                                                                                                                                                                                                                                                                  property text

                                                                                                                                                                                                                                                                                                  text?: string | undefined;

                                                                                                                                                                                                                                                                                                    interface AlertOptions

                                                                                                                                                                                                                                                                                                    interface AlertOptions {}

                                                                                                                                                                                                                                                                                                      property cancelable

                                                                                                                                                                                                                                                                                                      cancelable?: boolean | undefined;
                                                                                                                                                                                                                                                                                                      • android

                                                                                                                                                                                                                                                                                                      property onDismiss

                                                                                                                                                                                                                                                                                                      onDismiss?: (() => void) | undefined;
                                                                                                                                                                                                                                                                                                      • android

                                                                                                                                                                                                                                                                                                      interface AlertStatic

                                                                                                                                                                                                                                                                                                      interface AlertStatic {}
                                                                                                                                                                                                                                                                                                      • Launches an alert dialog with the specified title and message.

                                                                                                                                                                                                                                                                                                        Optionally provide a list of buttons. Tapping any button will fire the respective onPress callback and dismiss the alert. By default, the only button will be an 'OK' button.

                                                                                                                                                                                                                                                                                                        This is an API that works both on iOS and Android and can show static alerts. To show an alert that prompts the user to enter some information, see AlertIOS; entering text in an alert is common on iOS only.

                                                                                                                                                                                                                                                                                                        ## iOS

                                                                                                                                                                                                                                                                                                        On iOS you can specify any number of buttons. Each button can optionally specify a style, which is one of 'default', 'cancel' or 'destructive'.

                                                                                                                                                                                                                                                                                                        ## Android

                                                                                                                                                                                                                                                                                                        On Android at most three buttons can be specified. Android has a concept of a neutral, negative and a positive button:

                                                                                                                                                                                                                                                                                                        - If you specify one button, it will be the 'positive' one (such as 'OK') - Two buttons mean 'negative', 'positive' (such as 'Cancel', 'OK') - Three buttons mean 'neutral', 'negative', 'positive' (such as 'Later', 'Cancel', 'OK')

                                                                                                                                                                                                                                                                                                        // Works on both iOS and Android
                                                                                                                                                                                                                                                                                                        Alert.alert(
                                                                                                                                                                                                                                                                                                        'Alert Title',
                                                                                                                                                                                                                                                                                                        'My Alert Msg',
                                                                                                                                                                                                                                                                                                        [
                                                                                                                                                                                                                                                                                                        {text: 'Ask me later', onPress: () => console.log('Ask me later pressed')},
                                                                                                                                                                                                                                                                                                        {text: 'Cancel', onPress: () => console.log('Cancel Pressed'), style: 'cancel'},
                                                                                                                                                                                                                                                                                                        {text: 'OK', onPress: () => console.log('OK Pressed')},
                                                                                                                                                                                                                                                                                                        ]
                                                                                                                                                                                                                                                                                                        )

                                                                                                                                                                                                                                                                                                      property alert

                                                                                                                                                                                                                                                                                                      alert: (
                                                                                                                                                                                                                                                                                                      title: string,
                                                                                                                                                                                                                                                                                                      message?: string,
                                                                                                                                                                                                                                                                                                      buttons?: AlertButton[],
                                                                                                                                                                                                                                                                                                      options?: AlertOptions
                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                        property prompt

                                                                                                                                                                                                                                                                                                        prompt: (
                                                                                                                                                                                                                                                                                                        title: string,
                                                                                                                                                                                                                                                                                                        message?: string,
                                                                                                                                                                                                                                                                                                        callbackOrButtons?: ((text: string) => void) | AlertButton[],
                                                                                                                                                                                                                                                                                                        type?: AlertType,
                                                                                                                                                                                                                                                                                                        defaultValue?: string,
                                                                                                                                                                                                                                                                                                        keyboardType?: string
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          interface AppStateStatic

                                                                                                                                                                                                                                                                                                          interface AppStateStatic {}

                                                                                                                                                                                                                                                                                                            property currentState

                                                                                                                                                                                                                                                                                                            currentState: AppStateStatus;

                                                                                                                                                                                                                                                                                                              property isAvailable

                                                                                                                                                                                                                                                                                                              isAvailable: boolean;

                                                                                                                                                                                                                                                                                                                method addEventListener

                                                                                                                                                                                                                                                                                                                addEventListener: (
                                                                                                                                                                                                                                                                                                                type: AppStateEvent,
                                                                                                                                                                                                                                                                                                                listener: (state: AppStateStatus) => void
                                                                                                                                                                                                                                                                                                                ) => NativeEventSubscription;
                                                                                                                                                                                                                                                                                                                • Add a handler to AppState changes by listening to the change event type and providing the handler

                                                                                                                                                                                                                                                                                                                method removeEventListener

                                                                                                                                                                                                                                                                                                                removeEventListener: (
                                                                                                                                                                                                                                                                                                                type: AppStateEvent,
                                                                                                                                                                                                                                                                                                                listener: (state: AppStateStatus) => void
                                                                                                                                                                                                                                                                                                                ) => void;
                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                  Use the remove() method on the event subscription returned by addEventListener().

                                                                                                                                                                                                                                                                                                                  Remove a handler by passing the change event type and the handler

                                                                                                                                                                                                                                                                                                                interface AsyncStorageStatic

                                                                                                                                                                                                                                                                                                                interface AsyncStorageStatic {}
                                                                                                                                                                                                                                                                                                                • AsyncStorage is a simple, unencrypted, asynchronous, persistent, key-value storage system that is global to the app. It should be used instead of LocalStorage.

                                                                                                                                                                                                                                                                                                                  It is recommended that you use an abstraction on top of AsyncStorage instead of AsyncStorage directly for anything more than light usage since it operates globally.

                                                                                                                                                                                                                                                                                                                  On iOS, AsyncStorage is backed by native code that stores small values in a serialized dictionary and larger values in separate files. On Android, AsyncStorage will use either [RocksDB](http://rocksdb.org/) or SQLite based on what is available.

                                                                                                                                                                                                                                                                                                                  See Also

                                                                                                                                                                                                                                                                                                                  • https://reactnative.dev/docs/asyncstorage#content

                                                                                                                                                                                                                                                                                                                method clear