@react-navigation/core 8.0.0-alpha.4 → 8.0.0-alpha.41

package/lib/typescript/src/types.d.ts

@@ -1,6 +1,7 @@
 import type { DefaultRouterOptions, InitialState, NavigationAction, NavigationState, ParamListBase, PartialState, Route, Router } from '@react-navigation/routers';
 import type * as React from 'react';
-import type { FlatType, KeyOf, NotUndefined, UnionToIntersection } from './utilities';
+import type { Theme as InternalTheme } from './internal.js';
+import type { FlatType, KeyOf, NotUndefined, StandardSchemaV1, UnionToIntersection } from './utilities.js';
 /**
  * Root navigator used in the app.
  * It's used for the global types in the app.
@@ -33,9 +34,14 @@ export interface RootNavigator {
  * }
  * ```
  */
-export interface Theme {
+export interface Theme extends InternalTheme {
 }
-export type RootParamList = RootNavigator extends TypedNavigatorInternal<infer ParamList, any, any, any, any, any> ? ParamList : {};
+export type RootParamList = RootNavigator extends PrivateValueStore<[
+    infer ParamList extends {},
+    any,
+    any,
+    any
+]> ? ParamList : {};
 export type DefaultNavigatorOptions<ParamList extends ParamListBase, State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase, Navigation> = DefaultRouterOptions<KeyOf<ParamList>> & {
     /**
      * Children React Elements to extract the route configuration from.
@@ -46,31 +52,31 @@ export type DefaultNavigatorOptions<ParamList extends ParamListBase, State exten
      * Layout for the navigator.
      * Useful for wrapping with a component with access to navigator's state and options.
      */
-    layout?: (props: {
+    layout?: ((props: {
         state: State;
-        navigation: NavigationHelpers<ParamList>;
-        descriptors: Record<string, Descriptor<ScreenOptions, NavigationProp<ParamList, keyof ParamList, State, ScreenOptions, EventMap>, RouteProp<ParamList>>>;
+        navigation: NavigationHelpers<ParamList, State>;
+        descriptors: Record<string, Descriptor<ScreenOptions, NavigationProp<ParamList, keyof ParamList, State, ScreenOptions, EventMap>, ScreenRouteProp<ParamList>>>;
         children: React.ReactNode;
-    }) => React.ReactElement;
+    }) => React.ReactElement) | undefined;
     /**
      * Event listeners for all the screens in the navigator.
      */
-    screenListeners?: ScreenListeners<State, EventMap> | ((props: {
-        route: RouteProp<ParamList>;
+    screenListeners?: (ScreenListeners<State, EventMap> | ((props: {
+        route: ScreenRouteProp<ParamList>;
         navigation: Navigation;
-    }) => ScreenListeners<State, EventMap>);
+    }) => ScreenListeners<State, EventMap>)) | undefined;
     /**
      * Default options for all screens under this navigator.
      */
-    screenOptions?: ScreenOptions | ((props: {
-        route: RouteProp<ParamList>;
+    screenOptions?: (ScreenOptions | ((props: {
+        route: ScreenRouteProp<ParamList>;
         navigation: Navigation;
         theme: Theme;
-    }) => ScreenOptions);
+    }) => 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.
      * The overrides will be shallow merged onto the original router.
@@ -78,7 +84,7 @@ export type DefaultNavigatorOptions<ParamList extends ParamListBase, State exten
      *
      * 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.
      * e.g. when different screens are rendered based on a condition.
@@ -98,13 +104,13 @@ export type DefaultNavigatorOptions<ParamList extends ParamListBase, State exten
      * - 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;
+    canPreventDefault?: boolean | undefined;
 }>;
-export type EventMapCore<State extends NavigationState> = {
+export type EventMapCore<in out State extends NavigationState> = {
     focus: {
         data: undefined;
     };
@@ -131,7 +137,7 @@ export type EventArg<EventName, CanPreventDefault extends boolean | undefined =
     /**
      * Key of the route which received the event.
      */
-    readonly target?: string;
+    readonly target?: string | undefined;
 } & (CanPreventDefault extends true ? {
     /**
      * Whether `event.preventDefault()` was called on this event object.
@@ -142,12 +148,12 @@ export type EventArg<EventName, CanPreventDefault extends boolean | undefined =
      */
     preventDefault(): void;
 } : {}) & (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']> = (e: EventArg<EventName, undefined extends EventCanPreventDefault ? false : EventCanPreventDefault, EventMap[EventName]['data']>) => void;
-export type EventConsumer<EventMap extends EventMapBase> = {
+export type EventListenerCallback<in out EventMap extends EventMapBase, in out EventName extends keyof EventMap, in out EventCanPreventDefault extends boolean | undefined = EventMap[EventName]['canPreventDefault']> = (e: EventArg<EventName, undefined extends EventCanPreventDefault ? false : EventCanPreventDefault, EventMap[EventName]['data']>) => void;
+export type EventConsumer<in out EventMap extends EventMapBase> = {
     /**
      * Subscribe to events from the parent navigator.
      *
@@ -157,7 +163,7 @@ export type EventConsumer<EventMap extends EventMapBase> = {
     addListener<EventName extends KeyOf<EventMap>>(type: EventName, callback: EventListenerCallback<EventMap, EventName>): () => void;
     removeListener<EventName extends KeyOf<EventMap>>(type: EventName, callback: EventListenerCallback<EventMap, EventName>): void;
 };
-export type EventEmitter<EventMap extends EventMapBase> = {
+export type EventEmitter<in out EventMap extends EventMapBase> = {
     /**
      * Emit an event to child screens.
      *
@@ -168,7 +174,7 @@ export type EventEmitter<EventMap extends EventMapBase> = {
      */
     emit<EventName extends KeyOf<EventMap>>(options: {
         type: EventName;
-        target?: string;
+        target?: string | undefined;
     } & (EventMap[EventName]['canPreventDefault'] extends true ? {
         canPreventDefault: true;
     } : {}) & (undefined extends EventMap[EventName]['data'] ? {
@@ -177,7 +183,7 @@ export type EventEmitter<EventMap extends EventMapBase> = {
         data: EventMap[EventName]['data'];
     })): EventArg<EventName, EventMap[EventName]['canPreventDefault'], EventMap[EventName]['data']>;
 };
-export declare class PrivateValueStore<T extends [any, any, any]> {
+export declare class PrivateValueStore<T extends [any, any, any, any]> {
     /**
      * UGLY HACK! DO NOT USE THE TYPE!!!
      *
@@ -190,6 +196,25 @@ export declare class PrivateValueStore<T extends [any, any, any]> {
      */
     protected ''?: T;
 }
+type NavigatorLike = {
+    Navigator: React.ComponentType<any>;
+    Screen: unknown;
+    Group: unknown;
+} | {
+    config: unknown;
+    getComponent: () => React.ComponentType<any>;
+};
+export type ParamListForNavigator<T extends {}> = T extends NavigatorLike ? T extends PrivateValueStore<[infer ParamList extends {}, any, any, any]> ? ParamList : T : T;
+type NestedNavigatorForScreenParams<T, Params = NotUndefined<T>> = [
+    Params
+] extends [never] ? never : Params extends NavigatorScreenParams<infer Navigator> ? Navigator extends PrivateValueStore<[any, any, any, any]> ? Navigator extends NavigatorLike ? Navigator : never : never : never;
+export type NestedNavigatorsForParamList<ParamList extends {}> = {
+    [RouteName in keyof ParamList as NestedNavigatorForScreenParams<ParamList[RouteName]> extends never ? never : RouteName]: NestedNavigatorForScreenParams<ParamList[RouteName]>;
+};
+type NavigateOptions = {
+    merge?: boolean | undefined;
+    pop?: boolean | undefined;
+};
 type NavigationHelpersCommon<ParamList extends ParamListBase, State extends NavigationState = NavigationState> = {
     /**
      * Dispatch an action or an update function to the router.
@@ -210,34 +235,12 @@ type NavigationHelpersCommon<ParamList extends ParamListBase, State extends Navi
     navigate<RouteName extends keyof ParamList>(...args: RouteName extends unknown ? undefined extends ParamList[RouteName] ? [
         screen: RouteName,
         params?: ParamList[RouteName],
-        options?: {
-            merge?: boolean;
-            pop?: boolean;
-        }
+        options?: NavigateOptions
     ] : [
         screen: RouteName,
         params: ParamList[RouteName],
-        options?: {
-            merge?: boolean;
-            pop?: boolean;
-        }
+        options?: NavigateOptions
     ] : never): void;
-    /**
-     * Navigate to a route in current navigation tree.
-     *
-     * @param options.name Name of the route to navigate to.
-     * @param [options.params] Params object for the route.
-     * @param [options.path] Path to associate the route with (e.g. for deep links).
-     * @param [options.merge] Whether to merge the params onto the route. Defaults to `false`.
-     * @param [options.pop] Whether to pop routes in a stack to go back to the matching route. Defaults to `false`.
-     */
-    navigate<RouteName extends keyof ParamList>(options: RouteName extends unknown ? {
-        name: RouteName;
-        params: ParamList[RouteName];
-        path?: string;
-        merge?: boolean;
-        pop?: boolean;
-    } : never): void;
     /**
      * Preloads the route in current navigation tree.
      *
@@ -277,9 +280,9 @@ type NavigationHelpersCommon<ParamList extends ParamListBase, State extends Navi
      * 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>> = {
+};
+type ParamType<ParamList extends {}, RouteName, IsPartial extends boolean = false> = RouteName extends keyof ParamList ? ParamList[RouteName] extends undefined ? undefined : IsPartial extends true ? Partial<ParamList[RouteName]> : ParamList[RouteName] : unknown;
+type NavigationHelpersRoute<in out ParamList extends {}, in out RouteName extends keyof ParamList = KeyOf<ParamList>> = {
     /**
      * Update the param object for the route.
      * The new params will be shallow merged with the old one.
@@ -302,34 +305,34 @@ type NavigationHelpersRoute<ParamList extends {}, RouteName extends keyof ParamL
      */
     pushParams(params: ParamType<ParamList, RouteName>): void;
 };
-export type NavigationHelpers<ParamList extends ParamListBase, EventMap extends EventMapBase = {}> = NavigationHelpersCommon<ParamList> & EventEmitter<EventMap> & NavigationHelpersRoute<ParamList, keyof ParamList>;
+export type NavigationHelpers<ParamList extends ParamListBase, State extends NavigationState = NavigationState<ParamList>, EventMap extends EventMapBase = {}> = NavigationHelpersCommon<ParamList, State> & EventEmitter<EventMap> & NavigationHelpersRoute<ParamList, keyof ParamList> & PrivateValueStore<[ParamList, unknown, unknown, unknown]>;
 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.
      */
     children: React.ReactNode;
 };
-export type NavigationProp<ParamList extends {}, 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'> & {
+type NavigationPropBase<ParamList extends {}, RouteName extends keyof ParamList = KeyOf<ParamList>, State extends NavigationState = NavigationState<ParamList>, ScreenOptions extends {} = {}, EventMap extends EventMapBase = {}, ActionHelpers extends Record<string, (...args: any) => void> = {}> = NavigationHelpersCommon<ParamList, State> & {
     /**
      * Update the options for the route.
      * The options object will be shallow merged with default options object.
@@ -337,6 +340,8 @@ export type NavigationProp<ParamList extends {}, RouteName extends keyof ParamLi
      * @param options Partial options object for the current screen.
      */
     setOptions(options: Partial<ScreenOptions>): void;
+} & NavigationHelpersRoute<ParamList, RouteName> & ActionHelpers & EventConsumer<EventMap & EventMapCore<State>>;
+export type NavigationProp<ParamList extends {}, RouteName extends keyof ParamList = KeyOf<ParamList>, State extends NavigationState = NavigationState<ParamList>, ScreenOptions extends {} = {}, EventMap extends EventMapBase = {}, ActionHelpers extends Record<string, (...args: any) => void> = {}> = NavigationPropBase<ParamList, RouteName, State, ScreenOptions, EventMap, ActionHelpers> & {
     /**
      * 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.
@@ -346,51 +351,62 @@ export type NavigationProp<ParamList extends {}, RouteName extends keyof ParamLi
      */
     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>> = Route<Extract<RouteName, string>, ParamList[RouteName]>;
-export type CompositeNavigationProp<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<
+} & PrivateValueStore<[ParamList, RouteName, EventMap, ActionHelpers]>;
+export type RouteProp<in out ParamList extends ParamListBase, in out RouteName extends keyof ParamList = KeyOf<ParamList>> = Route<Extract<RouteName, string>, ParamList[RouteName]>;
+type ScreenRouteProp<ParamList extends ParamListBase, RouteName extends keyof ParamList = KeyOf<ParamList>> = {
+    [Name in Extract<RouteName, string>]: RouteProp<ParamList, Name>;
+}[Extract<RouteName, string>];
+export type CompositeNavigationProp<A extends NavigationProp<ParamListBase, any, any, any, any>, B extends NavigationProp<ParamListBase, any, any, any, any>> = CompositeNavigationPropInternal<A, B, 
 /**
  * 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
+ * Event map should refer to the config 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'> & {
+EventMapOfNavigationProp<A>>;
+type CompositeNavigationPropInternal<A extends NavigationProp<ParamListBase, any, any, any, any>, B extends NavigationProp<ParamListBase, any, any, any, any>, ParamList extends {}, RouteName extends keyof ParamList, EventMap extends EventMapBase> = // Action helpers are read from the private brand (4th slot) instead of
+ActionHelpersOfNavigationProp<A> & ActionHelpersOfNavigationProp<B> & NavigationPropBase<ParamList, RouteName, StateOfNavigationProp<A>, ScreenOptionsOfNavigationProp<A>, EventMap> & {
     getParent: A['getParent'] & B['getParent'];
-};
-export type CompositeScreenProps<A extends {
+} & PrivateValueStore<[
+    ParamList,
+    RouteName,
+    EventMap,
+    ActionHelpersOfNavigationProp<A> & ActionHelpersOfNavigationProp<B>
+]>;
+type PrivateValueOfNavigationProp<T> = T extends PrivateValueStore<infer Value> ? Value : [never, unknown, {}, {}];
+type ParamListOfNavigationProp<T> = PrivateValueOfNavigationProp<T>[0];
+type RouteNameOfNavigationProp<T> = PrivateValueOfNavigationProp<T>[1];
+type ActionHelpersOfNavigationProp<T> = PrivateValueOfNavigationProp<T>[3];
+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> = PrivateValueOfNavigationProp<T>[2];
+export type CompositeScreenProps<in out A extends {
     navigation: NavigationProp<ParamListBase, string, any, any, any>;
     route: RouteProp<ParamListBase>;
-}, B extends {
+}, in out B extends {
     navigation: NavigationProp<ParamListBase, string, any, any, any>;
 }> = {
     navigation: CompositeNavigationProp<A['navigation'], B['navigation']>;
     route: A['route'];
 };
-export type ScreenLayoutArgs<ParamList extends ParamListBase, RouteName extends keyof ParamList, ScreenOptions extends {}, Navigation> = {
-    route: RouteProp<ParamList, RouteName>;
+export type ScreenLayoutArgs<in out ParamList extends ParamListBase, in out RouteName extends keyof ParamList, in out ScreenOptions extends {}, in out Navigation> = {
+    route: ScreenRouteProp<ParamList, RouteName>;
     options: ScreenOptions;
     navigation: Navigation;
     theme: Theme;
     children: React.ReactElement;
 };
-export type Descriptor<ScreenOptions extends {}, Navigation extends NavigationProp<any, any, any, any, any>, Route extends RouteProp<any, any>> = {
+export type Descriptor<out ScreenOptions extends {}, out Navigation extends NavigationProp<ParamListBase, any, any, any, any>, out Route extends RouteProp<any, any>> = {
     /**
      * Render the component associated with this route.
      */
@@ -408,7 +424,7 @@ export type Descriptor<ScreenOptions extends {}, Navigation extends NavigationPr
      */
     navigation: Navigation;
 };
-export type ScreenListeners<State extends NavigationState, EventMap extends EventMapBase> = Partial<{
+export type ScreenListeners<in out State extends NavigationState, in out EventMap extends EventMapBase> = Partial<{
     [EventName in keyof (EventMap & EventMapCore<State>)]: EventListenerCallback<EventMap & EventMapCore<State>, EventName>;
 }>;
 type ScreenComponentType<ParamList extends ParamListBase, RouteName extends keyof ParamList> = React.ComponentType<{
@@ -440,13 +456,13 @@ export type RouteConfigComponent<ParamList extends ParamListBase, RouteName exte
     component?: never;
     getComponent?: never;
 };
-export type RouteConfigProps<ParamList extends ParamListBase, RouteName extends keyof ParamList, State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase, Navigation> = {
+export type RouteConfigProps<in out ParamList extends ParamListBase, in out RouteName extends keyof ParamList, in out State extends NavigationState, in out ScreenOptions extends {}, in out EventMap extends EventMapBase, in out Navigation> = {
     /**
      * Optional key for this screen. This doesn't need to be unique.
      * 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.
      */
@@ -454,58 +470,58 @@ export type RouteConfigProps<ParamList extends ParamListBase, RouteName extends
     /**
      * Navigator options for this screen.
      */
-    options?: ScreenOptions | ((props: {
+    options?: (ScreenOptions | ((props: {
         route: RouteProp<ParamList, RouteName>;
         navigation: Navigation;
         theme: Theme;
-    }) => ScreenOptions);
+    }) => ScreenOptions)) | undefined;
     /**
      * Event listeners for this screen.
      */
-    listeners?: ScreenListeners<State, EventMap> | ((props: {
+    listeners?: (ScreenListeners<State, EventMap> | ((props: {
         route: RouteProp<ParamList, RouteName>;
         navigation: Navigation;
-    }) => ScreenListeners<State, EventMap>);
+    }) => 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.
      * Receives an object with the route params.
      * 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, }: {
+    getId?: (({ params, }: {
         params: Readonly<ParamList[RouteName]>;
-    }) => string | undefined;
+    }) => string | undefined) | undefined;
     /**
      * Initial params object for the route.
      */
-    initialParams?: Partial<ParamList[RouteName]>;
+    initialParams?: Partial<ParamList[RouteName]> | undefined;
 };
 export type RouteConfig<ParamList extends ParamListBase, RouteName extends keyof ParamList, State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase, Navigation> = RouteConfigProps<ParamList, RouteName, State, ScreenOptions, EventMap, Navigation> & RouteConfigComponent<ParamList, RouteName>;
-export type RouteGroupConfig<ParamList extends ParamListBase, ScreenOptions extends {}, Navigation> = {
+export type RouteGroupConfig<in out ParamList extends ParamListBase, in out ScreenOptions extends {}, in out Navigation> = {
     /**
      * 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>;
+    screenOptions?: (ScreenOptions | ((props: {
+        route: ScreenRouteProp<ParamList>;
         navigation: Navigation;
         theme: Theme;
-    }) => ScreenOptions);
+    }) => 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) | {};
+    screenLayout?: (((props: ScreenLayoutArgs<ParamList, keyof ParamList, ScreenOptions, Navigation>) => React.ReactElement) | {}) | undefined;
     /**
      * Children React Elements to extract the route configuration from.
      * Only `Screen`, `Group` and `React.Fragment` are supported as children.
@@ -573,15 +589,19 @@ export type NavigationContainerEventMap = {
             /**
              * The data object passed when emitting the event.
              */
-            data: unknown;
+            data?: unknown;
             /**
              * The key of the target route which received the event.
              */
-            target: string | undefined;
+            target?: string | undefined;
             /**
              * Whether `event.preventDefault()` was called on this event.
              */
-            defaultPrevented: boolean | undefined;
+            defaultPrevented?: boolean | undefined;
+            /**
+             * Prevent the default action which happens on this event.
+             */
+            preventDefault?: (() => void) | undefined;
         };
     };
 };
@@ -628,46 +648,74 @@ export type GenericNavigation<ParamList extends {}> = Omit<NavigationProp<ParamL
      */
     setOptions(options: unknown): void;
 };
-export type RouteForName<ParamList extends {}, RouteName extends string> = Extract<ParamListRoute<ParamList>, {
-    name: RouteName;
-}>;
+export type RouteForName<ParamList extends {}, RouteName extends string> = string extends RouteName ? ParamListRoute<ParamList> : RouteForNameInternal<ParamList, RouteName>;
+type RouteForNameInternal<ParamList extends {}, RouteName extends string> = (RouteName extends KeyOf<ParamList> ? RouteProp<ParamList, RouteName> : never) | RouteForNameNested<NestedParamLists<ParamList>, RouteName>;
+type RouteForNameNested<ParamLists, RouteName extends string> = ParamLists extends {} ? RouteForNameInternal<ParamLists, RouteName> : never;
+/**
+ * Union of param lists of the nested navigators in a param list.
+ */
+export type NestedParamLists<ParamList extends {}> = {
+    [RouteName in keyof ParamList]: NavigatorScreenParams<{}> extends ParamList[RouteName] ? NotUndefined<ParamList[RouteName]> extends NavigatorScreenParams<infer T> ? ParamListForNavigator<T> : never : never;
+}[keyof ParamList];
 type ParamListRoute<ParamList extends {}> = {
-    [RouteName in keyof ParamList]: NavigatorScreenParams<{}> extends ParamList[RouteName] ? NotUndefined<ParamList[RouteName]> extends NavigatorScreenParams<infer T> ? ParamListRoute<T> | RouteProp<ParamList, RouteName> : RouteProp<ParamList, RouteName> : RouteProp<ParamList, RouteName>;
+    [RouteName in keyof ParamList]: NavigatorScreenParams<{}> extends ParamList[RouteName] ? NotUndefined<ParamList[RouteName]> extends NavigatorScreenParams<infer T> ? ParamListRoute<ParamListForNavigator<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 BasicNavigationComposite<Navigation extends NavigationProp<any, any, any, any, any>, Parent extends NavigationProp<any, any, any, any, any> | undefined> = Parent extends undefined ? Navigation : CompositeNavigationProp<Navigation, NonNullable<Parent>>;
 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 ? {} : {
+    [RouteName in keyof ParamList]: (NavigatorScreenParams<{}> extends ParamList[RouteName] ? NotUndefined<ParamList[RouteName]> extends NavigatorScreenParams<infer T> ? ParamListForNavigator<T> extends infer NestedParamList extends {} ? keyof NestedParamList extends ExcludedRouteNames ? {} : BasicNavigationList<NestedParamList, 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 InheritedParentParams<ParentParamList, ParamList> = {
+    [K in keyof ParentParamList as K extends keyof ParamList ? never : string extends K ? never : K]: ParentParamList[K];
 };
-type NavigationListForStaticConfig<ParentList, Navigator> = Navigator extends {
+type GenericNavigationComposite<ParamList extends ParamListBase, RouteName extends keyof ParamList, Parent> = Parent extends NavigationProp<any, any, any, any, any> ? ParamListOfNavigationProp<Parent> extends infer ParentParamList ? NavigationProp<ParamList & InheritedParentParams<ParentParamList, ParamList>, RouteName> & {
+    getParent: Parent['getParent'];
+} : never : NavigationProp<ParamList, RouteName>;
+type NavigationListForScreenParams<T extends {}, ParamList extends ParamListBase, RouteName extends keyof ParamList, ExcludedRouteNames, Parent extends NavigationProp<any, any, any, any, any> | undefined> = T extends PrivateValueStore<[any, any, any, any]> & NavigatorLike ? NavigationListForNestedInternal<T, GenericNavigationComposite<ParamList, RouteName, Parent>> : NavigationListForParamListScreenParams<T, ParamList, RouteName, ExcludedRouteNames, Parent>;
+type NavigationListForParamListScreenParams<T extends {}, ParamList extends ParamListBase, RouteName extends keyof ParamList, ExcludedRouteNames, Parent extends NavigationProp<any, any, any, any, any> | undefined> = T extends ParamListBase ? BasicNavigationListForParamList<T, ExcludedRouteNames, GenericNavigationComposite<ParamList, RouteName, Parent>> : {};
+type BasicNavigationListForParamList<ParamList extends ParamListBase, 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> ? NavigationListForScreenParams<T, ParamList, RouteName, ExcludedRouteNames, Parent> : {} : {}) & (RouteName extends ExcludedRouteNames ? {} : {
+        [Key in RouteName]: GenericNavigationComposite<ParamList, RouteName, Parent>;
+    });
+}[keyof ParamList]>;
+export type NavigationListForNavigator<Navigator> = Navigator extends PrivateValueStore<infer Value> ? Value[1] : {};
+export type NavigationListForNested<Navigator> = NavigationListForNestedInternal<Navigator> extends infer NavigationList ? Navigator extends PrivateValueStore<[infer ParamList, any, any, any]> ? ParamList extends {} ? NavigationList & BasicNavigationList<ParamList, keyof NavigationList, undefined> : NavigationList : NavigationList : never;
+type NavigationListForNestedInternal<Navigator, Parent = undefined, NavigatorList extends Record<string, any> = NavigationListForNavigator<Navigator>, Navigators = NestedNavigatorsOf<Navigator>, ComposedList = ComposeNavigationList<NavigatorList, Parent>> = (Navigator extends {
     readonly config: {
-        screens?: any;
-        groups?: any;
+        readonly screens?: infer Screens;
+        readonly groups?: infer Groups;
     };
-} ? NavigationListForScreens<ParentList, Navigator['config']['screens']> & NavigationListForGroups<ParentList, Navigator['config']['groups']> : {};
-type NavigationListForScreens<ParentList, Screens> = UnionToIntersection<{
-    [K in keyof Screens]: ParentList extends Record<K, any> ? Screens[K] extends {
+} ? ComposedList & NavigationListForScreens<ComposedList, Screens> & NavigationListForGroups<ComposedList, Groups> : ComposedList) & NavigationListForNestedNavigators<ComposedList, Navigators> & NavigationListForDynamicNestedParamLists<Navigator, ComposedList, Navigators>;
+type NavigationListForDynamicNestedParamLists<Navigator, ParentList, Navigators> = Navigator extends {
+    readonly config: unknown;
+} ? {} : Navigator extends PrivateValueStore<[infer ParamList, any, any, any]> ? NavigationListForNestedParamLists<ParentList, ParamList, Navigators> : {};
+type NestedNavigatorsOf<Navigator> = Navigator extends PrivateValueStore<[any, any, any, infer Nesting]> ? Nesting extends Record<string, any> ? Nesting : {} : {};
+type NavigationListForNestedNavigators<ParentList, Navigators> = UnionToIntersection<{
+    [K in keyof Navigators]: K extends keyof ParentList ? NavigationListForNestedInternal<Navigators[K], ParentList[K]> : {};
+}[keyof Navigators]>;
+type NavigationListForNestedParamLists<ParentList, ParamList, Navigators> = ParentList extends Record<string, any> ? ParamList extends ParamListBase ? UnionToIntersection<{
+    [K in keyof ParamList]: K extends keyof Navigators ? {} : K extends keyof ParentList ? NavigatorScreenParams<{}> extends ParamList[K] ? NotUndefined<ParamList[K]> extends NavigatorScreenParams<infer T> ? NavigationListForScreenParams<T, ParamList, K, keyof ParentList, ParentList[K]> : {} : {} : {};
+}[keyof ParamList]> : {} : {};
+type ComposeNavigationList<NavigatorList extends Record<string, any>, Parent> = Parent extends NavigationProp<any, any, any, any, any> ? {
+    [K in keyof NavigatorList]: CompositeNavigationProp<NavigatorList[K], Parent>;
+} : NavigatorList;
+type NavigationListForScreens<ParentList, Screens> = Screens extends {} ? UnionToIntersection<{
+    [K in keyof Screens]: Screens[K] extends {
         config: any;
-    } ? NavigationListWithComposite<ParentList[K], NavigationListForNested<Screens[K]>> : Screens[K] extends {
+    } ? K extends keyof ParentList ? NavigationListForNestedInternal<Screens[K], ParentList[K]> : never : 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']>;
+    } ? K extends keyof ParentList ? NavigationListForNestedInternal<Screens[K]['screen'], ParentList[K]> : never : never;
+}[keyof Screens]> : {};
+type NavigationListForGroups<ParentList, Groups> = Groups extends {} ? UnionToIntersection<{
+    [K in keyof Groups]: Groups[K] extends {
+        screens: any;
+    } ? NavigationListForScreens<ParentList, Groups[K]['screens']> : never;
 }[keyof Groups]> : {};
-export type NavigationContainerRef<ParamList extends {}> = NavigationHelpers<ParamList> & EventConsumer<NavigationContainerEventMap> & {
+export type NavigationContainerRef<ParamList extends {}> = Omit<NavigationHelpers<ParamList>, keyof NavigationHelpersRoute<{}> | 'isFocused'> & NavigationHelpersRoute<{}> & EventConsumer<NavigationContainerEventMap> & {
     /**
      * Reset the navigation state of the root navigator to the provided state.
      *
@@ -677,7 +725,7 @@ export type NavigationContainerRef<ParamList extends {}> = NavigationHelpers<Par
     /**
      * Get the rehydrated navigation state of the navigation tree.
      */
-    getRootState(): NavigationState;
+    getRootState(): NavigationState | undefined;
     /**
      * Get the currently focused navigation route.
      */
@@ -690,37 +738,61 @@ export type NavigationContainerRef<ParamList extends {}> = NavigationHelpers<Par
      * 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 NavigationContainerRefWithCurrent<ParamList extends {}> = NavigationContainerRef<ParamList> & {
     current: NavigationContainerRef<ParamList> | null;
 };
-export type NavigationListBase<ParamList extends ParamListBase> = {
+export type NavigationListBase<in out ParamList extends ParamListBase> = {
     [RouteName in keyof ParamList]: unknown;
 };
-export type NavigatorTypeBagBase = {
+type ActionHelpersOf<T> = T extends Record<string, (...args: any) => void> ? T : {};
+export interface NavigatorTypeBagBase {
     ParamList: {};
     State: NavigationState;
     ScreenOptions: {};
     EventMap: {};
-    NavigationList: NavigationListBase<ParamListBase>;
+    ActionHelpers: {};
+    NavigationList: {
+        [RouteName in keyof this['ParamList']]: NavigationProp<this['ParamList'], RouteName, this['State'], this['ScreenOptions'], this['EventMap'], ActionHelpersOf<this['ActionHelpers']>>;
+    };
     Navigator: React.ComponentType<any>;
+}
+/**
+ * Adds a proper `ParamList` to a type bag interface
+ * So it can be used as `this['ParamList']`
+ */
+export type NavigatorTypeBagFor<TypeBag extends NavigatorTypeBagBase, ParamList extends {}> = TypeBag & {
+    ParamList: ParamList;
 };
-export type TypedNavigator<Bag extends NavigatorTypeBagBase, Config = unknown> = TypedNavigatorInternal<Bag['ParamList'], Bag['State'], Bag['ScreenOptions'], Bag['EventMap'], Bag['NavigationList'], Bag['Navigator']> & (undefined extends Config ? {} : {
+export type NavigatorProps<ParamList extends ParamListBase, State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase, Navigation, Navigator extends React.ComponentType<any>> = Omit<React.ComponentProps<Navigator>, keyof DefaultNavigatorOptions<any, any, any, any, any>> & DefaultNavigatorOptions<ParamList, State, ScreenOptions, EventMap, Navigation>;
+type TypedNavigatorStaticComponent<Bag extends NavigatorTypeBagBase> = React.ComponentType<Partial<Omit<NavigatorProps<Bag['ParamList'], Bag['State'], Bag['ScreenOptions'], Bag['EventMap'], Bag['NavigationList'][keyof Bag['ParamList']], Bag['Navigator']>, 'children'>>>;
+type TypedNavigatorStaticDecorated<Bag extends NavigatorTypeBagBase, Config> = {
+    getComponent: () => React.ComponentType<{}>;
     config: Config;
-}) & PrivateValueStore<[Bag['ParamList'], Bag['NavigationList'], unknown]>;
-type TypedNavigatorInternal<ParamList extends ParamListBase, State extends NavigationState, ScreenOptions extends {}, EventMap extends EventMapBase, NavigationList extends NavigationListBase<ParamList>, Navigator extends React.ComponentType<any>> = {
+} & PrivateValueStore<[
+    Bag['ParamList'],
+    Bag['NavigationList'],
+    unknown,
+    unknown
+]>;
+type TypedNavigatorStatic<in out Bag extends NavigatorTypeBagBase, in out Config> = {
+    config: Config;
+    with: (Component: React.ComponentType<{
+        Navigator: TypedNavigatorStaticComponent<Bag>;
+    }>) => TypedNavigatorStaticDecorated<Bag, Config>;
+    getComponent: () => TypedNavigatorStaticComponent<Bag>;
+};
+export type TypedNavigator<Bag extends NavigatorTypeBagBase, Config = unknown, Nesting = unknown> = (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,
+    Nesting
+]>;
+type TypedNavigatorInternal<in out ParamList extends ParamListBase, in out State extends NavigationState, in out ScreenOptions extends {}, in out EventMap extends EventMapBase, in out NavigationList extends NavigationListBase<ParamList>, in out Navigator extends React.ComponentType<any>> = {
     /**
      * Navigator component which manages the child screens.
      */
-    Navigator: React.ComponentType<Omit<React.ComponentProps<Navigator>, keyof DefaultNavigatorOptions<any, any, any, any, any>> & DefaultNavigatorOptions<ParamList, State, ScreenOptions, EventMap, NavigationList[keyof ParamList]>>;
+    Navigator: React.ComponentType<NavigatorProps<ParamList, State, ScreenOptions, EventMap, NavigationList[keyof ParamList], Navigator>>;
     /**
      * Component used for grouping multiple route configuration.
      */
@@ -730,35 +802,45 @@ type TypedNavigatorInternal<ParamList extends ParamListBase, State extends Navig
      */
     Screen: <RouteName extends keyof ParamList>(_: RouteConfig<ParamList, RouteName, State, ScreenOptions, EventMap, NavigationList[RouteName]>) => null;
 };
-export type NavigatorScreenParams<ParamList extends {}> = {
+declare const NavigatorScreenParamsSymbol: unique symbol;
+type NavigatorScreenParamsBrand<T extends {}> = {
+    readonly [NavigatorScreenParamsSymbol]?: any & {
+        readonly type: T;
+    };
+};
+type NavigatorScreenParamsForParamList<ParamList extends {}> = {
     screen?: never;
     params?: never;
     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];
+export type NavigatorScreenParams<ParamList extends {}> = NavigatorScreenParamsForParamList<ParamListForNavigator<ParamList>> & NavigatorScreenParamsBrand<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> = {
     [K in keyof Params]?: (value: Params[K]) => string;
@@ -774,9 +856,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
@@ -786,12 +868,28 @@ type PathConfigAlias<Params> = {
      * }
      * ```
      */
-    parse?: ParseConfig<Params>;
+    parse?: ParseConfig<Params> | undefined;
+    /**
+     * Whether this path can resolve to multiple routes.
+     * Both routes should specify `shared: true` for this to work.
+     * By default, a path can only resolve to one route.
+     *
+     * This is useful when same screen used in multiple navigators,
+     * e.g. tabs with stacks containing profile screen in each stack.
+     *
+     * The path defined first will be the canonical path.
+     */
+    shared?: boolean | undefined;
 };
-export type PathConfig<Params> = FlatType<Partial<PathConfigAlias<Params>> & {
+export type PathConfig<Params> = FlatType<Partial<Omit<PathConfigAlias<Params>, 'path'>> & {
+    /**
+     * Path string to match against.
+     * e.g. `/users/:id` will match `/users/1` and extract `id` param as `1`.
+     */
+    path?: string | undefined;
     /**
      * 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)`.
+     * By default, arrays and null are preserved for query params, and other values are converted using `String(value)`.
      * Keys are constrained to valid param names when Params type is provided.
      *
      * @example
@@ -801,23 +899,23 @@ export type PathConfig<Params> = FlatType<Partial<PathConfigAlias<Params>> & {
      * }
      * ```
      */
-    stringify?: StringifyConfig<Params>;
+    stringify?: StringifyConfig<Params> | undefined;
     /**
      * Additional path alias that will be matched to the same screen.
      */
-    alias?: (string | PathConfigAlias<Params>)[];
-} & (NonNullable<Params> extends NavigatorScreenParams<infer ParamList> ? {
+    alias?: (string | PathConfigAlias<Params>)[] | undefined;
+} & (NonNullable<Params> extends NavigatorScreenParams<infer ParamList> ? ParamListForNavigator<ParamList> extends infer ChildParamList extends {} ? {
     /**
      * Path configuration for child screens.
      */
-    screens?: PathConfigMap<ParamList>;
+    screens?: PathConfigMap<ChildParamList> | undefined;
     /**
      * Name of the initial route to use for the navigator when the path matches.
      */
-    initialRouteName?: keyof ParamList;
-} : {})>;
+    initialRouteName?: Extract<keyof ChildParamList, string> | undefined;
+} : {} : {})>;
 export type PathConfigMap<ParamList extends {}> = {
-    [RouteName in keyof ParamList]?: string | PathConfig<ParamList[RouteName]>;
+    [RouteName in keyof ParamList]?: string | PathConfig<ParamList[RouteName]> | undefined;
 };
 export {};
 //# sourceMappingURL=types.d.ts.map