camox 0.33.0 → 0.34.0

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

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

@@ -0,0 +1,48 @@
+import { InferFileRouteTypes } from "./fileRoute.js";
+import { PartialMergeAll } from "./utils.js";
+import { AddTrailingSlash, RemoveTrailingSlashes } from "./link.js";
+import { AnyRoute } from "./route.js";
+import { AnyRouter, TrailingSlashOption } from "./router.js";
+
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.168.14/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 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;
+//#endregion
+export { AllParams, CatchAllPaths, CodeRouteToPath, CurrentPath, FullSearchSchema, FullSearchSchemaInput, ParentPath, ParseRoute, RouteById, RouteByPath, RouteByToPath, RoutePaths, RouteToPath, RoutesById, RoutesByPath, ToPath, TrailingSlashOptionByRouter };