@types/react-native

  • Version 0.64.13
  • Published
  • 386 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 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 fetch

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

                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                use isScreenReaderChanged instead

                                                                                                                                                                                                                                                              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;

                                                                                                                                                                                                                                                                                                            method addEventListener

                                                                                                                                                                                                                                                                                                            addEventListener: (
                                                                                                                                                                                                                                                                                                            type: AppStateEvent,
                                                                                                                                                                                                                                                                                                            listener: (state: AppStateStatus) => void
                                                                                                                                                                                                                                                                                                            ) => void;
                                                                                                                                                                                                                                                                                                            • 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;
                                                                                                                                                                                                                                                                                                            • 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

                                                                                                                                                                                                                                                                                                            clear: (callback?: (error?: Error) => void) => Promise<void>;
                                                                                                                                                                                                                                                                                                            • Erases all AsyncStorage for all clients, libraries, etc. You probably don't want to call this. Use removeItem or multiRemove to clear only your own keys instead.

                                                                                                                                                                                                                                                                                                            method getAllKeys

                                                                                                                                                                                                                                                                                                            getAllKeys: (
                                                                                                                                                                                                                                                                                                            callback?: (error?: Error, keys?: string[]) => void
                                                                                                                                                                                                                                                                                                            )