one

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

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;
};

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 preloadingLoader: {};

let rootComponent: ComponentType;

let rootState: any;

let routeInfo: any;

let routeNode: any;

canDismiss: () => boolean;

canGoBack: () => boolean;

cleanup: () => void;

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

dismissAll: () => void;

getSortedRoutes: () => any;

goBack: () => void;

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

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

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

preloadRoute: (href: string) => void;

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

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

rootStateSnapshot: () => any;

routeInfoSnapshot: () => any;

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

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

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;

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

useOneRouter: () => any;

useStoreRootState: () => any;

useStoreRouteInfo: () => any;