react-navigation

  • Version 4.4.4
  • Published
  • 53.8 kB
  • 2 dependencies
  • MIT license

Install

npm i react-navigation
yarn add react-navigation
pnpm add react-navigation

Overview

Routing and navigation for your React Native apps

Index

Variables

Functions

Interfaces

Type Aliases

Namespaces

Variables

const NavigationContext: any;
    const NavigationEvents: any;
      const NavigationProvider: any;

        variable SafeAreaView

        const SafeAreaView: any;

          variable SceneView

          const SceneView: any;

            variable ThemeColors

            const ThemeColors: { light: Theme; dark: Theme };

              variable ThemeContext

              const ThemeContext: any;

                Functions

                function createAppContainer

                createAppContainer: <Options, NavigationPropType>(
                Component: NavigationNavigator<Options, NavigationPropType>
                ) => NavigationContainer;
                • Create an app container to wrap the root navigator

                  See Also

                  • https://github.com/react-navigation/react-navigation-native/blob/098e2e52b349d37357109d5aee545fa74699d3d4/src/createAppContainer.js#L64

                function createKeyboardAwareNavigator

                createKeyboardAwareNavigator: <Props>(Comp: any, stackConfig: object) => any;

                  function createNavigationContainer

                  createNavigationContainer: <Options, NavigationPropType>(
                  Component: NavigationNavigator<Options, NavigationPropType>
                  ) => NavigationContainer;
                  • Create an HOC that injects the navigation and manages the navigation state in case it's not passed from above. This allows to use e.g. the StackNavigator and TabNavigator as root-level components.

                    See Also

                    • https://github.com/react-navigation/react-navigation/blob/master/src/createNavigationContainer.js

                  function createNavigator

                  createNavigator: <S, Options>(
                  view: NavigationView<Options, S>,
                  router: NavigationRouter<S, Options>,
                  navigatorConfig?: {},
                  navigatorType?: NavigatorType
                  ) => NavigationNavigator<Options, NavigationProp<NavigationState>>;

                    function createSwitchNavigator

                    createSwitchNavigator: (
                    routeConfigMap: NavigationRouteConfigMap<{}, NavigationSwitchProp>,
                    switchConfig?: CreateNavigatorConfig<
                    {},
                    NavigationSwitchRouterConfig,
                    {},
                    NavigationSwitchProp
                    >
                    ) => NavigationNavigator<{}, NavigationProp<NavigationState>>;

                      function getActiveChildNavigationOptions

                      getActiveChildNavigationOptions: <S>(
                      navigation: NavigationProp<S>,
                      screenProps?: unknown,
                      theme?: SupportedThemes
                      ) => NavigationParams;

                        function StackRouter

                        StackRouter: (
                        routeConfigs: NavigationRouteConfigMap<any, any>,
                        config?: NavigationTabRouterConfig
                        ) => NavigationRouter<any, any>;
                        • Stack Router

                          from react-navigation/src/routers/StackRouter.js

                        function SwitchRouter

                        SwitchRouter: (
                        routeConfigs: NavigationRouteConfigMap<any, any>,
                        config?: NavigationSwitchRouterConfig
                        ) => NavigationRouter<any, any>;

                          function TabRouter

                          TabRouter: (
                          routeConfigs: NavigationRouteConfigMap<any, any>,
                          config: NavigationTabRouterConfig
                          ) => NavigationRouter<any, any>;
                          • Tab Router

                            from react-navigation/src/routers/TabRouter.js

                          function useTheme

                          useTheme: () => SupportedThemes;

                            function withNavigation

                            withNavigation: {
                            <P extends NavigationInjectedProps<NavigationParams>, T extends any>(
                            Component: T & React.ComponentClass<P>
                            ): any;
                            <P extends NavigationInjectedProps<NavigationParams>>(Component: any): any;
                            <T = {}, P = NavigationParams>(Component: any): any;
                            };

                              function withNavigationFocus

                              withNavigationFocus: {
                              <P extends NavigationFocusInjectedProps<NavigationParams>, T extends any>(
                              Component: T & React.ComponentClass<P>
                              ): any;
                              <P extends NavigationFocusInjectedProps<NavigationParams>>(Component: any): any;
                              <T = {}, P = NavigationParams>(Component: any): any;
                              };

                                function withOrientation

                                withOrientation: <P extends NavigationOrientationInjectedProps>(
                                Component: any
                                ) => any;

                                  Interfaces

                                  interface DrawerNavigationState

                                  interface DrawerNavigationState extends NavigationState {}

                                    property isDrawerOpen

                                    isDrawerOpen: boolean;

                                      property isTransitioning

                                      isTransitioning: boolean;
                                        interface NavigationBackAction extends NavigationBackActionPayload {}
                                          type: 'Navigation/BACK';
                                            interface NavigationBackActionPayload {}
                                              immediate?: boolean;
                                                key?: string | null;
                                                  interface NavigationCloseDrawerAction {}
                                                    key?: string;
                                                      type: 'Navigation/CLOSE_DRAWER';
                                                        interface NavigationCompleteTransitionAction {}
                                                          key: string;
                                                            type: 'Navigation/COMPLETE_TRANSITION';
                                                              interface NavigationCompleteTransitionActionPayload {}
                                                                key?: string;
                                                                  toChildKey?: string;
                                                                    interface NavigationContainer
                                                                    extends React.ComponentClass<
                                                                    NavigationContainerProps & NavigationNavigatorProps<any>
                                                                    > {}
                                                                      navigationOptions: any;
                                                                        router: NavigationRouter<any, any>;
                                                                          screenProps: unknown;
                                                                            state: { nav: NavigationState | null };
                                                                              new (
                                                                              props: NavigationContainerProps & NavigationNavigatorProps<any>,
                                                                              context?: any
                                                                              ): NavigationContainerComponent;
                                                                                interface NavigationContainerComponent
                                                                                extends React.Component<
                                                                                NavigationContainerProps & NavigationNavigatorProps<any>
                                                                                > {}
                                                                                  dispatch: NavigationDispatch;
                                                                                    interface NavigationContainerProps<
                                                                                    State = {},
                                                                                    Options = {},
                                                                                    ScreenProps = unknown
                                                                                    > {}
                                                                                      enableURLHandling?: boolean;
                                                                                      • Controls whether the navigation container handles URLs opened via 'Linking'

                                                                                        See Also

                                                                                        • https://facebook.github.io/react-native/docs/linking

                                                                                        • https://reactnavigation.org/docs/en/deep-linking.html

                                                                                      loadNavigationState?: () => Promise<any>;
                                                                                        navigation?: NavigationScreenProp<State>;
                                                                                          navigationOptions?: Options;
                                                                                            onNavigationStateChange?: (
                                                                                            prevNavigationState: NavigationState,
                                                                                            nextNavigationState: NavigationState,
                                                                                            action: NavigationAction
                                                                                            ) => void | null | undefined;
                                                                                              persistenceKey?: string | null;
                                                                                                persistNavigationState?: (state: NavigationState) => Promise<any>;
                                                                                                  renderLoadingExperimental?: React.ComponentType;
                                                                                                    screenProps?: ScreenProps;
                                                                                                      style?: StyleProp<ViewStyle>;
                                                                                                        uriPrefix?: string | RegExp;
                                                                                                          interface NavigationDescriptor<
                                                                                                          Params = NavigationParams,
                                                                                                          Options = {},
                                                                                                          NavigationScreenPropType = NavigationScreenProp<NavigationRoute>
                                                                                                          > {}
                                                                                                          • Create Navigator

                                                                                                            See Also

                                                                                                            • https://github.com/react-navigation/react-navigation/blob/master/src/navigators/createNavigator.js

                                                                                                          getComponent: () => React.ComponentType;
                                                                                                            key: string;
                                                                                                              navigation: NavigationScreenPropType;
                                                                                                                options: Options;
                                                                                                                  state: NavigationLeafRoute<Params> | NavigationStateRoute<Params>;
                                                                                                                    interface NavigationDrawerClosedAction {}
                                                                                                                      key?: string;
                                                                                                                        type: 'Navigation/DRAWER_CLOSED';
                                                                                                                          interface NavigationDrawerOpenedAction {}
                                                                                                                            key?: string;
                                                                                                                              type: 'Navigation/DRAWER_OPENED';
                                                                                                                                interface NavigationEventPayload {}
                                                                                                                                  action: NavigationAction;
                                                                                                                                    lastState: NavigationState | null | undefined;
                                                                                                                                      state: NavigationState;
                                                                                                                                        type: EventType;
                                                                                                                                          interface NavigationEventsProps extends ViewProps {}
                                                                                                                                            onDidBlur?: NavigationEventCallback;
                                                                                                                                              onDidFocus?: NavigationEventCallback;
                                                                                                                                                onWillBlur?: NavigationEventCallback;
                                                                                                                                                  onWillFocus?: NavigationEventCallback;
                                                                                                                                                    interface NavigationEventSubscription {}
                                                                                                                                                      remove: () => void;
                                                                                                                                                        interface NavigationFocusInjectedProps<P = NavigationParams>
                                                                                                                                                        extends NavigationInjectedProps<P> {}
                                                                                                                                                          isFocused: boolean;
                                                                                                                                                            interface NavigationInitAction extends NavigationInitActionPayload {}
                                                                                                                                                              key?: string;
                                                                                                                                                                type: 'Navigation/INIT';
                                                                                                                                                                  interface NavigationInitActionPayload {}
                                                                                                                                                                    params?: NavigationParams;
                                                                                                                                                                      interface NavigationInjectedProps<P = NavigationParams> {}
                                                                                                                                                                        navigation: NavigationScreenProp<NavigationRoute<P>, P>;
                                                                                                                                                                          interface NavigationJumpToAction {}
                                                                                                                                                                            key: string;
                                                                                                                                                                              preserveFocus?: boolean;
                                                                                                                                                                                routeName: string;
                                                                                                                                                                                  type: 'Navigation/JUMP_TO';
                                                                                                                                                                                    interface NavigationJumpToActionPayload {}
                                                                                                                                                                                      key?: string;
                                                                                                                                                                                        preserveFocus?: boolean;
                                                                                                                                                                                          routeName: string;
                                                                                                                                                                                            interface NavigationLeafRoute<Params = NavigationParams> {}
                                                                                                                                                                                              index: number;
                                                                                                                                                                                              • Index that represents the depth of the stack

                                                                                                                                                                                              isTransitioning: boolean;
                                                                                                                                                                                              • Flag that indicates the transition state of the route

                                                                                                                                                                                              key: string;
                                                                                                                                                                                              • React's key used by some navigators. No need to specify these manually, they will be defined by the router.

                                                                                                                                                                                              params?: Params;
                                                                                                                                                                                              • Params passed to this route when navigating to it, e.g. { car_id: 123 } in a route that displays a car.

                                                                                                                                                                                              path?: string;
                                                                                                                                                                                              • Path is an advanced feature used for deep linking and on the web.

                                                                                                                                                                                              routeName: string;
                                                                                                                                                                                              • For example 'Home'. This is used as a key in a route config when creating a navigator.

                                                                                                                                                                                              routes: NavigationRoute[];
                                                                                                                                                                                              • Array containing the navigator's routes

                                                                                                                                                                                              interface NavigationNavigateAction extends NavigationNavigateActionPayload {}
                                                                                                                                                                                                type: 'Navigation/NAVIGATE';
                                                                                                                                                                                                  interface NavigationNavigateActionPayload {}
                                                                                                                                                                                                    action?: NavigationNavigateAction;
                                                                                                                                                                                                      key?: string;
                                                                                                                                                                                                        params?: NavigationParams;
                                                                                                                                                                                                          routeName: string;
                                                                                                                                                                                                            interface NavigationNavigatorProps<
                                                                                                                                                                                                            Options = {},
                                                                                                                                                                                                            State = {},
                                                                                                                                                                                                            ScreenProps = unknown
                                                                                                                                                                                                            > {}
                                                                                                                                                                                                              detached?: boolean;
                                                                                                                                                                                                                navigation?: NavigationProp<State>;
                                                                                                                                                                                                                  navigationOptions?: Options;
                                                                                                                                                                                                                    screenProps?: ScreenProps;
                                                                                                                                                                                                                      theme?: SupportedThemes | 'no-preference';
                                                                                                                                                                                                                        interface NavigationOpenDrawerAction {}
                                                                                                                                                                                                                          key?: string;
                                                                                                                                                                                                                            type: 'Navigation/OPEN_DRAWER';
                                                                                                                                                                                                                              interface NavigationOrientationInjectedProps {}
                                                                                                                                                                                                                                isLandscape: boolean;
                                                                                                                                                                                                                                  interface NavigationParams {}
                                                                                                                                                                                                                                    [key: string]: any;
                                                                                                                                                                                                                                      interface NavigationPathsConfig {}
                                                                                                                                                                                                                                        [routeName: string]: string;
                                                                                                                                                                                                                                          interface NavigationPopAction extends NavigationPopActionPayload {}
                                                                                                                                                                                                                                            key?: string;
                                                                                                                                                                                                                                              type: 'Navigation/POP';
                                                                                                                                                                                                                                                interface NavigationPopActionPayload {}
                                                                                                                                                                                                                                                  immediate?: boolean;
                                                                                                                                                                                                                                                    key?: string;
                                                                                                                                                                                                                                                      n?: number;
                                                                                                                                                                                                                                                        prune?: boolean;
                                                                                                                                                                                                                                                          interface NavigationPopToTopAction extends NavigationPopToTopActionPayload {}
                                                                                                                                                                                                                                                            type: 'Navigation/POP_TO_TOP';
                                                                                                                                                                                                                                                              interface NavigationPopToTopActionPayload {}
                                                                                                                                                                                                                                                                immediate?: boolean;
                                                                                                                                                                                                                                                                  key?: string;
                                                                                                                                                                                                                                                                    interface NavigationProp<S> {}
                                                                                                                                                                                                                                                                      dispatch: NavigationDispatch;
                                                                                                                                                                                                                                                                        state: S;
                                                                                                                                                                                                                                                                          interface NavigationPushAction {}
                                                                                                                                                                                                                                                                            action?: NavigationNavigateAction;
                                                                                                                                                                                                                                                                              key?: string;
                                                                                                                                                                                                                                                                                params?: NavigationParams;
                                                                                                                                                                                                                                                                                  routeName: string;
                                                                                                                                                                                                                                                                                    type: 'Navigation/PUSH';
                                                                                                                                                                                                                                                                                      interface NavigationPushActionPayload {}
                                                                                                                                                                                                                                                                                        action?: NavigationNavigateAction;
                                                                                                                                                                                                                                                                                          key?: string;
                                                                                                                                                                                                                                                                                            params?: NavigationParams;
                                                                                                                                                                                                                                                                                              routeName: string;
                                                                                                                                                                                                                                                                                                interface NavigationReplaceAction {}
                                                                                                                                                                                                                                                                                                  action?: NavigationAction;
                                                                                                                                                                                                                                                                                                    key: string;
                                                                                                                                                                                                                                                                                                      params?: NavigationParams;
                                                                                                                                                                                                                                                                                                        routeName: string;
                                                                                                                                                                                                                                                                                                          type: 'Navigation/REPLACE';
                                                                                                                                                                                                                                                                                                            interface NavigationReplaceActionPayload {}
                                                                                                                                                                                                                                                                                                              action?: NavigationAction;
                                                                                                                                                                                                                                                                                                                key?: string;
                                                                                                                                                                                                                                                                                                                  newKey?: string;
                                                                                                                                                                                                                                                                                                                    params?: NavigationParams;
                                                                                                                                                                                                                                                                                                                      routeName: string;
                                                                                                                                                                                                                                                                                                                        interface NavigationResetAction extends NavigationResetActionPayload {}
                                                                                                                                                                                                                                                                                                                          type: 'Navigation/RESET';
                                                                                                                                                                                                                                                                                                                            interface NavigationResetActionPayload {}
                                                                                                                                                                                                                                                                                                                              actions: NavigationNavigateAction[];
                                                                                                                                                                                                                                                                                                                                index: number;
                                                                                                                                                                                                                                                                                                                                  key?: string | null;
                                                                                                                                                                                                                                                                                                                                    interface NavigationRouteConfigMap<
                                                                                                                                                                                                                                                                                                                                    Options,
                                                                                                                                                                                                                                                                                                                                    NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                    ScreenProps = unknown
                                                                                                                                                                                                                                                                                                                                    > {}
                                                                                                                                                                                                                                                                                                                                      [routeName: string]: NavigationRouteConfig<
                                                                                                                                                                                                                                                                                                                                      Options,
                                                                                                                                                                                                                                                                                                                                      NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                      ScreenProps
                                                                                                                                                                                                                                                                                                                                      >;
                                                                                                                                                                                                                                                                                                                                        interface NavigationRouter<State = NavigationState, Options = {}> {}
                                                                                                                                                                                                                                                                                                                                          getActionCreators: (
                                                                                                                                                                                                                                                                                                                                          route: NavigationRoute,
                                                                                                                                                                                                                                                                                                                                          key: string
                                                                                                                                                                                                                                                                                                                                          ) => {
                                                                                                                                                                                                                                                                                                                                          [key: string]: () => NavigationAction;
                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                            getActionForPathAndParams: (
                                                                                                                                                                                                                                                                                                                                            path: string,
                                                                                                                                                                                                                                                                                                                                            params?: NavigationParams
                                                                                                                                                                                                                                                                                                                                            ) => NavigationAction | null;
                                                                                                                                                                                                                                                                                                                                            • Maps a URI-like string to an action. This can be mapped to a state using getStateForAction.

                                                                                                                                                                                                                                                                                                                                            getComponentForRouteName: (
                                                                                                                                                                                                                                                                                                                                            routeName: string
                                                                                                                                                                                                                                                                                                                                            ) => NavigationComponent<{}, NavigationScreenProp<NavigationRoute>>;
                                                                                                                                                                                                                                                                                                                                              getComponentForState: (
                                                                                                                                                                                                                                                                                                                                              state: State
                                                                                                                                                                                                                                                                                                                                              ) => NavigationComponent<{}, NavigationScreenProp<NavigationRoute>>;
                                                                                                                                                                                                                                                                                                                                                getPathAndParamsForState: (
                                                                                                                                                                                                                                                                                                                                                state: State
                                                                                                                                                                                                                                                                                                                                                ) => {
                                                                                                                                                                                                                                                                                                                                                path: string;
                                                                                                                                                                                                                                                                                                                                                params?: NavigationParams;
                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                  getScreenOptions: NavigationScreenOptionsGetter<Options>;
                                                                                                                                                                                                                                                                                                                                                  • Gets the screen navigation options for a given screen.

                                                                                                                                                                                                                                                                                                                                                    For example, we could get the config for the 'Foo' screen when the navigation.state is:

                                                                                                                                                                                                                                                                                                                                                    {routeName: 'Foo', key: '123'}

                                                                                                                                                                                                                                                                                                                                                  getStateForAction: (action: NavigationAction, lastState?: State) => State | null;
                                                                                                                                                                                                                                                                                                                                                  • The reducer that outputs the new navigation state for a given action, with an optional previous state. When the action is considered handled but the state is unchanged, the output state is null.

                                                                                                                                                                                                                                                                                                                                                  interface NavigationScreenConfigProps<
                                                                                                                                                                                                                                                                                                                                                  NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                                  ScreenProps = unknown
                                                                                                                                                                                                                                                                                                                                                  > {}
                                                                                                                                                                                                                                                                                                                                                    navigation: NavigationScreenPropType;
                                                                                                                                                                                                                                                                                                                                                      screenProps: ScreenProps;
                                                                                                                                                                                                                                                                                                                                                        theme: SupportedThemes;
                                                                                                                                                                                                                                                                                                                                                          interface NavigationScreenProp<S, P = NavigationParams> {}
                                                                                                                                                                                                                                                                                                                                                            addListener: (
                                                                                                                                                                                                                                                                                                                                                            eventName: string,
                                                                                                                                                                                                                                                                                                                                                            callback: NavigationEventCallback
                                                                                                                                                                                                                                                                                                                                                            ) => NavigationEventSubscription;
                                                                                                                                                                                                                                                                                                                                                              dangerouslyGetParent: () => NavigationScreenProp<S> | undefined;
                                                                                                                                                                                                                                                                                                                                                                dismiss: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                  dispatch: NavigationDispatch;
                                                                                                                                                                                                                                                                                                                                                                    emit: (eventName: 'refocus') => void;
                                                                                                                                                                                                                                                                                                                                                                      goBack: (routeKey?: string | null) => boolean;
                                                                                                                                                                                                                                                                                                                                                                        isFirstRouteInParent: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                          isFocused: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                            router?: NavigationRouter;
                                                                                                                                                                                                                                                                                                                                                                              setParams: (newParams: Partial<P>) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                state: S & { params?: P };
                                                                                                                                                                                                                                                                                                                                                                                  getParam: {
                                                                                                                                                                                                                                                                                                                                                                                  <T extends keyof P>(param: T, fallback: NonNullable<P[T]>): NonNullable<
                                                                                                                                                                                                                                                                                                                                                                                  P[T]
                                                                                                                                                                                                                                                                                                                                                                                  >;
                                                                                                                                                                                                                                                                                                                                                                                  <T extends keyof P>(param: T): P[T];
                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                    navigate: {
                                                                                                                                                                                                                                                                                                                                                                                    <T extends NavigationParams>(options: {
                                                                                                                                                                                                                                                                                                                                                                                    routeName:
                                                                                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                                                                                                    routeName: string;
                                                                                                                                                                                                                                                                                                                                                                                    params?: T;
                                                                                                                                                                                                                                                                                                                                                                                    action?: NavigationNavigateAction;
                                                                                                                                                                                                                                                                                                                                                                                    key?: string;
                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                    params?: T;
                                                                                                                                                                                                                                                                                                                                                                                    action?: NavigationAction;
                                                                                                                                                                                                                                                                                                                                                                                    key?: string;
                                                                                                                                                                                                                                                                                                                                                                                    }): boolean;
                                                                                                                                                                                                                                                                                                                                                                                    <T extends NavigationParams>(
                                                                                                                                                                                                                                                                                                                                                                                    routeNameOrOptions: string,
                                                                                                                                                                                                                                                                                                                                                                                    params?: T,
                                                                                                                                                                                                                                                                                                                                                                                    action?: NavigationAction
                                                                                                                                                                                                                                                                                                                                                                                    ): boolean;
                                                                                                                                                                                                                                                                                                                                                                                    };
                                                                                                                                                                                                                                                                                                                                                                                      interface NavigationSetParamsAction extends NavigationSetParamsActionPayload {}
                                                                                                                                                                                                                                                                                                                                                                                        type: 'Navigation/SET_PARAMS';
                                                                                                                                                                                                                                                                                                                                                                                          interface NavigationSetParamsActionPayload {}
                                                                                                                                                                                                                                                                                                                                                                                            key: string;
                                                                                                                                                                                                                                                                                                                                                                                              params: NavigationParams;
                                                                                                                                                                                                                                                                                                                                                                                                interface NavigationStackRouterConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                  initialRouteKey?: string;
                                                                                                                                                                                                                                                                                                                                                                                                    initialRouteName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                      initialRouteParams?: NavigationParams;
                                                                                                                                                                                                                                                                                                                                                                                                        paths?: NavigationPathsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                          interface NavigationState {}
                                                                                                                                                                                                                                                                                                                                                                                                          • NavigationState is a tree of routes for a single navigator, where each child route may either be a NavigationScreenRoute or a NavigationRouterRoute. NavigationScreenRoute represents a leaf screen, while the NavigationRouterRoute represents the state of a child navigator.

                                                                                                                                                                                                                                                                                                                                                                                                            NOTE: NavigationState is a state tree local to a single navigator and its child navigators (via the routes field). If we're in navigator nested deep inside the app, the state will only be the state for that navigator. The state for the root navigator of our app represents the whole navigation state for the whole app.

                                                                                                                                                                                                                                                                                                                                                                                                          index: number;
                                                                                                                                                                                                                                                                                                                                                                                                          • Index refers to the active child route in the routes array.

                                                                                                                                                                                                                                                                                                                                                                                                          isTransitioning: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                            key: string;
                                                                                                                                                                                                                                                                                                                                                                                                              params?: NavigationParams | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                routes: NavigationRoute[];
                                                                                                                                                                                                                                                                                                                                                                                                                  interface NavigationSwitchRouterConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                  • Switch Navigator

                                                                                                                                                                                                                                                                                                                                                                                                                  backBehavior?: 'none' | 'initialRoute' | 'history' | 'order';
                                                                                                                                                                                                                                                                                                                                                                                                                    initialRouteName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                      initialRouteParams?: NavigationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                        order?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                          paths?: NavigationPathsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                            resetOnBlur?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                              interface NavigationTabRouterConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                backBehavior?: 'none' | 'initialRoute' | 'history' | 'order';
                                                                                                                                                                                                                                                                                                                                                                                                                                  initialRouteName?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                    initialRouteParams?: NavigationParams;
                                                                                                                                                                                                                                                                                                                                                                                                                                      order?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                        paths?: NavigationPathsConfig;
                                                                                                                                                                                                                                                                                                                                                                                                                                          resetOnBlur?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NavigationToggleDrawerAction {}
                                                                                                                                                                                                                                                                                                                                                                                                                                              key?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'Navigation/TOGGLE_DRAWER';
                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NavigationUriAction extends NavigationUriActionPayload {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Navigation/URI';
                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NavigationUriActionPayload {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        uri: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SafeAreaViewProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SafeAreaViewProps extends ViewProps {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                            children?: React.ReactNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property forceInset

                                                                                                                                                                                                                                                                                                                                                                                                                                                              forceInset?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                              top?: SafeAreaViewForceInsetValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              bottom?: SafeAreaViewForceInsetValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              left?: SafeAreaViewForceInsetValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              right?: SafeAreaViewForceInsetValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              horizontal?: SafeAreaViewForceInsetValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              vertical?: SafeAreaViewForceInsetValue;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SceneViewProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface SceneViewProps {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • SceneView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                component: React.ComponentType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property navigation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  navigation: NavigationProp<any>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property screenProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    screenProps: unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Theme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Theme {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        body: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property bodyBorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bodyBorder: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property bodyContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bodyContent: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property bodyContentBorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bodyContentBorder: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property header

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                header: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property headerBorder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  headerBorder: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property label

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    label: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AnimatedValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type AnimatedValue = any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateNavigatorConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type CreateNavigatorConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NavigatorConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RouterConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NavigationScreenPropType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > = NavigatorConfig &
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        RouterConfig & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        defaultNavigationOptions?: NavigationScreenConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NavigationScreenPropType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        navigationOptions?: NavigationScreenConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        { [key: string]: any },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NavigationScreenProp<NavigationRoute>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EventType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type EventType = 'willFocus' | 'didFocus' | 'willBlur' | 'didBlur' | 'action';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InferProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type InferProps<T extends React.ComponentType<any>> = T extends React.ComponentType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            infer P
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ? P
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            : never;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NavigationAction =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | NavigationInitAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | NavigationStackAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | NavigationTabAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | NavigationDrawerAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | NavigationSwitchAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | { type: 'CHILD_ACTION'; key?: string };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NavigationComponent<Options, NavigationPropType> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | NavigationScreenComponent<Options, NavigationPropType>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | NavigationNavigator<Options, NavigationPropType>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NavigationDispatch = (action: NavigationAction) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NavigationDrawerAction =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationDrawerOpenedAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationDrawerClosedAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationOpenDrawerAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationCloseDrawerAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationToggleDrawerAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NavigationEventCallback = (payload: NavigationEventPayload) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NavigationNavigator<Options, NavigationPropType> = React.ComponentType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NavigationNavigatorProps<Options>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        > & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        router: NavigationRouter<Options>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        navigationOptions?: NavigationScreenConfig<Options, NavigationPropType>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NavigationRoute<Params = NavigationParams> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | NavigationLeafRoute<Params>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | NavigationStateRoute<Params>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NavigationRouteConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ScreenProps = unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | NavigationComponent<Options, NavigationScreenPropType>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | { screen: NavigationComponent<Options, NavigationScreenPropType> }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getScreen(): NavigationScreenComponent<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NavigationScreenPropType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            navigationOptions?: NavigationScreenConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ScreenProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            params?: { [key: string]: any };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NavigationScreenComponent<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NavigationScreenPropType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = React.ComponentType<any> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              navigationOptions?: NavigationScreenConfig<Options, NavigationScreenPropType>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NavigationScreenConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Options,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ScreenProps = unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | Options
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ((
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                navigationOptionsContainer: NavigationScreenConfigProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NavigationScreenPropType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ScreenProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                > & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                navigationOptions: Options;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Options);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NavigationScreenOptionsGetter<Options> = (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  navigation: NavigationScreenProp<NavigationRoute<any>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  screenProps: unknown | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  theme: SupportedThemes
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Options;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NavigationStackAction =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationInitAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationNavigateAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationBackAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationSetParamsAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationResetAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationReplaceAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationPopAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationPushAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationPopToTopAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | NavigationCompleteTransitionAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type NavigationStateRoute<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NavigationLeafRouteParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      > = NavigationLeafRoute<NavigationLeafRouteParams> & NavigationState;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NavigationSwitchAction = NavigationJumpToAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NavigationSwitchProp<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          State = NavigationRoute,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Params = NavigationParams
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          > = NavigationScreenProp<State, Params> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          jumpTo(routeName: string, key?: string): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type NavigationSwitchScreenComponent<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Params = NavigationParams,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ScreenProps = unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            > = React.ComponentType<NavigationSwitchScreenProps<Params, ScreenProps>> & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            navigationOptions?: NavigationScreenConfig<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {},
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NavigationSwitchProp<NavigationRoute, Params>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ScreenProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type NavigationSwitchScreenProps<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Params = NavigationParams,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ScreenProps = unknown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              > = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              theme: SupportedThemes;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              navigation: NavigationSwitchProp<NavigationRoute, Params>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              screenProps: ScreenProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NavigationTabAction =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | NavigationInitAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | NavigationNavigateAction
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | NavigationBackAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type NavigationView<Options, State, ScreenProps = unknown> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | React.ComponentType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  descriptors: { [key: string]: NavigationDescriptor };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  navigationConfig: Options;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  screenProps?: ScreenProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  } & NavigationInjectedProps
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | React.ComponentType<any>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type NavigatorType =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'react-navigation/STACK'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'react-navigation/TABS'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 'react-navigation/DRAWER';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Omit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SafeAreaViewForceInsetValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SafeAreaViewForceInsetValue = 'always' | 'never';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • SafeAreaView Component

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SupportedThemes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SupportedThemes = 'light' | 'dark';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Themes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace DrawerActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace DrawerActions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • DrawerActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable CLOSE_DRAWER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const CLOSE_DRAWER: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable OPEN_DRAWER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const OPEN_DRAWER: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable TOGGLE_DRAWER

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const TOGGLE_DRAWER: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function closeDrawer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              closeDrawer: () => NavigationCloseDrawerAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function openDrawer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                openDrawer: () => NavigationOpenDrawerAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function toggleDrawer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toggleDrawer: () => NavigationToggleDrawerAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace NavigationActions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • NavigationActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const BACK: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const INIT: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const NAVIGATE: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const SET_PARAMS: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            back: (options?: NavigationBackActionPayload) => NavigationBackAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              init: (options?: NavigationInitActionPayload) => NavigationInitAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                navigate: (options: NavigationNavigateActionPayload) => NavigationNavigateAction;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  setParams: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: NavigationSetParamsActionPayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => NavigationSetParamsAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace StackActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace StackActions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • StackActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable COMPLETE_TRANSITION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const COMPLETE_TRANSITION: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable POP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const POP: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable POP_TO_TOP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const POP_TO_TOP: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable PUSH

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const PUSH: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable REPLACE

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const REPLACE: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable RESET

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const RESET: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function completeTransition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                completeTransition: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                payload?: NavigationCompleteTransitionActionPayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => NavigationCompleteTransitionAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function pop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pop: (options?: NavigationPopActionPayload) => NavigationPopAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function popToTop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    popToTop: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: NavigationPopToTopActionPayload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => NavigationPopToTopAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function push

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      push: (options: NavigationPushActionPayload) => NavigationPushAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function replace

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        replace: (options: NavigationReplaceActionPayload) => NavigationReplaceAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reset: (options: NavigationResetActionPayload) => NavigationResetAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace SwitchActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace SwitchActions {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • SwitchActions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable JUMP_TO

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const JUMP_TO: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function jumpTo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jumpTo: (options: NavigationJumpToActionPayload) => NavigationJumpToAction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace Themed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace Themed {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable StatusBar

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const StatusBar: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable Text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const Text: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable TextInput

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const TextInput: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Dev Dependencies (7)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Badge

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

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

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