@bgub/fig-tanstack-router 0.0.0-tegami-trusted-publish-setup → 0.1.0-alpha.2

package/dist/router.d.ts

@@ -0,0 +1,214 @@
+import { HistoryAction, RouterHistory, RouterHistory as RouterHistory$1, createBrowserHistory, createHashHistory, createMemoryHistory } from "@tanstack/history";
+import { AnyContext, AnyRoute, AnyRoute as AnyRoute$1, AnyRouteMatch, AnyRouter, AnyRouter as AnyRouter$1, AssetCrossOriginConfig, BaseRootRoute, BaseRoute, BaseRouteApi, Constrain, ConstrainLiteral, CreateFileRoute, CreateLazyFileRoute, DeepPartial, Expand, FileRoutesByPath as FileRoutesByPath$1, FromPathOption, InferFrom, InferMaskFrom, InferMaskTo, InferTo, LinkOptions, LinkOptions as LinkOptions$1, MakeOptionalPathParams, MakeOptionalSearchParams, MakeRouteMatch, MakeRouteMatchUnion, MaskOptions, MatchRouteOptions, MetaDescriptor, NavigateOptions, NavigateOptions as NavigateOptions$1, NotFoundError, NotFoundRouteProps, ParseRoute, ParsedLocation, Register, RegisteredRouter, RegisteredRouter as RegisteredRouter$1, ResolveFullPath, ResolveId, ResolveParams, ResolveRoute, ResolveUseLoaderDeps, ResolveUseParams, ResolveUseSearch, RootRouteId, RootRouteOptions, RouteConstraints, RouteIds, RouteMask, RouteOptions, RouteTypesById, RouterConstructorOptions, RouterCore, RouterState, RouterState as RouterState$1, StrictOrFrom, ThrowConstraint, ThrowOrOptional, ToMaskOptions, ToSubOptionsProps, TrailingSlashOption, UseLoaderDepsResult, UseNavigateResult, UseParamsResult, UseRouteContextResult, UseSearchResult, defaultParseSearch, defaultStringifySearch, isNotFound, isRedirect, lazyFn, notFound, parseSearchWith, redirect, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams } from "@tanstack/router-core";
+import { ComponentType, DataResource, ErrorInfo, FigDataStoreHandle, FigNode, Props } from "@bgub/fig";
+import { HostIntrinsicElements } from "@bgub/fig-dom";
+//#region src/data-context.d.ts
+type RouteDataContext = {
+  data: FigDataStoreHandle;
+};
+declare function ensureRouteData<TArgs extends unknown[], TValue>(context: RouteDataContext, resource: DataResource<TArgs, TValue>, ...args: TArgs): Promise<void>;
+//#endregion
+//#region src/hooks.d.ts
+type StructuralSharingOptions = {
+  structuralSharing?: boolean;
+};
+type SelectRouteValue<TValue, TSelected> = StructuralSharingOptions & {
+  select?: (value: TValue) => TSelected;
+};
+type RouteMatchResult<TRouter extends AnyRouter$1, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? TStrict extends true ? MakeRouteMatch<TRouter["routeTree"], TFrom, true> : MakeRouteMatchUnion<TRouter> : TSelected;
+declare function useRouter<TRouter extends AnyRouter$1 = RegisteredRouter$1>(): TRouter;
+declare function useRouterState<TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = RouterState$1<TRouter["routeTree"]>>(options?: SelectRouteValue<RouterState$1<TRouter["routeTree"]>, TSelected> & {
+  router?: TRouter;
+}): TSelected;
+declare function useLocation<TRouter extends AnyRouter$1 = RegisteredRouter$1, TLocation = RouterState$1<TRouter["routeTree"]>["location"]>(options?: SelectRouteValue<RouterState$1<TRouter["routeTree"]>["location"], TLocation>): TLocation;
+type BlockerLocation<out TRouteId = string, out TFullPath = string, out TParams = unknown, out TSearch = unknown> = {
+  fullPath: TFullPath;
+  params: TParams;
+  pathname: string;
+  routeId: TRouteId;
+  search: TSearch;
+};
+type BlockerLocationUnion<TRouter extends AnyRouter$1 = RegisteredRouter$1, TRoute extends AnyRoute$1 = ParseRoute<TRouter["routeTree"]>> = TRoute extends AnyRoute$1 ? BlockerLocation<TRoute["id"], TRoute["fullPath"], TRoute["types"]["allParams"], TRoute["types"]["fullSearchSchema"]> : never;
+type BlockerResolver<TRouter extends AnyRouter$1 = RegisteredRouter$1> = {
+  action: HistoryAction;
+  current: BlockerLocationUnion<TRouter>;
+  next: BlockerLocationUnion<TRouter>;
+  proceed: () => void;
+  reset: () => void;
+  status: "blocked";
+} | {
+  action: undefined;
+  current: undefined;
+  next: undefined;
+  proceed: undefined;
+  reset: undefined;
+  status: "idle";
+};
+type ShouldBlockFn<TRouter extends AnyRouter$1 = RegisteredRouter$1> = (args: {
+  action: HistoryAction;
+  current: BlockerLocationUnion<TRouter>;
+  next: BlockerLocationUnion<TRouter>;
+}) => boolean | Promise<boolean>;
+type UseBlockerOpts<TRouter extends AnyRouter$1 = RegisteredRouter$1, TWithResolver extends boolean = boolean> = {
+  disabled?: boolean;
+  enableBeforeUnload?: boolean | (() => boolean);
+  shouldBlockFn: ShouldBlockFn<TRouter>;
+  withResolver?: TWithResolver;
+};
+declare function useBlocker<TRouter extends AnyRouter$1 = RegisteredRouter$1, TWithResolver extends boolean = false>(options: UseBlockerOpts<TRouter, TWithResolver>): TWithResolver extends true ? BlockerResolver<TRouter> : void;
+declare function useCanGoBack(): boolean;
+type TypedMatchOptions<TRouter extends AnyRouter$1, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & SelectRouteValue<MakeRouteMatch<TRouter["routeTree"], TFrom, TStrict>, TSelected> & {
+  shouldThrow?: TThrow;
+};
+declare function useMatch<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(options?: TypedMatchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): ThrowOrOptional<RouteMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>;
+type TypedRouteValueOptions<TRouter extends AnyRouter$1, TFrom, TStrict extends boolean, TValue, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & SelectRouteValue<TValue, TSelected>;
+declare function useParams<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(options?: TypedRouteValueOptions<TRouter, TFrom, TStrict, ResolveUseParams<TRouter, TFrom, TStrict>, TSelected> & {
+  shouldThrow?: ThrowConstraint<TStrict, TThrow>;
+}): ThrowOrOptional<UseParamsResult<TRouter, TFrom, TStrict, TSelected>, TThrow>;
+declare function useSearch<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(options?: TypedRouteValueOptions<TRouter, TFrom, TStrict, ResolveUseSearch<TRouter, TFrom, TStrict>, TSelected> & {
+  shouldThrow?: ThrowConstraint<TStrict, TThrow>;
+}): ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>;
+declare function useLoaderDeps<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends RouteIds<TRouter["routeTree"]> = RouteIds<TRouter["routeTree"]>, TSelected = unknown>(options?: SelectRouteValue<ResolveUseLoaderDeps<TRouter, TFrom>, TSelected> & {
+  from: TFrom;
+}): UseLoaderDepsResult<TRouter, TFrom, TSelected>;
+declare function useRouteContext<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(options?: TypedRouteValueOptions<TRouter, TFrom, TStrict, UseRouteContextResult<TRouter, TFrom, TStrict, unknown>, TSelected>): UseRouteContextResult<TRouter, TFrom, TStrict, TSelected>;
+declare function useNavigate<TRouter extends AnyRouter$1 = RegisteredRouter$1, TDefaultFrom extends string = string>(options?: {
+  from?: FromPathOption<TRouter, TDefaultFrom>;
+}): UseNavigateResult<TDefaultFrom>;
+declare function Navigate<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: NavigateOptions$1<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): null;
+type UseMatchesOptions<TRouter extends AnyRouter$1, TSelected> = StructuralSharingOptions & {
+  select?: (matches: Array<MakeRouteMatchUnion<TRouter>>) => TSelected;
+};
+type UseMatchesResult<TRouter extends AnyRouter$1, TSelected> = unknown extends TSelected ? Array<MakeRouteMatchUnion<TRouter>> : TSelected;
+declare function useMatches<TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = unknown>(options?: UseMatchesOptions<TRouter, TSelected>): UseMatchesResult<TRouter, TSelected>;
+type UseMatchRouteOptions<TRouter extends AnyRouter$1 = RegisteredRouter$1, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = ""> = ToSubOptionsProps<TRouter, TFrom, TTo> & DeepPartial<MakeOptionalSearchParams<TRouter, TFrom, TTo>> & DeepPartial<MakeOptionalPathParams<TRouter, TFrom, TTo>> & MaskOptions<TRouter, TMaskFrom, TMaskTo> & MatchRouteOptions;
+type MatchRouteFn<TRouter extends AnyRouter$1 = RegisteredRouter$1> = <const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(options: UseMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => false | Expand<ResolveRoute<TRouter, TFrom, TTo>["types"]["allParams"]>;
+declare function useMatchRoute<TRouter extends AnyRouter$1 = RegisteredRouter$1>(): MatchRouteFn<TRouter>;
+type MakeMatchRouteOptions<TRouter extends AnyRouter$1 = RegisteredRouter$1, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = ""> = UseMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+  children?: FigNode | ((params?: Expand<ResolveRoute<TRouter, TFrom, TTo>["types"]["allParams"]>) => FigNode);
+};
+declare function MatchRoute<TRouter extends AnyRouter$1 = RegisteredRouter$1, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: MakeMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): FigNode;
+//#endregion
+//#region src/link.d.ts
+type AnchorProps = HostIntrinsicElements["a"];
+type LinkStateProps = Partial<Omit<AnchorProps, "children" | "href" | "target">>;
+type LinkRenderState = {
+  isActive: boolean;
+  isTransitioning: boolean;
+};
+type LinkProps<TFrom extends string = string, TTo extends string | undefined = ".", TMaskFrom extends string = TFrom, TMaskTo extends string = "."> = Omit<AnchorProps, "children"> & LinkOptions$1<RegisteredRouter$1, TFrom, TTo, TMaskFrom, TMaskTo> & {
+  activeProps?: LinkStateProps | (() => LinkStateProps);
+  children?: FigNode | ((state: LinkRenderState) => FigNode);
+  inactiveProps?: LinkStateProps | (() => LinkStateProps);
+  preloadIntentProximity?: never;
+};
+declare function Link<const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: LinkProps<TFrom, TTo, TMaskFrom, TMaskTo>): FigNode;
+//#endregion
+//#region src/matches.d.ts
+declare module "@tanstack/router-core" {
+  interface RouteMatchExtensions {
+    headScripts?: Array<HostIntrinsicElements["script"] | undefined>;
+    links?: Array<HostIntrinsicElements["link"] | undefined>;
+    meta?: Array<HostIntrinsicElements["meta"] | MetaDescriptor | undefined>;
+    scripts?: Array<HostIntrinsicElements["script"] | undefined>;
+    styles?: Array<HostIntrinsicElements["style"] | undefined>;
+  }
+}
+type RouterProviderProps<TRouter extends AnyRouter$1 = RegisteredRouter$1> = Partial<Omit<TRouter["options"], "context">> & {
+  context?: Partial<TRouter["options"]["context"]>;
+  router: TRouter;
+};
+declare function RouterProvider<TRouter extends AnyRouter$1 = RegisteredRouter$1>({ router, ...options }: RouterProviderProps<TRouter>): FigNode;
+declare function Matches(): FigNode;
+declare function Outlet(): FigNode;
+declare function HeadContent(): FigNode;
+declare function Scripts(): FigNode;
+//#endregion
+//#region src/route.d.ts
+type ValidateLinkOptions<TRouter extends AnyRouter$1, TOptions, TDefaultFrom extends string = string> = Constrain<TOptions, LinkOptions$1<TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+type ValidateLinkOptionsArray<TRouter extends AnyRouter$1, TOptions extends ReadonlyArray<unknown>, TDefaultFrom extends string = string> = { [TIndex in keyof TOptions]: ValidateLinkOptions<TRouter, TOptions[TIndex], TDefaultFrom>; };
+type LinkOptionsFnOptions<TOptions, TRouter extends AnyRouter$1 = RegisteredRouter$1> = TOptions extends ReadonlyArray<unknown> ? ValidateLinkOptionsArray<TRouter, TOptions> : ValidateLinkOptions<TRouter, TOptions>;
+declare function linkOptions<const TOptions, TRouter extends AnyRouter$1 = RegisteredRouter$1>(options: LinkOptionsFnOptions<TOptions, TRouter>): TOptions;
+interface FileRoutesByPath extends FileRoutesByPath$1 {}
+type RouteErrorComponentProps = {
+  error: unknown;
+  reset: () => void;
+};
+type RouteComponent = ComponentType;
+type ErrorRouteComponent = ComponentType<RouteErrorComponentProps>;
+type NotFoundRouteComponent = ComponentType<NotFoundRouteProps>;
+type UseMatchRoute<out TFrom> = <TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = unknown>(options?: SelectRouteValue<MakeRouteMatch<TRouter["routeTree"], TFrom, true>, TSelected>) => RouteMatchResult<TRouter, TFrom, true, TSelected>;
+type UseParamsRoute<out TFrom> = <TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = unknown>(options?: SelectRouteValue<ResolveUseParams<TRouter, TFrom, true>, TSelected>) => UseParamsResult<TRouter, TFrom, true, TSelected>;
+type UseSearchRoute<out TFrom> = <TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = unknown>(options?: SelectRouteValue<ResolveUseSearch<TRouter, TFrom, true>, TSelected>) => UseSearchResult<TRouter, TFrom, true, TSelected>;
+type UseLoaderDepsRoute<out TFrom> = <TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = unknown>(options?: SelectRouteValue<ResolveUseLoaderDeps<TRouter, TFrom>, TSelected>) => UseLoaderDepsResult<TRouter, TFrom, TSelected>;
+type UseRouteContextRoute<out TFrom> = <TRouter extends AnyRouter$1 = RegisteredRouter$1, TSelected = unknown>(options?: SelectRouteValue<UseRouteContextResult<TRouter, TFrom, true, unknown>, TSelected>) => UseRouteContextResult<TRouter, TFrom, true, TSelected>;
+type LinkComponentRoute<TFrom extends string> = <const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(props: Omit<LinkProps<TFrom, TTo, TMaskFrom, TMaskTo>, "from">) => FigNode;
+type RouteApiMethods<TId extends string, TFullPath extends string> = {
+  Link: LinkComponentRoute<TFullPath>;
+  notFound: (options?: NotFoundError) => NotFoundError;
+  useLoaderDeps: UseLoaderDepsRoute<TId>;
+  useMatch: UseMatchRoute<TId>;
+  useNavigate: () => UseNavigateResult<TFullPath>;
+  useParams: UseParamsRoute<TId>;
+  useRouteContext: UseRouteContextRoute<TId>;
+  useSearch: UseSearchRoute<TId>;
+};
+type RouteWithApi<TRoute, TId extends string, TFullPath extends string> = TRoute & RouteApiMethods<TId, TFullPath>;
+declare module "@tanstack/router-core" {
+  interface RouteExtensions<in out TId extends string, in out TFullPath extends string> {
+    Link: LinkComponentRoute<TFullPath>;
+    notFound: (options?: NotFoundError) => NotFoundError;
+    useLoaderDeps: UseLoaderDepsRoute<TId>;
+    useMatch: UseMatchRoute<TId>;
+    useNavigate: () => UseNavigateResult<TFullPath>;
+    useParams: UseParamsRoute<TId>;
+    useRouteContext: UseRouteContextRoute<TId>;
+    useSearch: UseSearchRoute<TId>;
+  }
+  interface UpdatableRouteOptionsExtensions {
+    component?: RouteComponent;
+    errorComponent?: false | null | ErrorRouteComponent;
+    notFoundComponent?: NotFoundRouteComponent;
+    pendingComponent?: RouteComponent;
+  }
+  interface RouterOptionsExtensions {
+    assetCrossOrigin?: AssetCrossOriginConfig;
+    defaultComponent?: RouteComponent;
+    defaultErrorComponent?: ErrorRouteComponent;
+    defaultNotFoundComponent?: NotFoundRouteComponent;
+    defaultOnCatch?: (error: Error, info: ErrorInfo) => void;
+    defaultPendingComponent?: RouteComponent;
+  }
+}
+declare function createRouteMask<TRouteTree extends AnyRoute$1, TFrom extends string, TTo extends string>(options: {
+  routeTree: TRouteTree;
+} & ToMaskOptions<RouterCore<TRouteTree, "never", boolean>, TFrom, TTo>): RouteMask<TRouteTree>;
+declare function createRouter<TRouteTree extends AnyRoute$1, TTrailingSlashOption extends TrailingSlashOption = "never", TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory$1 = RouterHistory$1, TDehydrated extends Record<string, unknown> = Record<string, unknown>>(options: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>): RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>;
+declare function getRouteApi<const TId extends string, TRouter extends AnyRouter$1 = RegisteredRouter$1>(id: ConstrainLiteral<TId, RouteIds<TRouter["routeTree"]>>): RouteApi<TId, TRouter>;
+declare class RouteApi<TId extends string, TRouter extends AnyRouter$1 = RegisteredRouter$1> extends BaseRouteApi<TId, TRouter> {
+  Link: LinkComponentRoute<RouteTypesById<TRouter, TId>["fullPath"]>;
+  useLoaderDeps: UseLoaderDepsRoute<TId>;
+  useMatch: UseMatchRoute<TId>;
+  useNavigate: () => UseNavigateResult<RouteTypesById<TRouter, TId>["fullPath"]>;
+  useParams: UseParamsRoute<TId>;
+  useRouteContext: UseRouteContextRoute<TId>;
+  useSearch: UseSearchRoute<TId>;
+  constructor({ id }: {
+    id: TId;
+  });
+}
+declare function createRoute<TRegister = unknown, TParentRoute extends RouteConstraints["TParentRoute"] = AnyRoute$1, TPath extends RouteConstraints["TPath"] = "/", TFullPath extends RouteConstraints["TFullPath"] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints["TCustomId"] = string, TId extends RouteConstraints["TId"] = ResolveId<TParentRoute, TCustomId, TPath>, TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, unknown> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, const TServerMiddlewares = unknown, THandlers = undefined>(options: RouteOptions<TRegister, TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn, TSSR, TServerMiddlewares, THandlers>): RouteWithApi<BaseRoute<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, unknown, TSSR, TServerMiddlewares, THandlers>, TId, TFullPath>;
+declare function createFileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute$1 = FileRoutesByPath[TFilePath]["parentRoute"], TId extends RouteConstraints["TId"] = FileRoutesByPath[TFilePath]["id"], TPath extends RouteConstraints["TPath"] = FileRoutesByPath[TFilePath]["path"], TFullPath extends RouteConstraints["TFullPath"] = FileRoutesByPath[TFilePath]["fullPath"]>(_path?: TFilePath): CreateFileRoute<TFilePath, TParentRoute, TId, TPath, TFullPath>;
+declare function createLazyFileRoute<TFilePath extends keyof FileRoutesByPath, TRoute extends FileRoutesByPath[TFilePath]["preLoaderRoute"]>(id: TFilePath): CreateLazyFileRoute<TRoute>;
+type AsyncRouteComponent<TProps = Props> = ComponentType<TProps> & {
+  preload?: () => Promise<void>;
+};
+type ImportedRouteComponent<TValue> = TValue extends ComponentType<infer TProps> ? AsyncRouteComponent<TProps> : never;
+declare function lazyRouteComponent<TComponent>(importer: () => Promise<{
+  default: TComponent;
+}>): ImportedRouteComponent<TComponent>;
+declare function lazyRouteComponent<TModule extends Record<string, unknown>, TKey extends keyof TModule>(importer: () => Promise<TModule>, exportName: TKey): ImportedRouteComponent<TModule[TKey]>;
+declare function createRootRoute<TRegister = Register, TSearchValidator = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, unknown> = {}, TLoaderFn = undefined, TSSR = unknown, const TServerMiddlewares = unknown, THandlers = undefined>(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, TServerMiddlewares, THandlers>): RouteWithApi<BaseRootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, TServerMiddlewares, THandlers>, RootRouteId, "/">;
+declare function createRootRouteWithContext<TRouterContext extends object>(): <TRegister = Register, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSearchValidator = undefined, TLoaderDeps extends Record<string, unknown> = {}, TLoaderFn = undefined, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined>(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, TServerMiddlewares, THandlers>) => RouteWithApi<BaseRootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, TServerMiddlewares, THandlers>, "__root__", "/">;
+//#endregion
+export { type AnyRoute, type AnyRouteMatch, type AnyRouter, type AsyncRouteComponent, type ErrorRouteComponent, type FileRoutesByPath, HeadContent, Link, type LinkComponentRoute, type LinkOptions, type LinkOptionsFnOptions, type LinkProps, type LinkRenderState, type MakeMatchRouteOptions, MatchRoute, type MatchRouteFn, Matches, Navigate, type NavigateOptions, type NotFoundRouteComponent, Outlet, type ParsedLocation, type RegisteredRouter, type RouteApiMethods, type RouteComponent, type RouteDataContext, type RouteErrorComponentProps, type RouterHistory, RouterProvider, type RouterProviderProps, type RouterState, Scripts, type ShouldBlockFn, type UseBlockerOpts, type UseLoaderDepsRoute, type UseMatchRoute, type UseMatchRouteOptions, type UseMatchesOptions, type UseMatchesResult, type UseParamsRoute, type UseRouteContextRoute, type UseSearchRoute, createBrowserHistory, createFileRoute, createHashHistory, createLazyFileRoute, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, defaultParseSearch, defaultStringifySearch, ensureRouteData, getRouteApi, isNotFound, isRedirect, lazyFn, lazyRouteComponent, linkOptions, notFound, parseSearchWith, redirect, retainSearchParams, rootRouteId, stringifySearchWith, stripSearchParams, useBlocker, useCanGoBack, useLoaderDeps, useLocation, useMatch, useMatchRoute, useMatches, useNavigate, useParams, useRouteContext, useRouter, useRouterState, useSearch };