one

constructor(
    message: string,
    params: Record<string, unknown>,
    issues?: unknown[]
);

readonly issues: unknown[];

readonly params: Record<string, unknown>;

readonly routerCode: string;

constructor(message: string, details?: Record<string, unknown>);

readonly details?: Record<string, unknown>;

readonly routerCode: string;

blurDataURL: string;

height: number;

src: string;

width: number;

type Route<Path> = OneRouter.Route<Path>;

type RouteSitemap = {
    /**
     * Priority for this route (0.0 to 1.0).
     */
    priority?: number;
    /**
     * Change frequency for this route.
     */
    changefreq?: SitemapChangefreq;
    /**
     * Last modification date for this route.
     */
    lastmod?: string | Date;
    /**
     * Exclude this route from the sitemap.
     */
    exclude?: boolean;
};

type SitemapChangefreq =
    | 'always'
    | 'hourly'
    | 'daily'
    | 'weekly'
    | 'monthly'
    | 'yearly'
    | 'never';

const Link: LinkComponent;

const router: Router;

Redirect: (props: React.PropsWithChildren<{ href: Href }>) => ReactNode;

useActiveParams: <
    T extends string | UnknownOutputParams = UnknownOutputParams
>() => T extends AllRoutes ? SearchParams<T> : T;

useParams: <
    TParams extends string | UnknownOutputParams = UnknownOutputParams
>() => TParams extends AllRoutes ? SearchParams<TParams> : TParams;

useRouter: () => Router;

useSegments: <T extends string | [string]>() => T extends AbsoluteRoute
    ? RouteSegments<T>
    : T extends string
    ? string[]
    : T;

type AbsoluteRoute = DynamicRouteTemplate | StaticRoutes;

type AllRoutes = OneRouterRoutes | ExternalPathString;

type CatchAllRoutePart<S extends string> = S extends `${string}${SearchOrHash}`
    ? never
    : S extends ''
    ? never
    : S extends `${string}(${string})${string}`
    ? never
    : S extends `${string}[${string}]${string}`
    ? never
    : S;

type DynamicRoutesHref = DynamicRouteString<
    { __branded__: any },
    DynamicRouteTemplate
>;

type DynamicRoutesHref2 = DynamicRouteString<string, DynamicRouteTemplate>;

type DynamicRouteTemplate = __routes extends {
    DynamicRouteTemplate: string;
}
    ? __routes['DynamicRouteTemplate']
    : string;

type ExternalPathString = `${string}:${string}`;

type Href<T extends string | object = { __branded__: any }> =
    | StringRouteToType<
          AllUngroupedRoutes<StaticRoutes> | RelativePathString | ExternalPathString
      >
    | DynamicRouteString<T, DynamicRouteTemplate>
    | DynamicRouteObject<
          | StaticRoutes
          | RelativePathString
          | ExternalPathString
          | DynamicRouteTemplate
      >;

type InpurRouteParamsGeneric = InputRouteParamsBlank | InputRouteParams<any>;

type InputRouteParams<Path> = {
    [Key in ParameterNames<Path> as Key extends `...${infer Name}`
        ? Name
        : Key]: Key extends `...${string}` ? string[] : string;
};

type InputRouteParamsBlank = Record<string, string | undefined | null>;

type LinkToOptions = {
    scroll?: boolean;
    /**
     * Display a different URL in the browser than the actual route.
     * Useful for modals and overlays that should show a clean URL.
     *
     * @example
     * ```tsx
     * // Navigate to /photos/5/modal but show /photos/5 in browser
     * router.navigate('/photos/5/modal', {
     *   mask: { href: '/photos/5' }
     * })
     * ```
     */
    mask?: {
        /** The URL to display in the browser address bar */
        href: Href;
        /**
         * If true, unmask on page reload (show the masked URL in browser).
         * If false (default), keep masking (navigate to actual route on reload).
         */
        unmaskOnReload?: boolean;
    };
    /**
     * Specify a scroll group for this navigation.
     * Routes within the same scroll group will preserve scroll position
     * when navigating between them.
     *
     * @example
     * ```tsx
     * // Use scroll group to preserve scroll when switching tabs
     * router.navigate('/dashboard/settings', {
     *   scrollGroup: '/dashboard'
     * })
     * ```
     */
    scrollGroup?: string;
};

type LoadingState = 'loading' | 'loaded';

type LoadingStateListener = (state: LoadingState) => void;

type NavigationRef =
    NavigationContainerRefWithCurrent<ReactNavigation.RootParamList>;

type OneRouterRoutes = DynamicRouteTemplate | StaticRoutes | RelativePathString;

type Redirect = typeof Redirect;

type RelativePathString = `./${string}` | `../${string}` | '..';

type ResultState = PartialState<NavigationState> & {
    state?: ResultState;
    hash?: string;
    linkOptions?: OneRouter.LinkToOptions;
};

type RootStateListener = (state: ResultState) => void;

type Route<Path> = {
    Params: InputRouteParams<Path>;
    Props: { params: InputRouteParams<Path> };
    Loader: (props: { params: InputRouteParams<Path> }) => any;
};

