@sigmela/router 0.1.3 → 0.2.1

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

@@ -1,31 +1,43 @@
 import type { ScreenOptions } from './types';
-import { type ComponentWithController, type MixedComponent } from './createController';
-type BuiltRoute = {
-    routeId: string;
-    path: string;
-    match: (path: string) => false | {
-        params: Record<string, any>;
-    };
-    component: React.ComponentType<any>;
-    controller?: ComponentWithController['controller'];
-    options?: ScreenOptions;
-};
-export declare class NavigationStack {
+import { type MixedComponent } from './createController';
+import type { NavigationNode, NodeRoute, NodeChild } from './navigationNode';
+type BuiltRoute = NodeRoute;
+type ChildNode = NodeChild;
+export declare class NavigationStack implements NavigationNode {
     private readonly stackId;
     private readonly routes;
+    private readonly children;
     private readonly defaultOptions;
+    private readonly debugEnabled;
     constructor();
     constructor(id: string);
     constructor(defaultOptions: ScreenOptions);
     constructor(id: string, defaultOptions: ScreenOptions);
+    constructor(id: string, defaultOptions: ScreenOptions, debug: boolean);
+    private log;
     getId(): string;
-    addScreen(path: string, mixedComponent: MixedComponent, options?: ScreenOptions): NavigationStack;
+    addScreen(pathPattern: string, mixedComponent: MixedComponent | NavigationNode, options?: ScreenOptions): NavigationStack;
     addModal(path: string, mixedComponent: MixedComponent, options?: ScreenOptions): NavigationStack;
     addSheet(path: string, mixedComponent: MixedComponent, options?: ScreenOptions): NavigationStack;
+    addStack(prefixOrStack: string | NavigationStack, maybeStack?: NavigationStack): NavigationStack;
+    getChildren(): ChildNode[];
     getRoutes(): BuiltRoute[];
     getFirstRoute(): BuiltRoute | undefined;
     getDefaultOptions(): ScreenOptions | undefined;
+    getNodeRoutes(): BuiltRoute[];
+    getNodeChildren(): ChildNode[];
+    getRenderer(): React.ComponentType<any>;
+    seed?(): {
+        routeId: string;
+        params?: Record<string, unknown>;
+        path: string;
+        stackId?: string;
+    } | null;
     private extractComponent;
+    private isNavigationNode;
+    private buildQueryPattern;
+    private computeBaseSpecificity;
+    private normalizePrefix;
 }
 export {};
 //# sourceMappingURL=NavigationStack.d.ts.map

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

@@ -1,87 +1,200 @@
-import { NavigationStack } from './NavigationStack';
-import { TabBar } from './TabBar/TabBar';
-import type { HistoryItem, ScreenOptions, VisibleRoute } from './types';
+import type { NavigationNode } from './navigationNode';
+import type { HistoryItem, ScreenOptions, ActiveRoute, QueryPattern } from './types';
 type Listener = () => void;
 export interface RouterConfig {
-    root: TabBar | NavigationStack;
-    global?: NavigationStack;
+    root: NavigationNode;
     screenOptions?: ScreenOptions;
+    debug?: boolean;
 }
 export type RootTransition = ScreenOptions['stackAnimation'];
 type RouterState = {
     history: HistoryItem[];
-    activeTabIndex?: number;
 };
 export declare class Router {
-    tabBar: TabBar | null;
-    root: NavigationStack | TabBar | null;
-    global: NavigationStack | null;
+    root: NavigationNode | null;
     private readonly listeners;
     private readonly registry;
     private state;
     private readonly routerScreenOptions;
+    private readonly debugEnabled;
     private sheetDismissers;
-    private stackSlices;
     private stackListeners;
-    private activeTabListeners;
     private stackById;
     private routeById;
-    private visibleRoute;
+    private stackActivators;
+    private stackHistories;
+    private activeRoute;
     private rootListeners;
     private rootTransition?;
+    private lastBrowserIndex;
+    private suppressHistorySyncCount;
+    private navigationToken;
     constructor(config: RouterConfig);
+    private log;
     navigate: (path: string) => void;
     replace: (path: string, dedupe?: boolean) => void;
+    /**
+     * Web-only convenience: resets Router navigation state to what a fresh
+     * deep-link render would produce for the given URL.
+     *
+     * This intentionally clears preserved per-tab stacks (useful when tab stacks
+     * and browser URL can get out of sync).
+     */
+    reset: (path: string) => void;
     registerSheetDismisser: (key: string, dismisser: () => void) => void;
     unregisterSheetDismisser: (key: string) => void;
     goBack: () => void;
-    onTabIndexChange: (index: number) => void;
-    setActiveTabIndex: (index: number) => void;
-    ensureTabSeed: (index: number) => void;
     getState: () => RouterState;
     subscribe(listener: Listener): () => void;
-    getStackHistory: (stackId: string) => HistoryItem[];
+    getStackHistory: (stackId?: string) => HistoryItem[];
     subscribeStack: (stackId: string, cb: Listener) => (() => void);
-    getActiveTabIndex: () => number;
-    subscribeActiveTab: (cb: Listener) => (() => void);
     getRootStackId(): string | undefined;
     getGlobalStackId(): string | undefined;
-    hasTabBar(): boolean;
     subscribeRoot(listener: Listener): () => void;
     private emitRootChange;
     getRootTransition(): RootTransition | undefined;
-    setRoot(nextRoot: TabBar | NavigationStack, options?: {
+    setRoot(nextRoot: NavigationNode, options?: {
         transition?: RootTransition;
     }): void;
-    getVisibleRoute: () => VisibleRoute;
-    private recomputeVisibleRoute;
+    getActiveRoute: () => ActiveRoute;
+    debugGetState(): {
+        history: {
+            key: string;
+            routeId: string;
+            stackId: string | undefined;
+            path: string | undefined;
+            params: Record<string, unknown> | undefined;
+            query: Record<string, unknown> | undefined;
+            stackPresentation: import("./types").StackPresentationTypes | undefined;
+        }[];
+        stackSlices: {
+            stackId: string;
+            items: {
+                key: string;
+                routeId: string;
+                path: string | undefined;
+                params: Record<string, unknown> | undefined;
+                query: Record<string, unknown> | undefined;
+                stackPresentation: import("./types").StackPresentationTypes | undefined;
+            }[];
+        }[];
+        activeRoute: ActiveRoute;
+        registry: {
+            routeId: string;
+            path: string;
+            pathnamePattern: string;
+            stackId: string | undefined;
+            isWildcardPath: boolean;
+            baseSpecificity: number;
+            queryPattern: QueryPattern | null;
+            options: ScreenOptions | undefined;
+        }[];
+    };
+    debugMatchRoute(path: string): {
+        input: {
+            path: string;
+            pathname: string;
+            query: Record<string, unknown>;
+        };
+        matches: {
+            routeId: string;
+            path: string;
+            pathnamePattern: string;
+            stackId?: string;
+            isWildcardPath: boolean;
+            baseSpecificity: number;
+            pathMatch: boolean;
+            queryMatch: boolean;
+            options?: ScreenOptions;
+        }[];
+        best: {
+            routeId: string;
+            path: string;
+            stackId: string | undefined;
+            options: ScreenOptions | undefined;
+        } | null;
+    };
+    debugGetStackInfo(stackId: string): {
+        stackId: string;
+        historyLength: number;
+        items: {
+            key: string;
+            routeId: string;
+            path: string | undefined;
+            params: Record<string, unknown> | undefined;
+            query: Record<string, unknown> | undefined;
+            stackPresentation: import("./types").StackPresentationTypes | undefined;
+        }[];
+    };
+    debugGetAllStacks(): {
+        stackId: string;
+        historyLength: number;
+        items: {
+            key: string;
+            routeId: string;
+            path: string | undefined;
+            params: Record<string, unknown> | undefined;
+            query: Record<string, unknown> | undefined;
+            stackPresentation: import("./types").StackPresentationTypes | undefined;
+        }[];
+    }[];
+    private recomputeActiveRoute;
     private performNavigation;
     private createHistoryItem;
+    private applyHistoryChange;
+    private setState;
+    private updateStackHistories;
+    private areArraysEqual;
+    private syncStateForSameRoute;
+    private resolveTargetStackAndRoute;
+    private findChildStackRouteForPathname;
+    private findRootRouteWithContainer;
+    private isRouteInContainer;
+    private activateContainerForRoute;
+    private findContainerInStack;
+    private activateStack;
+    private ensureStackHasSeed;
+    private updateActiveRouteFromStack;
+    private emit;
+    private getTopOfStack;
+    private findExistingRoute;
+    private findExistingRouteByPathname;
     private buildRegistry;
+    private normalizeBasePath;
+    private joinPaths;
+    private stripBasePath;
+    private combinePathWithBase;
+    private computeBasePathSpecificity;
+    private getAutoSeed;
     private seedInitialHistory;
-    private matchRoute;
+    private addChildNodeSeedsToItems;
+    private addChildNodeSeedsToHistory;
+    private matchBaseRoute;
     private generateKey;
     private parsePath;
-    private applyHistoryChange;
-    private setState;
-    private emit;
-    private getTopForTarget;
     private mergeOptions;
     private findStackById;
+    private areShallowEqual;
+    private matchQueryPattern;
     private isWebEnv;
     private getCurrentUrl;
-    private readIndex;
+    private readHistoryIndex;
+    private getHistoryIndexOrNull;
     private getHistoryIndex;
     private ensureHistoryIndex;
+    private getRouterPathFromHistory;
+    private getReplaceDedupeFromHistory;
+    private shouldSyncPathWithUrl;
     private pushUrl;
     private replaceUrl;
-    private patchHistoryOnce;
-    private lastBrowserIndex;
-    private pendingReplaceDedupe;
+    private replaceUrlSilently;
+    private buildUrlFromActiveRoute;
+    private patchBrowserHistoryOnce;
     private setupBrowserHistory;
-    private popOnce;
-    private tryPopActiveStack;
-    private parse;
+    private syncUrlAfterInternalPop;
+    private popFromActiveStack;
+    private buildHistoryFromUrl;
+    private reuseKeysFromPreviousHistory;
 }
 export {};
 //# sourceMappingURL=Router.d.ts.map

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

@@ -11,7 +11,7 @@ export type RouteLocalContextValue = {
 };
 export declare const RouteLocalContext: React.Context<RouteLocalContextValue | null>;
 export declare const useRouter: () => Router;
-export declare const useCurrentRoute: () => import("./types").VisibleRoute;
+export declare const useCurrentRoute: () => import("./types").ActiveRoute;
 export declare function useParams<TParams extends Record<string, unknown> = Record<string, unknown>>(): TParams;
 export declare function useQueryParams<TQuery extends Record<string, unknown> = Record<string, unknown>>(): TQuery;
 export declare function useRoute(): RouteLocalContextValue;

package/lib/typescript/src/ScreenStack/ScreenStack.web.d.ts

@@ -1,9 +1,7 @@
 import type { ReactNode } from 'react';
-import { type TransitionStackType } from '../web/TransitionStack';
 type ScreenStackProps = {
     children: ReactNode;
     transitionTime?: number;
-    type?: TransitionStackType;
     animated?: boolean;
 };
 export declare const ScreenStack: import("react").NamedExoticComponent<ScreenStackProps>;

package/lib/typescript/src/ScreenStack/ScreenStackContext.d.ts

@@ -0,0 +1,31 @@
+import type { ScreenStackItemPhase } from '../ScreenStackItem/ScreenStackItem.types';
+import type { TransitionStatus } from 'react-transition-state';
+export type PresentationTypeClass = 'push' | 'modal' | 'transparent-modal' | 'contained-modal' | 'contained-transparent-modal' | 'fullscreen-modal' | 'formsheet' | 'pagesheet' | 'sheet';
+export type AnimationType = 'push-enter' | 'push-exit' | 'push-background' | 'pop-enter' | 'pop-exit' | 'pop-background' | 'modal-enter' | 'modal-exit' | 'transparent-modal-enter' | 'transparent-modal-exit' | 'contained-modal-enter' | 'contained-modal-exit' | 'fullscreen-modal-enter' | 'fullscreen-modal-exit' | 'formsheet-enter' | 'formsheet-exit' | 'pagesheet-enter' | 'pagesheet-exit' | 'sheet-enter' | 'sheet-exit' | 'no-animate' | 'none';
+export type ScreenStackItemState = {
+    presentationType: PresentationTypeClass;
+    animationType: AnimationType;
+    phase: ScreenStackItemPhase;
+    transitionStatus: TransitionStatus;
+    zIndex: number;
+};
+export type ScreenStackItemsContextValue = {
+    items: {
+        [key: string]: ScreenStackItemState;
+    };
+};
+export type ScreenStackAnimatingContextValue = boolean;
+export declare const ScreenStackItemsContext: import("react").Context<ScreenStackItemsContextValue | null>;
+export declare const ScreenStackAnimatingContext: import("react").Context<boolean>;
+export type ScreenStackConfig = {
+    /**
+     * When false, the first screen pushed after the stack becomes empty will NOT animate
+     * (treated as an initial render). Subsequent pushes/pops still animate normally.
+     */
+    animateFirstScreenAfterEmpty?: boolean;
+};
+export declare const ScreenStackConfigContext: import("react").Context<ScreenStackConfig>;
+export declare const useScreenStackConfig: () => ScreenStackConfig;
+export declare const useScreenStackItemsContext: () => ScreenStackItemsContextValue;
+export declare const useScreenStackAnimatingContext: () => boolean;
+//# sourceMappingURL=ScreenStackContext.d.ts.map

package/lib/typescript/src/ScreenStack/animationHelpers.d.ts

@@ -0,0 +1,6 @@
+import type { StackPresentationTypes } from '../types';
+import type { PresentationTypeClass, AnimationType } from './ScreenStackContext';
+export declare function getPresentationTypeClass(presentation: StackPresentationTypes): PresentationTypeClass;
+export declare function getAnimationTypeForPresentation(presentation: StackPresentationTypes, isEntering: boolean, direction: 'forward' | 'back'): string;
+export declare function computeAnimationType(_key: string, isInStack: boolean, isTop: boolean, direction: 'forward' | 'back', presentation: StackPresentationTypes, isInitialPhase: boolean, animated?: boolean): AnimationType;
+//# sourceMappingURL=animationHelpers.d.ts.map

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

@@ -1,10 +1,14 @@
 import type { HistoryItem, NavigationAppearance, ScreenOptions } from '../types';
-export type ScreenStackItemPhase = 'active' | 'exiting';
+import type { TransitionStatus } from 'react-transition-state';
+import type { CSSProperties } from 'react';
+export type ScreenStackItemPhase = 'active' | 'inactive' | 'exiting';
 export interface ScreenStackItemProps {
     item: HistoryItem;
     stackId?: string;
     stackAnimation?: ScreenOptions['stackAnimation'];
     appearance?: NavigationAppearance;
     phase?: ScreenStackItemPhase;
+    transitionStatus?: TransitionStatus;
+    style?: CSSProperties;
 }
 //# sourceMappingURL=ScreenStackItem.types.d.ts.map

package/lib/typescript/src/ScreenStackItem/ScreenStackItem.web.d.ts

@@ -1,3 +1,3 @@
 import type { ScreenStackItemProps } from './ScreenStackItem.types';
-export declare const ScreenStackItem: import("react").MemoExoticComponent<({ phase, item, appearance }: ScreenStackItemProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const ScreenStackItem: import("react").MemoExoticComponent<({ item, appearance, style }: ScreenStackItemProps) => import("react/jsx-runtime").JSX.Element | null>;
 //# sourceMappingURL=ScreenStackItem.web.d.ts.map

package/lib/typescript/src/SplitView/RenderSplitView.native.d.ts

@@ -0,0 +1,8 @@
+import type { NavigationAppearance } from '../types';
+import type { SplitView } from './SplitView';
+export interface RenderSplitViewProps {
+    splitView: SplitView;
+    appearance?: NavigationAppearance;
+}
+export declare const RenderSplitView: import("react").NamedExoticComponent<RenderSplitViewProps>;
+//# sourceMappingURL=RenderSplitView.native.d.ts.map

package/lib/typescript/src/SplitView/RenderSplitView.web.d.ts

@@ -0,0 +1,8 @@
+import type { NavigationAppearance } from '../types';
+import type { SplitView } from './SplitView';
+export interface RenderSplitViewProps {
+    splitView: SplitView;
+    appearance?: NavigationAppearance;
+}
+export declare const RenderSplitView: import("react").NamedExoticComponent<RenderSplitViewProps>;
+//# sourceMappingURL=RenderSplitView.web.d.ts.map

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

@@ -0,0 +1,31 @@
+import React from 'react';
+import type { NavigationNode, NodeChild, NodeRoute } from '../navigationNode';
+import type { NavigationStack } from '../NavigationStack';
+export type SplitViewOptions = {
+    minWidth: number;
+    primary: NavigationStack;
+    secondary: NavigationStack;
+    primaryMaxWidth?: number;
+};
+export declare class SplitView implements NavigationNode {
+    private readonly splitViewId;
+    readonly primary: NavigationStack;
+    readonly secondary: NavigationStack;
+    readonly minWidth: number;
+    readonly primaryMaxWidth: number;
+    constructor(options: SplitViewOptions);
+    getId(): string;
+    getNodeRoutes(): NodeRoute[];
+    getNodeChildren(): NodeChild[];
+    getRenderer(): React.ComponentType<any>;
+    hasRoute(routeId: string): boolean;
+    switchToRoute(_routeId: string): void;
+    setActiveChildByRoute(routeId: string): void;
+    seed(): {
+        routeId: string;
+        params?: Record<string, unknown>;
+        path: string;
+        stackId?: string;
+    } | null;
+}
+//# sourceMappingURL=SplitView.d.ts.map

package/lib/typescript/src/SplitView/SplitViewContext.d.ts

@@ -0,0 +1,3 @@
+import type { SplitView } from './SplitView';
+export declare const SplitViewContext: import("react").Context<SplitView | null>;
+//# sourceMappingURL=SplitViewContext.d.ts.map

package/lib/typescript/src/SplitView/index.d.ts

@@ -0,0 +1,5 @@
+export { SplitView } from './SplitView';
+export type { SplitViewOptions } from './SplitView';
+export { RenderSplitView } from './RenderSplitView';
+export { useSplitView } from './useSplitView';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/SplitView/useSplitView.d.ts

@@ -0,0 +1,2 @@
+export declare const useSplitView: () => import("./SplitView").SplitView;
+//# sourceMappingURL=useSplitView.d.ts.map

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

@@ -1,8 +1,9 @@
-import type { NavigationAppearance } from './types';
+import type { HistoryItem, NavigationAppearance } from './types';
 import { NavigationStack } from './NavigationStack';
 export interface StackRendererProps {
     stack: NavigationStack;
     appearance?: NavigationAppearance;
+    history?: HistoryItem[];
 }
 export declare const StackRenderer: import("react").NamedExoticComponent<StackRendererProps>;
 //# sourceMappingURL=StackRenderer.d.ts.map

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

@@ -3,14 +3,16 @@ import { NavigationStack } from '../NavigationStack';
 import type { ComponentType } from 'react';
 import type { TabItem } from '../types';
 import React from 'react';
-type IOSIconShape = {
+import type { NavigationNode, NodeChild, NodeRoute } from '../navigationNode';
+import type { PlatformIcon } from 'react-native-screens';
+type LegacyIOSIconShape = {
     sfSymbolName: string;
 } | {
     imageSource: ImageSourcePropType;
 } | {
     templateSource: ImageSourcePropType;
 };
-type ExtendedIcon = ImageSourcePropType | IOSIconShape;
+type ExtendedIcon = ImageSourcePropType | LegacyIOSIconShape | PlatformIcon;
 export type InternalTabItem = Omit<TabItem, 'icon' | 'selectedIcon'> & {
     icon?: ExtendedIcon;
     selectedIcon?: ExtendedIcon;
@@ -21,6 +23,9 @@ export type TabBarProps = {
     tabs: InternalTabItem[];
     activeIndex: number;
 };
+export type TabBarDescriptor = {
+    renderer?: ComponentType<TabBarProps>;
+};
 type TabBarConfig = Omit<InternalTabItem, 'tabKey' | 'key'> & {
     stack?: NavigationStack;
     screen?: React.ComponentType<any>;
@@ -31,12 +36,14 @@ type TabBarOptions = {
     config?: TabBarConfig;
     initialIndex?: number;
 };
-export declare class TabBar {
+export declare class TabBar implements NavigationNode {
+    private readonly tabBarId;
     screens: Record<string, React.ComponentType<any>>;
     stacks: Record<string, NavigationStack>;
     private listeners;
     private state;
     constructor(options?: TabBarOptions);
+    getId(): string;
     addTab(tab: Omit<TabBarConfig, 'tabKey'> & {
         key: string;
     }): TabBar;
@@ -51,6 +58,23 @@ export declare class TabBar {
     private setState;
     private notifyListeners;
     subscribe(listener: () => void): () => void;
+    getTabs(): InternalTabItem[];
+    getInitialIndex(): number;
+    getActiveChildId(): string | undefined;
+    switchToRoute(routeId: string): void;
+    hasRoute(routeId: string): boolean;
+    setActiveChildByRoute(routeId: string): void;
+    getNodeRoutes(): NodeRoute[];
+    getNodeChildren(): NodeChild[];
+    getRenderer(): React.ComponentType<any>;
+    seed(): {
+        routeId: string;
+        params?: Record<string, unknown>;
+        path: string;
+        stackId?: string;
+    } | null;
+    private findTabIndexByRoute;
+    private nodeHasRoute;
 }
 export {};
 //# sourceMappingURL=TabBar.d.ts.map

package/lib/typescript/src/TabBar/index.d.ts

@@ -1,2 +1,5 @@
 export { RenderTabBar } from './RenderTabBar';
+export { TabBar } from './TabBar';
+export { useTabBar } from './useTabBar';
+export { useTabBarHeight, TAB_BAR_HEIGHT } from './useTabBarHeight';
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/TabBar/useTabBarHeight.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The height of the TabBar in pixels
+ */
+export declare const TAB_BAR_HEIGHT = 57;
+/**
+ * Hook that returns the height of the TabBar
+ * @returns {number} The height of the TabBar in pixels
+ *
+ * @example
+ * ```tsx
+ * const TabBarExample = () => {
+ *   const tabBarHeight = useTabBarHeight();
+ *   return <div style={{ paddingBottom: tabBarHeight }}>Content</div>;
+ * };
+ * ```
+ */
+export declare const useTabBarHeight: () => number;
+//# sourceMappingURL=useTabBarHeight.d.ts.map

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

@@ -7,6 +7,7 @@ export type Controller<TParams = Record<string, unknown>, TQuery = Record<string
 export type ComponentWithController = {
     controller?: Controller<any, any>;
     component: React.ComponentType<any>;
+    childNode?: import('./navigationNode').NavigationNode;
 };
 export type MixedComponent = ComponentWithController | React.ComponentType<any>;
 export declare function createController<TParams, TQuery = Record<string, unknown>>(controller: Controller<TParams, TQuery>): Controller<TParams, TQuery>;

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

@@ -1,10 +1,11 @@
 export { useTabBar } from './TabBar/useTabBar';
+export { useTabBarHeight, TAB_BAR_HEIGHT } from './TabBar/useTabBarHeight';
 export { TabBar } from './TabBar/TabBar';
 export type { TabBarProps } from './TabBar/TabBar';
+export { SplitView } from './SplitView/SplitView';
+export type { SplitViewOptions } from './SplitView/SplitView';
+export { useSplitView } from './SplitView/useSplitView';
 export type { NavigationAppearance } from './types';
-/**
- * Navigation System
- */
 export { Router } from './Router';
 export { Navigation } from './Navigation';
 export { createController } from './createController';

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

@@ -0,0 +1,41 @@
+import type { ScreenOptions, QueryPattern } from './types';
+import type { Controller } from './createController';
+import type React from 'react';
+export type NodeRoute = {
+    routeId: string;
+    path: string;
+    pathnamePattern: string;
+    isWildcardPath: boolean;
+    queryPattern: QueryPattern | null;
+    baseSpecificity: number;
+    matchPath: (path: string) => false | {
+        params: Record<string, any>;
+    };
+    component: React.ComponentType<any>;
+    controller?: Controller<any, any>;
+    options?: ScreenOptions;
+    childNode?: NavigationNode;
+};
+export type NodeChild = {
+    prefix: string;
+    node: NavigationNode;
+    onMatch?: () => void;
+};
+export interface NavigationNode {
+    getId(): string;
+    getNodeRoutes(): NodeRoute[];
+    getNodeChildren(): NodeChild[];
+    getRenderer(): React.ComponentType<any>;
+    getActiveChildId?: () => string | undefined;
+    switchToRoute?: (routeId: string) => void;
+    hasRoute?: (routeId: string) => boolean;
+    setActiveChildByRoute?: (routeId: string) => void;
+    seed?: () => {
+        routeId: string;
+        params?: Record<string, unknown>;
+        path: string;
+        stackId?: string;
+    } | null;
+    getDefaultOptions?: () => ScreenOptions | undefined;
+}
+//# sourceMappingURL=navigationNode.d.ts.map