@react-navigation/core 8.0.0-alpha.1 → 8.0.0-alpha.11

package/src/types.tsx

@@ -14,6 +14,7 @@ import type {
   FlatType,
   KeyOf,
   NotUndefined,
+  StandardSchemaV1,
   UnionToIntersection,
 } from './utilities';
 
@@ -54,15 +55,10 @@ export interface RootNavigator {}
 export interface Theme {}
 
 export type RootParamList =
-  RootNavigator extends TypedNavigatorInternal<
-    infer ParamList,
-    any,
-    any,
-    any,
-    any,
-    any
-  >
-    ? ParamList
+  RootNavigator extends PrivateValueStore<[infer ParamList, any, any]>
+    ? ParamList extends {}
+      ? ParamList
+      : {}
     : {};
 
 export type DefaultNavigatorOptions<
@@ -82,58 +78,68 @@ export type DefaultNavigatorOptions<
    * Layout for the navigator.
    * Useful for wrapping with a component with access to navigator's state and options.
    */
-  layout?: (props: {
-    state: State;
-    navigation: NavigationHelpers<ParamList>;
-    descriptors: Record<
-      string,
-      Descriptor<
-        ScreenOptions,
-        NavigationProp<
-          ParamList,
-          keyof ParamList,
-          State,
-          ScreenOptions,
-          EventMap
-        >,
-        RouteProp<ParamList>
-      >
-    >;
-    children: React.ReactNode;
-  }) => React.ReactElement;
+  layout?:
+    | ((props: {
+        state: State;
+        navigation: NavigationHelpers<ParamList>;
+        descriptors: Record<
+          string,
+          Descriptor<
+            ScreenOptions,
+            NavigationProp<
+              ParamList,
+              keyof ParamList,
+              State,
+              ScreenOptions,
+              EventMap
+            >,
+            RouteProp<ParamList>
+          >
+        >;
+        children: React.ReactNode;
+      }) => React.ReactElement)
+    | undefined;
 
   /**
    * Event listeners for all the screens in the navigator.
    */
   screenListeners?:
-    | ScreenListeners<State, EventMap>
-    | ((props: {
-        route: RouteProp<ParamList>;
-        navigation: Navigation;
-      }) => ScreenListeners<State, EventMap>);
+    | (
+        | ScreenListeners<State, EventMap>
+        | ((props: {
+            route: RouteProp<ParamList>;
+            navigation: Navigation;
+          }) => ScreenListeners<State, EventMap>)
+      )
+    | undefined;
 
   /**
    * Default options for all screens under this navigator.
    */
   screenOptions?:
-    | ScreenOptions
-    | ((props: {
-        route: RouteProp<ParamList>;
-        navigation: Navigation;
-        theme: Theme;
-      }) => ScreenOptions);
+    | (
+        | ScreenOptions
+        | ((props: {
+            route: RouteProp<ParamList>;
+            navigation: Navigation;
+            theme: Theme;
+          }) => ScreenOptions)
+      )
+    | undefined;
 
   /**
    * Layout for all screens under this navigator.
    */
-  screenLayout?: (
-    props: ScreenLayoutArgs<
-      ParamList,
-      keyof ParamList,
-      ScreenOptions,
-      Navigation
-    >
-  ) => React.ReactElement;
+  screenLayout?:
+    | ((
+        props: ScreenLayoutArgs<
+          ParamList,
+          keyof ParamList,
+          ScreenOptions,
+          Navigation
+        >
+      ) => React.ReactElement)
+    | undefined;
 
   /**
    * A function returning overrides for the underlying router used by the navigator.
@@ -142,9 +148,11 @@ export type DefaultNavigatorOptions<
    *
    * This must be a pure function and cannot reference outside dynamic variables.
    */
-  router?: <Action extends NavigationAction>(
-    original: Router<State, Action>
-  ) => Partial<Router<State, Action>>;
+  router?:
+    | (<Action extends NavigationAction>(
+        original: Router<State, Action>
+      ) => Partial<Router<State, Action>>)
+    | undefined;
 
   /**
    * What should happen when the available route names change.
@@ -165,12 +173,12 @@ 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.
    */