type Router = {
    /** Go back in the history. */
    back: () => void;
    /** If there's history that supports invoking the `back` function. */
    canGoBack: () => boolean;
    /** Navigate to the provided href using a push operation if possible. */
    push: (href: Href, options?: LinkToOptions) => void;
    /** Navigate to the provided href. */
    navigate: (href: Href, options?: LinkToOptions) => void;
    /** Navigate to route without appending to the history. */
    replace: (href: Href, options?: LinkToOptions) => void;
    /** Navigate to the provided href using a push operation if possible. */
    dismiss: (count?: number) => void;
    /** Navigate to first screen within the lowest stack. */
    dismissAll: () => void;
    /** If there's history that supports invoking the `dismiss` and `dismissAll` function. */
    canDismiss: () => boolean;
    /** Update the current route query params. */
    setParams: <T = ''>(
        params?: T extends '' ? InputRouteParamsBlank : InputRouteParams<T>
    ) => void;
    /** Subscribe to state updates from the router */
    subscribe: (listener: RootStateListener) => () => void;
    /** Subscribe to loading state updates */
    onLoadState: (listener: LoadingStateListener) => () => void;
};

type RouteType<Path extends string> = Path extends keyof __routes['RouteTypes']
    ? __routes['RouteTypes'][Path]
    : {
          Params: InputRouteParams<Path>;
          LoaderProps: import('../types').LoaderProps<InputRouteParams<Path>>;
      };

type SearchParams<T extends AllRoutes = never> = T extends DynamicRouteTemplate
    ? OutputRouteParams<T>
    : T extends StaticRoutes
    ? never
    : UnknownOutputParams;

type SingleRoutePart<S extends string> = S extends `${string}/${string}`
    ? never
    : S extends `${string}${SearchOrHash}`
    ? never
    : S extends ''
    ? never
    : S extends `(${string})`
    ? never
    : S extends `[${string}]`
    ? never
    : S;

type UnknownInputParams = Record<
    string,
    string | number | undefined | null | (string | number)[]
>;

let hasAttemptedToHideSplash: boolean;

let initialState: any;

let navigationRef: NavigationContainerRefWithCurrent<ReactNavigation.RootParamList>;

const preloadedLoaderData: Record<string, any>;

const preloadingLoader: Record<string, Promise<any>>;

let rootComponent: ComponentType;

let rootState: any;

let routeInfo: any;

let routeNode: any;

canDismiss: () => boolean;

canGoBack: () => boolean;

cleanup: () => void;

dismiss: (count?: number) => void;

dismissAll: () => void;

getPreloadHistory: () => PreloadEntry[];

getSortedRoutes: () => any;

getValidationState: () => ValidationState;

goBack: () => void;

initialize: (
    context: One.RouteContext,
    ref: NavigationContainerRefWithCurrent<ReactNavigation.RootParamList>,
    initialLocation?: URL
) => void;

isRouteProtected: (href: string) => boolean;

linkTo: (
    href: string,
    event?: string,
    options?: OneRouter.LinkToOptions
) => Promise<void>;

navigate: (
    url: OneRouter.Href,
    options?: OneRouter.LinkToOptions
) => Promise<void>;

preloadRoute: (href: string, injectCSS?: boolean) => Promise<any> | undefined;

push: (url: OneRouter.Href, options?: OneRouter.LinkToOptions) => Promise<void>;

registerProtectedRoutes: (
    contextKey: string,
    protectedScreens: Set<string>
) => void;

replace: (
    url: OneRouter.Href,
    options?: OneRouter.LinkToOptions
) => Promise<void>;

rootStateSnapshot: () => any;

routeInfoSnapshot: () => any;

setLoadingState: (state: OneRouter.LoadingState) => void;

setParams: (params?: OneRouter.InpurRouteParamsGeneric) => any;

setValidationState: (state: ValidationState) => void;

snapshot: () => {
    linkTo: (
        href: string,
        event?: string,
        options?: OneRouter.LinkToOptions
    ) => Promise<void>;
    routeNode: any;
    rootComponent: ComponentType;
    linking: any;
    hasAttemptedToHideSplash: boolean;
    initialState: any;
    rootState: any;
    nextState: any;
    routeInfo: any;
    splashScreenAnimationFrame: number;
    navigationRef: NavigationContainerRefWithCurrent<ReactNavigation.RootParamList>;
    navigationRefSubscription: () => void;
    rootStateSubscribers: Set<OneRouter.RootStateListener>;
    storeSubscribers: Set<() => void>;
};

subscribeToLoadingState: (
    subscriber: OneRouter.LoadingStateListener
) => () => void;

subscribeToRootState: (subscriber: OneRouter.RootStateListener) => () => void;

subscribeToStore: (subscriber: () => void) => () => void;

subscribeToValidationState: (
    subscriber: (state: ValidationState) => void
) => () => boolean;

unregisterProtectedRoutes: (contextKey: string) => void;

updateState: (state: OneRouter.ResultState, nextStateParam?: any) => void;

useOneRouter: () => any;

useStoreRootState: () => any;

useStoreRouteInfo: () => any;

useValidationState: () => any;

type PreloadEntry = {
    href: string;
    status: PreloadStatus;
    startTime: number;
    endTime?: number;
    error?: string;
    hasLoader: boolean;
    hasCss: boolean;
};

type PreloadStatus = 'pending' | 'loading' | 'loaded' | 'error';