autotel-tanstack 1.13.30 → 1.13.31

package/dist/loaders-DrVVY25K.d.ts

@@ -0,0 +1,2402 @@
+import { i as TraceLoaderConfig } from "./types-pQgmQa4j.js";
+import * as React$2 from "react";
+import React$1 from "react";
+
+//#region ../../node_modules/.pnpm/@tanstack+history@1.162.0/node_modules/@tanstack/history/dist/esm/index.d.ts
+interface NavigateOptions$1 {
+  ignoreBlocker?: boolean;
+}
+type SubscriberHistoryAction = {
+  type: Exclude<HistoryAction, 'GO'>;
+} | {
+  type: 'GO';
+  index: number;
+};
+type SubscriberArgs = {
+  location: HistoryLocation$1;
+  action: SubscriberHistoryAction;
+};
+interface RouterHistory {
+  location: HistoryLocation$1;
+  length: number;
+  subscribers: Set<(opts: SubscriberArgs) => void>;
+  subscribe: (cb: (opts: SubscriberArgs) => void) => () => void;
+  push: (path: string, state?: any, navigateOpts?: NavigateOptions$1) => void;
+  replace: (path: string, state?: any, navigateOpts?: NavigateOptions$1) => void;
+  go: (index: number, navigateOpts?: NavigateOptions$1) => void;
+  back: (navigateOpts?: NavigateOptions$1) => void;
+  forward: (navigateOpts?: NavigateOptions$1) => void;
+  canGoBack: () => boolean;
+  createHref: (href: string) => string;
+  block: (blocker: NavigationBlocker) => () => void;
+  flush: () => void;
+  destroy: () => void;
+  notify: (action: SubscriberHistoryAction) => void;
+  _ignoreSubscribers?: boolean;
+}
+interface HistoryLocation$1 extends ParsedPath {
+  state: ParsedHistoryState;
+}
+interface ParsedPath {
+  href: string;
+  pathname: string;
+  search: string;
+  hash: string;
+}
+interface HistoryState {}
+type ParsedHistoryState = HistoryState & {
+  key?: string;
+  __TSR_key?: string;
+  __TSR_index: number;
+};
+type ShouldAllowNavigation = any;
+type HistoryAction = 'PUSH' | 'REPLACE' | 'FORWARD' | 'BACK' | 'GO';
+type BlockerFnArgs = {
+  currentLocation: HistoryLocation$1;
+  nextLocation: HistoryLocation$1;
+  action: HistoryAction;
+};
+type BlockerFn = (args: BlockerFnArgs) => Promise<ShouldAllowNavigation> | ShouldAllowNavigation;
+type NavigationBlocker = {
+  blockerFn: BlockerFn;
+  enableBeforeUnload?: (() => boolean) | boolean;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/fileRoute.d.ts
+interface FileRouteTypes {
+  fileRoutesByFullPath: any;
+  fullPaths: any;
+  to: any;
+  fileRoutesByTo: any;
+  id: any;
+  fileRoutesById: any;
+}
+type InferFileRouteTypes<TRouteTree extends AnyRoute> = unknown extends TRouteTree['types']['fileRouteTypes'] ? never : TRouteTree['types']['fileRouteTypes'] extends FileRouteTypes ? TRouteTree['types']['fileRouteTypes'] : never;
+type LazyRouteOptions = Pick<UpdatableRouteOptions<AnyRoute, string, string, AnyPathParams, AnyValidator, {}, AnyContext, AnyContext, AnyContext, AnyContext>, 'component' | 'errorComponent' | 'pendingComponent' | 'notFoundComponent'>;
+interface LazyRoute<in out TRoute extends AnyRoute> {
+  options: {
+    id: string;
+  } & LazyRouteOptions;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/utils.d.ts
+type Awaitable<T> = T | Promise<T>;
+type NoInfer<T> = [T][T extends any ? 0 : never];
+type PickAsRequired<TValue, TKey extends keyof TValue> = Omit<TValue, TKey> & Required<Pick<TValue, TKey>>;
+type Expand<T> = T extends object ? T extends infer O ? O extends Function ? O : { [K in keyof O]: O[K] } : never : T;
+type MakeDifferenceOptional<TLeft, TRight> = keyof TLeft & keyof TRight extends never ? TRight : Omit<TRight, keyof TLeft & keyof TRight> & { [K in keyof TLeft & keyof TRight]?: TRight[K] };
+type IsNonEmptyObject<T> = T extends object ? keyof T extends never ? false : true : false;
+type Assign<TLeft, TRight> = TLeft extends any ? TRight extends any ? IsNonEmptyObject<TLeft> extends false ? TRight : IsNonEmptyObject<TRight> extends false ? TLeft : keyof TLeft & keyof TRight extends never ? TLeft & TRight : Omit<TLeft, keyof TRight> & TRight : never : never;
+type IntersectAssign<TLeft, TRight> = TLeft extends any ? TRight extends any ? IsNonEmptyObject<TLeft> extends false ? TRight : IsNonEmptyObject<TRight> extends false ? TLeft : TRight & TLeft : never : never;
+type Updater<TPrevious, TResult = TPrevious> = TResult | ((prev?: TPrevious) => TResult);
+type NonNullableUpdater<TPrevious, TResult = TPrevious> = TResult | ((prev: TPrevious) => TResult);
+type ExtractObjects<TUnion> = TUnion extends MergeAllPrimitive ? never : TUnion;
+type PartialMergeAllObject<TUnion> = ExtractObjects<TUnion> extends infer TObj ? [TObj] extends [never] ? never : { [TKey in TObj extends any ? keyof TObj : never]?: TObj extends any ? TKey extends keyof TObj ? TObj[TKey] : never : never } : never;
+type MergeAllPrimitive = ReadonlyArray<any> | number | string | bigint | boolean | symbol | undefined | null;
+type ExtractPrimitives<TUnion> = TUnion extends MergeAllPrimitive ? TUnion : TUnion extends object ? never : TUnion;
+type PartialMergeAll<TUnion> = ExtractPrimitives<TUnion> | PartialMergeAllObject<TUnion>;
+type Constrain<T, TConstraint, TDefault = TConstraint> = (T extends TConstraint ? T : never) | TDefault;
+type ConstrainLiteral<T, TConstraint, TDefault = TConstraint> = (T & TConstraint) | TDefault;
+type ValidateJSON<T> = ((...args: Array<any>) => any) extends T ? unknown extends T ? never : 'Function is not serializable' : { [K in keyof T]: ValidateJSON<T[K]> };
+type LooseReturnType<T> = T extends ((...args: Array<any>) => infer TReturn) ? TReturn : never;
+type LooseAsyncReturnType<T> = T extends ((...args: Array<any>) => infer TReturn) ? TReturn extends Promise<infer TReturn> ? TReturn : TReturn : never;
+type ControlledPromise<T> = Promise<T> & {
+  resolve: (value: T) => void;
+  reject: (value: any) => void;
+  status: 'pending' | 'resolved' | 'rejected';
+  value?: T;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/link.d.ts
+type IsRequiredParams<TParams> = Record<never, never> extends TParams ? never : true;
+interface ParsePathParamsResult<in out TRequired, in out TOptional, in out TRest> {
+  required: TRequired;
+  optional: TOptional;
+  rest: TRest;
+}
+type ParsePathParamsBoundaryStart<T extends string> = T extends `${infer TLeft}{-${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['required'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : T extends `${infer TLeft}{${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'] | ParsePathParams<TRight>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : never;
+type ParsePathParamsSymbol<T extends string> = T extends `${string}$${infer TRight}` ? TRight extends `${string}/${string}` ? TRight extends `${infer TParam}/${infer TRest}` ? TParam extends '' ? ParsePathParamsResult<ParsePathParams<TRest>['required'], '_splat' | ParsePathParams<TRest>['optional'], ParsePathParams<TRest>['rest']> : ParsePathParamsResult<TParam | ParsePathParams<TRest>['required'], ParsePathParams<TRest>['optional'], ParsePathParams<TRest>['rest']> : never : TRight extends '' ? ParsePathParamsResult<never, '_splat', never> : ParsePathParamsResult<TRight, never, never> : never;
+type ParsePathParamsBoundaryEnd<T extends string> = T extends `${infer TLeft}}${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'] | ParsePathParams<TRight>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : never;
+type ParsePathParamsEscapeStart<T extends string> = T extends `${infer TLeft}[${infer TRight}` ? ParsePathParamsResult<ParsePathParams<TLeft>['required'] | ParsePathParams<TRight>['required'], ParsePathParams<TLeft>['optional'] | ParsePathParams<TRight>['optional'], ParsePathParams<TRight>['rest']> : never;
+type ParsePathParamsEscapeEnd<T extends string> = T extends `${string}]${infer TRight}` ? ParsePathParams<TRight> : never;
+type ParsePathParams<T extends string> = T extends `${string}[${string}` ? ParsePathParamsEscapeStart<T> : T extends `${string}]${string}` ? ParsePathParamsEscapeEnd<T> : T extends `${string}}${string}` ? ParsePathParamsBoundaryEnd<T> : T extends `${string}{${string}` ? ParsePathParamsBoundaryStart<T> : T extends `${string}$${string}` ? ParsePathParamsSymbol<T> : never;
+type AddTrailingSlash<T> = T extends `${string}/` ? T : `${T & string}/`;
+type RemoveTrailingSlashes<T> = T & `${string}/` extends never ? T : T extends `${infer R}/` ? R : T;
+type AddLeadingSlash<T> = T & `/${string}` extends never ? `/${T & string}` : T;
+type RemoveLeadingSlashes<T> = T & `/${string}` extends never ? T : T extends `/${infer R}` ? R : T;
+type JoinPath<TLeft extends string, TRight extends string> = TRight extends '' ? TLeft : TLeft extends '' ? TRight : `${RemoveTrailingSlashes<TLeft>}/${RemoveLeadingSlashes<TRight>}`;
+type RemoveLastSegment<T extends string, TAcc extends string = ''> = T extends `${infer TSegment}/${infer TRest}` ? TRest & `${string}/${string}` extends never ? TRest extends '' ? TAcc : `${TAcc}${TSegment}` : RemoveLastSegment<TRest, `${TAcc}${TSegment}/`> : TAcc;
+type ResolveCurrentPath<TFrom extends string, TTo extends string> = TTo extends '.' ? TFrom : TTo extends './' ? AddTrailingSlash<TFrom> : TTo & `./${string}` extends never ? never : TTo extends `./${infer TRest}` ? AddLeadingSlash<JoinPath<TFrom, TRest>> : never;
+type ResolveParentPath<TFrom extends string, TTo extends string> = TTo extends '../' | '..' ? TFrom extends '' | '/' ? never : AddLeadingSlash<RemoveLastSegment<TFrom>> : TTo & `../${string}` extends never ? AddLeadingSlash<JoinPath<TFrom, TTo>> : TFrom extends '' | '/' ? never : TTo extends `../${infer ToRest}` ? ResolveParentPath<RemoveLastSegment<TFrom>, ToRest> : AddLeadingSlash<JoinPath<TFrom, TTo>>;
+type ResolveRelativePath<TFrom, TTo = '.'> = string extends TFrom ? TTo : string extends TTo ? TFrom : undefined extends TTo ? TFrom : TTo extends string ? TFrom extends string ? TTo extends `/${string}` ? TTo : TTo extends `..${string}` ? ResolveParentPath<TFrom, TTo> : TTo extends `.${string}` ? ResolveCurrentPath<TFrom, TTo> : AddLeadingSlash<JoinPath<TFrom, TTo>> : never : never;
+type FindDescendantToPaths<TRouter extends AnyRouter, TPrefix extends string> = `${TPrefix}/${string}` & RouteToPath<TRouter>;
+type InferDescendantToPaths<TRouter extends AnyRouter, TPrefix extends string, TPaths = FindDescendantToPaths<TRouter, TPrefix>> = TPaths extends `${TPrefix}/` ? never : TPaths extends `${TPrefix}/${infer TRest}` ? TRest : never;
+type RelativeToPath<TRouter extends AnyRouter, TTo extends string, TResolvedPath extends string> = (TResolvedPath & RouteToPath<TRouter> extends never ? never : ToPath<TRouter, TTo>) | `${RemoveTrailingSlashes<TTo>}/${InferDescendantToPaths<TRouter, RemoveTrailingSlashes<TResolvedPath>>}`;
+type RelativeToParentPath<TRouter extends AnyRouter, TFrom extends string, TTo extends string, TResolvedPath extends string = ResolveRelativePath<TFrom, TTo>> = RelativeToPath<TRouter, TTo, TResolvedPath> | (TTo extends `${string}..` | `${string}../` ? TResolvedPath extends '/' | '' ? never : FindDescendantToPaths<TRouter, RemoveTrailingSlashes<TResolvedPath>> extends never ? never : `${RemoveTrailingSlashes<TTo>}/${ParentPath<TRouter>}` : never);
+type RelativeToCurrentPath<TRouter extends AnyRouter, TFrom extends string, TTo extends string, TResolvedPath extends string = ResolveRelativePath<TFrom, TTo>> = RelativeToPath<TRouter, TTo, TResolvedPath> | CurrentPath<TRouter>;
+type AbsoluteToPath<TRouter extends AnyRouter, TFrom extends string> = (string extends TFrom ? CurrentPath<TRouter> : TFrom extends `/` ? never : CurrentPath<TRouter>) | (string extends TFrom ? ParentPath<TRouter> : TFrom extends `/` ? never : ParentPath<TRouter>) | RouteToPath<TRouter> | (TFrom extends '/' ? never : string extends TFrom ? never : InferDescendantToPaths<TRouter, RemoveTrailingSlashes<TFrom>>);
+type RelativeToPathAutoComplete<TRouter extends AnyRouter, TFrom extends string, TTo extends string> = string extends TTo ? string : string extends TFrom ? AbsoluteToPath<TRouter, TFrom> : TTo & `..${string}` extends never ? TTo & `.${string}` extends never ? AbsoluteToPath<TRouter, TFrom> : RelativeToCurrentPath<TRouter, TFrom, TTo> : RelativeToParentPath<TRouter, TFrom, TTo>;
+type NavigateOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ToOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & NavigateOptionProps;
+/**
+ * The NavigateOptions type is used to describe the options that can be used when describing a navigation action in TanStack Router.
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType)
+ */
+interface NavigateOptionProps {
+  /**
+   * If set to `true`, the router will scroll the element with an id matching the hash into view with default `ScrollIntoViewOptions`.
+   * If set to `false`, the router will not scroll the element with an id matching the hash into view.
+   * If set to `ScrollIntoViewOptions`, the router will scroll the element with an id matching the hash into view with the provided options.
+   * @default true
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#hashscrollintoview)
+   * @see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView)
+   */
+  hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+  /**
+   * `replace` is a boolean that determines whether the navigation should replace the current history entry or push a new one.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#replace)
+   */
+  replace?: boolean;
+  /**
+   * Defaults to `true` so that the scroll position will be reset to 0,0 after the location is committed to the browser history.
+   * If `false`, the scroll position will not be reset to 0,0 after the location is committed to history.
+   * @default true
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#resetscroll)
+   */
+  resetScroll?: boolean;
+  /** @deprecated All navigations now use startTransition under the hood */
+  startTransition?: boolean;
+  /**
+   * If set to `true`, the router will wrap the resulting navigation in a `document.startViewTransition()` call.
+   * If `ViewTransitionOptions`, route navigations will be called using `document.startViewTransition({update, types})`
+   * where `types` will be the strings array passed with `ViewTransitionOptions["types"]`.
+   * If the browser does not support viewTransition types, the navigation will fall back to normal `document.startTransition()`, same as if `true` was passed.
+   *
+   * If the browser does not support this api, this option will be ignored.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#viewtransition)
+   * @see [MDN](https://developer.mozilla.org/en-US/docs/Web/API/Document/startViewTransition)
+   * @see [Google](https://developer.chrome.com/docs/web-platform/view-transitions/same-document#view-transition-types)
+   */
+  viewTransition?: boolean | ViewTransitionOptions;
+  /**
+   * If `true`, navigation will ignore any blockers that might prevent it.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#ignoreblocker)
+   */
+  ignoreBlocker?: boolean;
+  /**
+   * If `true`, navigation to a route inside of router will trigger a full page load instead of the traditional SPA navigation.
+   * @default false
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#reloaddocument)
+   */
+  reloadDocument?: boolean;
+  /**
+   * This can be used instead of `to` to navigate to a fully built href, e.g. pointing to an external target.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#href)
+   */
+  href?: string;
+}
+type ToOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ToSubOptions<TRouter, TFrom, TTo> & MaskOptions<TRouter, TMaskFrom, TMaskTo>;
+interface MaskOptions<in out TRouter extends AnyRouter, in out TMaskFrom extends string, in out TMaskTo extends string> {
+  _fromLocation?: ParsedLocation;
+  mask?: ToMaskOptions<TRouter, TMaskFrom, TMaskTo>;
+}
+type ToMaskOptions<TRouter extends AnyRouter = RegisteredRouter, TMaskFrom extends string = string, TMaskTo extends string = '.'> = ToSubOptions<TRouter, TMaskFrom, TMaskTo> & {
+  unmaskOnReload?: boolean;
+};
+type ToSubOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.'> = ToSubOptionsProps<TRouter, TFrom, TTo> & SearchParamOptions<TRouter, TFrom, TTo> & PathParamOptions<TRouter, TFrom, TTo>;
+interface RequiredToOptions<in out TRouter extends AnyRouter, in out TFrom extends string, in out TTo extends string | undefined> {
+  /**
+   * The internal route path to navigate to. This should be a relative or absolute path within your application.
+   * For external URLs, use the `href` property instead.
+   * @example "/dashboard" or "../profile"
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#href)
+   */
+  to: ToPathOption<TRouter, TFrom, TTo> & {};
+}
+interface OptionalToOptions<in out TRouter extends AnyRouter, in out TFrom extends string, in out TTo extends string | undefined> {
+  /**
+   * The internal route path to navigate to. This should be a relative or absolute path within your application.
+   * For external URLs, use the `href` property instead.
+   * @example "/dashboard" or "../profile"
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType#href)
+   */
+  to?: ToPathOption<TRouter, TFrom, TTo> & {};
+}
+type MakeToRequired<TRouter extends AnyRouter, TFrom extends string, TTo extends string | undefined> = string extends TFrom ? string extends TTo ? OptionalToOptions<TRouter, TFrom, TTo> : TTo & CatchAllPaths<TRouter> extends never ? RequiredToOptions<TRouter, TFrom, TTo> : OptionalToOptions<TRouter, TFrom, TTo> : OptionalToOptions<TRouter, TFrom, TTo>;
+type ToSubOptionsProps<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.'> = MakeToRequired<TRouter, TFrom, TTo> & {
+  hash?: true | Updater<string>;
+  state?: true | NonNullableUpdater<ParsedHistoryState, HistoryState>;
+  from?: FromPathOption<TRouter, TFrom> & {};
+  unsafeRelative?: 'path';
+};
+type ParamsReducerFn<in out TRouter extends AnyRouter, in out TParamVariant extends ParamVariant, in out TFrom, in out TTo> = (current: Expand<ResolveFromParams<TRouter, TParamVariant, TFrom>>) => Expand<ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo>>;
+type ParamsReducer<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = Expand<ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo>> | (ParamsReducerFn<TRouter, TParamVariant, TFrom, TTo> & {});
+type ParamVariant = 'PATH' | 'SEARCH';
+type ResolveRoute<TRouter extends AnyRouter, TFrom, TTo, TPath = ResolveRelativePath<TFrom, TTo>> = TPath extends string ? TFrom extends TPath ? RouteByPath<TRouter['routeTree'], TPath> : RouteByToPath<TRouter, TPath> : never;
+type ResolveFromParamType<TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? 'allParams' : 'fullSearchSchema';
+type ResolveFromAllParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? AllParams<TRouter['routeTree']> : FullSearchSchema<TRouter['routeTree']>;
+type ResolveFromParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom> = string extends TFrom ? ResolveFromAllParams<TRouter, TParamVariant> : RouteByPath<TRouter['routeTree'], TFrom>['types'][ResolveFromParamType<TParamVariant>];
+type ResolveToParamType<TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? 'allParams' : 'fullSearchSchemaInput';
+type ResolveAllToParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant> = TParamVariant extends 'PATH' ? AllParams<TRouter['routeTree']> : FullSearchSchemaInput<TRouter['routeTree']>;
+type ResolveToParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = ResolveRelativePath<TFrom, TTo> extends infer TPath ? undefined extends TPath ? never : string extends TPath ? ResolveAllToParams<TRouter, TParamVariant> : TPath extends CatchAllPaths<TRouter> ? ResolveAllToParams<TRouter, TParamVariant> : ResolveRoute<TRouter, TFrom, TTo>['types'][ResolveToParamType<TParamVariant>] : never;
+type ResolveRelativeToParams<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo, TToParams = ResolveToParams<TRouter, TParamVariant, TFrom, TTo>> = TParamVariant extends 'SEARCH' ? TToParams : string extends TFrom ? TToParams : MakeDifferenceOptional<ResolveFromParams<TRouter, TParamVariant, TFrom>, TToParams>;
+interface MakeOptionalSearchParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  search?: true | (ParamsReducer<TRouter, 'SEARCH', TFrom, TTo> & {});
+}
+interface MakeOptionalPathParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  params?: true | (ParamsReducer<TRouter, 'PATH', TFrom, TTo> & {});
+}
+type MakeRequiredParamsReducer<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = (string extends TFrom ? never : ResolveFromParams<TRouter, TParamVariant, TFrom> extends ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo> ? true : never) | (ParamsReducer<TRouter, TParamVariant, TFrom, TTo> & {});
+interface MakeRequiredPathParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  params: MakeRequiredParamsReducer<TRouter, 'PATH', TFrom, TTo> & {};
+}
+interface MakeRequiredSearchParams<in out TRouter extends AnyRouter, in out TFrom, in out TTo> {
+  search: MakeRequiredParamsReducer<TRouter, 'SEARCH', TFrom, TTo> & {};
+}
+type IsRequired<TRouter extends AnyRouter, TParamVariant extends ParamVariant, TFrom, TTo> = ResolveRelativePath<TFrom, TTo> extends infer TPath ? undefined extends TPath ? never : TPath extends CatchAllPaths<TRouter> ? never : IsRequiredParams<ResolveRelativeToParams<TRouter, TParamVariant, TFrom, TTo>> : never;
+type SearchParamOptions<TRouter extends AnyRouter, TFrom, TTo> = IsRequired<TRouter, 'SEARCH', TFrom, TTo> extends never ? MakeOptionalSearchParams<TRouter, TFrom, TTo> : MakeRequiredSearchParams<TRouter, TFrom, TTo>;
+type PathParamOptions<TRouter extends AnyRouter, TFrom, TTo> = IsRequired<TRouter, 'PATH', TFrom, TTo> extends never ? MakeOptionalPathParams<TRouter, TFrom, TTo> : MakeRequiredPathParams<TRouter, TFrom, TTo>;
+type ToPathOption<TRouter extends AnyRouter = AnyRouter, TFrom extends string = string, TTo extends string | undefined = string> = ConstrainLiteral<TTo, RelativeToPathAutoComplete<TRouter, NoInfer<TFrom> extends string ? NoInfer<TFrom> : '', NoInfer<TTo> & string>>;
+type FromPathOption<TRouter extends AnyRouter, TFrom> = ConstrainLiteral<TFrom, RoutePaths<TRouter['routeTree']>>;
+/**
+ * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/navigation#active-options)
+ */
+interface ActiveOptions {
+  /**
+   * If true, the link will be active if the current route matches the `to` route path exactly (no children routes)
+   * @default false
+   */
+  exact?: boolean;
+  /**
+   * If true, the link will only be active if the current URL hash matches the `hash` prop
+   * @default false
+   */
+  includeHash?: boolean;
+  /**
+   * If true, the link will only be active if the current URL search params inclusively match the `search` prop
+   * @default true
+   */
+  includeSearch?: boolean;
+  /**
+   * This modifies the `includeSearch` behavior.
+   * If true,  properties in `search` that are explicitly `undefined` must NOT be present in the current URL search params for the link to be active.
+   * @default false
+   */
+  explicitUndefined?: boolean;
+}
+interface LinkOptionsProps {
+  /**
+   * The standard anchor tag target attribute
+   */
+  target?: HTMLAnchorElement['target'];
+  /**
+   * Configurable options to determine if the link should be considered active or not
+   * @default {exact:true,includeHash:true}
+   */
+  activeOptions?: ActiveOptions;
+  /**
+   * The preloading strategy for this link
+   * - `false` - No preloading
+   * - `'intent'` - Preload the linked route on hover and cache it for this many milliseconds in hopes that the user will eventually navigate there.
+   * - `'viewport'` - Preload the linked route when it enters the viewport
+   */
+  preload?: false | 'intent' | 'viewport' | 'render';
+  /**
+   * When a preload strategy is set, this delays the preload by this many milliseconds.
+   * If the user exits the link before this delay, the preload will be cancelled.
+   */
+  preloadDelay?: number;
+  /**
+   * Control whether the link should be disabled or not
+   * If set to `true`, the link will be rendered without an `href` attribute
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * When the preload strategy is set to `intent`, this controls the proximity of the link to the cursor before it is preloaded.
+   * If the user exits this proximity before this delay, the preload will be cancelled.
+   */
+  preloadIntentProximity?: number;
+}
+type LinkOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & LinkOptionsProps;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/routeInfo.d.ts
+type ParseRoute<TRouteTree, TAcc = TRouteTree> = TRouteTree extends {
+  types: {
+    children: infer TChildren;
+  };
+} ? unknown extends TChildren ? TAcc : TChildren extends ReadonlyArray<any> ? ParseRoute<TChildren[number], TAcc | TChildren[number]> : ParseRoute<TChildren[keyof TChildren], TAcc | TChildren[keyof TChildren]> : TAcc;
+type ParseRouteWithoutBranches<TRouteTree> = ParseRoute<TRouteTree> extends infer TRoute extends AnyRoute ? TRoute extends any ? unknown extends TRoute['types']['children'] ? TRoute : TRoute['types']['children'] extends ReadonlyArray<any> ? '/' extends TRoute['types']['children'][number]['path'] ? never : TRoute : '/' extends TRoute['types']['children'][keyof TRoute['types']['children']]['path'] ? never : TRoute : never : never;
+type CodeRoutesById<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? { [K in TRoutes as K['id']]: K } : never;
+type RoutesById<TRouteTree extends AnyRoute> = InferFileRouteTypes<TRouteTree> extends never ? CodeRoutesById<TRouteTree> : InferFileRouteTypes<TRouteTree>['fileRoutesById'];
+type RouteById<TRouteTree extends AnyRoute, TId> = Extract<RoutesById<TRouteTree>[TId & keyof RoutesById<TRouteTree>], AnyRoute>;
+type CodeRouteIds<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? TRoutes['id'] : never;
+type RouteIds<TRouteTree extends AnyRoute> = InferFileRouteTypes<TRouteTree> extends never ? CodeRouteIds<TRouteTree> : InferFileRouteTypes<TRouteTree>['id'];
+type ParentPath<TRouter extends AnyRouter> = TrailingSlashOptionByRouter<TRouter> extends 'always' ? '../' : TrailingSlashOptionByRouter<TRouter> extends 'never' ? '..' : '../' | '..';
+type CurrentPath<TRouter extends AnyRouter> = TrailingSlashOptionByRouter<TRouter> extends 'always' ? './' : TrailingSlashOptionByRouter<TRouter> extends 'never' ? '.' : './' | '.';
+type ToPath<TRouter extends AnyRouter, TTo extends string> = TrailingSlashOptionByRouter<TRouter> extends 'always' ? AddTrailingSlash<TTo> : TrailingSlashOptionByRouter<TRouter> extends 'never' ? RemoveTrailingSlashes<TTo> : AddTrailingSlash<TTo> | RemoveTrailingSlashes<TTo>;
+type CatchAllPaths<TRouter extends AnyRouter> = CurrentPath<TRouter> | ParentPath<TRouter>;
+type CodeRoutesByPath<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? { [K in TRoutes as K['fullPath']]: K } : never;
+type RoutesByPath<TRouteTree extends AnyRoute> = InferFileRouteTypes<TRouteTree> extends never ? CodeRoutesByPath<TRouteTree> : InferFileRouteTypes<TRouteTree>['fileRoutesByFullPath'];
+type RouteByPath<TRouteTree extends AnyRoute, TPath> = Extract<RoutesByPath<TRouteTree>[TPath & keyof RoutesByPath<TRouteTree>], AnyRoute>;
+type CodeRoutePaths<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? TRoutes['fullPath'] : never;
+type RoutePaths<TRouteTree extends AnyRoute> = unknown extends TRouteTree ? string : (InferFileRouteTypes<TRouteTree> extends never ? CodeRoutePaths<TRouteTree> : InferFileRouteTypes<TRouteTree>['fullPaths']) | '/';
+type RouteToPathAlwaysTrailingSlash<TRoute extends AnyRoute> = TRoute['path'] extends '/' ? TRoute['fullPath'] : TRoute['fullPath'] extends '/' ? TRoute['fullPath'] : `${TRoute['fullPath']}/`;
+type RouteToPathNeverTrailingSlash<TRoute extends AnyRoute> = TRoute['path'] extends '/' ? TRoute['fullPath'] extends '/' ? TRoute['fullPath'] : RemoveTrailingSlashes<TRoute['fullPath']> : TRoute['fullPath'];
+type RouteToPathPreserveTrailingSlash<TRoute extends AnyRoute> = RouteToPathNeverTrailingSlash<TRoute> | RouteToPathAlwaysTrailingSlash<TRoute>;
+type RouteToPathByTrailingSlashOption<TRoute extends AnyRoute> = {
+  always: RouteToPathAlwaysTrailingSlash<TRoute>;
+  preserve: RouteToPathPreserveTrailingSlash<TRoute>;
+  never: RouteToPathNeverTrailingSlash<TRoute>;
+};
+type TrailingSlashOptionByRouter<TRouter extends AnyRouter> = TrailingSlashOption extends TRouter['options']['trailingSlash'] ? 'never' : NonNullable<TRouter['options']['trailingSlash']>;
+type RouteToByRouter<TRouter extends AnyRouter, TRoute extends AnyRoute> = RouteToPathByTrailingSlashOption<TRoute>[TrailingSlashOptionByRouter<TRouter>];
+type CodeRouteToPath<TRouter extends AnyRouter> = ParseRouteWithoutBranches<TRouter['routeTree']> extends infer TRoute extends AnyRoute ? TRoute extends any ? RouteToByRouter<TRouter, TRoute> : never : never;
+type FileRouteToPath<TRouter extends AnyRouter, TTo = InferFileRouteTypes<TRouter['routeTree']>['to'], TTrailingSlashOption = TrailingSlashOptionByRouter<TRouter>> = 'never' extends TTrailingSlashOption ? TTo : 'always' extends TTrailingSlashOption ? AddTrailingSlash<TTo> : TTo | AddTrailingSlash<TTo>;
+type RouteToPath<TRouter extends AnyRouter> = unknown extends TRouter ? string : InferFileRouteTypes<TRouter['routeTree']> extends never ? CodeRouteToPath<TRouter> : FileRouteToPath<TRouter>;
+type CodeRoutesByToPath<TRouter extends AnyRouter> = ParseRouteWithoutBranches<TRouter['routeTree']> extends infer TRoutes extends AnyRoute ? { [TRoute in TRoutes as RouteToByRouter<TRouter, TRoute>]: TRoute } : never;
+type RoutesByToPath<TRouter extends AnyRouter> = InferFileRouteTypes<TRouter['routeTree']> extends never ? CodeRoutesByToPath<TRouter> : InferFileRouteTypes<TRouter['routeTree']>['fileRoutesByTo'];
+type CodeRouteByToPath<TRouter extends AnyRouter, TTo> = Extract<RoutesByToPath<TRouter>[TTo & keyof RoutesByToPath<TRouter>], AnyRoute>;
+type FileRouteByToPath<TRouter extends AnyRouter, TTo> = 'never' extends TrailingSlashOptionByRouter<TRouter> ? CodeRouteByToPath<TRouter, TTo> : 'always' extends TrailingSlashOptionByRouter<TRouter> ? TTo extends '/' ? CodeRouteByToPath<TRouter, TTo> : TTo extends `${infer TPath}/` ? CodeRouteByToPath<TRouter, TPath> : never : CodeRouteByToPath<TRouter, TTo extends '/' ? TTo : RemoveTrailingSlashes<TTo>>;
+type RouteByToPath<TRouter extends AnyRouter, TTo> = InferFileRouteTypes<TRouter['routeTree']> extends never ? CodeRouteByToPath<TRouter, TTo> : FileRouteByToPath<TRouter, TTo>;
+type FullSearchSchema<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? PartialMergeAll<TRoutes['types']['fullSearchSchema']> : never;
+type FullSearchSchemaInput<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? PartialMergeAll<TRoutes['types']['fullSearchSchemaInput']> : never;
+type AllParams<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? PartialMergeAll<TRoutes['types']['allParams']> : never;
+type AllContext<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? PartialMergeAll<TRoutes['types']['allContext']> : never;
+type AllLoaderData<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree> extends infer TRoutes extends AnyRoute ? PartialMergeAll<TRoutes['types']['loaderData']> : never;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/redirect.d.ts
+type AnyRedirect = Redirect<any, any, any, any, any>;
+/**
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType)
+ */
+type Redirect<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = Response & {
+  options: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {};
+  redirectHandled?: boolean;
+};
+type RedirectOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = {
+  href?: string;
+  /**
+   * @deprecated Use `statusCode` instead
+   **/
+  code?: number;
+  /**
+   * The HTTP status code to use when redirecting.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#statuscode-property)
+   */
+  statusCode?: number;
+  /**
+   * If provided, will throw the redirect object instead of returning it. This can be useful in places where `throwing` in a function might cause it to have a return type of `never`. In that case, you can use `redirect({ throw: true })` to throw the redirect object instead of returning it.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#throw-property)
+   */
+  throw?: any;
+  /**
+   * The HTTP headers to use when redirecting.
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType#headers-property)
+   */
+  headers?: HeadersInit;
+} & NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+/**
+ * Options for route-bound redirect, where 'from' is automatically set.
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType)
+ */
+type RedirectOptionsRoute<TDefaultFrom extends string = string, TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TMaskTo extends string = ''> = Omit<RedirectOptions<TRouter, TDefaultFrom, TTo, TDefaultFrom, TMaskTo>, 'from'>;
+/**
+ * A redirect function bound to a specific route, with 'from' pre-set to the route's fullPath.
+ * This enables relative redirects like `Route.redirect({ to: './overview' })`.
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RedirectType)
+ */
+interface RedirectFnRoute<in out TDefaultFrom extends string = string> {
+  <TRouter extends AnyRouter = RegisteredRouter, const TTo extends string | undefined = undefined, const TMaskTo extends string = ''>(opts: RedirectOptionsRoute<TDefaultFrom, TRouter, TTo, TMaskTo>): Redirect<TRouter, TDefaultFrom, TTo, TDefaultFrom, TMaskTo>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/Matches.d.ts
+interface DefaultRouteMatchExtensions {
+  scripts?: unknown;
+  links?: unknown;
+  headScripts?: unknown;
+  meta?: unknown;
+  styles?: unknown;
+}
+interface RouteMatchExtensions extends DefaultRouteMatchExtensions {}
+interface RouteMatch$1<out TRouteId, out TFullPath, out TAllParams, out TFullSearchSchema, out TLoaderData, out TAllContext, out TLoaderDeps> extends RouteMatchExtensions {
+  id: string;
+  routeId: TRouteId;
+  fullPath: TFullPath;
+  index: number;
+  pathname: string;
+  params: TAllParams;
+  _strictParams: TAllParams;
+  status: 'pending' | 'success' | 'error' | 'redirected' | 'notFound';
+  isFetching: false | 'beforeLoad' | 'loader';
+  error: unknown;
+  paramsError: unknown;
+  searchError: unknown;
+  updatedAt: number;
+  _nonReactive: {
+    loadPromise?: ControlledPromise<void>;
+    displayPendingPromise?: Promise<void>;
+    minPendingPromise?: ControlledPromise<void>;
+    dehydrated?: boolean;
+  };
+  loaderData?: TLoaderData;
+  context: TAllContext;
+  search: TFullSearchSchema;
+  _strictSearch: TFullSearchSchema;
+  fetchCount: number;
+  abortController: AbortController;
+  cause: 'preload' | 'enter' | 'stay';
+  loaderDeps: TLoaderDeps;
+  preload: boolean;
+  invalid: boolean;
+  headers?: Record<string, string>;
+  globalNotFound?: boolean;
+  staticData: StaticDataRouteOption;
+  /** This attribute is not reactive */
+  ssr?: SSROption;
+  _forcePending?: boolean;
+  _displayPending?: boolean;
+}
+interface PreValidationErrorHandlingRouteMatch<TRouteId, TFullPath, TAllParams, TFullSearchSchema> {
+  id: string;
+  routeId: TRouteId;
+  fullPath: TFullPath;
+  index: number;
+  pathname: string;
+  search: {
+    status: 'success';
+    value: TFullSearchSchema;
+  } | {
+    status: 'error';
+    error: unknown;
+  };
+  params: {
+    status: 'success';
+    value: TAllParams;
+  } | {
+    status: 'error';
+    error: unknown;
+  };
+  staticData: StaticDataRouteOption;
+  ssr?: boolean | 'data-only';
+}
+type MakePreValidationErrorHandlingRouteMatchUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? PreValidationErrorHandlingRouteMatch<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema']> : never;
+type MakeRouteMatchFromRoute<TRoute extends AnyRoute> = RouteMatch$1<TRoute['types']['id'], TRoute['types']['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema'], TRoute['types']['loaderData'], TRoute['types']['allContext'], TRoute['types']['loaderDeps']>;
+type MakeRouteMatch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TRouteId = RouteIds<TRouteTree>, TStrict extends boolean = true> = RouteMatch$1<TRouteId, RouteById<TRouteTree, TRouteId>['types']['fullPath'], TStrict extends false ? AllParams<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['allParams'], TStrict extends false ? FullSearchSchema<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'], TStrict extends false ? AllLoaderData<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['loaderData'], TStrict extends false ? AllContext<TRouteTree> : RouteById<TRouteTree, TRouteId>['types']['allContext'], RouteById<TRouteTree, TRouteId>['types']['loaderDeps']>;
+type AnyRouteMatch = RouteMatch$1<any, any, any, any, any, any, any>;
+type MakeRouteMatchUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? RouteMatch$1<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema'], TRoute['types']['loaderData'], TRoute['types']['allContext'], TRoute['types']['loaderDeps']> : never;
+/**
+ * The `MatchRouteOptions` type is used to describe the options that can be used when matching a route.
+ *
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#matchrouteoptions-type)
+ */
+interface MatchRouteOptions {
+  /**
+   * If `true`, will match against pending location instead of the current location.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#pending-property)
+   */
+  pending?: boolean;
+  /**
+   * If `true`, will match against the current location with case sensitivity.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#casesensitive-property)
+   *
+   * @deprecated Declare case sensitivity in the route definition instead, or globally for all routes using the `caseSensitive` option on the router.
+   */
+  caseSensitive?: boolean;
+  /**
+   * If `true`, will match against the current location's search params using a deep inclusive check. e.g. `{ a: 1 }` will match for a current location of `{ a: 1, b: 2 }`.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#includesearch-property)
+   */
+  includeSearch?: boolean;
+  /**
+   * If `true`, will match against the current location using a fuzzy match. e.g. `/posts` will match for a current location of `/posts/123`.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#fuzzy-property)
+   */
+  fuzzy?: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/root.d.ts
+/** Stable identifier used for the root route in a route tree. */
+declare const rootRouteId = "__root__";
+type RootRouteId = typeof rootRouteId;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/RouterProvider.d.ts
+interface CommitLocationOptions {
+  replace?: boolean;
+  resetScroll?: boolean;
+  hashScrollIntoView?: boolean | ScrollIntoViewOptions;
+  viewTransition?: boolean | ViewTransitionOptions;
+  /**
+   * @deprecated All navigations use transitions under the hood now
+   **/
+  startTransition?: boolean;
+  ignoreBlocker?: boolean;
+}
+type NavigateFn = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = ''>(opts: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+type BuildLocationFn = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = ''>(opts: ToOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+  leaveParams?: boolean;
+  _includeValidateSearch?: boolean;
+  _isNavigate?: boolean;
+}) => ParsedLocation;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStream.d.ts
+/**
+ * Hint for RawStream encoding strategy during SSR serialization.
+ * - 'binary': Always use base64 encoding (best for binary data like files, images)
+ * - 'text': Try UTF-8 first, fallback to base64 (best for text-heavy data like RSC payloads)
+ */
+type RawStreamHint = 'binary' | 'text';
+/**
+ * Options for RawStream configuration.
+ */
+interface RawStreamOptions {
+  /**
+   * Encoding hint for SSR serialization.
+   * - 'binary' (default): Always use base64 encoding
+   * - 'text': Try UTF-8 first, fallback to base64 for invalid UTF-8 chunks
+   */
+  hint?: RawStreamHint;
+}
+/**
+ * Marker class for ReadableStream<Uint8Array> that should be serialized
+ * with base64 encoding (SSR) or binary framing (server functions).
+ *
+ * Wrap your binary streams with this to get efficient serialization:
+ * ```ts
+ * // For binary data (files, images, etc.)
+ * return { data: new RawStream(file.stream()) }
+ *
+ * // For text-heavy data (RSC payloads, etc.)
+ * return { data: new RawStream(rscStream, { hint: 'text' }) }
+ * ```
+ */
+declare class RawStream {
+  readonly stream: ReadableStream<Uint8Array>;
+  readonly hint: RawStreamHint;
+  constructor(stream: ReadableStream<Uint8Array>, options?: RawStreamOptions);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/transformer.d.ts
+declare const TSR_SERIALIZABLE: unique symbol;
+type TSR_SERIALIZABLE = typeof TSR_SERIALIZABLE;
+type TsrSerializable = {
+  [TSR_SERIALIZABLE]: true;
+};
+interface DefaultSerializable {
+  number: number;
+  string: string;
+  boolean: boolean;
+  null: null;
+  undefined: undefined;
+  bigint: bigint;
+  Date: Date;
+  Uint8Array: Uint8Array;
+  RawStream: RawStream;
+  TsrSerializable: TsrSerializable;
+  void: void;
+}
+interface SerializableExtensions extends DefaultSerializable {}
+type Serializable = SerializableExtensions[keyof SerializableExtensions];
+type UnionizeSerializationAdaptersInput<TAdapters extends ReadonlyArray<AnySerializationAdapter>> = TAdapters[number]['~types']['input'];
+type ValidateSerializable<T, TSerializable> = T extends TSerializable ? T : T extends ((...args: Array<any>) => any) ? SerializationError<'Function may not be serializable'> : T extends RegisteredReadableStream ? SerializationError<'JSX is not be serializable'> : T extends ReadonlyArray<any> ? ValidateSerializableArray<T, TSerializable> : T extends Promise<any> ? ValidateSerializablePromise<T, TSerializable> : T extends ReadableStream<any> ? ValidateReadableStream<T, TSerializable> : T extends Set<any> ? ValidateSerializableSet<T, TSerializable> : T extends Map<any, any> ? ValidateSerializableMap<T, TSerializable> : T extends AsyncGenerator<any, any> ? ValidateSerializableAsyncGenerator<T, TSerializable> : T extends object ? ValidateSerializableMapped<T, TSerializable> : SerializationError<'Type may not be serializable'>;
+type ValidateSerializableAsyncGenerator<T, TSerializable> = T extends AsyncGenerator<infer T, infer TReturn, infer TNext> ? AsyncGenerator<ValidateSerializable<T, TSerializable>, ValidateSerializable<TReturn, TSerializable>, TNext> : never;
+type ValidateSerializablePromise<T, TSerializable> = T extends Promise<infer TAwaited> ? Promise<ValidateSerializable<TAwaited, TSerializable>> : never;
+type ValidateReadableStream<T, TSerializable> = T extends ReadableStream<infer TStreamed> ? ReadableStream<ValidateSerializable<TStreamed, TSerializable>> : never;
+type ValidateSerializableSet<T, TSerializable> = T extends Set<infer TItem> ? Set<ValidateSerializable<TItem, TSerializable>> : never;
+type ValidateSerializableMap<T, TSerializable> = T extends Map<infer TKey, infer TValue> ? Map<ValidateSerializable<TKey, TSerializable>, ValidateSerializable<TValue, TSerializable>> : never;
+type ValidateSerializableArray<T, TSerializable> = T extends readonly [any, ...Array<any>] ? ValidateSerializableMapped<T, TSerializable> : T extends Array<infer U> ? Array<ValidateSerializable<U, TSerializable>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<ValidateSerializable<U, TSerializable>> : never;
+type ValidateSerializableMapped<T, TSerializable> = { [K in keyof T]: ValidateSerializable<T[K], TSerializable> };
+declare const SERIALIZATION_ERROR: unique symbol;
+interface SerializationError<in out TMessage extends string> {
+  [SERIALIZATION_ERROR]: TMessage;
+}
+interface SerializationAdapter<TInput, TOutput, TExtendsAdapters extends ReadonlyArray<AnySerializationAdapter>> {
+  '~types': SerializationAdapterTypes<TInput, TOutput, TExtendsAdapters>;
+  key: string;
+  extends?: TExtendsAdapters;
+  test: (value: unknown) => value is TInput;
+  toSerializable: (value: TInput) => TOutput;
+  fromSerializable: (value: TOutput) => TInput;
+}
+interface SerializationAdapterTypes<TInput, TOutput, TExtendsAdapters extends ReadonlyArray<AnySerializationAdapter>> {
+  input: TInput | UnionizeSerializationAdaptersInput<TExtendsAdapters>;
+  output: TOutput;
+  extends: TExtendsAdapters;
+}
+type AnySerializationAdapter = SerializationAdapter<any, any, any>;
+type ValidateSerializableInput<TRegister, T> = ValidateSerializable<T, RegisteredSerializableInput<TRegister>>;
+type RegisteredSerializableInput<TRegister> = (unknown extends RegisteredSerializationAdapters<TRegister> ? never : RegisteredSerializationAdapters<TRegister> extends ReadonlyArray<AnySerializationAdapter> ? RegisteredSerializationAdapters<TRegister>[number]['~types']['input'] : never) | Serializable;
+type RegisteredSerializationAdapters<TRegister> = RegisteredConfigType<TRegister, 'serializationAdapters'>;
+type RegisteredSSROption<TRegister> = unknown extends RegisteredConfigType<TRegister, 'defaultSsr'> ? SSROption : RegisteredConfigType<TRegister, 'defaultSsr'>;
+type ValidateSerializableLifecycleResult<TRegister, TParentRoute extends AnyRoute, TSSR, TFn> = false extends RegisteredSsr<TRegister> ? any : ValidateSerializableLifecycleResultSSR<TRegister, TParentRoute, TSSR, TFn> extends infer TInput ? TInput : never;
+type ValidateSerializableLifecycleResultSSR<TRegister, TParentRoute extends AnyRoute, TSSR, TFn> = ResolveAllSSR<TParentRoute, TSSR> extends false ? any : RegisteredSSROption<TRegister> extends false ? any : ValidateSerializableInput<TRegister, LooseReturnType<TFn>>;
+type RegisteredReadableStream = unknown extends SerializerExtensions['ReadableStream'] ? never : SerializerExtensions['ReadableStream'];
+interface DefaultSerializerExtensions {
+  ReadableStream: unknown;
+}
+interface SerializerExtensions extends DefaultSerializerExtensions {}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/route.d.ts
+type AnyPathParams = {};
+type SearchSchemaInput = {
+  __TSearchSchemaInput__: 'TSearchSchemaInput';
+};
+type AnyContext = {};
+type RoutePathOptions<TCustomId, TPath> = {
+  path: TPath;
+} | {
+  id: TCustomId;
+};
+interface StaticDataRouteOption {}
+type SearchFilter<TInput, TResult = TInput> = (prev: TInput) => TResult;
+type SearchMiddlewareMeta = {
+  removed?: Map<string, unknown>;
+  removedAny?: Set<string>;
+  defaulted?: Map<string, unknown>;
+  explicit?: unknown;
+};
+type SearchMiddlewareContext<TSearchSchema> = {
+  search: TSearchSchema;
+  next: (newSearch: TSearchSchema) => TSearchSchema;
+  meta?: SearchMiddlewareMeta;
+};
+type SearchMiddleware<TSearchSchema> = (ctx: SearchMiddlewareContext<TSearchSchema>) => TSearchSchema;
+type InferFullSearchSchema<TRoute> = TRoute extends {
+  types: {
+    fullSearchSchema: infer TFullSearchSchema;
+  };
+} ? TFullSearchSchema : {};
+type InferFullSearchSchemaInput<TRoute> = TRoute extends {
+  types: {
+    fullSearchSchemaInput: infer TFullSearchSchemaInput;
+  };
+} ? TFullSearchSchemaInput : {};
+type InferAllParams<TRoute> = TRoute extends {
+  types: {
+    allParams: infer TAllParams;
+  };
+} ? TAllParams : {};
+type InferAllContext<TRoute> = unknown extends TRoute ? TRoute : TRoute extends {
+  types: {
+    allContext: infer TAllContext;
+  };
+} ? TAllContext : {};
+type ResolveRequiredParams<TPath extends string, T> = { [K in ParsePathParams<TPath>['required']]: T };
+type ResolveOptionalParams<TPath extends string, T> = { [K in ParsePathParams<TPath>['optional']]?: T | undefined };
+type ResolveParams<TPath extends string, T = string> = ResolveRequiredParams<TPath, T> & ResolveOptionalParams<TPath, T>;
+type ParseParamsFn<in out TPath extends string, in out TParams> = (rawParams: Expand<ResolveParams<TPath>>) => TParams | false;
+type ValidateParsedParams<TPath extends string, TParams> = [TParams] extends [ResolveParams<TPath, any>] ? unknown : never;
+type StringifyParamsFn<in out TPath extends string, in out TParams> = (params: TParams) => ResolveParams<TPath>;
+type ParamsOptions<in out TPath extends string, in out TParams> = {
+  params?: {
+    parse?: ParseParamsFn<TPath, TParams> & ValidateParsedParams<TPath, TParams>;
+    /**
+     * When multiple route candidates use `params.parse` during matching,
+     * higher priorities are tried first.
+     *
+     * @default 0
+     */
+    priority?: number;
+    stringify?: StringifyParamsFn<TPath, TParams>;
+  };
+  /**
+  @deprecated Use params.parse instead
+  */
+  parseParams?: ParseParamsFn<TPath, TParams> & ValidateParsedParams<TPath, TParams>;
+  /**
+  @deprecated Use params.stringify instead
+  */
+  stringifyParams?: StringifyParamsFn<TPath, TParams>;
+};
+interface RequiredStaticDataRouteOption {
+  staticData: StaticDataRouteOption;
+}
+interface OptionalStaticDataRouteOption {
+  staticData?: StaticDataRouteOption;
+}
+type UpdatableStaticRouteOption = {} extends StaticDataRouteOption ? OptionalStaticDataRouteOption : RequiredStaticDataRouteOption;
+type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
+type ContextReturnType<TContextFn> = unknown extends TContextFn ? TContextFn : LooseReturnType<TContextFn> extends never ? AnyContext : LooseReturnType<TContextFn>;
+type ContextAsyncReturnType<TContextFn> = unknown extends TContextFn ? TContextFn : LooseAsyncReturnType<TContextFn> extends never ? AnyContext : LooseAsyncReturnType<TContextFn>;
+type ResolveRouteContext<TRouteContextFn, TBeforeLoadFn> = Assign<ContextReturnType<TRouteContextFn>, ContextAsyncReturnType<TBeforeLoadFn>>;
+type ResolveRouteLoaderFn<TLoaderFn> = TLoaderFn extends {
+  handler: infer THandler;
+} ? THandler : TLoaderFn;
+type RouteLoaderObject<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TParams = {}, TLoaderDeps = {}, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TServerMiddlewares = unknown, THandlers = undefined> = {
+  handler: RouteLoaderFn<TRegister, TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers>;
+  staleReloadMode?: LoaderStaleReloadMode;
+};
+type ResolveLoaderData<TLoaderFn> = unknown extends TLoaderFn ? TLoaderFn : LooseAsyncReturnType<ResolveRouteLoaderFn<TLoaderFn>> extends never ? undefined : LooseAsyncReturnType<ResolveRouteLoaderFn<TLoaderFn>>;
+type ResolveFullSearchSchema<TParentRoute extends AnyRoute, TSearchValidator> = unknown extends TParentRoute ? ResolveValidatorOutput<TSearchValidator> : IntersectAssign<InferFullSearchSchema<TParentRoute>, ResolveValidatorOutput<TSearchValidator>>;
+type ResolveFullSearchSchemaInput<TParentRoute extends AnyRoute, TSearchValidator> = IntersectAssign<InferFullSearchSchemaInput<TParentRoute>, ResolveSearchValidatorInput<TSearchValidator>>;
+type ResolveAllParamsFromParent<TParentRoute extends AnyRoute, TParams> = Assign<InferAllParams<TParentRoute>, TParams>;
+type RouteContextParameter<TParentRoute extends AnyRoute, TRouterContext> = unknown extends TParentRoute ? TRouterContext : Assign<TRouterContext, InferAllContext<TParentRoute>>;
+type BeforeLoadContextParameter<TParentRoute extends AnyRoute, TRouterContext, TRouteContextFn> = Assign<RouteContextParameter<TParentRoute, TRouterContext>, ContextReturnType<TRouteContextFn>>;
+type ResolveAllContext<TParentRoute extends AnyRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn> = Assign<BeforeLoadContextParameter<TParentRoute, TRouterContext, TRouteContextFn>, ContextAsyncReturnType<TBeforeLoadFn>>;
+interface FullSearchSchemaOption<in out TParentRoute extends AnyRoute, in out TSearchValidator> {
+  search: Expand<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>;
+}
+interface RemountDepsOptions<in out TRouteId, in out TFullSearchSchema, in out TAllParams, in out TLoaderDeps> {
+  routeId: TRouteId;
+  search: TFullSearchSchema;
+  params: TAllParams;
+  loaderDeps: TLoaderDeps;
+}
+type MakeRemountDepsOptionsUnion<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']> = ParseRoute<TRouteTree> extends infer TRoute extends AnyRoute ? TRoute extends any ? RemountDepsOptions<TRoute['id'], TRoute['types']['fullSearchSchema'], TRoute['types']['allParams'], TRoute['types']['loaderDeps']> : never : never;
+interface RouteTypes$1<in out TRegister, in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps, in out TLoaderFn, in out TChildren, in out TFileRouteTypes, in out TSSR, in out TServerMiddlewares, in out THandlers> {
+  parentRoute: TParentRoute;
+  path: TPath;
+  to: TrimPathRight<TFullPath>;
+  fullPath: TFullPath;
+  customId: TCustomId;
+  id: TId;
+  searchSchema: ResolveValidatorOutput<TSearchValidator>;
+  searchSchemaInput: ResolveSearchValidatorInput<TSearchValidator>;
+  searchValidator: TSearchValidator;
+  fullSearchSchema: ResolveFullSearchSchema<TParentRoute, TSearchValidator>;
+  fullSearchSchemaInput: ResolveFullSearchSchemaInput<TParentRoute, TSearchValidator>;
+  params: TParams;
+  allParams: ResolveAllParamsFromParent<TParentRoute, TParams>;
+  routerContext: TRouterContext;
+  routeContext: ResolveRouteContext<TRouteContextFn, TBeforeLoadFn>;
+  routeContextFn: TRouteContextFn;
+  beforeLoadFn: TBeforeLoadFn;
+  allContext: ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>;
+  children: TChildren;
+  loaderData: ResolveLoaderData<TLoaderFn>;
+  loaderDeps: TLoaderDeps;
+  fileRouteTypes: TFileRouteTypes;
+  ssr: ResolveSSR<TSSR>;
+  allSsr: ResolveAllSSR<TParentRoute, TSSR>;
+}
+type ResolveSSR<TSSR> = TSSR extends ((...args: ReadonlyArray<any>) => any) ? LooseReturnType<TSSR> : TSSR;
+type ResolveAllSSR<TParentRoute extends AnyRoute, TSSR> = unknown extends TParentRoute ? ResolveSSR<TSSR> : unknown extends TSSR ? TParentRoute['types']['allSsr'] : ResolveSSR<TSSR>;
+interface RouteExtensions<in out TId, in out TFullPath> {
+  id: TId;
+  fullPath: TFullPath;
+}
+type RouteLazyFn<TRoute extends AnyRoute> = (lazyFn: () => Promise<LazyRoute<TRoute>>) => TRoute;
+type RouteAddChildrenFn<in out TRegister, in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps extends Record<string, any>, in out TLoaderFn, in out TFileRouteTypes, in out TSSR, in out TServerMiddlewares, in out THandlers> = <const TNewChildren>(children: Constrain<TNewChildren, ReadonlyArray<AnyRoute> | Record<string, AnyRoute>>) => Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TNewChildren, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>;
+type RouteAddFileChildrenFn<in out TRegister, in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps extends Record<string, any>, in out TLoaderFn, in out TFileRouteTypes, in out TSSR, in out TServerMiddlewares, in out THandlers> = <const TNewChildren>(children: TNewChildren) => Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TNewChildren, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>;
+type RouteAddFileTypesFn<TRegister, TParentRoute extends AnyRoute, TPath extends string, TFullPath extends string, TCustomId extends string, TId extends string, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps extends Record<string, any>, TLoaderFn, TChildren, TSSR, TServerMiddlewares, THandlers> = <TNewFileRouteTypes>() => Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TNewFileRouteTypes, TSSR, TServerMiddlewares, THandlers>;
+interface Route<in out TRegister, in out TParentRoute extends AnyRoute, in out TPath extends string, in out TFullPath extends string, in out TCustomId extends string, in out TId extends string, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps extends Record<string, any>, in out TLoaderFn, in out TChildren, in out TFileRouteTypes, in out TSSR, in out TServerMiddlewares, in out THandlers> extends RouteExtensions<TId, TFullPath> {
+  path: TPath;
+  parentRoute: TParentRoute;
+  children?: TChildren;
+  types: RouteTypes$1<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>;
+  options: RouteOptions<TRegister, TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TSSR, TServerMiddlewares, THandlers>;
+  isRoot: TParentRoute extends AnyRoute ? true : false;
+  lazyFn?: () => Promise<LazyRoute<Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>>>;
+  rank: number;
+  to: TrimPathRight<TFullPath>;
+  init: (opts: {
+    originalIndex: number;
+  }) => void;
+  update: (options: UpdatableRouteOptions<TParentRoute, TCustomId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn>) => this;
+  lazy: RouteLazyFn<Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>>;
+  addChildren: RouteAddChildrenFn<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>;
+  _addFileChildren: RouteAddFileChildrenFn<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TFileRouteTypes, TSSR, TServerMiddlewares, THandlers>;
+  _addFileTypes: RouteAddFileTypesFn<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TSSR, TServerMiddlewares, THandlers>;
+  /**
+   * Create a redirect with `from` automatically set to this route's path.
+   * Enables relative redirects like `Route.redirect({ to: './overview' })`.
+   * @param opts Redirect options (same as `redirect()` but without `from`)
+   * @returns A redirect Response that can be thrown from loaders/beforeLoad
+   * @link https://tanstack.com/router/latest/docs/framework/react/api/router/redirectFunction
+   */
+  redirect: RedirectFnRoute<TFullPath>;
+}
+type AnyRoute = Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>;
+type RouteOptions<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TCustomId extends string = string, TFullPath extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = AnyPathParams, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> = BaseRouteOptions<TRegister, TParentRoute, TId, TCustomId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TSSR, TServerMiddlewares, THandlers> & UpdatableRouteOptions<NoInfer<TParentRoute>, NoInfer<TCustomId>, NoInfer<TFullPath>, NoInfer<TParams>, NoInfer<TSearchValidator>, NoInfer<TLoaderFn>, NoInfer<TLoaderDeps>, NoInfer<TRouterContext>, NoInfer<TRouteContextFn>, NoInfer<TBeforeLoadFn>>;
+type FileBaseRouteOptions<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TRemountDepsFn = AnyContext, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> = ParamsOptions<TPath, TParams> & FilebaseRouteOptionsInterface<TRegister, TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TRemountDepsFn, TSSR, TServerMiddlewares, THandlers>;
+interface FilebaseRouteOptionsInterface<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TRemountDepsFn = AnyContext, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> {
+  validateSearch?: Constrain<TSearchValidator, AnyValidator, DefaultValidator>;
+  shouldReload?: boolean | ((match: LoaderFnContext<TRegister, TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers>) => any);
+  context?: Constrain<TRouteContextFn, (ctx: RouteContextOptions<TParentRoute, TParams, TRouterContext, TLoaderDeps, TId>) => any>;
+  ssr?: Constrain<TSSR, undefined | SSROption | ((ctx: SsrContextOptions<TParentRoute, TSearchValidator, TParams>) => Awaitable<undefined | SSROption>)>;
+  beforeLoad?: Constrain<TBeforeLoadFn, (ctx: BeforeLoadContextOptions<TRegister, TParentRoute, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TId, TServerMiddlewares, THandlers>) => ValidateSerializableLifecycleResult<TRegister, TParentRoute, TSSR, TBeforeLoadFn>>;
+  loaderDeps?: (opts: FullSearchSchemaOption<TParentRoute, TSearchValidator>) => TLoaderDeps;
+  remountDeps?: Constrain<TRemountDepsFn, (opt: RemountDepsOptions<TId, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>, TLoaderDeps>) => any>;
+  loader?: Constrain<TLoaderFn, RouteLoaderFn<TRegister, TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers> | RouteLoaderObject<TRegister, TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers>>;
+}
+type BaseRouteOptions<TRegister, TParentRoute extends AnyRoute = AnyRoute, TId extends string = string, TCustomId extends string = string, TPath extends string = string, TSearchValidator = undefined, TParams = {}, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSSR = unknown, TServerMiddlewares = unknown, THandlers = undefined> = RoutePathOptions<TCustomId, TPath> & FileBaseRouteOptions<TRegister, TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, AnyContext, TSSR, TServerMiddlewares, THandlers> & {
+  getParentRoute: () => TParentRoute;
+};
+interface ContextOptions<in out TParentRoute extends AnyRoute, in out TParams, in out TRouteId> {
+  abortController: AbortController;
+  preload: boolean;
+  params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>;
+  location: ParsedLocation;
+  /**
+   * @deprecated Use `throw redirect({ to: '/somewhere' })` instead
+   **/
+  navigate: NavigateFn;
+  buildLocation: BuildLocationFn;
+  cause: 'preload' | 'enter' | 'stay';
+  matches: Array<MakeRouteMatchUnion>;
+  routeId: TRouteId;
+}
+interface RouteContextOptions<in out TParentRoute extends AnyRoute, in out TParams, in out TRouterContext, in out TLoaderDeps, in out TRouteId> extends ContextOptions<TParentRoute, TParams, TRouteId> {
+  deps: TLoaderDeps;
+  context: Expand<RouteContextParameter<TParentRoute, TRouterContext>>;
+}
+interface SsrContextOptions<in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams> {
+  params: {
+    status: 'success';
+    value: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>;
+  } | {
+    status: 'error';
+    error: unknown;
+  };
+  search: {
+    status: 'success';
+    value: Expand<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>;
+  } | {
+    status: 'error';
+    error: unknown;
+  };
+  location: ParsedLocation;
+  matches: Array<MakePreValidationErrorHandlingRouteMatchUnion>;
+}
+interface BeforeLoadContextOptions<in out TRegister, in out TParentRoute extends AnyRoute, in out TSearchValidator, in out TParams, in out TRouterContext, in out TRouteContextFn, in out TRouteId, in out TServerMiddlewares, in out THandlers> extends ContextOptions<TParentRoute, TParams, TRouteId>, FullSearchSchemaOption<TParentRoute, TSearchValidator> {
+  context: Expand<BeforeLoadContextParameter<TParentRoute, TRouterContext, TRouteContextFn>>;
+}
+type AssetFnContextOptions<in out TRouteId, in out TFullPath, in out TParentRoute extends AnyRoute, in out TParams, in out TSearchValidator, in out TLoaderFn, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn, in out TLoaderDeps> = {
+  ssr?: {
+    nonce?: string;
+  };
+  matches: Array<RouteMatch$1<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>>;
+  match: RouteMatch$1<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>;
+  params: ResolveAllParamsFromParent<TParentRoute, TParams>;
+  loaderData?: ResolveLoaderData<TLoaderFn>;
+};
+interface DefaultUpdatableRouteOptionsExtensions {
+  component?: unknown;
+  errorComponent?: unknown;
+  notFoundComponent?: unknown;
+  pendingComponent?: unknown;
+}
+interface UpdatableRouteOptionsExtensions extends DefaultUpdatableRouteOptionsExtensions {}
+interface UpdatableRouteOptions<in out TParentRoute extends AnyRoute, in out TRouteId, in out TFullPath, in out TParams, in out TSearchValidator, in out TLoaderFn, in out TLoaderDeps, in out TRouterContext, in out TRouteContextFn, in out TBeforeLoadFn> extends UpdatableStaticRouteOption, UpdatableRouteOptionsExtensions {
+  /**
+   * If true, this route will be matched as case-sensitive
+   *
+   * @default false
+   */
+  caseSensitive?: boolean;
+  /**
+   * If true, this route will be forcefully wrapped in a suspense boundary
+   */
+  wrapInSuspense?: boolean;
+  pendingMs?: number;
+  pendingMinMs?: number;
+  staleTime?: number;
+  gcTime?: number;
+  preload?: boolean;
+  preloadStaleTime?: number;
+  preloadGcTime?: number;
+  search?: {
+    middlewares?: Array<SearchMiddleware<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>>;
+  };
+  /**
+  @deprecated Use search.middlewares instead
+  */
+  preSearchFilters?: Array<SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>>;
+  /**
+  @deprecated Use search.middlewares instead
+  */
+  postSearchFilters?: Array<SearchFilter<ResolveFullSearchSchema<TParentRoute, TSearchValidator>>>;
+  onCatch?: (error: Error) => void;
+  onError?: (err: any) => void;
+  onEnter?: (match: RouteMatch$1<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
+  onStay?: (match: RouteMatch$1<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
+  onLeave?: (match: RouteMatch$1<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
+  headers?: (ctx: AssetFnContextOptions<TRouteId, TFullPath, TParentRoute, TParams, TSearchValidator, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps>) => Awaitable<Record<string, string> | undefined>;
+  head?: (ctx: AssetFnContextOptions<TRouteId, TFullPath, TParentRoute, TParams, TSearchValidator, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps>) => Awaitable<{
+    links?: AnyRouteMatch['links'];
+    scripts?: AnyRouteMatch['headScripts'];
+    meta?: AnyRouteMatch['meta'];
+    styles?: AnyRouteMatch['styles'];
+  }>;
+  scripts?: (ctx: AssetFnContextOptions<TRouteId, TFullPath, TParentRoute, TParams, TSearchValidator, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps>) => Awaitable<AnyRouteMatch['scripts']>;
+  codeSplitGroupings?: Array<Array<'loader' | 'component' | 'pendingComponent' | 'notFoundComponent' | 'errorComponent'>>;
+}
+type RouteLoaderFn<in out TRegister, in out TParentRoute extends AnyRoute = AnyRoute, in out TId extends string = string, in out TParams = {}, in out TLoaderDeps = {}, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TServerMiddlewares = unknown, in out THandlers = undefined> = (match: LoaderFnContext<TRegister, TParentRoute, TId, TParams, TLoaderDeps, TRouterContext, TRouteContextFn, TBeforeLoadFn, TServerMiddlewares, THandlers>) => any;
+type LoaderStaleReloadMode = 'background' | 'blocking';
+interface LoaderFnContext<in out TRegister = unknown, in out TParentRoute extends AnyRoute = AnyRoute, in out TId extends string = string, in out TParams = {}, in out TLoaderDeps = {}, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TServerMiddlewares = unknown, in out THandlers = undefined> {
+  abortController: AbortController;
+  preload: boolean;
+  params: Expand<ResolveAllParamsFromParent<TParentRoute, TParams>>;
+  deps: TLoaderDeps;
+  context: Expand<ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>>;
+  location: ParsedLocation;
+  /**
+   * @deprecated Use `throw redirect({ to: '/somewhere' })` instead
+   **/
+  navigate: (opts: NavigateOptions<AnyRouter>) => Promise<void> | void;
+  parentMatchPromise: TId extends RootRouteId ? never : Promise<MakeRouteMatchFromRoute<TParentRoute>>;
+  cause: 'preload' | 'enter' | 'stay';
+  route: AnyRoute;
+}
+type RouteMask<TRouteTree extends AnyRoute> = {
+  routeTree: TRouteTree;
+  from: RoutePaths<TRouteTree>;
+  to?: any;
+  params?: any;
+  search?: any;
+  hash?: any;
+  state?: any;
+  unmaskOnReload?: boolean;
+};
+type ErrorComponentProps<TError = Error> = {
+  error: TError;
+  info?: {
+    componentStack: string;
+  };
+  reset: () => void;
+};
+type NotFoundRouteProps = {
+  data?: unknown;
+  isNotFound: boolean;
+  routeId: RouteIds<RegisteredRouter['routeTree']>;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/validators.d.ts
+interface StandardSchemaValidatorProps<TInput, TOutput> {
+  readonly types?: StandardSchemaValidatorTypes<TInput, TOutput> | undefined;
+  readonly validate: AnyStandardSchemaValidate;
+}
+interface StandardSchemaValidator<TInput, TOutput> {
+  readonly '~standard': StandardSchemaValidatorProps<TInput, TOutput>;
+}
+type AnyStandardSchemaValidator = StandardSchemaValidator<any, any>;
+interface StandardSchemaValidatorTypes<TInput, TOutput> {
+  readonly input: TInput;
+  readonly output: TOutput;
+}
+interface AnyStandardSchemaValidateSuccess {
+  readonly value: any;
+  readonly issues?: undefined;
+}
+interface AnyStandardSchemaValidateFailure {
+  readonly issues: ReadonlyArray<AnyStandardSchemaValidateIssue>;
+}
+interface AnyStandardSchemaValidateIssue {
+  readonly message: string;
+}
+type AnyStandardSchemaValidate = (value: unknown) => (AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure) | Promise<AnyStandardSchemaValidateSuccess | AnyStandardSchemaValidateFailure>;
+interface ValidatorObj<TInput, TOutput> {
+  parse: ValidatorFn<TInput, TOutput>;
+}
+type AnyValidatorObj = ValidatorObj<any, any>;
+interface ValidatorAdapter<TInput, TOutput> {
+  types: {
+    input: TInput;
+    output: TOutput;
+  };
+  parse: (input: unknown) => TOutput;
+}
+type AnyValidatorAdapter = ValidatorAdapter<any, any>;
+type ValidatorFn<TInput, TOutput> = (input: TInput) => TOutput;
+type Validator<TInput, TOutput> = ValidatorObj<TInput, TOutput> | ValidatorFn<TInput, TOutput> | ValidatorAdapter<TInput, TOutput> | StandardSchemaValidator<TInput, TOutput> | undefined;
+type AnyValidator = Validator<any, any>;
+type AnySchema = {};
+type DefaultValidator = Validator<Record<string, unknown>, AnySchema>;
+type ResolveSearchValidatorInputFn<TValidator> = TValidator extends ((input: infer TSchemaInput) => any) ? TSchemaInput extends SearchSchemaInput ? Omit<TSchemaInput, keyof SearchSchemaInput> : ResolveValidatorOutputFn<TValidator> : AnySchema;
+type ResolveSearchValidatorInput<TValidator> = TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['input'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['input'] : TValidator extends AnyValidatorObj ? ResolveSearchValidatorInputFn<TValidator['parse']> : ResolveSearchValidatorInputFn<TValidator>;
+type ResolveValidatorOutputFn<TValidator> = TValidator extends ((...args: any) => infer TSchema) ? TSchema : AnySchema;
+type ResolveValidatorOutput<TValidator> = unknown extends TValidator ? TValidator : TValidator extends AnyStandardSchemaValidator ? NonNullable<TValidator['~standard']['types']>['output'] : TValidator extends AnyValidatorAdapter ? TValidator['types']['output'] : TValidator extends AnyValidatorObj ? ResolveValidatorOutputFn<TValidator['parse']> : ResolveValidatorOutputFn<TValidator>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/location.d.ts
+interface ParsedLocation<TSearchObj extends AnySchema = {}> {
+  /**
+   * The full path of the location, including pathname, search, and hash.
+   * Does not include the origin. Is the equivalent of calling
+   * `url.replace(url.origin, '')`
+   */
+  href: string;
+  /**
+   * @description The pathname of the location, including the leading slash.
+   */
+  pathname: string;
+  /**
+   * The parsed search parameters of the location in object form.
+   */
+  search: TSearchObj;
+  /**
+   * The search string of the location, including the leading question mark.
+   */
+  searchStr: string;
+  /**
+   * The in-memory state of the location as it *may* exist in the browser's history.
+   */
+  state: ParsedHistoryState;
+  /**
+   * The hash of the location, excluding the leading hash character.
+   * (e.g., '123' instead of '#123')
+   */
+  hash: string;
+  /**
+   * The masked location of the location.
+   */
+  maskedLocation?: ParsedLocation<TSearchObj>;
+  /**
+   * Whether to unmask the location on reload.
+   */
+  unmaskOnReload?: boolean;
+  /**
+   * @private
+   * @description The public href of the location.
+   * If a rewrite is applied, the `href` property will be the rewritten URL.
+   */
+  publicHref: string;
+  /**
+   * @private
+   * @description Whether the publicHref is external (different origin from rewrite).
+   */
+  external: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/load-matches.d.ts
+type RouteComponentType = 'component' | 'errorComponent' | 'pendingComponent' | 'notFoundComponent';
+declare function loadRouteChunk(route: AnyRoute, componentTypesToLoad?: Array<RouteComponentType>): Promise<void> | undefined;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/lru-cache.d.ts
+type LRUCache<TKey, TValue> = {
+  get: (key: TKey) => TValue | undefined;
+  set: (key: TKey, value: TValue) => void;
+  clear: () => void;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.d.ts
+declare const SEGMENT_TYPE_PATHNAME = 0;
+declare const SEGMENT_TYPE_PARAM = 1;
+declare const SEGMENT_TYPE_WILDCARD = 2;
+declare const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
+declare const SEGMENT_TYPE_INDEX = 4;
+declare const SEGMENT_TYPE_PATHLESS = 5;
+/**
+ * All the kinds of segments that can be present in a route path.
+ */
+type SegmentKind = typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
+/**
+ * All the kinds of segments that can be present in the segment tree.
+ */
+type ExtendedSegmentKind = SegmentKind | typeof SEGMENT_TYPE_INDEX | typeof SEGMENT_TYPE_PATHLESS;
+type StaticSegmentNode<T extends RouteLike> = SegmentNode<T> & {
+  kind: typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PATHLESS | typeof SEGMENT_TYPE_INDEX;
+};
+type DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {
+  kind: typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
+  prefix?: string;
+  suffix?: string;
+  caseSensitive: boolean;
+};
+type AnySegmentNode<T extends RouteLike> = StaticSegmentNode<T> | DynamicSegmentNode<T>;
+type SegmentNode<T extends RouteLike> = {
+  kind: ExtendedSegmentKind;
+  pathless: Array<StaticSegmentNode<T>> | null; /** Exact index segment (highest priority) */
+  index: StaticSegmentNode<T> | null; /** Static segments (2nd priority) */
+  static: Map<string, StaticSegmentNode<T>> | null; /** Case insensitive static segments (3rd highest priority) */
+  staticInsensitive: Map<string, StaticSegmentNode<T>> | null; /** Dynamic segments ($param) */
+  dynamic: Array<DynamicSegmentNode<T>> | null; /** Optional dynamic segments ({-$param}) */
+  optional: Array<DynamicSegmentNode<T>> | null; /** Wildcard segments ($ - lowest priority) */
+  wildcard: Array<DynamicSegmentNode<T>> | null; /** Terminal route (if this path can end here) */
+  route: T | null; /** The full path for this segment node (will only be valid on leaf nodes) */
+  fullPath: string;
+  parent: AnySegmentNode<T> | null;
+  depth: number; /** route.options.params.parse function, set on the last node of the route */
+  parse: null | ((params: Record<string, string>) => unknown); /** route.options.params.priority ?? 0 */
+  priority: number;
+};
+type RouteLike = {
+  id?: string;
+  path?: string;
+  children?: Array<RouteLike>;
+  parentRoute?: RouteLike;
+  isRoot?: boolean;
+  options?: {
+    caseSensitive?: boolean;
+    parseParams?: (params: Record<string, string>) => unknown;
+    params?: {
+      parse?: (params: Record<string, string>) => unknown;
+      priority?: number;
+    };
+  };
+} & ({
+  fullPath: string;
+  from?: never;
+} | {
+  fullPath?: never;
+  from: string;
+});
+type ProcessedTree<TTree extends Extract<RouteLike, {
+  fullPath: string;
+}>, TFlat extends Extract<RouteLike, {
+  from: string;
+}>, TSingle extends Extract<RouteLike, {
+  from: string;
+}>> = {
+  /** a representation of the `routeTree` as a segment tree */segmentTree: AnySegmentNode<TTree>; /** a mini route tree generated from the flat `routeMasks` list */
+  masksTree: AnySegmentNode<TFlat> | null; /** @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree */
+  singleCache: LRUCache<string, AnySegmentNode<TSingle>>; /** a cache of route matches from the `segmentTree` */
+  matchCache: LRUCache<string, RouteMatch<TTree> | null>; /** a cache of route matches from the `masksTree` */
+  flatCache: LRUCache<string, ReturnType<typeof findMatch<TFlat>>> | null;
+};
+type RouteMatch<T extends Extract<RouteLike, {
+  fullPath: string;
+}>> = {
+  route: T;
+  rawParams: Record<string, string>;
+  branch: ReadonlyArray<T>;
+};
+interface ProcessRouteTreeResult<TRouteLike extends Extract<RouteLike, {
+  fullPath: string;
+}> & {
+  id: string;
+}> {
+  /** Should be considered a black box, needs to be provided to all matching functions in this module. */
+  processedTree: ProcessedTree<TRouteLike, any, any>;
+  /** A lookup map of routes by their unique IDs. */
+  routesById: Record<string, TRouteLike>;
+  /** A lookup map of routes by their trimmed full paths. */
+  routesByPath: Record<string, TRouteLike>;
+}
+declare function findMatch<T extends RouteLike>(path: string, segmentTree: AnySegmentNode<T>, fuzzy?: boolean): {
+  route: T;
+  /**
+   * The raw (unparsed) params extracted from the path.
+   * This will be the exhaustive list of all params defined in the route's path.
+   */
+  rawParams: Record<string, string>;
+} | null;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/searchParams.d.ts
+type SearchSerializer = (searchObj: Record<string, any>) => string;
+type SearchParser = (searchStr: string) => Record<string, any>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/manifest.d.ts
+type AssetCrossOrigin = 'anonymous' | 'use-credentials';
+type ScriptFormat = 'module' | 'iife';
+declare const DEV_STYLES_ATTR = "data-tanstack-router-dev-styles";
+type ManifestAssetLink = string | {
+  href: string;
+  crossOrigin?: AssetCrossOrigin;
+};
+type Manifest = {
+  scriptFormat?: ScriptFormat;
+  inlineStyle?: ManifestInlineCss;
+  routes: Record<string, ManifestRoute>;
+};
+type ManifestRoute = {
+  filePath?: string;
+  preloads?: Array<ManifestAssetLink>;
+  scripts?: Array<ManifestScript>;
+  css?: Array<ManifestCssLink>;
+};
+type ManifestRouteAssets = Pick<ManifestRoute, 'preloads' | 'scripts' | 'css'>;
+type RouterManagedTitleTag = {
+  tag: 'title';
+  attrs?: Record<string, any>;
+  children: string;
+};
+type RouterManagedMetaTag = {
+  tag: 'meta';
+  attrs?: Record<string, any>;
+  children?: never;
+};
+type RouterManagedLinkTag = {
+  tag: 'link';
+  attrs?: Record<string, any>;
+  children?: never;
+};
+type RouterManagedScriptTag = {
+  tag: 'script';
+  attrs?: Record<string, any>;
+  children?: string;
+};
+type ManifestScript = Omit<RouterManagedScriptTag, 'tag'>;
+type RouterManagedStyleTag = {
+  tag: 'style';
+  attrs?: Record<string, any>;
+  children?: string;
+  inlineCss?: true;
+};
+type RouterManagedTag = RouterManagedTitleTag | RouterManagedMetaTag | RouterManagedLinkTag | RouterManagedScriptTag | RouterManagedStyleTag;
+type ManifestCssLink = string | {
+  href: string;
+  crossOrigin?: AssetCrossOrigin;
+  [DEV_STYLES_ATTR]?: true;
+};
+type ManifestInlineCss = {
+  attrs?: Record<string, any>;
+  children?: string;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/stores.d.ts
+interface RouterReadableStore<TValue> {
+  get: () => TValue;
+}
+interface RouterWritableStore<TValue> extends RouterReadableStore<TValue> {
+  set: ((updater: (prev: TValue) => TValue) => void) & ((value: TValue) => void);
+}
+type RouterBatchFn = (fn: () => void) => void;
+type MutableStoreFactory = <TValue>(initialValue: TValue) => RouterWritableStore<TValue>;
+type ReadonlyStoreFactory = <TValue>(read: () => TValue) => RouterReadableStore<TValue>;
+type GetStoreConfig = (opts: {
+  isServer?: boolean;
+}) => StoreConfig;
+type StoreConfig = {
+  createMutableStore: MutableStoreFactory;
+  createReadonlyStore: ReadonlyStoreFactory;
+  batch: RouterBatchFn;
+  init?: (stores: RouterStores<AnyRoute>) => void;
+};
+type MatchStore = RouterWritableStore<AnyRouteMatch> & {
+  routeId?: string;
+};
+type ReadableStore<TValue> = RouterReadableStore<TValue>;
+/** SSR non-reactive createMutableStore */
+interface RouterStores<in out TRouteTree extends AnyRoute> {
+  status: RouterWritableStore<RouterState<TRouteTree>['status']>;
+  loadedAt: RouterWritableStore<number>;
+  isLoading: RouterWritableStore<boolean>;
+  isTransitioning: RouterWritableStore<boolean>;
+  location: RouterWritableStore<ParsedLocation<FullSearchSchema<TRouteTree>>>;
+  resolvedLocation: RouterWritableStore<ParsedLocation<FullSearchSchema<TRouteTree>> | undefined>;
+  statusCode: RouterWritableStore<number>;
+  redirect: RouterWritableStore<AnyRedirect | undefined>;
+  matchesId: RouterWritableStore<Array<string>>;
+  pendingIds: RouterWritableStore<Array<string>>;
+  matches: ReadableStore<Array<AnyRouteMatch>>;
+  pendingMatches: ReadableStore<Array<AnyRouteMatch>>;
+  cachedMatches: ReadableStore<Array<AnyRouteMatch>>;
+  firstId: ReadableStore<string | undefined>;
+  hasPending: ReadableStore<boolean>;
+  matchRouteDeps: ReadableStore<{
+    locationHref: string;
+    resolvedLocationHref: string | undefined;
+    status: RouterState<TRouteTree>['status'];
+  }>;
+  __store: RouterReadableStore<RouterState<TRouteTree>>;
+  matchStores: Map<string, MatchStore>;
+  pendingMatchStores: Map<string, MatchStore>;
+  cachedMatchStores: Map<string, MatchStore>;
+  /**
+   * Get a computed store that resolves a routeId to its current match state.
+   * Returns the same cached store instance for repeated calls with the same key.
+   * The computed depends on matchesId + the individual match store, so
+   * subscribers are only notified when the resolved match state changes.
+   */
+  getRouteMatchStore: (routeId: string) => RouterReadableStore<AnyRouteMatch | undefined>;
+  setMatches: (nextMatches: Array<AnyRouteMatch>) => void;
+  setPending: (nextMatches: Array<AnyRouteMatch>) => void;
+  setCached: (nextMatches: Array<AnyRouteMatch>) => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/router.d.ts
+interface Register {}
+type RegisteredSsr<TRegister = Register> = TRegister extends {
+  ssr: infer TSSR;
+} ? TSSR : false;
+type RegisteredRouter<TRegister = Register> = TRegister extends {
+  router: infer TRouter;
+} ? TRouter : AnyRouter;
+type RegisteredConfigType<TRegister, TKey> = TRegister extends {
+  config: infer TConfig;
+} ? TConfig extends {
+  '~types': infer TTypes;
+} ? TKey extends keyof TTypes ? TTypes[TKey] : unknown : unknown : unknown;
+type DefaultRemountDepsFn<TRouteTree extends AnyRoute> = (opts: MakeRemountDepsOptionsUnion<TRouteTree>) => any;
+interface DefaultRouterOptionsExtensions {}
+interface RouterOptionsExtensions extends DefaultRouterOptionsExtensions {}
+type SSROption = boolean | 'data-only';
+interface RouterOptions<TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption, TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated = undefined> 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 `preloadIntentProximity` a route should use if no preloadIntentProximity is provided.
+   *
+   * @default 0
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpreloadintentproximity-property)
+   * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/preloading#preload-intent-proximity)
+   */
+  defaultPreloadIntentProximity?: 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 stale reload mode a route loader should use if no `loader.staleReloadMode` is provided.
+   *
+   * `'background'` preserves the current stale-while-revalidate behavior.
+   * `'blocking'` waits for stale loader reloads to complete before resolving navigation.
+   *
+   * @default 'background'
+   */
+  defaultStaleReloadMode?: LoaderStaleReloadMode;
+  /**
+   * 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>;
+  additionalContext?: any;
+  /**
+   * 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?: () => Awaitable<Constrain<TDehydrated, ValidateSerializableInput<Register, TDehydrated>>>;
+  /**
+   * A function that will be called when the router is hydrated.
+   *
+   * @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) => Awaitable<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;
+  /**
+   * @default false
+   */
+  isShell?: boolean;
+  /**
+   * @default false
+   */
+  isPrerendering?: boolean;
+  /**
+   * The default `ssr` a route should use if no `ssr` is provided.
+   *
+   * @default true
+   */
+  defaultSsr?: SSROption;
+  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 | ((opts: {
+    location: ParsedLocation;
+  }) => 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 | (() => Element | null | undefined)>;
+  /**
+   * When `true`, disables the global catch boundary that normally wraps all route matches.
+   * This allows unhandled errors to bubble up to top-level error handlers in the browser.
+   *
+   * Useful for testing tools (like Storybook Test Runner), error reporting services,
+   * and debugging scenarios where you want errors to reach the browser's global error handlers.
+   *
+   * @default false
+   */
+  disableGlobalCatchBoundary?: boolean;
+  /**
+   * An array of URL protocols to allow in links, redirects, and navigation.
+   * Absolute URLs with protocols not in this list will be rejected.
+   *
+   * @default DEFAULT_PROTOCOL_ALLOWLIST (http:, https:, mailto:, tel:)
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#protocolallowlist-property)
+   */
+  protocolAllowlist?: Array<string>;
+  serializationAdapters?: ReadonlyArray<AnySerializationAdapter>;
+  /**
+   * Configures how the router will rewrite the location between the actual href and the internal href of the router.
+   *
+   * @default undefined
+   * @description You can provide a custom rewrite pair (in/out).
+   * This is useful for shifting data from the origin to the path (for things like subdomain routing), or other advanced use cases.
+   */
+  rewrite?: LocationRewrite;
+  origin?: string;
+  ssr?: {
+    nonce?: string;
+  };
+}
+type LocationRewrite = {
+  /**
+   * A function that will be called to rewrite the URL before it is interpreted by the router from the history instance.
+   *
+   * @default undefined
+   */
+  input?: LocationRewriteFunction;
+  /**
+   * A function that will be called to rewrite the URL before it is committed to the actual history instance from the router.
+   *
+   * @default undefined
+   */
+  output?: LocationRewriteFunction;
+};
+/**
+ * A function that will be called to rewrite the URL.
+ *
+ * @param url The URL to rewrite.
+ * @returns The rewritten URL (as a URL instance or full href string) or undefined if no rewrite is needed.
+ */
+type LocationRewriteFunction = ({
+  url
+}: {
+  url: URL;
+}) => undefined | string | URL;
+interface RouterState<in out TRouteTree extends AnyRoute = AnyRoute, in out TRouteMatch = MakeRouteMatchUnion> {
+  status: 'pending' | 'idle';
+  loadedAt: number;
+  isLoading: boolean;
+  isTransitioning: boolean;
+  matches: Array<TRouteMatch>;
+  location: ParsedLocation<FullSearchSchema<TRouteTree>>;
+  resolvedLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>;
+  statusCode: number;
+  redirect?: AnyRedirect;
+}
+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;
+  href?: string;
+  _fromLocation?: ParsedLocation;
+  unsafeRelative?: 'path';
+  _isNavigate?: boolean;
+}
+type NavigationEventInfo = {
+  fromLocation?: ParsedLocation;
+  toLocation: ParsedLocation;
+  pathChanged: boolean;
+  hrefChanged: boolean;
+  hashChanged: boolean;
+};
+interface RouterEvents {
+  onBeforeNavigate: {
+    type: 'onBeforeNavigate';
+  } & NavigationEventInfo;
+  onBeforeLoad: {
+    type: 'onBeforeLoad';
+  } & NavigationEventInfo;
+  onLoad: {
+    type: 'onLoad';
+  } & NavigationEventInfo;
+  onResolved: {
+    type: 'onResolved';
+  } & NavigationEventInfo;
+  onBeforeRouteMount: {
+    type: 'onBeforeRouteMount';
+  } & NavigationEventInfo;
+  onRendered: {
+    type: 'onRendered';
+  } & NavigationEventInfo;
+}
+type RouterEvent = RouterEvents[keyof RouterEvents];
+type ListenerFn<TEvent extends RouterEvent> = (event: TEvent) => void;
+type RouterListener<TRouterEvent extends RouterEvent> = {
+  eventType: TRouterEvent['type'];
+  fn: ListenerFn<TRouterEvent>;
+};
+type SubscribeFn = <TType extends keyof RouterEvents>(eventType: TType, fn: ListenerFn<RouterEvents[TType]>) => () => void;
+interface MatchRoutesOpts {
+  preload?: boolean;
+  throwOnError?: boolean;
+  dest?: BuildNextOptions;
+}
+type InferRouterContext<TRouteTree extends AnyRoute> = TRouteTree['types']['routerContext'];
+type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext extends InferRouterContext<TRouteTree> ? {
+  context?: InferRouterContext<TRouteTree>;
+} : {
+  context: InferRouterContext<TRouteTree>;
+};
+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' | 'serializationAdapters' | 'defaultSsr'> & RouterContextOptions<TRouteTree>;
+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<RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>, TFrom, TTo, TMaskFrom, TMaskTo> & {}) => Promise<Array<AnyRouteMatch> | undefined>;
+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<RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>['types']['allParams'];
+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;
+type InvalidateFn<TRouter extends AnyRouter> = (opts?: {
+  filter?: (d: MakeRouteMatchUnion<TRouter>) => boolean;
+  sync?: boolean;
+  forcePending?: boolean;
+}) => Promise<void>;
+type ParseLocationFn<TRouteTree extends AnyRoute> = (locationToParse: HistoryLocation$1, previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>) => ParsedLocation<FullSearchSchema<TRouteTree>>;
+type GetMatchRoutesFn = (pathname: string) => {
+  matchedRoutes: ReadonlyArray<AnyRoute>; /** exhaustive params, still in their string form */
+  routeParams: Record<string, string>;
+  foundRoute: AnyRoute | undefined;
+  parseError?: unknown;
+};
+type EmitFn = (routerEvent: RouterEvent) => void;
+type LoadFn = (opts?: {
+  sync?: boolean;
+  action?: {
+    type: HistoryAction;
+  };
+}) => Promise<void>;
+type CommitLocationFn = ({
+  viewTransition,
+  ignoreBlocker,
+  ...next
+}: ParsedLocation & CommitLocationOptions) => Promise<void>;
+type StartTransitionFn = (fn: () => void) => void;
+interface MatchRoutesFn {
+  (pathname: string, locationSearch?: AnySchema, opts?: MatchRoutesOpts): Array<MakeRouteMatchUnion>;
+  /**
+   * @deprecated use the following signature instead
+   */
+  (next: ParsedLocation, opts?: MatchRoutesOpts): Array<AnyRouteMatch>;
+  (pathnameOrNext: string | ParsedLocation, locationSearchOrOpts?: AnySchema | MatchRoutesOpts, opts?: MatchRoutesOpts): Array<AnyRouteMatch>;
+}
+type GetMatchFn = (matchId: string) => AnyRouteMatch | undefined;
+type UpdateMatchFn = (id: string, updater: (match: AnyRouteMatch) => AnyRouteMatch) => void;
+type ClearCacheFn<TRouter extends AnyRouter> = (opts?: {
+  filter?: (d: MakeRouteMatchUnion<TRouter>) => boolean;
+}) => void;
+interface ServerSsr {
+  /** Framework-only: injects router-owned HTML into the SSR stream. */
+  injectHtml: (html: string) => void;
+  /** Framework-only: injects a router-owned script tag into the SSR stream. */
+  injectScript: (script: string) => void;
+  isDehydrated: () => boolean;
+  isSerializationFinished: () => boolean;
+  /** Framework-only: atomically reserves the pass-through stream path if safe. */
+  reserveStreamFastPath: () => boolean;
+  /** Framework-only. */
+  onInjectedHtml: (listener: () => void) => () => void;
+  /** Framework-only. */
+  onRenderFinished: (listener: () => void) => void;
+  /** Framework-only. */
+  setRenderFinished: () => void;
+  /** Framework-only. */
+  cleanup: () => void;
+  /**
+   * Register a listener invoked when the SSR request lifecycle ends (success,
+   * error, abort, or stream lifetime expiry). Use to tear down per-request
+   * resources whose references would otherwise pin the router (e.g. query
+   * cache subscriptions, gcTime timers, abort controllers).
+   *
+   * Listeners run synchronously and exactly once. Errors are caught and logged.
+   */
+  onCleanup: (listener: () => void) => void;
+  /** Framework-only. */
+  onSerializationFinished: (listener: () => void) => () => void;
+  /** Framework-only. */
+  dehydrate: (opts?: {
+    requestAssets?: ManifestRouteAssets;
+  }) => Promise<void>;
+  /** Framework-only. */
+  takeBufferedScripts: () => RouterManagedTag | undefined;
+  /** Framework-only: takes buffered router-owned HTML. */
+  takeBufferedHtml: () => string | undefined;
+  /** Framework-only. */
+  liftScriptBarrier: () => void;
+}
+interface RouterSsrLifecycle {
+  onServerSsrAttach?: Array<(serverSsr: ServerSsr) => void>;
+}
+type AnyRouter = RouterCore<any, any, any, any, any>;
+interface ViewTransitionOptions {
+  types: Array<string> | ((locationChangeInfo: {
+    fromLocation?: ParsedLocation;
+    toLocation: ParsedLocation;
+    pathChanged: boolean;
+    hrefChanged: boolean;
+    hashChanged: boolean;
+  }) => Array<string> | false);
+}
+/** Options for configuring trailing-slash behavior. */
+declare const trailingSlashOptions: {
+  readonly always: "always";
+  readonly never: "never";
+  readonly preserve: "preserve";
+};
+type TrailingSlashOption = (typeof trailingSlashOptions)[keyof typeof trailingSlashOptions];
+declare global {
+  var __TSR_CACHE__: {
+    routeTree: AnyRoute;
+    processRouteTreeResult: ProcessRouteTreeResult<AnyRoute>;
+    resolvePathCache: LRUCache<string, string>;
+  } | undefined;
+}
+/**
+ * Core, framework-agnostic router engine that powers TanStack Router.
+ *
+ * Provides navigation, matching, loading, preloading, caching and event APIs
+ * used by framework adapters (React/Solid). Prefer framework helpers like
+ * `createRouter` in app code.
+ *
+ * @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouterType
+ */
+declare class RouterCore<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>> {
+  tempLocationKey: string | undefined;
+  _scroll: {
+    next: boolean;
+    restoring?: boolean;
+    restoration?: boolean;
+    reset?: boolean;
+  };
+  shouldViewTransition?: boolean | ViewTransitionOptions;
+  isViewTransitionTypesSupported?: boolean;
+  subscribers: Set<RouterListener<RouterEvent>>;
+  viewTransitionPromise?: ControlledPromise<true>;
+  stores: RouterStores<TRouteTree>;
+  private getStoreConfig;
+  batch: (fn: () => void) => void;
+  options: PickAsRequired<RouterOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
+  history: TRouterHistory;
+  rewrite?: LocationRewrite;
+  origin?: string;
+  latestLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
+  pendingBuiltLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>;
+  basepath: string;
+  routeTree: TRouteTree;
+  routesById: RoutesById<TRouteTree>;
+  routesByPath: RoutesByPath<TRouteTree>;
+  processedTree: ProcessedTree<TRouteTree, any, any>;
+  resolvePathCache: LRUCache<string, string>;
+  private routeBranchCache;
+  isServer: boolean;
+  pathParamsDecoder?: (encoded: string) => string;
+  protocolAllowlist: Set<string>;
+  /**
+   * @deprecated Use the `createRouter` function instead
+   */
+  constructor(options: RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, getStoreConfig: GetStoreConfig);
+  startTransition: StartTransitionFn;
+  isShell(): boolean;
+  isPrerendering(): boolean;
+  update: UpdateFn<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>;
+  get state(): RouterState<TRouteTree>;
+  updateLatestLocation: () => void;
+  buildRouteTree: () => ProcessRouteTreeResult<TRouteTree>;
+  setRoutes({
+    routesById,
+    routesByPath,
+    processedTree
+  }: ProcessRouteTreeResult<TRouteTree>): void;
+  /**
+   * Subscribe to router lifecycle events like `onBeforeNavigate`, `onLoad`,
+   * `onResolved`, etc. Returns an unsubscribe function.
+   *
+   * @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouterEventsType
+   */
+  subscribe: SubscribeFn;
+  emit: EmitFn;
+  /**
+   * Parse a HistoryLocation into a strongly-typed ParsedLocation using the
+   * current router options, rewrite rules and search parser/stringifier.
+   */
+  parseLocation: ParseLocationFn<TRouteTree>;
+  /** Resolve a path using the router's trailing-slash policy. */
+  resolvePathWithBase: (from: string, path: string) => string;
+  private getRouteBranch;
+  get looseRoutesById(): Record<string, AnyRoute>;
+  matchRoutes: MatchRoutesFn;
+  private getParentContext;
+  private matchRoutesInternal;
+  getMatchedRoutes: GetMatchRoutesFn;
+  /**
+   * Lightweight route matching for buildLocation.
+   * Only computes fullPath, accumulated search, and params - skipping expensive
+   * operations like AbortController, ControlledPromise, loaderDeps, and full match objects.
+   */
+  private matchRoutesLightweight;
+  cancelMatch: (id: string) => void;
+  cancelMatches: () => void;
+  /**
+   * Build the next ParsedLocation from navigation options without committing.
+   * Resolves `to`/`from`, params/search/hash/state, applies search validation
+   * and middlewares, and returns a stable, stringified location object.
+   *
+   * @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouterType#buildlocation-method
+   */
+  buildLocation: BuildLocationFn;
+  commitLocationPromise: undefined | ControlledPromise<void>;
+  /**
+   * Commit a previously built location to history (push/replace), optionally
+   * using view transitions and scroll restoration options.
+   */
+  commitLocation: CommitLocationFn;
+  /** Convenience helper: build a location from options, then commit it. */
+  buildAndCommitLocation: ({
+    replace,
+    resetScroll,
+    hashScrollIntoView,
+    viewTransition,
+    ignoreBlocker,
+    href,
+    ...rest
+  }?: BuildNextOptions & CommitLocationOptions) => Promise<void>;
+  /**
+   * Imperatively navigate using standard `NavigateOptions`. When `reloadDocument`
+   * or an absolute `href` is provided, performs a full document navigation.
+   * Otherwise, builds and commits a client-side location.
+   *
+   * @link https://tanstack.com/router/latest/docs/framework/react/api/router/NavigateOptionsType
+   */
+  navigate: NavigateFn;
+  latestLoadPromise: undefined | Promise<void>;
+  beforeLoad: () => void;
+  load: LoadFn;
+  startViewTransition: (fn: () => Promise<void>) => void;
+  updateMatch: UpdateMatchFn;
+  getMatch: GetMatchFn;
+  /**
+   * Invalidate the current matches and optionally force them back into a pending state.
+   *
+   * - Marks all matches that pass the optional `filter` as `invalid: true`.
+   * - If `forcePending` is true, or a match is currently in `'error'` or `'notFound'` status,
+   *   its status is reset to `'pending'` and its `error` cleared so that the loader is re-run
+   *   on the next `load()` call (eg. after HMR or a manual invalidation).
+   */
+  invalidate: InvalidateFn<RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>>;
+  getParsedLocationHref: (location: ParsedLocation) => string;
+  resolveRedirect: (redirect: AnyRedirect) => AnyRedirect;
+  clearCache: ClearCacheFn<this>;
+  clearExpiredCache: () => void;
+  loadRouteChunk: typeof loadRouteChunk;
+  preloadRoute: PreloadRouteFn<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>;
+  matchRoute: MatchRouteFn<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>;
+  ssr?: {
+    manifest: Manifest | undefined;
+  };
+  serverSsr?: ServerSsr;
+  serverSsrLifecycle?: RouterSsrLifecycle;
+  hasNotFoundMatch: () => boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/global.d.ts
+declare global {
+  interface Window {
+    __TSR_ROUTER__?: AnyRouter;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/structuralSharing.d.ts
+interface OptionalStructuralSharing<TStructuralSharing, TConstraint> {
+  readonly structuralSharing?: Constrain<TStructuralSharing, TConstraint> | undefined;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/useRouteContext.d.ts
+interface UseRouteContextBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> {
+  select?: (search: ResolveUseRouteContext<TRouter, TFrom, TStrict>) => TSelected;
+}
+type ResolveUseRouteContext<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllContext<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allContext']>;
+type UseRouteContextResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseRouteContext<TRouter, TFrom, TStrict> : TSelected;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/useSearch.d.ts
+type UseSearchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseSearch<TRouter, TFrom, TStrict> : TSelected;
+type ResolveUseSearch<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? FullSearchSchema<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['fullSearchSchema']>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/useParams.d.ts
+type ResolveUseParams<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllParams<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allParams']>;
+type UseParamsResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseParams<TRouter, TFrom, TStrict> : TSelected;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/useNavigate.d.ts
+type UseNavigateResult<TDefaultFrom extends string> = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends string = TDefaultFrom, TMaskFrom extends string = TFrom, TMaskTo extends string = ''>({
+  from,
+  ...rest
+}: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/useLoaderDeps.d.ts
+type ResolveUseLoaderDeps<TRouter extends AnyRouter, TFrom> = Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderDeps']>;
+type UseLoaderDepsResult<TRouter extends AnyRouter, TFrom, TSelected> = unknown extends TSelected ? ResolveUseLoaderDeps<TRouter, TFrom> : TSelected;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.13/node_modules/@tanstack/router-core/dist/esm/useLoaderData.d.ts
+type ResolveUseLoaderData<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllLoaderData<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderData']>;
+type UseLoaderDataResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveUseLoaderData<TRouter, TFrom, TStrict> : TSelected;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/structuralSharing.d.ts
+type DefaultStructuralSharingEnabled<TRouter extends AnyRouter> = boolean extends TRouter['options']['defaultStructuralSharing'] ? false : NonNullable<TRouter['options']['defaultStructuralSharing']>;
+interface RequiredStructuralSharing<TStructuralSharing, TConstraint> {
+  readonly structuralSharing: Constrain<TStructuralSharing, TConstraint>;
+}
+type StructuralSharingOption<TRouter extends AnyRouter, TSelected, TStructuralSharing> = unknown extends TSelected ? OptionalStructuralSharing<TStructuralSharing, boolean> : unknown extends TRouter['routeTree'] ? OptionalStructuralSharing<TStructuralSharing, boolean> : TSelected extends ValidateJSON<TSelected> ? OptionalStructuralSharing<TStructuralSharing, boolean> : DefaultStructuralSharingEnabled<TRouter> extends true ? RequiredStructuralSharing<TStructuralSharing, false> : OptionalStructuralSharing<TStructuralSharing, false>;
+type StructuralSharingEnabled<TRouter extends AnyRouter, TStructuralSharing> = boolean extends TStructuralSharing ? DefaultStructuralSharingEnabled<TRouter> : TStructuralSharing;
+type ValidateSelected<TRouter extends AnyRouter, TSelected, TStructuralSharing> = StructuralSharingEnabled<TRouter, TStructuralSharing> extends true ? ValidateJSON<TSelected> : TSelected;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/useLoaderData.d.ts
+interface UseLoaderDataBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected, TStructuralSharing> {
+  select?: (match: ResolveUseLoaderData<TRouter, TFrom, TStrict>) => ValidateSelected<TRouter, TSelected, TStructuralSharing>;
+}
+type UseLoaderDataRoute<out TId> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown, TStructuralSharing extends boolean = boolean>(opts?: UseLoaderDataBaseOptions<TRouter, TId, true, TSelected, TStructuralSharing> & StructuralSharingOption<TRouter, TSelected, TStructuralSharing>) => UseLoaderDataResult<TRouter, TId, true, TSelected>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/useMatch.d.ts
+interface UseMatchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected, TStructuralSharing extends boolean> {
+  select?: (match: MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>) => ValidateSelected<TRouter, TSelected, TStructuralSharing>;
+  shouldThrow?: TThrow;
+}
+type UseMatchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown, TStructuralSharing extends boolean = boolean>(opts?: UseMatchBaseOptions<TRouter, TFrom, true, true, TSelected, TStructuralSharing> & StructuralSharingOption<TRouter, TSelected, TStructuralSharing>) => UseMatchResult<TRouter, TFrom, true, TSelected>;
+type UseMatchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? TStrict extends true ? MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict> : MakeRouteMatchUnion<TRouter> : TSelected;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/useLoaderDeps.d.ts
+interface UseLoaderDepsBaseOptions<TRouter extends AnyRouter, TFrom, TSelected, TStructuralSharing> {
+  select?: (deps: ResolveUseLoaderDeps<TRouter, TFrom>) => ValidateSelected<TRouter, TSelected, TStructuralSharing>;
+}
+type UseLoaderDepsRoute<out TId> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown, TStructuralSharing extends boolean = boolean>(opts?: UseLoaderDepsBaseOptions<TRouter, TId, TSelected, TStructuralSharing> & StructuralSharingOption<TRouter, TSelected, TStructuralSharing>) => UseLoaderDepsResult<TRouter, TId, TSelected>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/useParams.d.ts
+interface UseParamsBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected, TStructuralSharing> {
+  select?: (params: ResolveUseParams<TRouter, TFrom, TStrict>) => ValidateSelected<TRouter, TSelected, TStructuralSharing>;
+  shouldThrow?: TThrow;
+}
+type UseParamsRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown, TStructuralSharing extends boolean = boolean>(opts?: UseParamsBaseOptions<TRouter, TFrom, true, true, TSelected, TStructuralSharing> & StructuralSharingOption<TRouter, TSelected, TStructuralSharing>) => UseParamsResult<TRouter, TFrom, true, TSelected>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/useSearch.d.ts
+interface UseSearchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected, TStructuralSharing> {
+  select?: (state: ResolveUseSearch<TRouter, TFrom, TStrict>) => ValidateSelected<TRouter, TSelected, TStructuralSharing>;
+  shouldThrow?: TThrow;
+}
+type UseSearchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown, TStructuralSharing extends boolean = boolean>(opts?: UseSearchBaseOptions<TRouter, TFrom, true, true, TSelected, TStructuralSharing> & StructuralSharingOption<TRouter, TSelected, TStructuralSharing>) => UseSearchResult<TRouter, TFrom, true, TSelected>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/useRouteContext.d.ts
+type UseRouteContextRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseRouteContextBaseOptions<TRouter, TFrom, true, TSelected>) => UseRouteContextResult<TRouter, TFrom, true, TSelected>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/link.d.ts
+type UseLinkReactProps<TComp> = TComp extends keyof React$2.JSX.IntrinsicElements ? React$2.JSX.IntrinsicElements[TComp] : TComp extends React$2.ComponentType<any> ? React$2.ComponentPropsWithoutRef<TComp> & React$2.RefAttributes<React$2.ComponentRef<TComp>> : never;
+type ActiveLinkOptions<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & ActiveLinkOptionProps<TComp>;
+type ActiveLinkProps<TComp> = Partial<LinkComponentReactProps<TComp> & {
+  [key: `data-${string}`]: unknown;
+}>;
+interface ActiveLinkOptionProps<TComp = 'a'> {
+  /**
+   * A function that returns additional props for the `active` state of this link.
+   * These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)
+   */
+  activeProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
+  /**
+   * A function that returns additional props for the `inactive` state of this link.
+   * These props override other props passed to the link (`style`'s are merged, `className`'s are concatenated)
+   */
+  inactiveProps?: ActiveLinkProps<TComp> | (() => ActiveLinkProps<TComp>);
+}
+type LinkProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = ActiveLinkOptions<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & LinkPropsChildren;
+interface LinkPropsChildren {
+  children?: React$2.ReactNode | ((state: {
+    isActive: boolean;
+    isTransitioning: boolean;
+  }) => React$2.ReactNode);
+}
+type LinkComponentReactProps<TComp> = Omit<UseLinkReactProps<TComp>, keyof CreateLinkProps>;
+type LinkComponentProps<TComp = 'a', TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = '.', TMaskFrom extends string = TFrom, TMaskTo extends string = '.'> = LinkComponentReactProps<TComp> & LinkProps<TComp, TRouter, TFrom, TTo, TMaskFrom, TMaskTo>;
+type CreateLinkProps = LinkProps<any, any, string, string, string, string>;
+interface LinkComponentRoute<in out TDefaultFrom extends string = string> {
+  defaultFrom: TDefaultFrom;
+  <TRouter extends AnyRouter = RegisteredRouter, const TTo extends string | undefined = undefined, const TMaskTo extends string = ''>(props: LinkComponentProps<'a', TRouter, this['defaultFrom'], TTo, this['defaultFrom'], TMaskTo>): React$2.ReactElement;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/route.d.ts
+declare module '@tanstack/router-core' {
+  interface UpdatableRouteOptionsExtensions {
+    component?: RouteComponent;
+    errorComponent?: false | null | undefined | ErrorRouteComponent;
+    notFoundComponent?: NotFoundRouteComponent;
+    pendingComponent?: RouteComponent;
+  }
+  interface RootRouteOptionsExtensions {
+    shellComponent?: ({
+      children
+    }: {
+      children: React$1.ReactNode;
+    }) => React$1.ReactNode;
+  }
+  interface RouteExtensions<in out TId extends string, in out TFullPath extends string> {
+    useMatch: UseMatchRoute<TId>;
+    useRouteContext: UseRouteContextRoute<TId>;
+    useSearch: UseSearchRoute<TId>;
+    useParams: UseParamsRoute<TId>;
+    useLoaderDeps: UseLoaderDepsRoute<TId>;
+    useLoaderData: UseLoaderDataRoute<TId>;
+    useNavigate: () => UseNavigateResult<TFullPath>;
+    Link: LinkComponentRoute<TFullPath>;
+  }
+}
+/**
+ * Returns a route-specific API that exposes type-safe hooks pre-bound
+ * to a single route ID. Useful for consuming a route's APIs from files
+ * where the route object isn't directly imported (e.g. code-split files).
+ *
+ * @param id Route ID string literal for the target route.
+ * @returns A `RouteApi` instance bound to the given route ID.
+ * @link https://tanstack.com/router/latest/docs/framework/react/api/router/getRouteApiFunction
+ */
+interface DefaultRouteTypes<TProps> {
+  component: ((props: TProps) => any) | React$1.LazyExoticComponent<(props: TProps) => any>;
+}
+interface RouteTypes<TProps> extends DefaultRouteTypes<TProps> {}
+type AsyncRouteComponent<TProps> = RouteTypes<TProps>['component'] & {
+  preload?: () => Promise<void>;
+};
+type RouteComponent = AsyncRouteComponent<{}>;
+type ErrorRouteComponent = AsyncRouteComponent<ErrorComponentProps>;
+type NotFoundRouteComponent = RouteTypes<NotFoundRouteProps>['component'];
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/fileRoute.d.ts
+declare module '@tanstack/router-core' {
+  interface LazyRoute<in out TRoute extends AnyRoute> {
+    useMatch: UseMatchRoute<TRoute['id']>;
+    useRouteContext: UseRouteContextRoute<TRoute['id']>;
+    useSearch: UseSearchRoute<TRoute['id']>;
+    useParams: UseParamsRoute<TRoute['id']>;
+    useLoaderDeps: UseLoaderDepsRoute<TRoute['id']>;
+    useLoaderData: UseLoaderDataRoute<TRoute['id']>;
+    useNavigate: () => UseNavigateResult<TRoute['fullPath']>;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/history.d.ts
+declare module '@tanstack/history' {
+  interface HistoryState {
+    __tempLocation?: HistoryLocation;
+    __tempKey?: string;
+    __hashScrollIntoViewOptions?: boolean | ScrollIntoViewOptions;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/Matches.d.ts
+declare module '@tanstack/router-core' {
+  interface RouteMatchExtensions {
+    meta?: Array<React$2.JSX.IntrinsicElements['meta'] | undefined>;
+    links?: Array<React$2.JSX.IntrinsicElements['link'] | undefined>;
+    scripts?: Array<React$2.JSX.IntrinsicElements['script'] | undefined>;
+    styles?: Array<React$2.JSX.IntrinsicElements['style'] | undefined>;
+    headScripts?: Array<React$2.JSX.IntrinsicElements['script'] | undefined>;
+  }
+}
+/**
+ * Internal component that renders the router's active match tree with
+ * suspense, error, and not-found boundaries. Rendered by `RouterProvider`.
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/router.d.ts
+declare module '@tanstack/router-core' {
+  interface RouterOptionsExtensions {
+    /**
+     * The default `component` a route should use if no component is provided.
+     *
+     * @default Outlet
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultcomponent-property)
+     */
+    defaultComponent?: RouteComponent;
+    /**
+     * The default `errorComponent` a route should use if no error component is provided.
+     *
+     * @default ErrorComponent
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaulterrorcomponent-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionserrorcomponent)
+     */
+    defaultErrorComponent?: ErrorRouteComponent;
+    /**
+     * The default `pendingComponent` a route should use if no pending component is provided.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultpendingcomponent-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#showing-a-pending-component)
+     */
+    defaultPendingComponent?: RouteComponent;
+    /**
+     * The default `notFoundComponent` a route should use if no notFound component is provided.
+     *
+     * @default NotFound
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultnotfoundcomponent-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/not-found-errors#default-router-wide-not-found-handling)
+     */
+    defaultNotFoundComponent?: NotFoundRouteComponent;
+    /**
+     * A component that will be used to wrap the entire router.
+     *
+     * This is useful for providing a context to the entire router.
+     *
+     * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#wrap-property)
+     */
+    Wrap?: (props: {
+      children: any;
+    }) => React.JSX.Element;
+    /**
+     * A component that will be used to wrap the inner contents of the router.
+     *
+     * This is useful for providing a context to the inner contents of the router where you also need access to the router context and hooks.
+     *
+     * Only non-DOM-rendering components like providers should be used, anything else will cause a hydration error.
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#innerwrap-property)
+     */
+    InnerWrap?: (props: {
+      children: any;
+    }) => React.JSX.Element;
+    /**
+     * The default `onCatch` handler for errors caught by the Router ErrorBoundary
+     *
+     * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/RouterOptionsType#defaultoncatch-property)
+     * @link [Guide](https://tanstack.com/router/latest/docs/framework/react/guide/data-loading#handling-errors-with-routeoptionsoncatch)
+     */
+    defaultOnCatch?: (error: Error, errorInfo: React.ErrorInfo) => void;
+  }
+}
+/**
+ * Creates a new Router instance for React.
+ *
+ * Pass the returned router to `RouterProvider` to enable routing.
+ * Notable options: `routeTree` (your route definitions) and `context`
+ * (required if the root route was created with `createRootRouteWithContext`).
+ *
+ * @param options Router options used to configure the router.
+ * @returns A Router instance to be provided to `RouterProvider`.
+ * @link https://tanstack.com/router/latest/docs/framework/react/api/router/createRouterFunction
+ */
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+react-router@1.170.15_react-dom@19.2.7_react@19.2.7__react@19.2.7/node_modules/@tanstack/react-router/dist/esm/ssr/serializer.d.ts
+declare module '@tanstack/router-core' {
+  interface SerializerExtensions {
+    ReadableStream: React$2.JSX.Element;
+  }
+}
+//#endregion
+//#region src/loaders.d.ts
+/**
+ * Wrap a TanStack route loader with OpenTelemetry tracing
+ *
+ * This function wraps a loader function to automatically create spans
+ * for each invocation. It captures route ID, params (optionally),
+ * and errors.
+ *
+ * The generic type TLoaderFn preserves the full TanStack Router type inference,
+ * including typed params, context, and return types.
+ *
+ * @param loaderFn - The loader function to wrap
+ * @param config - Configuration options
+ * @returns Wrapped loader function with tracing (preserves original types)
+ *
+ * @example
+ * ```typescript
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { traceLoader } from 'autotel-tanstack/loaders';
+ *
+ * export const Route = createFileRoute('/users/$userId')({
+ *   // Types are fully preserved - params.userId is typed as string
+ *   loader: traceLoader(async ({ params }) => {
+ *     return await db.users.findUnique({ where: { id: params.userId } });
+ *   }),
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Sync loaders are also supported
+ * export const Route = createFileRoute('/static')({
+ *   loader: traceLoader(({ context }) => ({
+ *     message: `Welcome, ${context.userId}!`,
+ *   })),
+ * });
+ * ```
+ */
+declare function traceLoader<TLoaderFn extends (ctx: any) => any>(loaderFn: TLoaderFn, config?: TraceLoaderConfig): TLoaderFn;
+/**
+ * Wrap a TanStack route beforeLoad function with OpenTelemetry tracing
+ *
+ * This function wraps a beforeLoad function to automatically create spans.
+ * beforeLoad runs before the route component renders and is typically
+ * used for auth checks, redirects, or data prefetching.
+ *
+ * The generic type TBeforeLoadFn preserves the full TanStack Router type inference,
+ * including typed params, context, search, and return types.
+ *
+ * @param beforeLoadFn - The beforeLoad function to wrap
+ * @param config - Configuration options
+ * @returns Wrapped beforeLoad function with tracing (preserves original types)
+ *
+ * @example
+ * ```typescript
+ * import { createFileRoute, redirect } from '@tanstack/react-router';
+ * import { traceBeforeLoad } from 'autotel-tanstack/loaders';
+ *
+ * export const Route = createFileRoute('/dashboard')({
+ *   // Types are fully preserved - context, params, search are all typed
+ *   beforeLoad: traceBeforeLoad(async ({ context, params }) => {
+ *     if (!context.auth.isAuthenticated) {
+ *       throw redirect({ to: '/login' });
+ *     }
+ *     return { userId: params.userId }; // Return type flows to loader context
+ *   }),
+ *   loader: ({ context }) => {
+ *     // context.userId is typed from beforeLoad return
+ *     return { user: context.userId };
+ *   },
+ * });
+ * ```
+ */
+declare function traceBeforeLoad<TBeforeLoadFn extends (opts: any) => any>(beforeLoadFn: TBeforeLoadFn, config?: TraceLoaderConfig): TBeforeLoadFn;
+/**
+ * Create a traced route configuration helper
+ *
+ * This higher-order function helps create route configurations
+ * with automatic tracing for both loader and beforeLoad.
+ *
+ * @param routeId - The route identifier
+ * @param config - Tracing configuration
+ * @returns Object with traced loader and beforeLoad wrappers
+ *
+ * @example
+ * ```typescript
+ * import { createFileRoute } from '@tanstack/react-router';
+ * import { createTracedRoute } from 'autotel-tanstack/loaders';
+ *
+ * const traced = createTracedRoute('/users/$userId');
+ *
+ * export const Route = createFileRoute('/users/$userId')({
+ *   beforeLoad: traced.beforeLoad(async ({ context }) => {
+ *     // Auth check
+ *   }),
+ *   loader: traced.loader(async ({ params }) => {
+ *     return await getUser(params.userId);
+ *   }),
+ * });
+ * ```
+ */
+declare function createTracedRoute(routeId: string, config?: Omit<TraceLoaderConfig, 'name'>): {
+  /**
+   * Wrap a loader function with tracing
+   */
+  loader<TLoaderFn extends (ctx: any) => any>(loaderFn: TLoaderFn): TLoaderFn;
+  /**
+   * Wrap a beforeLoad function with tracing
+   */
+  beforeLoad<TBeforeLoadFn extends (opts: any) => any>(beforeLoadFn: TBeforeLoadFn): TBeforeLoadFn;
+};
+//#endregion
+export { LoaderFnContext as i, traceBeforeLoad as n, traceLoader as r, createTracedRoute as t };
+//# sourceMappingURL=loaders-DrVVY25K.d.ts.map