@powerhousedao/connect-core 6.2.3-dev.70 → 6.2.3-dev.71

package/dist/index-PjlUqG36.d.ts

@@ -0,0 +1,2023 @@
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/node_modules/@tanstack/router-core/dist/esm/sieve-cache.d.ts
+type SieveCache<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.34/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.34/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+history@1.162.4/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;
+  action: SubscriberHistoryAction;
+};
+interface RouterHistory {
+  location: HistoryLocation;
+  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;
+  _getBlockers: () => Array<NavigationBlocker>;
+  _ignoreSubscribers?: boolean;
+  _ignoreNextBeforeUnload?: (href: string) => void;
+}
+interface HistoryLocation 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;
+  nextLocation: HistoryLocation;
+  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.34/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 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;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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.34/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']>>;
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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.34/node_modules/@tanstack/router-core/dist/esm/not-found.d.ts
+type NotFoundError = {
+  /**
+      @deprecated
+      Use `routeId: rootRouteId` instead
+    */
+  global?: boolean;
+  /**
+      @private
+      Do not use this. It's used internally to indicate a path matching error
+    */
+  _global?: boolean;
+  data?: any;
+  throw?: boolean;
+  routeId?: RouteIds<RegisteredRouter['routeTree']>;
+  headers?: HeadersInit;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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>;
+};
+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.34/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' | 'notFound';
+  isFetching: false | 'beforeLoad' | 'loader';
+  error: unknown;
+  paramsError: unknown;
+  searchError: unknown;
+  updatedAt: number;
+  loaderData?: TLoaderData;
+  context: TAllContext;
+  search: TFullSearchSchema;
+  _strictSearch: TFullSearchSchema;
+  abortController: AbortController;
+  cause: 'preload' | 'enter' | 'stay';
+  loaderDeps: TLoaderDeps;
+  preload: boolean;
+  invalid: boolean;
+  headers?: Record<string, string>;
+  _notFound?: boolean;
+  staticData: StaticDataRouteOption;
+  /** This attribute is not reactive */
+  ssr?: SSROption;
+}
+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.34/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.34/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.34/node_modules/@tanstack/router-core/dist/esm/ssr/serializer/RawStream.d.ts
+type RawStreamHint = 'binary' | 'text';
+interface RawStreamOptions {
+  /**
+   * Encoding hint for JSON and 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/text encoding (JSON and SSR) or binary framing
+ * (server-function responses).
+ *
+ * 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' }) }
+ * ```
+ *
+ * RawStreams returned from one server function share one ordered response.
+ * Arbitrary or sequential consumption can require potentially unbounded client
+ * buffering for unread data. Cancelling one RawStream discards it locally;
+ * abort the whole server-function call to cancel the response and server work.
+ * Consume streams concurrently, cancel unused streams promptly, or use separate
+ * calls when independent backpressure is required.
+ */
+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.34/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.34/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<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: (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: ErrorBoundaryTypes['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;
+};
+interface DefaultErrorBoundaryTypes {
+  error: unknown;
+}
+/** Frameworks can specialize the error exposed by boundary components and callbacks. */
+interface ErrorBoundaryTypes extends DefaultErrorBoundaryTypes {}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/node_modules/@tanstack/router-core/dist/esm/path.d.ts
+type InterpolationSegment = string | DynamicPathSegment;
+type RouteInterpolation = Array<InterpolationSegment> & {
+  names?: Array<string>;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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 DynamicPathSegment = [kind: Exclude<SegmentKind, typeof SEGMENT_TYPE_PATHNAME>, key: string, prefix: string,
+/** Undefined marks a bare splat, which discards the remaining template. */
+suffix: string | undefined];
+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;
+  prefix?: string;
+  suffix?: string;
+  caseSensitive?: boolean;
+  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;
+  /** Original template data for this candidate or parse gate. */
+  data: RouteInterpolation | undefined;
+  parent: AnySegmentNode<T> | undefined;
+  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 = {
+  _interpolation?: RouteInterpolation;
+  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: SieveCache<string, AnySegmentNode<TSingle>>;
+  /** a cache of route matches from the `segmentTree` */
+  matchCache: SieveCache<string, RouteMatch<TTree> | null>;
+  /** a cache of route matches from the `masksTree` */
+  flatCache: SieveCache<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.34/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.34/node_modules/@tanstack/router-core/dist/esm/ssr/constants.d.ts
+declare const GLOBAL_TSR = "$_TSR";
+declare const GLOBAL_SEROVAL: '$R';
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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.34/node_modules/@tanstack/router-core/dist/esm/ssr/types.d.ts
+interface DehydratedMatch {
+  i: MakeRouteMatch['id'];
+  l?: MakeRouteMatch['loaderData'];
+  e?: MakeRouteMatch['error'];
+  u: MakeRouteMatch['updatedAt'];
+  s: MakeRouteMatch['status'];
+  ssr?: MakeRouteMatch['ssr'];
+  g?: true;
+}
+interface DehydratedRouter {
+  manifest: Manifest | undefined;
+  dehydratedData?: any;
+  matches: Array<DehydratedMatch>;
+}
+interface TsrSsrGlobal {
+  router?: DehydratedRouter;
+  h: () => void;
+  e: () => void;
+  c: () => void;
+  p: (script: () => void) => void;
+  buffer: Array<() => void>;
+  t?: Map<string, (value: any) => any>;
+  initialized?: boolean;
+  hydrated?: boolean;
+  streamEnded?: boolean;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/node_modules/@tanstack/router-core/dist/esm/load-client.d.ts
+declare const SUCCESS = 0;
+declare const ERROR = 1;
+declare const NOT_FOUND = 2;
+declare const REDIRECTED = 3;
+declare const CANCELED = 4;
+type NonRedirectOutcome = [kind: typeof SUCCESS, data: unknown] | [kind: typeof ERROR, error: unknown] | [kind: typeof NOT_FOUND, error: NotFoundError] | [kind: typeof CANCELED];
+type RawLoaderOutcome = NonRedirectOutcome | [kind: typeof REDIRECTED, redirect: AnyRedirect];
+type LoaderFlight = [outcome: Promise<RawLoaderOutcome>, controller: AbortController, leases: number];
+type LoadTransaction = [controller: AbortController, redirects: number, location: ParsedLocation, matches: Array<AnyRouteMatch>, startedAt: number, done: Promise<void>,
+/**
+ * Dev-only HMR refresh mode. Presence forces successor rematerialization
+ * until this publication is acknowledged. The optional hydration handoff is
+ * retired when the refresh publishes.
+ */
+refresh?: [handoff: NonNullable<AnyRouter['_handoff']> | undefined]];
+type PendingSession = [generation: LoadTransaction, boundaryId: string,
+/** Pending reveal time until acknowledged, then minimum-visible-until time. */
+deadline: number, revealTimer?: ReturnType<typeof setTimeout>, ack?: Promise<boolean> | true, component?: unknown];
+declare global {
+  interface Window {
+    [GLOBAL_TSR]?: TsrSsrGlobal;
+    [GLOBAL_SEROVAL]?: any;
+  }
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/node_modules/@tanstack/router-core/dist/esm/load-server.d.ts
+type ServerLoadResult = {
+  type: 'render';
+  status: 200 | 404 | 500;
+  matches: Array<AnyRouteMatch>;
+} | {
+  type: 'redirect';
+  redirect: AnyRedirect;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/node_modules/@tanstack/router-core/dist/esm/ssr/hydrationScripts.d.ts
+/** The one-time initial `<Scripts>` take: hydration tags plus the boundary. */
+type InitialHydrationScriptTags = {
+  before: Array<RouterManagedTag>;
+  boundary: RouterManagedTag;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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;
+};
+type MatchStore = RouterWritableStore<AnyRouteMatch | undefined>;
+type ReadableStore<TValue> = RouterReadableStore<TValue>;
+interface RouterStores<in out TRouteTree extends AnyRoute> {
+  status: RouterWritableStore<RouterState<TRouteTree>['status']>;
+  location: RouterWritableStore<ParsedLocation<FullSearchSchema<TRouteTree>>>;
+  resolvedLocation: RouterWritableStore<ParsedLocation<FullSearchSchema<TRouteTree>> | undefined>;
+  ids: RouterWritableStore<Array<string>>;
+  matches: ReadableStore<Array<AnyRouteMatch>>;
+  __store: RouterReadableStore<RouterState<TRouteTree>>;
+  byRoute: Map<string, MatchStore>;
+  /**
+   * Get the stable atom for a route's presented match. The atom remains in the
+   * pool when the route leaves and contains `undefined` until it re-enters.
+   */
+  getMatchStore: (routeId: string) => RouterReadableStore<AnyRouteMatch | undefined>;
+  setMatches: (nextMatches: Array<AnyRouteMatch>) => void;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/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 before intent focus/hover and viewport preloading.
+   * Touch intent preloads immediately.
+   *
+   * @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 `preloadGcTime` a route should use if none is provided.
+   *
+   * @default 300_000 `(5 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 300_000 `(5 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.
+   * This is read only during initialization. Create a new router to change it.
+   *
+   * @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)
+   */
+  readonly pathParamsAllowedCharacters?: ReadonlyArray<';' | ':' | '@' | '&' | '=' | '+' | '$' | ','>;
+  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;
+  /**
+   * The origin used to resolve URLs. Pass a normalized origin, such as
+   * `https://example.com` or `http://localhost:3000`, without a path or trailing slash.
+   * Defaults to the browser origin, or `http://localhost` on the server.
+   */
+  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';
+  isLoading: boolean;
+  matches: Array<TRouteMatch>;
+  location: ParsedLocation<FullSearchSchema<TRouteTree>>;
+  resolvedLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>;
+}
+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 {
+  throwOnError?: boolean;
+}
+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, TDehydrated extends Record<string, any> = Record<string, any>> = <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, TDehydrated>, 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: Omit<RouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>, 'pathParamsAllowedCharacters'>) => 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, previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>) => ParsedLocation<FullSearchSchema<TRouteTree>>;
+type GetMatchRoutesFn = (pathname: string) => [matchedRoutes: ReadonlyArray<AnyRoute>,
+/** exhaustive params, still in their string form */
+rawParams: Record<string, string>, foundRoute: AnyRoute | undefined];
+type EmitFn = (routerEvent: RouterEvent) => void;
+type LoadFn = (opts?: {
+  sync?: boolean;
+  action?: {
+    type: HistoryAction;
+  };
+  _signal?: AbortSignal;
+}) => Promise<void>;
+type CommitLocationFn = ({ viewTransition, ignoreBlocker, ...next }: ParsedLocation & CommitLocationOptions) => Promise<void>;
+type StartTransitionFn = (fn: () => void, expected: Array<AnyRouteMatch>) => Promise<boolean>;
+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 ClearCacheFn<TRouter extends AnyRouter> = (opts?: {
+  filter?: (d: MakeRouteMatchUnion<TRouter>) => boolean;
+}) => void;
+/**
+ * Server-side SSR request contract.
+ *
+ * Tiering rule: the flat methods are the adapter/framework contract;
+ * `hydrationScripts` is transport for the core SSR stream merger only.
+ * New members must land on the matching tier.
+ */
+interface ServerSsr {
+  /** 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).
+   *
+   * `settled` is true when every value the router dehydrated has settled, so
+   * no loader work can still be pending. It is false when the response ended
+   * early (abort, cancellation, timeout) or never consumed the loader data.
+   *
+   * Listeners run synchronously and exactly once. Errors are caught and logged.
+   * A listener registered after cleanup already ran is invoked immediately.
+   */
+  onCleanup: (listener: (settled: boolean) => void) => void;
+  /** Framework-only. */
+  dehydrate: (opts?: {
+    requestAssets?: ManifestRouteAssets;
+    signal?: AbortSignal;
+  }) => Promise<void>;
+  /**
+   * Framework-only: opt this request out of hydration output entirely (for
+   * example a `hydrate: false` page). Call instead of `dehydrate()`, before
+   * rendering starts. No hydration scripts are emitted, `<Scripts>` renders
+   * no boundary, and the response takes the pass-through stream path.
+   */
+  disableHydration: () => void;
+  /** Framework-only. */
+  takeInitialHydrationScriptTags: () => InitialHydrationScriptTags | undefined;
+}
+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];
+/** Indexes and caches rebuilt together when the route tree changes. */
+type RouteTreeCaches<TRouteTree extends AnyRoute> = ProcessRouteTreeResult<TRouteTree> & {
+  resolvePathCache: SieveCache<string, string>;
+};
+declare global {
+  var __TSR_CACHE__: {
+    routeTree: AnyRoute;
+    caseSensitive: boolean | undefined;
+    processRouteTreeResult: RouteTreeCaches<AnyRoute>;
+  } | undefined;
+}
+interface 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>> {
+  shouldViewTransition?: boolean | ViewTransitionOptions;
+  /**
+   * Foreground lifecycle boundary survives invalidation/background statuses.
+   * Zero or undefined means the whole branch participates.
+   */
+  _lifecycleEnd?: number;
+  /** Current client load transaction and owner of navigation writes. */
+  _tx?: LoadTransaction;
+  /** Joinable in-flight loader generations keyed by match ID. */
+  _flights?: Map<string, LoaderFlight>;
+  /** Active speculative lanes retained for cancellation, invalidation, and cache clearing. */
+  _preloads?: Map<AbortController, Array<AnyRouteMatch>>;
+  /** Owns cancellable work before a client transaction publishes. */
+  _preflight?: AbortController;
+  /** Transfers one reconstructed SSR prefix into its initial client load. */
+  _handoff?: HydrationHandoff;
+  /** Pending-boundary reveal and minimum-visible timing state. */
+  _pending?: PendingSession;
+  /** Result of the latest server load, used to render or redirect. */
+  _serverResult?: ServerLoadResult;
+  /** Framework publication waiting for an exact render acknowledgement. */
+  _rendered?: [offered?: Array<AnyRouteMatch>, settle?: (rendered: boolean) => void];
+  /** Development-only HMR reload for a route and its descendants. */
+  _refreshRoute: (() => Promise<void>) | undefined;
+  /** Development-only replacement for a route's lazy chunk owner. */
+  _replaceRouteChunk: ((route: AnyRoute, lazyFn: AnyRoute['lazyFn']) => void) | undefined;
+}
+type HydrationHandoff = [claim: () => AbortController | undefined, finish: (matches?: Array<AnyRouteMatch>) => number | 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: {
+    n: boolean;
+    h?: boolean;
+    e?: boolean;
+    s?: boolean;
+    r?: boolean;
+  };
+  subscribers: Set<RouterListener<RouterEvent>>;
+  /** Accepted off-screen loader generations keyed by match ID. */
+  _cache: Map<string, AnyRouteMatch>;
+  /** Accepted semantic lane, excluding temporary pending presentation. */
+  _committed: Array<AnyRouteMatch>;
+  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>>;
+  _pendingLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>;
+  basepath: string;
+  routeTree: TRouteTree;
+  routesById: RoutesById<TRouteTree>;
+  routesByPath: RoutesByPath<TRouteTree>;
+  processedTree: ProcessedTree<TRouteTree, any, any>;
+  resolvePathCache: SieveCache<string, string>;
+  private lightweightCache;
+  private staticLocations;
+  isServer: boolean;
+  readonly 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;
+  update: UpdateFn<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>;
+  get state(): RouterState<TRouteTree>;
+  updateLatestLocation: () => void;
+  buildRouteTree: () => RouteTreeCaches<TRouteTree>;
+  setRoutes(caches: RouteTreeCaches<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>;
+  matchRoutes: MatchRoutesFn;
+  private matchRoutesInternal;
+  getMatchedRoutes: GetMatchRoutesFn;
+  /**
+   * Lightweight route matching for buildLocation.
+   * Only computes fullPath, accumulated search, and params - skipping expensive
+   * operations like AbortController, loaderDeps, and full match objects.
+   */
+  private matchRoutesLightweight;
+  /**
+   * Build the next ParsedLocation from navigation options without committing.
+   * Resolves `to`/`from`, params/search/hash/state, applies search validation
+   * and middlewares, and returns a stringified location object. The built
+   * `search` and `state` are not structurally shared with the current
+   * location; `parseLocation` stabilizes them once the location is committed.
+   *
+   * @link https://tanstack.com/router/latest/docs/framework/react/api/router/RouterType#buildlocation-method
+   */
+  buildLocation: BuildLocationFn;
+  _commitPromise: (Promise<void> & {
+    resolve: () => void;
+  }) | undefined;
+  /**
+   * 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, ...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;
+  load: LoadFn;
+  startViewTransition: (fn: () => Promise<void>) => any;
+  /**
+   * Invalidate selected match generations and optionally force current matches
+   * back into a pending state.
+   *
+   * - Marks committed and cached matches whose IDs are selected as invalid.
+   * - Retires selected active preloads so older work cannot publish fresh data.
+   *
+   * The next load decides when to publish pending UI, so invalidation does not
+   * mutate the currently rendered status.
+   */
+  invalidate: InvalidateFn<RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>>;
+  resolveRedirect: (redirect: AnyRedirect) => AnyRedirect;
+  clearCache: ClearCacheFn<this>;
+  loadRouteChunk: (route: AnyRoute, componentType?: 'errorComponent' | 'notFoundComponent' | false) => Promise<void> | undefined;
+  preloadRoute: PreloadRouteFn<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>;
+  matchRoute: MatchRouteFn<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory>;
+  ssr?: {
+    manifest: Manifest | undefined;
+  };
+  serverSsr?: ServerSsr;
+  serverSsrLifecycle?: RouterSsrLifecycle;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+router-core@1.171.34/node_modules/@tanstack/router-core/dist/esm/global.d.ts
+declare global {
+  interface Window {
+    __TSR_ROUTER__?: AnyRouter;
+  }
+}
+//#endregion
+export { ResolveParams as n, Route as r, AnyContext as t };
+export {};
+//# sourceMappingURL=index-PjlUqG36.d.ts.map