@tanstack/router-core 1.112.8 → 1.112.18

package/src/router.ts

@@ -1,7 +1,61 @@
 import type { ParsedLocation } from './location'
 import type { DeferredPromiseState } from './defer'
-import type { ControlledPromise } from './utils'
-import type { AnyRoute, AnyRouteWithContext } from './route'
+import type {
+  ControlledPromise,
+  NoInfer,
+  NonNullableUpdater,
+  Updater,
+} from './utils'
+import type {
+  AnyContext,
+  AnyRoute,
+  AnyRouteWithContext,
+  MakeRemountDepsOptionsUnion,
+  RouteMask,
+} from './route'
+import type { Store } from '@tanstack/store'
+import type {
+  FullSearchSchema,
+  RouteById,
+  RoutePaths,
+  RoutesById,
+  RoutesByPath,
+} from './routeInfo'
+import type {
+  AnyRouteMatch,
+  MakeRouteMatchUnion,
+  MatchRouteOptions,
+} from './Matches'
+import type { AnyRedirect, ResolvedRedirect } from './redirect'
+import type {
+  BuildLocationFn,
+  CommitLocationOptions,
+  NavigateFn,
+} from './RouterProvider'
+import type {
+  HistoryLocation,
+  HistoryState,
+  ParsedHistoryState,
+  RouterHistory,
+} from '@tanstack/history'
+import type { Manifest } from './manifest'
+import type { StartSerializer } from './serializer'
+import type { AnySchema } from './validators'
+import type { NavigateOptions, ResolveRelativePath, ToOptions } from './link'
+import type { SearchParser, SearchSerializer } from './searchParams'
+
+declare global {
+  interface Window {
+    __TSR_ROUTER__?: AnyRouter
+  }
+}
+
+export type ControllablePromise<T = any> = Promise<T> & {
+  resolve: (value: T) => void
+  reject: (value?: any) => void
+}
+
+export type InjectedHtmlEntry = Promise<string>
 
 export interface Register {
   // router: Router
@@ -13,26 +67,660 @@ export type RegisteredRouter = Register extends {
   ? TRouter
   : AnyRouter
 
+export type DefaultRemountDepsFn<TRouteTree extends AnyRoute> = (
+  opts: MakeRemountDepsOptionsUnion<TRouteTree>,
+) => any
+
+export interface DefaultRouterOptionsExtensions {}
+
+export interface RouterOptionsExtensions
+  extends DefaultRouterOptionsExtensions {}
+
 export interface RouterOptions<
-  in out TTrailingSlashOption extends TrailingSlashOption,
-> {
+  TRouteTree extends AnyRoute,
+  TTrailingSlashOption extends TrailingSlashOption,
+  TDefaultStructuralSharingOption extends boolean = false,
+  TRouterHistory extends RouterHistory = RouterHistory,
+  TDehydrated extends Record<string, any> = Record<string, any>,
+> extends RouterOptionsExtensions {
+  /**
+   * The history object that will be used to manage the browser history.
+   *
+   * If not provided, a new createBrowserHistory instance will be created and used.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#history-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/history-types)
+   */
+  history?: TRouterHistory
+  /**
+   * A function that will be used to stringify search params when generating links.
+   *
+   * @default defaultStringifySearch
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#stringifysearch-method)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/custom-search-param-serialization)
+   */
+  stringifySearch?: SearchSerializer
+  /**
+   * A function that will be used to parse search params when parsing the current location.
+   *
+   * @default defaultParseSearch
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#parsesearch-method)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/custom-search-param-serialization)
+   */
+  parseSearch?: SearchParser
+  /**
+   * If `false`, routes will not be preloaded by default in any way.
+   *
+   * If `'intent'`, routes will be preloaded by default when the user hovers over a link or a `touchstart` event is detected on a `<Link>`.
+   *
+   * If `'viewport'`, routes will be preloaded by default when they are within the viewport.
+   *
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpreload-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading)
+   */
+  defaultPreload?: false | 'intent' | 'viewport' | 'render'
+  /**
+   * The delay in milliseconds that a route must be hovered over or touched before it is preloaded.
+   *
+   * @default 50
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpreloaddelay-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading#preload-delay)
+   */
+  defaultPreloadDelay?: number
+  /**
+   * The default `pendingMs` a route should use if no pendingMs is provided.
+   *
+   * @default 1000
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpendingms-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#avoiding-pending-component-flash)
+   */
+  defaultPendingMs?: number
+  /**
+   * The default `pendingMinMs` a route should use if no pendingMinMs is provided.
+   *
+   * @default 500
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpendingminms-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#avoiding-pending-component-flash)
+   */
+  defaultPendingMinMs?: number
+  /**
+   * The default `staleTime` a route should use if no staleTime is provided. This is the time in milliseconds that a route will be considered fresh.
+   *
+   * @default 0
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultstaletime-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#key-options)
+   */
+  defaultStaleTime?: number
+  /**
+   * The default `preloadStaleTime` a route should use if no preloadStaleTime is provided.
+   *
+   * @default 30_000 `(30 seconds)`
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpreloadstaletime-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading)
+   */
+  defaultPreloadStaleTime?: number
+  /**
+   * The default `defaultPreloadGcTime` a route should use if no preloadGcTime is provided.
+   *
+   * @default 1_800_000 `(30 minutes)`
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpreloadgctime-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading)
+   */
+  defaultPreloadGcTime?: number
+  /**
+   * If `true`, route navigations will called using `document.startViewTransition()`.
+   *
+   * If the browser does not support this api, this option will be ignored.
+   *
+   * See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition) for more information on how this function works.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultviewtransition-property)
+   */
+  defaultViewTransition?: boolean | ViewTransitionOptions
+  /**
+   * The default `hashScrollIntoView` a route should use if no hashScrollIntoView is provided while navigating
+   *
+   * See [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView) for more information on `ScrollIntoViewOptions`.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaulthashscrollintoview-property)
+   */
+  defaultHashScrollIntoView?: boolean | ScrollIntoViewOptions
+  /**
+   * @default 'fuzzy'
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#notfoundmode-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/not-found-errors#the-notfoundmode-option)
+   */
+  notFoundMode?: 'root' | 'fuzzy'
+  /**
+   * The default `gcTime` a route should use if no gcTime is provided.
+   *
+   * @default 1_800_000 `(30 minutes)`
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultgctime-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#key-options)
+   */
+  defaultGcTime?: number
+  /**
+   * If `true`, all routes will be matched as case-sensitive.
+   *
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#casesensitive-property)
+   */
+  caseSensitive?: boolean
+  /**
+   *
+   * The route tree that will be used to configure the router instance.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#routetree-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/routing/route-trees)
+   */
+  routeTree?: TRouteTree
+  /**
+   * The basepath for then entire router. This is useful for mounting a router instance at a subpath.
+   *
+   * @default '/'
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#basepath-property)
+   */
+  basepath?: string
+  /**
+   * The root context that will be provided to all routes in the route tree.
+   *
+   * This can be used to provide a context to all routes in the tree without having to provide it to each route individually.
+   *
+   * Optional or required if the root route was created with [`createRootRouteWithContext()`](https://tanstack.com/router/latest/docs/framework/react/api/router/createRootRouteWithContextFunction).
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#context-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/router-context)
+   */
+  context?: InferRouterContext<TRouteTree>
+  /**
+   * A function that will be called when the router is dehydrated.
+   *
+   * The return value of this function will be serialized and stored in the router's dehydrated state.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#dehydrate-method)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/external-data-loading#critical-dehydrationhydration)
+   */
+  dehydrate?: () => TDehydrated
+  /**
+   * A function that will be called when the router is hydrated.
+   *
+   * The return value of this function will be serialized and stored in the router's dehydrated state.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#hydrate-method)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/external-data-loading#critical-dehydrationhydration)
+   */
+  hydrate?: (dehydrated: TDehydrated) => void
+  /**
+   * An array of route masks that will be used to mask routes in the route tree.
+   *
+   * Route masking is when you display a route at a different path than the one it is configured to match, like a modal popup that when shared will unmask to the modal's content instead of the modal's context.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#routemasks-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/route-masking)
+   */
+  routeMasks?: Array<RouteMask<TRouteTree>>
+  /**
+   * If `true`, route masks will, by default, be removed when the page is reloaded.
+   *
+   * This can be overridden on a per-mask basis by setting the `unmaskOnReload` option on the mask, or on a per-navigation basis by setting the `unmaskOnReload` option in the `Navigate` options.
+   *
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#unmaskonreload-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/route-masking#unmasking-on-page-reload)
+   */
+  unmaskOnReload?: boolean
+
+  /**
+   * Use `notFoundComponent` instead.
+   *
+   * @deprecated
+   * See https://tanstack.com/router/v1/docs/guide/not-found-errors#migrating-from-notfoundroute for more info.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#notfoundroute-property)
+   */
+  notFoundRoute?: AnyRoute
+  /**
+   * Configures how trailing slashes are treated.
+   *
+   * - `'always'` will add a trailing slash if not present
+   * - `'never'` will remove the trailing slash if present
+   * - `'preserve'` will not modify the trailing slash.
+   *
+   * @default 'never'
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#trailingslash-property)
+   */
   trailingSlash?: TTrailingSlashOption
+  /**
+   * While usually automatic, sometimes it can be useful to force the router into a server-side state, e.g. when using the router in a non-browser environment that has access to a global.document object.
+   *
+   * @default typeof document !== 'undefined'
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#isserver-property)
+   */
+  isServer?: boolean
+
+  defaultSsr?: boolean
+
+  search?: {
+    /**
+     * Configures how unknown search params (= not returned by any `validateSearch`) are treated.
+     *
+     * @default false
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#search.strict-property)
+     */
+    strict?: boolean
+  }
+
+  /**
+   * Configures whether structural sharing is enabled by default for fine-grained selectors.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultstructuralsharing-property)
+   */
+  defaultStructuralSharing?: TDefaultStructuralSharingOption
+
+  /**
+   * Configures which URI characters are allowed in path params that would ordinarily be escaped by encodeURIComponent.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#pathparamsallowedcharacters-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/path-params#allowed-characters)
+   */
+  pathParamsAllowedCharacters?: Array<
+    ';' | ':' | '@' | '&' | '=' | '+' | '$' | ','
+  >
+
+  defaultRemountDeps?: DefaultRemountDepsFn<TRouteTree>
+
+  /**
+   * If `true`, scroll restoration will be enabled
+   *
+   * @default false
+   */
+  scrollRestoration?: boolean
+
+  /**
+   * A function that will be called to get the key for the scroll restoration cache.
+   *
+   * @default (location) => location.href
+   */
+  getScrollRestorationKey?: (location: ParsedLocation) => string
+  /**
+   * The default behavior for scroll restoration.
+   *
+   * @default 'auto'
+   */
+  scrollRestorationBehavior?: ScrollBehavior
+  /**
+   * An array of selectors that will be used to scroll to the top of the page in addition to `window`
+   *
+   * @default ['window']
+   */
+  scrollToTopSelectors?: Array<string>
+}
+
+export interface RouterState<
+  in out TRouteTree extends AnyRoute = AnyRoute,
+  in out TRouteMatch = MakeRouteMatchUnion,
+> {
+  status: 'pending' | 'idle'
+  loadedAt: number
+  isLoading: boolean
+  isTransitioning: boolean
+  matches: Array<TRouteMatch>
+  pendingMatches?: Array<TRouteMatch>
+  cachedMatches: Array<TRouteMatch>
+  location: ParsedLocation<FullSearchSchema<TRouteTree>>
+  resolvedLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>
+  statusCode: number
+  redirect?: ResolvedRedirect
+}
+
+export interface BuildNextOptions {
+  to?: string | number | null
+  params?: true | Updater<unknown>
+  search?: true | Updater<unknown>
+  hash?: true | Updater<string>
+  state?: true | NonNullableUpdater<ParsedHistoryState, HistoryState>
+  mask?: {
+    to?: string | number | null
+    params?: true | Updater<unknown>
+    search?: true | Updater<unknown>
+    hash?: true | Updater<string>
+    state?: true | NonNullableUpdater<ParsedHistoryState, HistoryState>
+    unmaskOnReload?: boolean
+  }
+  from?: string
+  _fromLocation?: ParsedLocation
+  href?: string
+}
+
+type NavigationEventInfo = {
+  fromLocation?: ParsedLocation
+  toLocation: ParsedLocation
+  pathChanged: boolean
+  hrefChanged: boolean
+  hashChanged: boolean
+}
+
+export type RouterEvents = {
+  onBeforeNavigate: {
+    type: 'onBeforeNavigate'
+  } & NavigationEventInfo
+  onBeforeLoad: {
+    type: 'onBeforeLoad'
+  } & NavigationEventInfo
+  onLoad: {
+    type: 'onLoad'
+  } & NavigationEventInfo
+  onResolved: {
+    type: 'onResolved'
+  } & NavigationEventInfo
+  onBeforeRouteMount: {
+    type: 'onBeforeRouteMount'
+  } & NavigationEventInfo
+  onInjectedHtml: {
+    type: 'onInjectedHtml'
+    promise: Promise<string>
+  }
+  onRendered: {
+    type: 'onRendered'
+  } & NavigationEventInfo
+}
+
+export type RouterEvent = RouterEvents[keyof RouterEvents]
+
+export type ListenerFn<TEvent extends RouterEvent> = (event: TEvent) => void
+
+export type RouterListener<TRouterEvent extends RouterEvent> = {
+  eventType: TRouterEvent['type']
+  fn: ListenerFn<TRouterEvent>
+}
+
+export interface MatchRoutesOpts {
+  preload?: boolean
+  throwOnError?: boolean
+  _buildLocation?: boolean
+  dest?: BuildNextOptions
+}
+
+export type InferRouterContext<TRouteTree extends AnyRoute> =
+  TRouteTree['types']['routerContext']
+
+export type RouterContextOptions<TRouteTree extends AnyRoute> =
+  AnyContext extends InferRouterContext<TRouteTree>
+    ? {
+        context?: InferRouterContext<TRouteTree>
+      }
+    : {
+        context: InferRouterContext<TRouteTree>
+      }
+
+export type RouterConstructorOptions<
+  TRouteTree extends AnyRoute,
+  TTrailingSlashOption extends TrailingSlashOption,
+  TDefaultStructuralSharingOption extends boolean,
+  TRouterHistory extends RouterHistory,
+  TDehydrated extends Record<string, any>,
+> = Omit<
+  RouterOptions<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory,
+    TDehydrated
+  >,
+  'context'
+> &
+  RouterContextOptions<TRouteTree>
+
+export interface RouterErrorSerializer<TSerializedError> {
+  serialize: (err: unknown) => TSerializedError
+  deserialize: (err: TSerializedError) => unknown
+}
+
+export interface MatchedRoutesResult {
+  matchedRoutes: Array<AnyRoute>
+  routeParams: Record<string, string>
+}
+
+export type PreloadRouteFn<
+  TRouteTree extends AnyRoute,
+  TTrailingSlashOption extends TrailingSlashOption,
+  TDefaultStructuralSharingOption extends boolean,
+  TRouterHistory extends RouterHistory,
+> = <
+  TFrom extends RoutePaths<TRouteTree> | string = string,
+  TTo extends string | undefined = undefined,
+  TMaskFrom extends RoutePaths<TRouteTree> | string = TFrom,
+  TMaskTo extends string = '',
+>(
+  opts: NavigateOptions<
+    Router<
+      TRouteTree,
+      TTrailingSlashOption,
+      TDefaultStructuralSharingOption,
+      TRouterHistory
+    >,
+    TFrom,
+    TTo,
+    TMaskFrom,
+    TMaskTo
+  >,
+) => Promise<Array<AnyRouteMatch> | undefined>
+
+export type MatchRouteFn<
+  TRouteTree extends AnyRoute,
+  TTrailingSlashOption extends TrailingSlashOption,
+  TDefaultStructuralSharingOption extends boolean,
+  TRouterHistory extends RouterHistory,
+> = <
+  TFrom extends RoutePaths<TRouteTree> = '/',
+  TTo extends string | undefined = undefined,
+  TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>,
+>(
+  location: ToOptions<
+    Router<
+      TRouteTree,
+      TTrailingSlashOption,
+      TDefaultStructuralSharingOption,
+      TRouterHistory
+    >,
+    TFrom,
+    TTo
+  >,
+  opts?: MatchRouteOptions,
+) => false | RouteById<TRouteTree, TResolved>['types']['allParams']
+
+export type UpdateFn<
+  TRouteTree extends AnyRoute,
+  TTrailingSlashOption extends TrailingSlashOption,
+  TDefaultStructuralSharingOption extends boolean,
+  TRouterHistory extends RouterHistory,
+  TDehydrated extends Record<string, any>,
+> = (
+  newOptions: RouterConstructorOptions<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory,
+    TDehydrated
+  >,
+) => void
+
+export type InvalidateFn<TRouter extends AnyRouter> = (opts?: {
+  filter?: (d: MakeRouteMatchUnion<TRouter>) => boolean
+  sync?: boolean
+}) => Promise<void>
+
+export type ParseLocationFn<TRouteTree extends AnyRoute> = (
+  previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>,
+  locationToParse?: HistoryLocation,
+) => ParsedLocation<FullSearchSchema<TRouteTree>>
+
+export type GetMatchRoutesFn = (
+  next: ParsedLocation,
+  dest?: BuildNextOptions,
+) => {
+  matchedRoutes: Array<AnyRoute>
+  routeParams: Record<string, string>
+  foundRoute: AnyRoute | undefined
+}
+
+export type EmitFn = (routerEvent: RouterEvent) => void
+
+export type LoadFn = (opts?: { sync?: boolean }) => Promise<void>
+
+export type CommitLocationFn = ({
+  viewTransition,
+  ignoreBlocker,
+  ...next
+}: ParsedLocation & CommitLocationOptions) => Promise<void>
+
+export type StartTransitionFn = (fn: () => void) => void
+
+export type SubscribeFn = <TType extends keyof RouterEvents>(
+  eventType: TType,
+  fn: ListenerFn<RouterEvents[TType]>,
+) => () => void
+
+export interface MatchRoutesFn {
+  (
+    pathname: string,
+    locationSearch: AnySchema,
+    opts?: MatchRoutesOpts,
+  ): Array<AnyRouteMatch>
+  (next: ParsedLocation, opts?: MatchRoutesOpts): Array<AnyRouteMatch>
+  (
+    pathnameOrNext: string | ParsedLocation,
+    locationSearchOrOpts?: AnySchema | MatchRoutesOpts,
+    opts?: MatchRoutesOpts,
+  ): Array<AnyRouteMatch>
+}
+
+export type GetMatchFn = (matchId: string) => AnyRouteMatch | undefined
+
+export type UpdateMatchFn = (
+  id: string,
+  updater: (match: AnyRouteMatch) => AnyRouteMatch,
+) => AnyRouteMatch
+
+export type LoadRouteChunkFn = (route: AnyRoute) => Promise<Array<void>>
+
+export type ResolveRedirect = (err: AnyRedirect) => ResolvedRedirect
+
+export type ClearCacheFn<TRouter extends AnyRouter> = (opts?: {
+  filter?: (d: MakeRouteMatchUnion<TRouter>) => boolean
+}) => void
+
+export interface ServerSrr {
+  injectedHtml: Array<InjectedHtmlEntry>
+  injectHtml: (getHtml: () => string | Promise<string>) => Promise<void>
+  injectScript: (
+    getScript: () => string | Promise<string>,
+    opts?: { logScript?: boolean },
+  ) => Promise<void>
+  streamValue: (key: string, value: any) => void
+  streamedKeys: Set<string>
+  onMatchSettled: (opts: { router: AnyRouter; match: AnyRouteMatch }) => any
 }
 
 export interface Router<
   in out TRouteTree extends AnyRoute,
   in out TTrailingSlashOption extends TrailingSlashOption,
+  in out TDefaultStructuralSharingOption extends boolean,
+  in out TRouterHistory extends RouterHistory = RouterHistory,
+  in out TDehydrated extends Record<string, any> = Record<string, any>,
 > {
   routeTree: TRouteTree
-  options: RouterOptions<TTrailingSlashOption>
+  options: RouterOptions<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory,
+    TDehydrated
+  >
+  __store: Store<RouterState<TRouteTree>>
+  navigate: NavigateFn
+  history: TRouterHistory
+  state: RouterState<TRouteTree>
+  isServer: boolean
+  clientSsr?: {
+    getStreamedValue: <T>(key: string) => T | undefined
+  }
+  looseRoutesById: Record<string, AnyRoute>
+  latestLocation: ParsedLocation<FullSearchSchema<TRouteTree>>
+  isScrollRestoring: boolean
+  resetNextScroll: boolean
+  isScrollRestorationSetup: boolean
+  ssr?: {
+    manifest: Manifest | undefined
+    serializer: StartSerializer
+  }
+  serverSsr?: ServerSrr
+  basepath: string
+  routesById: RoutesById<TRouteTree>
+  routesByPath: RoutesByPath<TRouteTree>
+  flatRoutes: Array<AnyRoute>
+  parseLocation: ParseLocationFn<TRouteTree>
+  getMatchedRoutes: GetMatchRoutesFn
+  emit: EmitFn
+  load: LoadFn
+  commitLocation: CommitLocationFn
+  buildLocation: BuildLocationFn
+  startTransition: StartTransitionFn
+  subscribe: SubscribeFn
+  matchRoutes: MatchRoutesFn
+  preloadRoute: PreloadRouteFn<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory
+  >
+  getMatch: GetMatchFn
+  updateMatch: UpdateMatchFn
+  matchRoute: MatchRouteFn<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory
+  >
+  update: UpdateFn<
+    TRouteTree,
+    TTrailingSlashOption,
+    TDefaultStructuralSharingOption,
+    TRouterHistory,
+    TDehydrated
+  >
+  invalidate: InvalidateFn<
+    Router<
+      TRouteTree,
+      TTrailingSlashOption,
+      TDefaultStructuralSharingOption,
+      TRouterHistory,
+      TDehydrated
+    >
+  >
+  loadRouteChunk: LoadRouteChunkFn
+  resolveRedirect: ResolveRedirect
+  buildRouteTree: () => void
+  clearCache: ClearCacheFn<
+    Router<
+      TRouteTree,
+      TTrailingSlashOption,
+      TDefaultStructuralSharingOption,
+      TRouterHistory,
+      TDehydrated
+    >
+  >
 }
 
 export type AnyRouterWithContext<TContext> = Router<
   AnyRouteWithContext<TContext>,
+  any,
+  any,
+  any,
   any
 >
 
-export type AnyRouter = Router<any, any>
+export type AnyRouter = Router<any, any, any, any, any>
 
 export interface ViewTransitionOptions {
   types: Array<string>