import type React from 'react';
import type { PlatformIcon, PlatformIconIOS } from 'react-native-screens';
export interface RouteConfig {
    component?: React.ComponentType<any>;
    layout?: React.ComponentType<{
        children: React.ReactNode;
    }>;
    navigator?: 'stack' | 'tabs';
    children?: Record<string, RouteConfig>;
    /** Route metadata */
    meta?: Record<string, unknown>;
    /** Route guard */
    guard?: () => boolean | Promise<boolean>;
    /** Redirect path when guard fails */
    guardRedirect?: string;
    /** Tab-specific options */
    tabOptions?: {
        title?: string;
        icon?: PlatformIcon;
        selectedIcon?: PlatformIconIOS;
        badgeValue?: string;
    };
    /** Custom tab bar renderer — replaces the native tab bar when provided */
    customTabBar?: (props: TabBarRenderProps) => React.ReactNode;
}
export interface StackEntry {
    key: string;
    routeName: string;
    path: string;
    params: Record<string, string>;
    nestedState?: NavigatorState;
}
export interface StackState {
    type: 'stack';
    entries: StackEntry[];
}
export interface TabEntry {
    key: string;
    path: string;
    params: Record<string, string>;
    rendered: boolean;
    nestedState?: NavigatorState;
    tabOptions?: RouteConfig['tabOptions'];
}
export interface TabState {
    type: 'tabs';
    activeKey: string;
    tabs: Record<string, TabEntry>;
}
export type NavigatorState = StackState | TabState;
export interface TabBarRenderProps {
    state: TabState;
    onTabPress: (tabKey: string) => void;
}
export interface RouterInstance<TConfig extends RouteConfig = RouteConfig> {
    config: TConfig;
    /** Flattened route patterns for matching */
    patterns: RoutePattern[];
}
export interface RoutePattern {
    /** e.g. '/profile' */
    path: string;
    segments: string[];
    paramNames: string[];
    routeName: string;
    routeConfig: RouteConfig;
    /** Path through navigators to reach this route */
    navigatorPath: NavigatorSegment[];
}
export interface NavigatorSegment {
    name: string;
    type: 'stack' | 'tabs';
    childName: string;
}
export type Action = {
    type: 'NAVIGATE';
    path: string;
} | {
    type: 'REPLACE';
    path: string;
} | {
    type: 'GO_BACK';
} | {
    type: 'DISMISS';
    key: string;
} | {
    type: 'SWITCH_TAB';
    tabKey: string;
};
export interface Route {
    key: string;
    path: string;
    name: string;
    params?: Record<string, string>;
    query?: Record<string, string>;
}
export interface RouterContextValue {
    router: RouterInstance;
    state: NavigatorState;
    path: string;
    navigate: NavigateFn;
    goBack: GoBackFn;
    replace: ReplaceFn;
}
export interface ScreenContextValue {
    route: Route;
    params: Record<string, string>;
    query: Record<string, string>;
    meta?: Record<string, unknown>;
    isFocused: boolean;
}
export type NavigationEventType = 'focus' | 'blur' | 'beforeNavigate' | 'afterNavigate';
export type NavigationListener = (event: {
    type: NavigationEventType;
    route?: Route;
}) => void;
/**
 * Users augment this interface to register their router for type inference:
 *
 * ```ts
 * declare module 'blaze-navigation' {
 *   interface Register {
 *     router: typeof router;
 *   }
 * }
 * ```
 */
export interface Register {
}
/** Extract router type from Register */
export type RegisteredRouter = Register extends {
    router: infer R;
} ? R : RouterInstance;
/** Helper: join path segments */
type JoinPath<A extends string, B extends string> = A extends '' ? `/${B}` : `${A}/${B}`;
/** Extract all paths from a route config tree */
export type ExtractPaths<T extends Record<string, RouteConfig>, Prefix extends string = ''> = {
    [K in keyof T & string]: JoinPath<Prefix, K> | (T[K] extends {
        children: infer C extends Record<string, RouteConfig>;
    } ? ExtractPaths<C, JoinPath<Prefix, K>> : never);
}[keyof T & string];
/** Replace $param segments with string values */
export type ReplaceParams<T extends string> = T extends `${infer Before}/$${infer _Param}/${infer After}` ? `${Before}/${string}/${ReplaceParams<After>}` : T extends `${infer Before}/$${infer _Param}` ? `${Before}/${string}` : T;
/** Get all valid href paths from registered router */
export type ValidPaths = Register extends {
    router: {
        config: {
            children: infer C extends Record<string, RouteConfig>;
        };
    };
} ? ReplaceParams<ExtractPaths<C>> : string;
export type NavigateFn = (path: ValidPaths) => void;
export type ReplaceFn = (path: ValidPaths) => void;
export type GoBackFn = () => void;
/** Extract params from a path pattern */
export type ExtractParams<T extends string> = T extends `${infer _}/$${infer Param}/${infer Rest}` ? {
    [K in Param | keyof ExtractParams<Rest>]: string;
} : T extends `${infer _}/$${infer Param}` ? {
    [K in Param]: string;
} : Record<string, never>;
export {};
//# sourceMappingURL=types.d.ts.map