camox 0.33.1 → 0.34.0

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/location.d.ts

@@ -0,0 +1,54 @@
+import { AnySchema } from "./validators.js";
+import { ParsedHistoryState } from "@tanstack/history";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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
+export { ParsedLocation };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/lru-cache.d.ts

@@ -0,0 +1,8 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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
+export { LRUCache };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/manifest.d.ts

@@ -0,0 +1,32 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/manifest.d.ts
+type AssetCrossOrigin = 'anonymous' | 'use-credentials';
+type ManifestAssetLink = string | {
+  href: string;
+  crossOrigin?: AssetCrossOrigin;
+};
+type Manifest = {
+  routes: Record<string, {
+    filePath?: string;
+    preloads?: Array<ManifestAssetLink>;
+    assets?: Array<RouterManagedTag>;
+  }>;
+};
+type RouterManagedTag = {
+  tag: 'title';
+  attrs?: Record<string, any>;
+  children: string;
+} | {
+  tag: 'meta' | 'link';
+  attrs?: Record<string, any>;
+  children?: never;
+} | {
+  tag: 'script';
+  attrs?: Record<string, any>;
+  children?: string;
+} | {
+  tag: 'style';
+  attrs?: Record<string, any>;
+  children?: string;
+};
+//#endregion
+export { AssetCrossOrigin, Manifest, ManifestAssetLink, RouterManagedTag };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/new-process-route-tree.d.ts

