@react-navigation/core 8.0.0-alpha.2 → 8.0.0-alpha.20

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

@@ -1,6 +1,6 @@
 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 { FlatType, KeyOf, NotUndefined, StandardSchemaV1, UnionToIntersection } from './utilities.js';
 /**
  * Root navigator used in the app.
  * It's used for the global types in the app.
@@ -35,7 +35,12 @@ export interface RootNavigator {
  */
 export interface Theme {
 }
-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 +51,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>>>;
         children: React.ReactNode;
-    }) => React.ReactElement;
+    }) => React.ReactElement) | undefined;
     /**
      * Event listeners for all the screens in the navigator.
      */
-    screenListeners?: ScreenListeners<State, EventMap> | ((props: {
+    screenListeners?: (ScreenListeners<State, EventMap> | ((props: {
         route: RouteProp<ParamList>;
         navigation: Navigation;
-    }) => ScreenListeners<State, EventMap>);
+    }) => ScreenListeners<State, EventMap>)) | undefined;
     /**
      * Default options for all screens under this navigator.
      */
-    screenOptions?: ScreenOptions | ((props: {
+    screenOptions?: (ScreenOptions | ((props: {
         route: RouteProp<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 +83,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 +103,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;
     };
@@ -128,7 +133,10 @@ export type EventArg<EventName, CanPreventDefault extends boolean | undefined =
      * 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 ? {
     /**
      * Whether `event.preventDefault()` was called on this event object.
@@ -139,12 +147,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.
      *
@@ -154,7 +162,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.
      *
@@ -174,7 +182,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!!!
      *
@@ -208,15 +216,15 @@ type NavigationHelpersCommon<ParamList extends ParamListBase, State extends Navi
         screen: RouteName,
         params?: ParamList[RouteName],
         options?: {
-            merge?: boolean;
-            pop?: boolean;
+            merge?: boolean | undefined;
+            pop?: boolean | undefined;
         }
     ] : [
         screen: RouteName,
         params: ParamList[RouteName],
         options?: {
-            merge?: boolean;
-            pop?: boolean;
+            merge?: boolean | undefined;
+            pop?: boolean | undefined;
         }
     ] : never): void;
     /**
@@ -231,9 +239,9 @@ type NavigationHelpersCommon<ParamList extends ParamListBase, State extends Navi
     navigate<RouteName extends keyof ParamList>(options: RouteName extends unknown ? {
         name: RouteName;
         params: ParamList[RouteName];
-        path?: string;
-        merge?: boolean;
-        pop?: boolean;
+        path?: string | undefined;
+        merge?: boolean | undefined;
+        pop?: boolean | undefined;
     } : never): void;
     /**
      * Preloads the route in current navigation tree.
@@ -274,9 +282,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 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.
@@ -299,34 +307,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, EventMap extends EventMapBase = {}> = NavigationHelpersCommon<ParamList> & 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.
@@ -334,6 +342,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.
@@ -343,51 +353,59 @@ 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]>;
+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, 
-/**
- * The type of state should refer to the state specified in the first type
  */
-A extends NavigationProp<any, any, infer S> ? S : NavigationState, 
+RouteNameOfNavigationProp<A>, 
 /**
- * Screen options should refer to the options specified in the first type
+ * Event map should refer to the config 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> = {
+export type ScreenLayoutArgs<in out ParamList extends ParamListBase, in out RouteName extends keyof ParamList, in out ScreenOptions extends {}, in out Navigation> = {
     route: RouteProp<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.
      */
@@ -405,7 +423,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<{
@@ -417,15 +435,15 @@ export type RouteConfigComponent<ParamList extends ParamListBase, RouteName exte
      * 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;
 } | {
     /**
      * Render callback to render content of this screen.
@@ -434,16 +452,16 @@ export type RouteConfigComponent<ParamList extends ParamListBase, RouteName exte
         route: RouteProp<ParamList, RouteName>;
         navigation: any;
     }) => React.ReactNode;
-    component?: never;
-    getComponent?: never;
+    component?: never | undefined;
+    getComponent?: never | undefined;
 };
-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.
      */
@@ -451,58 +469,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: {
+    screenOptions?: (ScreenOptions | ((props: {
         route: RouteProp<ParamList, keyof 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.
@@ -556,6 +574,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;
+        };
+    };
 };
 /**
  * A stripped down NavigationProp if the navigator is not known.
@@ -600,46 +643,46 @@ export type GenericNavigation<ParamList extends {}> = Omit<NavigationProp<ParamL
      */
     setOptions(options: unknown): void;
 };
-export type RouteForName<ParamList extends {}, RouteName extends string> = Extract<ParamListRoute<ParamList>, {
+export type RouteForName<ParamList extends {}, RouteName extends string> = RouteForNameInternal<RouteName, ParamListRoute<ParamList>>;
+type RouteForNameInternal<RouteName extends string, Routes> = string extends RouteName ? Routes : Extract<Routes, {
     name: RouteName;
 }>;
 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>;
 }[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> ? keyof T extends ExcludedRouteNames ? {} : 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 {
+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>, 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;
+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<{}>> & NavigationHelpersRoute<{}> & EventConsumer<NavigationContainerEventMap> & {
     /**
      * Reset the navigation state of the root navigator to the provided state.
      *
@@ -666,29 +709,56 @@ export type NavigationContainerRef<ParamList extends {}> = NavigationHelpers<Par
      * 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 ? {} : {
+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 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: TypedNavigatorComponent<Bag>;
+    }>) => TypedNavigatorStaticDecorated<Bag, Config>;
+    getComponent: () => TypedNavigatorComponent<Bag>;
+};
+export type TypedNavigator<Bag extends NavigatorTypeBagBase, Config = 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,
+    unknown
+]>;
+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.
      */
@@ -708,29 +778,32 @@ 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> = {
     [K in keyof Params]?: (value: Params[K]) => string;
@@ -746,9 +819,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
@@ -758,7 +831,18 @@ 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>> & {
     /**
@@ -773,23 +857,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>)[];
+    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;
 };
 export {};
 //# sourceMappingURL=types.d.ts.map