@react-navigation/core 7.13.6 → 8.0.0-alpha.0

package/src/types.tsx

@@ -10,27 +10,68 @@ import type {
 } from '@react-navigation/routers';
 import type * as React from 'react';
 
-declare global {
-  // eslint-disable-next-line @typescript-eslint/no-namespace
-  namespace ReactNavigation {
-    // eslint-disable-next-line @typescript-eslint/no-empty-interface
-    interface RootParamList {}
-
-    // eslint-disable-next-line @typescript-eslint/no-empty-interface
-    interface Theme {}
-  }
-}
-
-type Keyof<T extends {}> = Extract<keyof T, string>;
+import type {
+  FlatType,
+  KeyOf,
+  NotUndefined,
+  UnionToIntersection,
+} from './utilities';
+
+/**
+ * Root navigator used in the app.
+ * It's used for the global types in the app.
+ * Users need to use module augmentation to add their navigator type:
+ *
+ * ```ts
+ * // Navigator created with static or dynamic API
+ * const RootStack = createStackNavigator({
+ *   // ...
+ * });
+ *
+ * type RootStackType = typeof RootStack;
+ *
+ * declare module '@react-navigation/core' {
+ *   interface RootNavigator extends RootStackType {}
+ * }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface RootNavigator {}
+
+/**
+ * Theme object for the navigation components.
+ * Custom properties can be added using declaration merging:
+ *
+ * ```ts
+ * declare module '@react-navigation/core' {
+ *   interface Theme extends NativeTheme {
+ *     myCustomProperty: string;
+ *   }
+ * }
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+export interface Theme {}
+
+export type RootParamList =
+  RootNavigator extends TypedNavigatorInternal<
+    infer ParamList,
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+    ? ParamList
+    : {};
 
 export type DefaultNavigatorOptions<
   ParamList extends ParamListBase,
-  NavigatorID extends string | undefined,
   State extends NavigationState,
   ScreenOptions extends {},
   EventMap extends EventMapBase,
   Navigation,
-> = DefaultRouterOptions<Keyof<ParamList>> & {
+> = DefaultRouterOptions<KeyOf<ParamList>> & {
   /**
    * Children React Elements to extract the route configuration from.
    * Only `Screen`, `Group` and `React.Fragment` are supported as children.
@@ -51,7 +92,6 @@ export type DefaultNavigatorOptions<
         NavigationProp<
           ParamList,
           keyof ParamList,
-          string | undefined,
           State,
           ScreenOptions,
           EventMap
@@ -80,7 +120,7 @@ export type DefaultNavigatorOptions<
     | ((props: {
         route: RouteProp<ParamList>;
         navigation: Navigation;
-        theme: ReactNavigation.Theme;
+        theme: Theme;
       }) => ScreenOptions);
 
   /**
@@ -102,7 +142,7 @@ export type DefaultNavigatorOptions<
    *
    * This must be a pure function and cannot reference outside dynamic variables.
    */
-  UNSTABLE_router?: <Action extends NavigationAction>(
+  router?: <Action extends NavigationAction>(
     original: Router<State, Action>
   ) => Partial<Router<State, Action>>;
 
@@ -125,17 +165,8 @@ export type DefaultNavigatorOptions<
    * - Direct navigation is only handled for `NAVIGATE` actions.
    * - Unhandled state is restored only if the current state becomes invalid, i.e. it doesn't contain any currently defined screens.
    */
-  UNSTABLE_routeNamesChangeBehavior?: 'firstMatch' | 'lastUnhandled';
-} & (NavigatorID extends string
-    ? {
-        /**
-         * Optional ID for the navigator. Can be used with `navigation.getParent(id)` to refer to a parent.
-         */
-        id: NavigatorID;
-      }
-    : {
-        id?: undefined;
-      });
+  routeNamesChangeBehavior?: 'firstMatch' | 'lastUnhandled';
+};
 
 export type EventMapBase = Record<
   string,