@@ -0,0 +1,115 @@
+import { LRUCache } from "./lru-cache.js";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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>) => any); /** options.skipRouteOnParseError.params ?? false */
+  skipOnParamError: boolean; /** options.skipRouteOnParseError.priority ?? 0 */
+  parsingPriority: number;
+};
+type RouteLike = {
+  id?: string;
+  path?: string;
+  children?: Array<RouteLike>;
+  parentRoute?: RouteLike;
+  isRoot?: boolean;
+  options?: {
+    skipRouteOnParseError?: {
+      params?: boolean;
+      priority?: number;
+    };
+    caseSensitive?: boolean;
+    params?: {
+      parse?: (params: Record<string, string>) => any;
+    };
+  };
+} & ({
+  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>;
+  parsedParams?: Record<string, unknown>;
+  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>;
+  /**
+   * The accumlulated parsed params of each route in the branch that had `skipRouteOnParseError` enabled.
+   * Will not contain all params defined in the route's path. Those w/ a `params.parse` but no `skipRouteOnParseError` will need to be parsed separately.
+   */
+  parsedParams?: Record<string, unknown>;
+} | null;
+//#endregion
+export { ProcessRouteTreeResult, ProcessedTree };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/not-found.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/redirect.d.ts

@@ -0,0 +1,49 @@
+import { NavigateOptions } from "./link.js";
+import { AnyRouter, RegisteredRouter } from "./router.js";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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
+export { AnyRedirect, Redirect, RedirectFnRoute, RedirectOptions, RedirectOptionsRoute };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/rewrite.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/root.d.ts

@@ -0,0 +1,6 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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
+export { RootRouteId, rootRouteId };

package/dist/node_modules/.pnpm/@tanstack_router-core@1.168.14/node_modules/@tanstack/router-core/dist/esm/route.d.ts

@@ -0,0 +1,343 @@
+import { LazyRoute } from "./fileRoute.js";
+import { Assign, Awaitable, Constrain, Expand, IntersectAssign, LooseAsyncReturnType, LooseReturnType, NoInfer } from "./utils.js";
+import { NavigateOptions, ParsePathParams } from "./link.js";
+import { ParseRoute, RoutePaths } from "./routeInfo.js";
+import { RedirectFnRoute } from "./redirect.js";
+import { AnyRouteMatch, MakePreValidationErrorHandlingRouteMatchUnion, MakeRouteMatchFromRoute, MakeRouteMatchUnion, RouteMatch } from "./Matches.js";
+import { RootRouteId } from "./root.js";
+import { BuildLocationFn, NavigateFn } from "./RouterProvider.js";
+import { ValidateSerializableLifecycleResult } from "./ssr/serializer/transformer.js";
+import { AnyValidator, DefaultValidator, ResolveSearchValidatorInput, ResolveValidatorOutput } from "./validators.js";
+import { ParsedLocation } from "./location.js";
+import { AnyRouter, RegisteredRouter, SSROption } from "./router.js";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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 SearchMiddlewareContext<TSearchSchema> = {
+  search: TSearchSchema;
+  next: (newSearch: TSearchSchema) => TSearchSchema;
+};
+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 extends ResolveParams<TPath, any> ? TParams : ResolveParams<TPath, any>;
+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>;
+    stringify?: StringifyParamsFn<TPath, TParams>;
+  };
+  /**
+  @deprecated Use params.parse instead
+  */
+  parseParams?: ParseParamsFn<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<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<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<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>>;
+  match: RouteMatch<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 {
+  /**
+   * Options to control route matching behavior with runtime code.
+   *
+   * @experimental 🚧 this feature is subject to change
+   *
+   * @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouteOptionsType
+   */
+  skipRouteOnParseError?: {
+    /**
+     * If `true`, skip this route during matching if `params.parse` fails.
+     *
+     * Without this option, a `/$param` route could match *any* value for `param`,
+     * and only later during the route lifecycle would `params.parse` run and potentially
+     * show the `errorComponent` if validation failed.
+     *
+     * With this option enabled, the route will only match if `params.parse` succeeds.
+     * If it fails, the router will continue trying to match other routes, potentially
+     * finding a different route that works, or ultimately showing the `notFoundComponent`.
+     *
+     * @default false
+     */
+    params?: boolean;
+    /**
+     * In cases where multiple routes would need to run `params.parse` during matching
+     * to determine which route to pick, this priority number can be used as a tie-breaker
+     * for which route to try first. Higher number = higher priority.
+     *
+     * @default 0
+     */
+    priority?: number;
+  };
+  /**
+   * 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<ResolveFullSearchSchemaInput<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<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
+  onStay?: (match: RouteMatch<TRouteId, TFullPath, ResolveAllParamsFromParent<TParentRoute, TParams>, ResolveFullSearchSchema<TParentRoute, TSearchValidator>, ResolveLoaderData<TLoaderFn>, ResolveAllContext<TParentRoute, TRouterContext, TRouteContextFn, TBeforeLoadFn>, TLoaderDeps>) => void;
+  onLeave?: (match: RouteMatch<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;
+};
+//#endregion
+export { AnyContext, AnyPathParams, AnyRoute, BaseRouteOptions, BeforeLoadContextOptions, BeforeLoadContextParameter, ContextAsyncReturnType, ContextOptions, ContextReturnType, FileBaseRouteOptions, FilebaseRouteOptionsInterface, FullSearchSchemaOption, InferAllContext, InferAllParams, InferFullSearchSchema, InferFullSearchSchemaInput, LoaderFnContext, LoaderStaleReloadMode, MakeRemountDepsOptionsUnion, ParamsOptions, ParseParamsFn, RemountDepsOptions, ResolveAllContext, ResolveAllParamsFromParent, ResolveAllSSR, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, ResolveLoaderData, ResolveOptionalParams, ResolveParams, ResolveRequiredParams, ResolveRouteContext, Route, RouteAddChildrenFn, RouteAddFileChildrenFn, RouteAddFileTypesFn, RouteContextOptions, RouteContextParameter, RouteExtensions, RouteLazyFn, RouteLoaderFn, RouteMask, RouteOptions, RoutePathOptions, RouteTypes, SearchFilter, SearchMiddleware, SearchMiddlewareContext, SearchSchemaInput, StaticDataRouteOption, StringifyParamsFn, TrimPathRight, UpdatableRouteOptions, UpdatableRouteOptionsExtensions, UpdatableStaticRouteOption };