-  routeNamesChangeBehavior?: 'firstMatch' | 'lastUnhandled';
+  routeNamesChangeBehavior?: ('firstMatch' | 'lastUnhandled') | undefined;
 };
 
 export type EventMapBase = Record<
   string,
-  { data?: any; canPreventDefault?: boolean }
+  { data?: any; canPreventDefault?: boolean | undefined }
 >;
 
 export type EventMapCore<State extends NavigationState> = {
@@ -189,7 +197,10 @@ export type EventArg<
    * Type of the event (e.g. `focus`, `blur`)
    */
   readonly type: EventName;
-  readonly target?: string;
+  /**
+   * Key of the route which received the event.
+   */
+  readonly target?: string | undefined;
 } & (CanPreventDefault extends true
   ? {
       /**
@@ -203,15 +214,14 @@ export type EventArg<
     }
   : {}) &
   (undefined extends Data
-    ? { readonly data?: Readonly<Data> }
+    ? { readonly data?: Readonly<Data> | undefined }
     : { readonly data: Readonly<Data> });
 
 export type EventListenerCallback<
   EventMap extends EventMapBase,
   EventName extends keyof EventMap,
-  EventCanPreventDefault extends
-    | boolean
-    | undefined = EventMap[EventName]['canPreventDefault'],
+  EventCanPreventDefault extends boolean | undefined =
+    EventMap[EventName]['canPreventDefault'],
 > = (
   e: EventArg<
     EventName,
@@ -311,12 +321,18 @@ type NavigationHelpersCommon<
         ? [
             screen: RouteName,
             params?: ParamList[RouteName],
-            options?: { merge?: boolean; pop?: boolean },
+            options?: {
+              merge?: boolean | undefined;
+              pop?: boolean | undefined;
+            },
           ]
         : [
             screen: RouteName,
             params: ParamList[RouteName],
-            options?: { merge?: boolean; pop?: boolean },
+            options?: {
+              merge?: boolean | undefined;
+              pop?: boolean | undefined;
+            },
           ]
       : never
   ): void;
@@ -335,9 +351,9 @@ type NavigationHelpersCommon<
       ? {
           name: RouteName;
           params: ParamList[RouteName];
-          path?: string;
-          merge?: boolean;
-          pop?: boolean;
+          path?: string | undefined;
+          merge?: boolean | undefined;
+          pop?: boolean | undefined;
         }
       : never
   ): void;
@@ -347,12 +363,25 @@ type NavigationHelpersCommon<
    *
    * @param screen Name of the route to preload.
    * @param [params] Params object for the route.
+   * @param [options.reuse] Whether to reuse a matching route or preloaded route.
    */
   preload<RouteName extends keyof ParamList>(
     ...args: RouteName extends unknown
       ? undefined extends ParamList[RouteName]
-        ? [screen: RouteName, params?: ParamList[RouteName]]
-        : [screen: RouteName, params: ParamList[RouteName]]
+        ? [
+            screen: RouteName,
+            params?: ParamList[RouteName],
+            options?: {
+              reuse?: boolean | undefined;
+            },
+          ]
+        : [
+            screen: RouteName,
+            params: ParamList[RouteName],
+            options?: {
+              reuse?: boolean | undefined;
+            },
+          ]
       : never
   ): void;
 
@@ -446,23 +475,27 @@ export type NavigationContainerProps = {
   /**
    * Initial state object for the navigation tree.
    */
-  initialState?: InitialState;
+  initialState?: InitialState | undefined;
   /**
    * Callback which is called with the latest navigation state when it changes.
    */
-  onStateChange?: (state: Readonly<NavigationState> | undefined) => void;
+  onStateChange?:
+    | ((state: Readonly<NavigationState> | undefined) => void)
+    | undefined;
   /**
    * Callback which is called after the navigation tree mounts.
    */
-  onReady?: () => void;
+  onReady?: (() => void) | undefined;
   /**
    * Callback which is called when an action is not handled.
    */
-  onUnhandledAction?: (action: Readonly<NavigationAction>) => void;
+  onUnhandledAction?:
+    | ((action: Readonly<NavigationAction>) => void)
+    | undefined;
   /**
    * Theme object for the UI elements.
    */
-  theme?: Theme;
+  theme?: Theme | undefined;
   /**
    * Children elements to render.
    */
@@ -522,31 +555,60 @@ export type CompositeNavigationProp<
        * 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),
+      ParamListOfNavigationProp<A> & ParamListOfNavigationProp<B>,
       /**
        * 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,
+      RouteNameOfNavigationProp<A>,
       /**
        * The type of state should refer to the state specified in the first type
        */
-      A extends NavigationProp<any, any, infer S> ? S : NavigationState,
+      StateOfNavigationProp<A>,
       /**
        * Screen options should refer to the options specified in the first type
        */
-      A extends NavigationProp<any, any, any, infer O> ? O : {},
+      ScreenOptionsOfNavigationProp<A>,
       /**
-       * Event consumer config should refer to the config specified in the first type
-       * This allows typechecking `addListener`/`removeListener`
+       * Event map should refer to the config specified in the first type
        */
-      A extends NavigationProp<any, any, any, any, infer E> ? E : {}
+      EventMapOfNavigationProp<A>
     >,
     'getParent'
   > & {
     getParent: A['getParent'] & B['getParent'];
-  };
+  } & // Mapped types don't preserve protected members
+  // So `Omit` drops `PrivateValueStore`'s `protected` brand
+  // We add it back so this can be used for type inference
+  PrivateValueStore<
+    [
+      ParamListOfNavigationProp<A> & ParamListOfNavigationProp<B>,
+      RouteNameOfNavigationProp<A>,
+      EventMapOfNavigationProp<A>,
+    ]
+  >;
+
+type ParamListOfNavigationProp<T> =
+  T extends PrivateValueStore<[infer ParamList, any, any]> ? ParamList : never;
+
+type RouteNameOfNavigationProp<T> =
+  T extends PrivateValueStore<[any, infer RouteName, any]>
+    ? RouteName
+    : unknown;
+
+type StateOfNavigationProp<T> = T extends {
+  getState: () => infer State extends NavigationState;
+}
+  ? State
+  : NavigationState;
+
+type ScreenOptionsOfNavigationProp<T> = T extends {
+  setOptions: (options: Partial<infer ScreenOptions>) => void;
+}
+  ? ScreenOptions
+  : {};
+
+type EventMapOfNavigationProp<T> =
+  T extends PrivateValueStore<[any, any, infer EventMap]> ? EventMap : {};
 
 export type CompositeScreenProps<
   A extends {
@@ -576,7 +638,7 @@ export type ScreenLayoutArgs<
 
 export type Descriptor<
   ScreenOptions extends {},
-  Navigation extends NavigationProp<any, any, any, any, any>,
+  Navigation extends NavigationProp<ParamListBase, any, any, any, any>,
   Route extends RouteProp<any, any>,
 > = {
   /**
@@ -629,16 +691,16 @@ export type RouteConfigComponent<
        * React component to render for this screen.
        */
       component: ScreenComponentType<ParamList, RouteName>;
-      getComponent?: never;
-      children?: never;
+      getComponent?: never | undefined;
+      children?: never | undefined;
     }
   | {
       /**
        * Lazily get a React component to render for this screen.
        */
       getComponent: () => ScreenComponentType<ParamList, RouteName>;
-      component?: never;
-      children?: never;
+      component?: never | undefined;
+      children?: never | undefined;
     }
   | {
       /**
@@ -648,8 +710,8 @@ export type RouteConfigComponent<
         route: RouteProp<ParamList, RouteName>;
         navigation: any;
       }) => React.ReactNode;
-      component?: never;
-      getComponent?: never;
+      component?: never | undefined;
+      getComponent?: never | undefined;
     };
 
 export type RouteConfigProps<
@@ -665,7 +727,7 @@ export type RouteConfigProps<
    * If the key changes, existing screens with this name will be removed or reset.
    * Useful when we have some common screens and have conditional rendering.
    */
-  navigationKey?: string;
+  navigationKey?: string | undefined;
 
   /**
    * Route name of this screen.
@@ -676,31 +738,39 @@ export type RouteConfigProps<
    * Navigator options for this screen.
    */
   options?:
-    | ScreenOptions
-    | ((props: {
-        route: RouteProp<ParamList, RouteName>;
-        navigation: Navigation;
-        theme: Theme;
-      }) => ScreenOptions);
+    | (
+        | ScreenOptions
+        | ((props: {
+            route: RouteProp<ParamList, RouteName>;
+            navigation: Navigation;
+            theme: Theme;
+          }) => ScreenOptions)
+      )
+    | undefined;
 
   /**
    * Event listeners for this screen.
    */
   listeners?:
-    | ScreenListeners<State, EventMap>
-    | ((props: {
-        route: RouteProp<ParamList, RouteName>;
-        navigation: Navigation;
-      }) => ScreenListeners<State, EventMap>);
+    | (
+        | ScreenListeners<State, EventMap>
+        | ((props: {
+            route: RouteProp<ParamList, RouteName>;
+            navigation: Navigation;
+          }) => ScreenListeners<State, EventMap>)
+      )
+    | undefined;
 
   /**
    * Layout for this screen.
    * Useful for wrapping the screen with custom containers.
    * e.g. for styling, error boundaries, suspense, etc.
    */
-  layout?: (
-    props: ScreenLayoutArgs<ParamList, RouteName, ScreenOptions, Navigation>
-  ) => React.ReactElement;
+  layout?:
+    | ((
+        props: ScreenLayoutArgs<ParamList, RouteName, ScreenOptions, Navigation>
+      ) => React.ReactElement)
+    | undefined;
 
   /**
    * Function to return an unique ID for this screen.
@@ -708,16 +778,18 @@ export type RouteConfigProps<
    * For a given screen name, there will always be only one screen corresponding to an ID.
    * If `undefined` is returned, it acts same as no `getId` being specified.
    */
-  getId?: ({
-    params,
-  }: {
-    params: Readonly<ParamList[RouteName]>;
-  }) => string | undefined;
+  getId?:
+    | (({
+        params,
+      }: {
+        params: Readonly<ParamList[RouteName]>;
+      }) => string | undefined)
+    | undefined;
 
   /**
    * Initial params object for the route.
    */
-  initialParams?: Partial<ParamList[RouteName]>;
+  initialParams?: Partial<ParamList[RouteName]> | undefined;
 };
 
 export type RouteConfig<
@@ -746,35 +818,41 @@ export type RouteGroupConfig<
    * Optional key for the screens in this group.
    * If the key changes, all existing screens in this group will be removed or reset.
    */
-  navigationKey?: string;
+  navigationKey?: string | undefined;
 
   /**
    * Navigator options for this screen.
    */
   screenOptions?:
-    | ScreenOptions
-    | ((props: {
-        route: RouteProp<ParamList, keyof ParamList>;
-        navigation: Navigation;
-        theme: Theme;
-      }) => ScreenOptions);
+    | (
+        | ScreenOptions
+        | ((props: {
+            route: RouteProp<ParamList, keyof ParamList>;
+            navigation: Navigation;
+            theme: Theme;
+          }) => ScreenOptions)
+      )
+    | undefined;
 
   /**
    * Layout for the screens inside the group.
    * This will override the `screenLayout` of parent group or navigator.
    */
   screenLayout?:
-    | ((
-        props: ScreenLayoutArgs<
-          ParamList,
-          keyof ParamList,
-          ScreenOptions,
-          Navigation
-        >
-      ) => React.ReactElement)
-    | {
-        // FIXME: TypeScript doesn't seem to infer `navigation` correctly without this
-      };
+    | (
+        | ((
+            props: ScreenLayoutArgs<
+              ParamList,
+              keyof ParamList,
+              ScreenOptions,
+              Navigation
+            >
+          ) => React.ReactElement)
+        | {
+            // FIXME: TypeScript doesn't seem to infer `navigation` correctly without this
+          }
+      )
+    | undefined;
 
   /**
    * Children React Elements to extract the route configuration from.
@@ -826,6 +904,31 @@ export type NavigationContainerEventMap = {
       stack: string | undefined;
     };
   };
+  /**
+   * Event that fires when an event is emitted.
+   * Only intended for debugging purposes, don't use it for app logic.
+   * This event will be emitted after all listeners have been called.
+   */
+  __unsafe_event__: {
+    data: {
+      /**
+       * The type of the event that was emitted.
+       */
+      type: string;
+      /**
+       * The data object passed when emitting the event.
+       */
+      data: unknown;
+      /**
+       * The key of the target route which received the event.
+       */
+      target: string | undefined;
+      /**
+       * Whether `event.preventDefault()` was called on this event.
+       */
+      defaultPrevented: boolean | undefined;
+    };
+  };
 };
 
 /**
@@ -1026,40 +1129,39 @@ type NavigationListForGroups<ParentList, Groups> =
       >
     : {};
 
-export type NavigationContainerRef<ParamList extends {}> =
-  NavigationHelpers<ParamList> &
-    EventConsumer<NavigationContainerEventMap> & {
-      /**
-       * Reset the navigation state of the root navigator to the provided state.
-       *
-       * @param state Navigation state object.
-       */
-      resetRoot(state?: PartialState<NavigationState> | NavigationState): void;
-      /**
-       * Get the rehydrated navigation state of the navigation tree.
-       */
-      getRootState(): NavigationState;
-      /**
-       * Get the currently focused navigation route.
-       */
-      getCurrentRoute(): MaybeParamListRoute<ParamList> | undefined;
-      /**
-       * Get the currently focused route's options.
-       */
-      getCurrentOptions(): object | undefined;
-      /**
-       * Whether the navigation container is ready to handle actions.
-       */
-      isReady(): boolean;
-      /**
-       * Stub function for setOptions on navigation object for use with useNavigation.
-       */
-      setOptions(): never;
-      /**
-       * Stub function for getParent on navigation object for use with useNavigation.
-       */
-      getParent(): undefined;
-    };
+export type NavigationContainerRef<ParamList extends {}> = Omit<
+  NavigationHelpers<ParamList>,
+  keyof NavigationHelpersRoute<{}>
+> &
+  NavigationHelpersRoute<{}> &
+  EventConsumer<NavigationContainerEventMap> & {
+    /**
+     * Reset the navigation state of the root navigator to the provided state.
+     *
+     * @param state Navigation state object.
+     */
+    resetRoot(state?: PartialState<NavigationState> | NavigationState): void;
+    /**
+     * Get the rehydrated navigation state of the navigation tree.
+     */
+    getRootState(): NavigationState;
+    /**
+     * Get the currently focused navigation route.
+     */
+    getCurrentRoute(): MaybeParamListRoute<ParamList> | undefined;
+    /**
+     * Get the currently focused route's options.
+     */
+    getCurrentOptions(): object | undefined;
+    /**
+     * Whether the navigation container is ready to handle actions.
+     */
+    isReady(): boolean;
+    /**
+     * Stub function for setOptions on navigation object for use with useNavigation.
+     */
+    setOptions(): never;
+  };
 
 export type NavigationContainerRefWithCurrent<ParamList extends {}> =
   NavigationContainerRef<ParamList> & {
@@ -1079,18 +1181,51 @@ export type NavigatorTypeBagBase = {
   Navigator: React.ComponentType<any>;
 };
 
+type TypedNavigatorComponent<Bag extends NavigatorTypeBagBase> =
+  React.ComponentType<
+    Omit<
+      React.ComponentProps<
+        TypedNavigatorInternal<
+          Bag['ParamList'],
+          Bag['State'],
+          Bag['ScreenOptions'],
+          Bag['EventMap'],
+          Bag['NavigationList'],
+          Bag['Navigator']
+        >['Navigator']
+      >,
+      'children'
+    >
+  >;
+
+type TypedNavigatorStaticDecorated<Bag extends NavigatorTypeBagBase, Config> = {
+  getComponent: () => React.ComponentType<{}>;
+  config: Config;
+} & PrivateValueStore<[Bag['ParamList'], Bag['NavigationList'], unknown]>;
+
+type TypedNavigatorStatic<Bag extends NavigatorTypeBagBase, Config> = {
+  config: Config;
+  with: (
+    Component: React.ComponentType<{
+      Navigator: TypedNavigatorComponent<Bag>;
+    }>
+  ) => TypedNavigatorStaticDecorated<Bag, Config>;
+  getComponent: () => TypedNavigatorComponent<Bag>;
+};
+
 export type TypedNavigator<
   Bag extends NavigatorTypeBagBase,
   Config = unknown,
-> = TypedNavigatorInternal<
-  Bag['ParamList'],
-  Bag['State'],
-  Bag['ScreenOptions'],
-  Bag['EventMap'],
-  Bag['NavigationList'],
-  Bag['Navigator']
-> &
-  (undefined extends Config ? {} : { config: Config }) &
+> = (undefined extends Config
+  ? TypedNavigatorInternal<
+      Bag['ParamList'],
+      Bag['State'],
+      Bag['ScreenOptions'],
+      Bag['EventMap'],
+      Bag['NavigationList'],
+      Bag['Navigator']
+    >
+  : TypedNavigatorStatic<Bag, Config>) &
   PrivateValueStore<[Bag['ParamList'], Bag['NavigationList'], unknown]>;
 
 type TypedNavigatorInternal<
@@ -1145,33 +1280,38 @@ export type NavigatorScreenParams<ParamList extends {}> =
       merge?: never;
       initial?: never;
       pop?: never;
-      path?: string;
+      preload?: never;
+      path?: string | undefined;
       state: PartialState<NavigationState> | NavigationState | undefined;
     }
   | {
       [RouteName in keyof ParamList]: undefined extends ParamList[RouteName]
         ? {
             screen: RouteName;
-            params?: ParamList[RouteName];
-            merge?: boolean;
-            initial?: boolean;
-            path?: string;
-            pop?: boolean;
+            params?: ParamList[RouteName] | undefined;
+            merge?: boolean | undefined;
+            initial?: boolean | undefined;
+            path?: string | undefined;
+            pop?: boolean | undefined;
+            preload?: boolean | undefined;
             state?: never;
           }
         : {
             screen: RouteName;
             params: ParamList[RouteName];
-            merge?: boolean;
-            initial?: boolean;
-            path?: string;
-            pop?: boolean;
+            merge?: boolean | undefined;
+            initial?: boolean | undefined;
+            path?: string | undefined;
+            pop?: boolean | undefined;
+            preload?: boolean | undefined;
             state?: never;
           };
     }[keyof ParamList];
 
 type ParseConfig<Params> = {
-  [K in keyof Params]?: (value: string) => Params[K];
+  [K in keyof Params]?:
+    | ((value: string) => Params[K])
+    | StandardSchemaV1<string | string[] | null | undefined, Params[K]>;
 };
 
 type StringifyConfig<Params> = {
@@ -1189,9 +1329,9 @@ type PathConfigAlias<Params> = {
    * By default, paths are relating to the path config on the parent screen.
    * If `exact` is set to `true`, the parent path configuration is not used.
    */
-  exact?: boolean;
+  exact?: boolean | undefined;
   /**
-   * An object mapping the param name to a function which parses the param value.
+   * An object mapping the param name to a parser function or a Standard Schema.
    *
    * @example
    * ```js
@@ -1201,7 +1341,7 @@ type PathConfigAlias<Params> = {
    * }
    * ```
    */
-  parse?: ParseConfig<Params>;
+  parse?: ParseConfig<Params> | undefined;
 };
 
 export type PathConfig<Params> = FlatType<
@@ -1218,25 +1358,28 @@ export type PathConfig<Params> = FlatType<
      * }
      * ```
      */
-    stringify?: StringifyConfig<Params>;
+    stringify?: StringifyConfig<Params> | undefined;
     /**
      * Additional path alias that will be matched to the same screen.
      */
-    alias?: (string | PathConfigAlias<Params>)[];
+    alias?: (string | PathConfigAlias<Params>)[] | undefined;
   } & (NonNullable<Params> extends NavigatorScreenParams<infer ParamList>
       ? {
           /**
            * Path configuration for child screens.
            */
-          screens?: PathConfigMap<ParamList>;
+          screens?: PathConfigMap<ParamList> | undefined;
           /**
            * Name of the initial route to use for the navigator when the path matches.
            */
-          initialRouteName?: keyof ParamList;
+          initialRouteName?: Extract<keyof ParamList, string> | undefined;
         }
       : {})
 >;
 
 export type PathConfigMap<ParamList extends {}> = {
-  [RouteName in keyof ParamList]?: string | PathConfig<ParamList[RouteName]>;
+  [RouteName in keyof ParamList]?:
+    | string
+    | PathConfig<ParamList[RouteName]>
+    | undefined;
 };