import type { ReactNode } from 'react';
export type TransitionName = 'fade' | 'slide' | 'scale' | 'none';
export type TransitionStage = 'idle' | 'entering' | 'exiting';
export type QueryValue = string | number | string[] | number[];
export type Query = Record<string, QueryValue>;
export type LoaderContext<P = any> = {
    params: P;
    path: string;
    query?: Query;
    hash?: string;
};
export type LoaderFn<P, R> = (context: LoaderContext<P>) => Promise<R> | R;
export type OnEnterFn<P = any> = (context: LoaderContext<P>) => void | Promise<void>;
export type OnLeaveFn<P = any> = (context: LoaderContext<P>) => void | Promise<void>;
export type OnErrorFn<P = any> = (error: unknown, context: LoaderContext<P>) => void | boolean | Promise<void | boolean>;
export type PolicyFn<P = any> = (context: LoaderContext<P>) => boolean | Promise<boolean>;
export type PrefetchFn<P = any> = (context: LoaderContext<P>) => Promise<any>;
export type RouteOptions<P = any, R = any> = {
    loader?: LoaderFn<P, R>;
    ttl?: number;
    shouldReload?: (context: {
        prev?: LoaderContext<P>;
        next: LoaderContext<P>;
    }) => boolean;
    fallback?: ReactNode | ((context: LoaderContext<P>) => ReactNode);
    errorBoundary?: React.ComponentType<{
        error: any;
        params?: P;
    }>;
    preload?: boolean;
    keepPreviousData?: boolean;
    revalidateOnFocus?: boolean;
    meta?: Record<string, any>;
    priority?: number;
    transition?: TransitionName;
    duration?: number;
};
type GuardResult = boolean | {
    redirect: string;
};
export type GuardFn<P = any> = (context: LoaderContext<P>) => GuardResult | Promise<GuardResult>;
export type MiddlewareFn<P = any> = (context: LoaderContext<P>) => void | Promise<void>;
export type RouteComponent<P = any> = React.ComponentType<P & {
    children?: ReactNode;
}> | (() => Promise<{
    default: React.ComponentType<P & {
        children?: ReactNode;
    }>;
}>);
export type RouteNode<P = any, R = any> = {
    path: string;
    component?: RouteComponent;
    children: RouteNode[];
    parent?: RouteNode;
    options: RouteOptions<P, R>;
    guardFns?: GuardFn<P>[];
    middlewares?: MiddlewareFn<P>[];
    meta?: Record<string, any>;
    onEnter?: OnEnterFn<P>[];
    onLeave?: OnLeaveFn<P>[];
    onError?: OnErrorFn<P>[];
    policies?: PolicyFn<P>[];
    prefetch?: PrefetchFn<P>;
    errorBoundary?: RouteComponent;
};
export type InternalRouteMatch<P = any> = {
    node: RouteNode<P>;
    params: P;
    query?: Query;
    hash?: string;
};
export type ExtractParams<Path extends string> = Path extends `${string}:${infer Param}/${infer Rest}` ? {
    [K in Param | keyof ExtractParams<`/${Rest}`>]: string;
} : Path extends `${string}:${infer Param}` ? {
    [K in Param]: string;
} : object;
export type BuilderRouteAPI<Params = any> = {
    guard: (fn: GuardFn<Params>) => BuilderRouteAPI<Params>;
    middleware: (fn: MiddlewareFn<Params>) => BuilderRouteAPI<Params>;
    meta: (obj: Record<string, any>) => BuilderRouteAPI<Params>;
    onEnter: (fn: OnEnterFn<Params>) => BuilderRouteAPI<Params>;
    onLeave: (fn: OnLeaveFn<Params>) => BuilderRouteAPI<Params>;
    onError: (fn: OnErrorFn<Params>) => BuilderRouteAPI<Params>;
    policy: (fn: PolicyFn<Params>) => BuilderRouteAPI<Params>;
    prefetch: (fn: PrefetchFn<Params>) => BuilderRouteAPI<Params>;
    errorBoundary: (component: RouteComponent<{
        error: any;
        params?: Params;
    }>) => BuilderRouteAPI<Params>;
    route: <Path extends string, R = any>(path: Path, component?: RouteComponent, options?: ((api: BuilderRouteAPI<Params & ExtractParams<Path>>) => void) | RouteOptions<Params & ExtractParams<Path>, R>) => BuilderRouteAPI<Params & ExtractParams<Path>>;
};
export type InferParams<T> = T extends InternalRouteMatch<infer P> ? P : never;
export type InferLoaderData<T> = T extends RouteNode<any, infer R> ? R : never;
export {};