@@ -196,11 +227,11 @@ export type EventConsumer<EventMap extends EventMapBase> = {
    * @param type Type of the event (e.g. `focus`, `blur`)
    * @param callback Callback listener which is executed upon receiving the event.
    */
-  addListener<EventName extends Keyof<EventMap>>(
+  addListener<EventName extends KeyOf<EventMap>>(
     type: EventName,
     callback: EventListenerCallback<EventMap, EventName>
   ): () => void;
-  removeListener<EventName extends Keyof<EventMap>>(
+  removeListener<EventName extends KeyOf<EventMap>>(
     type: EventName,
     callback: EventListenerCallback<EventMap, EventName>
   ): void;
@@ -215,7 +246,7 @@ export type EventEmitter<EventMap extends EventMapBase> = {
    * @param [options.target] Key of the target route which should receive the event.
    * If not specified, all routes receive the event.
    */
-  emit<EventName extends Keyof<EventMap>>(
+  emit<EventName extends KeyOf<EventMap>>(
     options: {
       type: EventName;
       target?: string;
@@ -311,39 +342,6 @@ type NavigationHelpersCommon<
       : never
   ): void;
 
-  /**
-   * Navigate to a route in current navigation tree.
-   *
-   * @deprecated Use `navigate` instead.
-   *
-   * @param screen Name of the route to navigate to.
-   * @param [params] Params object for the route.
-   */
-  navigateDeprecated<RouteName extends keyof ParamList>(
-    ...args: RouteName extends unknown
-      ? undefined extends ParamList[RouteName]
-        ? [screen: RouteName, params?: ParamList[RouteName]]
-        : [screen: RouteName, params: ParamList[RouteName]]
-      : never
-  ): void;
-
-  /**
-   * Navigate to a route in current navigation tree.
-   *
-   * @deprecated Use `navigate` instead.
-   *
-   * @param options Object with `name` for the route to navigate to, and a `params` object.
-   */
-  navigateDeprecated<RouteName extends keyof ParamList>(
-    options: RouteName extends unknown
-      ? {
-          name: RouteName;
-          params: ParamList[RouteName];
-          merge?: boolean;
-        }
-      : never
-  ): void;
-
   /**
    * Preloads the route in current navigation tree.
    *
@@ -372,7 +370,10 @@ type NavigationHelpersCommon<
 
   /**
    * Check if the screen is focused. The method returns `true` if focused, `false` otherwise.
-   * Note that this method doesn't re-render screen when the focus changes. So don't use it in `render`.
+   * Note that this method is non-reactive.
+   * It doesn't re-render the component when the result changes.
+   * So don't use it in `render`.
+   *
    * To get notified of focus changes, use `addListener('focus', cb)` and `addListener('blur', cb)`.
    * To conditionally render content based on focus state, use the `useIsFocused` hook.
    */
@@ -384,31 +385,30 @@ type NavigationHelpersCommon<
    */
   canGoBack(): boolean;
 
-  /**
-   * Returns the name of the navigator specified in the `name` prop.
-   * If no name is specified, returns `undefined`.
-   */
-  getId(): string | undefined;
-
-  /**
-   * Returns the navigation helpers from a parent navigator based on the ID.
-   * If an ID is provided, the navigation helper from the parent navigator with matching ID (including current) will be returned.
-   * If no ID is provided, the navigation helper from the immediate parent navigator will be returned.
-   *
-   * @param id Optional ID of a parent navigator.
-   */
-  getParent<T = NavigationHelpers<ParamListBase> | undefined>(id?: string): T;
-
   /**
    * Returns the navigator's state.
-   * Note that this method doesn't re-render screen when the result changes. So don't use it in `render`.
+   * Note that this method is non-reactive.
+   * It doesn't re-render the component when the result changes.
+   * So don't use it in `render`.
    */
   getState(): State;
 } & PrivateValueStore<[ParamList, unknown, unknown]>;
 
+type ParamType<
+  ParamList extends {},
+  RouteName extends keyof ParamList | unknown,
+  IsPartial extends boolean = false,
+> = RouteName extends keyof ParamList
+  ? ParamList[RouteName] extends undefined
+    ? undefined
+    : IsPartial extends true
+      ? Partial<ParamList[RouteName]>
+      : ParamList[RouteName]
+  : unknown;
+
 type NavigationHelpersRoute<
   ParamList extends {},
-  RouteName extends keyof ParamList = Keyof<ParamList>,
+  RouteName extends keyof ParamList = KeyOf<ParamList>,
 > = {
   /**
    * Update the param object for the route.
@@ -416,22 +416,23 @@ type NavigationHelpersRoute<
    *
    * @param params Partial params object for the current route.
    */
-  setParams(
-    params: ParamList[RouteName] extends undefined
-      ? undefined
-      : Partial<ParamList[RouteName]>
-  ): void;
+  setParams(params: ParamType<ParamList, RouteName, true>): void;
 
   /**
    * Replace the param object for the route
    *
    * @param params Params object for the current route.
    */
-  replaceParams(
-    params: ParamList[RouteName] extends undefined
-      ? undefined
-      : ParamList[RouteName]
-  ): void;
+  replaceParams(params: ParamType<ParamList, RouteName>): void;
+
+  /**
+   * Push new params for the route.
+   * The params are not merged with previous params.
+   * This adds an entry to navigation history.
+   *
+   * @param params Params object for the current route.
+   */
+  pushParams(params: ParamType<ParamList, RouteName>): void;
 };
 
 export type NavigationHelpers<
@@ -458,20 +459,10 @@ export type NavigationContainerProps = {
    * Callback which is called when an action is not handled.
    */
   onUnhandledAction?: (action: Readonly<NavigationAction>) => void;
-  /**
-   * Whether child navigator should handle a navigation action.
-   * The child navigator needs to be mounted before it can handle the action.
-   * Defaults to `false`.
-   *
-   * This will be removed in the next major release.
-   *
-   * @deprecated Use nested navigation API instead
-   */
-  navigationInChildEnabled?: boolean;
   /**
    * Theme object for the UI elements.
    */
-  theme?: ReactNavigation.Theme;
+  theme?: Theme;
   /**
    * Children elements to render.
    */
@@ -480,87 +471,90 @@ export type NavigationContainerProps = {
 
 export type NavigationProp<
   ParamList extends {},
-  RouteName extends keyof ParamList = Keyof<ParamList>,
-  NavigatorID extends string | undefined = string | undefined,
+  RouteName extends keyof ParamList = KeyOf<ParamList>,
   State extends NavigationState = NavigationState<ParamList>,
   ScreenOptions extends {} = {},
   EventMap extends EventMapBase = {},
+  ActionHelpers extends Record<string, (...args: any) => void> = {},
 > = Omit<NavigationHelpersCommon<ParamList, State>, 'getParent'> & {
-  /**
-   * Returns the navigation prop from a parent navigator based on the ID.
-   * If an ID is provided, the navigation prop from the parent navigator with matching ID (including current) will be returned.
-   * If no ID is provided, the navigation prop from the immediate parent navigator will be returned.
-   *
-   * @param id Optional ID of a parent navigator.
-   */
-  getParent<T = NavigationProp<ParamListBase> | undefined>(id?: NavigatorID): T;
-
   /**
    * Update the options for the route.
    * The options object will be shallow merged with default options object.
    *
-   * @param update Options object or a callback which takes the options from navigator config and returns a new options object.
+   * @param options Partial options object for the current screen.
    */
   setOptions(options: Partial<ScreenOptions>): void;
+  /**
+   * Returns the navigation prop of the parent screen.
+   * If a route name is provided, the navigation prop from the parent screen with matching route name (including current) will be returned.
+   * If no route name is provided, the navigation prop from the immediate parent screen will be returned.
+   *
+   * @param routeName Optional route name of a parent screen.
+   */
+  getParent(
+    routeName: RouteName
+  ): NavigationProp<
+    ParamList,
+    RouteName,
+    State,
+    ScreenOptions,
+    EventMap,
+    ActionHelpers
+  >;
+  getParent(): NavigationProp<ParamListBase> | undefined;
 } & NavigationHelpersRoute<ParamList, RouteName> &
+  ActionHelpers &
   EventConsumer<EventMap & EventMapCore<State>> &
   PrivateValueStore<[ParamList, RouteName, EventMap]>;
 
 export type RouteProp<
   ParamList extends ParamListBase,
-  RouteName extends keyof ParamList = Keyof<ParamList>,
+  RouteName extends keyof ParamList = KeyOf<ParamList>,
 > = Route<Extract<RouteName, string>, ParamList[RouteName]>;
 
 export type CompositeNavigationProp<
-  A extends NavigationProp<ParamListBase, string, any, any, any>,
-  B extends NavigationHelpersCommon<ParamListBase, any>,
-> = Omit<A & B, keyof NavigationProp<any>> &
-  NavigationProp<
-    /**
-     * Param list from both navigation objects needs to be combined
-     * For example, we should be able to navigate to screens in both A and B
-     */
-    (A extends NavigationHelpersCommon<infer T> ? T : never) &
-      (B extends NavigationHelpersCommon<infer U> ? U : never),
-    /**
-     * The route name should refer to the route name specified in the first type
-     * Ideally it should work for any of them, but it's not possible to infer that way
-     */
-    A extends NavigationProp<any, infer R> ? R : string,
-    /**
-     * ID from both navigation objects needs to be combined for `getParent`
-     */
-    | (A extends NavigationProp<any, any, infer I> ? I : never)
-    | (B extends NavigationProp<any, any, infer J> ? J : never),
-    /**
-     * The type of state should refer to the state specified in the first type
-     */
-    A extends NavigationProp<any, any, any, infer S> ? S : NavigationState,
-    /**
-     * Screen options should refer to the options specified in the first type
-     */
-    A extends NavigationProp<any, any, any, any, infer O> ? O : {},
-    /**
-     * Event consumer config should refer to the config specified in the first type
-     * This allows typechecking `addListener`/`removeListener`
-     */
-    A extends NavigationProp<any, any, any, any, any, infer E> ? E : {}
-  >;
+  A extends NavigationProp<ParamListBase, any, any, any, any>,
+  B extends NavigationProp<ParamListBase, any, any, any, any>,
+> = Omit<A & B, keyof NavigationProp<any, any, any, any, any>> &
+  Omit<
+    NavigationProp<
+      /**
+       * Param list from both navigation objects needs to be combined
+       * For example, we should be able to navigate to screens in both A and B
+       */
+      (A extends NavigationHelpersCommon<infer T> ? T : never) &
+        (B extends NavigationHelpersCommon<infer U> ? U : never),
+      /**
+       * The route name should refer to the route name specified in the first type
+       * Ideally it should work for any of them, but it's not possible to infer that way
+       */
+      A extends NavigationProp<any, infer R> ? R : string,
+      /**
+       * The type of state should refer to the state specified in the first type
+       */
+      A extends NavigationProp<any, any, infer S> ? S : NavigationState,
+      /**
+       * Screen options should refer to the options specified in the first type
+       */
+      A extends NavigationProp<any, any, any, infer O> ? O : {},
+      /**
+       * Event consumer config should refer to the config specified in the first type
+       * This allows typechecking `addListener`/`removeListener`
+       */
+      A extends NavigationProp<any, any, any, any, infer E> ? E : {}
+    >,
+    'getParent'
+  > & {
+    getParent: A['getParent'] & B['getParent'];
+  };
 
 export type CompositeScreenProps<
   A extends {
-    navigation: NavigationProp<
-      ParamListBase,
-      string,
-      string | undefined,
-      any,
-      any,
-      any
-    >;
+    navigation: NavigationProp<ParamListBase, string, any, any, any>;
     route: RouteProp<ParamListBase>;
   },
   B extends {
-    navigation: NavigationHelpersCommon<any, any>;
+    navigation: NavigationProp<ParamListBase, string, any, any, any>;
   },
 > = {
   navigation: CompositeNavigationProp<A['navigation'], B['navigation']>;
@@ -576,13 +570,13 @@ export type ScreenLayoutArgs<
   route: RouteProp<ParamList, RouteName>;
   options: ScreenOptions;
   navigation: Navigation;
-  theme: ReactNavigation.Theme;
+  theme: Theme;
   children: React.ReactElement;
 };
 
 export type Descriptor<
   ScreenOptions extends {},
-  Navigation extends NavigationProp<any, any, any, any, any, any>,
+  Navigation extends NavigationProp<any, any, any, any, any>,
   Route extends RouteProp<any, any>,
 > = {
   /**
@@ -686,7 +680,7 @@ export type RouteConfigProps<
     | ((props: {
         route: RouteProp<ParamList, RouteName>;
         navigation: Navigation;
-        theme: ReactNavigation.Theme;
+        theme: Theme;
       }) => ScreenOptions);
 
   /**
@@ -762,7 +756,7 @@ export type RouteGroupConfig<
     | ((props: {
         route: RouteProp<ParamList, keyof ParamList>;
         navigation: Navigation;
-        theme: ReactNavigation.Theme;
+        theme: Theme;
       }) => ScreenOptions);
 
   /**
@@ -834,20 +828,204 @@ export type NavigationContainerEventMap = {
   };
 };
 
-type NotUndefined<T> = T extends undefined ? never : T;
+/**
+ * A stripped down NavigationProp if the navigator is not known.
+ *
+ * The hook can be used in `NavigationContainer` directly, not inside of a navigator.
+ * So navigator specific methods won't be available.
+ */
+export type GenericNavigation<ParamList extends {}> = Omit<
+  NavigationProp<ParamList>,
+  'getState' | 'setParams' | 'replaceParams' | 'pushParams' | 'setOptions'
+> & {
+  /**
+   * Returns the navigator's state.
+   *
+   * This may return `undefined` if used outside of a navigator,
+   * as the navigator may not have rendered yet
+   */
+  getState(): NavigationState | undefined;
+
+  /**
+   * Update the param object for the route.
+   * The new params will be shallow merged with the old one.
+   *
+   * @param params Partial params object for the current route.
+   */
+  setParams(
+    // We don't know which route to set params for
+    params: unknown
+  ): void;
+
+  /**
+   * Replace the param object for the route
+   *
+   * @param params Params object for the current route.
+   */
+  replaceParams(
+    // We don't know which route to replace params for
+    params: unknown
+  ): void;
+
+  /**
+   * Push new params for the route.
+   * The params are not merged with previous params.
+   * This adds an entry to navigation history.
+   *
+   * @param params Params object for the current route.
+   */
+  pushParams(
+    // We don't know which route to push params for
+    params: unknown
+  ): void;
+
+  /**
+   * Update the options for the route.
+   * The options object will be shallow merged with default options object.
+   *
+   * @param options Partial options object for the current screen.
+   */
+  setOptions(
+    // We don't know which navigator to set options for
+    options: unknown
+  ): void;
+};
+
+export type RouteForName<
+  ParamList extends {},
+  RouteName extends string,
+> = Extract<ParamListRoute<ParamList>, { name: RouteName }>;
 
-export type ParamListRoute<ParamList extends ParamListBase> = {
+type ParamListRoute<ParamList extends {}> = {
   [RouteName in keyof ParamList]: NavigatorScreenParams<{}> extends ParamList[RouteName]
     ? NotUndefined<ParamList[RouteName]> extends NavigatorScreenParams<infer T>
-      ? ParamListRoute<T>
-      : Route<Extract<RouteName, string>, ParamList[RouteName]>
-    : Route<Extract<RouteName, string>, ParamList[RouteName]>;
+      ? ParamListRoute<T> | RouteProp<ParamList, RouteName>
+      : RouteProp<ParamList, RouteName>
+    : RouteProp<ParamList, RouteName>;
 }[keyof ParamList];
 
 type MaybeParamListRoute<ParamList extends {}> = ParamList extends ParamListBase
   ? ParamListRoute<ParamList>
   : Route<string>;
 
+type BasicNavigationComposite<
+  Navigation extends NavigationProp<any, any, any, any, any>,
+  Parent,
+> =
+  Parent extends NavigationProp<any, any, any, any, any>
+    ? CompositeNavigationProp<Navigation, Parent>
+    : Navigation;
+
+type BasicNavigationList<
+  ParamList extends {},
+  ExcludedRouteNames,
+  Parent extends NavigationProp<any, any, any, any, any> | undefined,
+> = UnionToIntersection<
+  {
+    [RouteName in keyof ParamList]: (NavigatorScreenParams<{}> extends ParamList[RouteName]
+      ? NotUndefined<ParamList[RouteName]> extends NavigatorScreenParams<
+          infer T
+        >
+        ? BasicNavigationList<
+            T,
+            ExcludedRouteNames,
+            NavigationProp<ParamList, RouteName>
+          >
+        : {}
+      : {}) &
+      (RouteName extends ExcludedRouteNames
+        ? {}
+        : {
+            [Key in RouteName]: BasicNavigationComposite<
+              NavigationProp<ParamList, RouteName>,
+              Parent
+            >;
+          });
+  }[keyof ParamList]
+>;
+
+export type NavigationListForNavigator<Navigator> =
+  Navigator extends TypedNavigator<infer Bag, any>
+    ? Bag['NavigationList']
+    : Navigator extends PrivateValueStore<[any, infer NavigationList, any]>
+      ? NavigationList
+      : {};
+
+export type NavigationListForNested<Navigator> = FlatType<
+  NavigationListForNestedInternal<Navigator> &
+    (Navigator extends TypedNavigator<infer Bag, any>
+      ? BasicNavigationList<
+          Bag['ParamList'],
+          keyof NavigationListForNestedInternal<Navigator>,
+          undefined
+        >
+      : Navigator extends PrivateValueStore<[infer ParamList, any, any]>
+        ? ParamList extends {}
+          ? BasicNavigationList<
+              ParamList,
+              keyof NavigationListForNestedInternal<Navigator>,
+              undefined
+            >
+          : {}
+        : {})
+>;
+
+type NavigationListForNestedInternal<Navigator> =
+  NavigationListForNavigator<Navigator> &
+    NavigationListForStaticConfig<
+      NavigationListForNavigator<Navigator>,
+      Navigator
+    >;
+
+type NavigationListWithComposite<
+  Parent extends NavigationProp<any, any, any, any, any>,
+  NavigatorList extends Record<string, any>,
+> = {
+  [K in keyof NavigatorList]: CompositeNavigationProp<NavigatorList[K], Parent>;
+};
+
+type NavigationListForStaticConfig<ParentList, Navigator> = Navigator extends {
+  readonly config: {
+    screens?: any;
+    groups?: any;
+  };
+}
+  ? NavigationListForScreens<ParentList, Navigator['config']['screens']> &
+      NavigationListForGroups<ParentList, Navigator['config']['groups']>
+  : {};
+
+type NavigationListForScreens<ParentList, Screens> = UnionToIntersection<
+  {
+    // Only check screens with static config to avoid overly-complex types
+    // Otherwise TypeScript fails to load the types due to complexity
+    [K in keyof Screens]: ParentList extends Record<K, any>
+      ? Screens[K] extends { config: any }
+        ? NavigationListWithComposite<
+            ParentList[K],
+            NavigationListForNested<Screens[K]>
+          >
+        : Screens[K] extends { screen: { config: any } }
+          ? NavigationListWithComposite<
+              ParentList[K],
+              NavigationListForNested<Screens[K]['screen']>
+            >
+          : {}
+      : {};
+  }[keyof Screens]
+>;
+
+type NavigationListForGroups<ParentList, Groups> =
+  Groups extends Record<string, { screens: any }>
+    ? UnionToIntersection<
+        {
+          [K in keyof Groups]: NavigationListForScreens<
+            ParentList,
+            Groups[K]['screens']
+          >;
+        }[keyof Groups]
+      >
+    : {};
+
 export type NavigationContainerRef<ParamList extends {}> =
   NavigationHelpers<ParamList> &
     EventConsumer<NavigationContainerEventMap> & {
@@ -892,27 +1070,8 @@ export type NavigationListBase<ParamList extends ParamListBase> = {
   [RouteName in keyof ParamList]: unknown;
 };
 
-export type TypeBag<
-  ParamList extends ParamListBase,
-  NavigatorID extends string | undefined,
-  State extends NavigationState,
-  ScreenOptions extends {},
-  EventMap extends EventMapBase,
-  NavigationList extends NavigationListBase<ParamList>,
-  Navigator extends React.ComponentType<any>,
-> = {
-  ParamList: ParamList;
-  NavigatorID: NavigatorID;
-  State: State;
-  ScreenOptions: ScreenOptions;
-  EventMap: EventMap;
-  NavigationList: NavigationList;
-  Navigator: Navigator;
-};
-
 export type NavigatorTypeBagBase = {
   ParamList: {};
-  NavigatorID: string | undefined;
   State: NavigationState;
   ScreenOptions: {};
   EventMap: {};
@@ -920,41 +1079,22 @@ export type NavigatorTypeBagBase = {
   Navigator: React.ComponentType<any>;
 };
 
-export type NavigatorTypeBag<
-  ParamList extends ParamListBase,
-  NavigatorID extends string | undefined,
-  State extends NavigationState,
-  ScreenOptions extends {},
-  EventMap extends EventMapBase,
-  NavigationList extends NavigationListBase<ParamList>,
-  Navigator extends React.ComponentType<any>,
-> = {
-  ParamList: ParamList;
-  NavigatorID: NavigatorID;
-  State: State;
-  ScreenOptions: ScreenOptions;
-  EventMap: EventMap;
-  NavigationList: NavigationList;
-  Navigator: Navigator;
-};
-
 export type TypedNavigator<
   Bag extends NavigatorTypeBagBase,
   Config = unknown,
 > = TypedNavigatorInternal<
   Bag['ParamList'],
-  Bag['NavigatorID'],
   Bag['State'],
   Bag['ScreenOptions'],
   Bag['EventMap'],
   Bag['NavigationList'],
   Bag['Navigator']
 > &
-  (undefined extends Config ? {} : { config: Config });
+  (undefined extends Config ? {} : { config: Config }) &
+  PrivateValueStore<[Bag['ParamList'], Bag['NavigationList'], unknown]>;
 
 type TypedNavigatorInternal<
   ParamList extends ParamListBase,
-  NavigatorID extends string | undefined,
   State extends NavigationState,
   ScreenOptions extends {},
   EventMap extends EventMapBase,
@@ -967,11 +1107,10 @@ type TypedNavigatorInternal<
   Navigator: React.ComponentType<
     Omit<
       React.ComponentProps<Navigator>,
-      keyof DefaultNavigatorOptions<any, any, any, any, any, any>
+      keyof DefaultNavigatorOptions<any, any, any, any, any>
     > &
       DefaultNavigatorOptions<
         ParamList,
-        NavigatorID,
         State,
         ScreenOptions,
         EventMap,
@@ -1031,7 +1170,15 @@ export type NavigatorScreenParams<ParamList extends {}> =
           };
     }[keyof ParamList];
 
-type PathConfigAlias = {
+type ParseConfig<Params> = {
+  [K in keyof Params]?: (value: string) => Params[K];
+};
+
+type StringifyConfig<Params> = {
+  [K in keyof Params]?: (value: Params[K]) => string;
+};
+
+type PathConfigAlias<Params> = {
   /**
    * Path string to match against.
    * e.g. `/users/:id` will match `/users/1` and extract `id` param as `1`.
@@ -1054,40 +1201,42 @@ type PathConfigAlias = {
    * }
    * ```
    */
-  parse?: Record<string, (value: string) => any>;
+  parse?: ParseConfig<Params>;
 };
 
-export type PathConfig<ParamList extends {}> = Partial<PathConfigAlias> & {
-  /**
-   * An object mapping the param name to a function which converts the param value to a string.
-   * By default, all params are converted to strings using `String(value)`.
-   *
-   * @example
-   * ```js
-   * stringify: {
-   *   date: (value) => value.toISOString()
-   * }
-   * ```
-   */
-  stringify?: Record<string, (value: any) => string>;
-  /**
-   * Additional path alias that will be matched to the same screen.
-   */
-  alias?: (string | PathConfigAlias)[];
-  /**
-   * Path configuration for child screens.
-   */
-  screens?: PathConfigMap<ParamList>;
-  /**
-   * Name of the initial route to use for the navigator when the path matches.
-   */
-  initialRouteName?: keyof ParamList;
-};
+export type PathConfig<Params> = FlatType<
+  Partial<PathConfigAlias<Params>> & {
+    /**
+     * An object mapping the param name to a function which converts the param value to a string.
+     * By default, all params are converted to strings using `String(value)`.
+     * Keys are constrained to valid param names when Params type is provided.
+     *
+     * @example
+     * ```js
+     * stringify: {
+     *   date: (value) => value.toISOString()
+     * }
+     * ```
+     */
+    stringify?: StringifyConfig<Params>;
+    /**
+     * Additional path alias that will be matched to the same screen.
+     */
+    alias?: (string | PathConfigAlias<Params>)[];
+  } & (NonNullable<Params> extends NavigatorScreenParams<infer ParamList>
+      ? {
+          /**
+           * Path configuration for child screens.
+           */
+          screens?: PathConfigMap<ParamList>;
+          /**
+           * Name of the initial route to use for the navigator when the path matches.
+           */
+          initialRouteName?: keyof ParamList;
+        }
+      : {})
+>;
 
 export type PathConfigMap<ParamList extends {}> = {
-  [RouteName in keyof ParamList]?: NonNullable<
-    ParamList[RouteName]
-  > extends NavigatorScreenParams<infer T extends {}>
-    ? string | PathConfig<T>
-    : string | Omit<PathConfig<{}>, 'screens' | 'initialRouteName'>;
+  [RouteName in keyof ParamList]?: string | PathConfig<ParamList[RouteName]>;
 };