@benjavicente/angular-router-experimental 1.142.11

package/dist/types/tanstack-angular-router-experimental.d.ts

@@ -0,0 +1,733 @@
+import * as Angular from '@angular/core';
+import { AnyContext } from '@benjavicente/router-core';
+import { AnyRoute } from '@benjavicente/router-core';
+import { AnyRouteMatch } from '@benjavicente/router-core';
+import { AnyRouter } from '@benjavicente/router-core';
+import { BaseRootRoute } from '@benjavicente/router-core';
+import { BaseRoute } from '@benjavicente/router-core';
+import { BaseRouteApi } from '@benjavicente/router-core';
+import { BlockerFn } from '@benjavicente/history';
+import { ConstrainLiteral } from '@benjavicente/router-core';
+import { createBrowserHistory } from '@benjavicente/history';
+import { CreateFileRoute } from '@benjavicente/router-core';
+import { createHashHistory } from '@benjavicente/history';
+import { createHistory } from '@benjavicente/history';
+import { CreateLazyFileRoute } from '@benjavicente/router-core';
+import { createMemoryHistory } from '@benjavicente/history';
+import { createRouterConfig } from '@benjavicente/router-core';
+import { CreateSignalOptions } from '@angular/core';
+import { DeepPartial } from '@benjavicente/router-core';
+import { EffectRef } from '@angular/core';
+import { EnvironmentInjector } from '@angular/core';
+import { Expand } from '@benjavicente/router-core';
+import { FileBaseRouteOptions } from '@benjavicente/router-core';
+import { FileRoutesByPath } from '@benjavicente/router-core';
+import { FromPathOption } from '@benjavicente/router-core';
+import { FullSearchSchema } from '@benjavicente/router-core';
+import { HistoryAction } from '@benjavicente/history';
+import { HistoryLocation } from '@benjavicente/history';
+import { HistoryState } from '@benjavicente/history';
+import { InjectionToken } from '@angular/core';
+import { InputSignal } from '@angular/core';
+import { isRedirect } from '@benjavicente/router-core';
+import { lazyFn } from '@benjavicente/router-core';
+import { LazyRouteOptions } from '@benjavicente/router-core';
+import { LinkOptions } from '@benjavicente/router-core';
+import { MakeOptionalPathParams } from '@benjavicente/router-core';
+import { MakeOptionalSearchParams } from '@benjavicente/router-core';
+import { MakeRouteMatch } from '@benjavicente/router-core';
+import { MakeRouteMatchUnion } from '@benjavicente/router-core';
+import { MaskOptions } from '@benjavicente/router-core';
+import { MatchRouteOptions } from '@benjavicente/router-core';
+import { NavigateOptions } from '@benjavicente/router-core';
+import { NoInfer as NoInfer_2 } from '@benjavicente/router-core';
+import { notFound } from '@benjavicente/router-core';
+import { NotFoundError } from '@benjavicente/router-core';
+import { ParsedLocation } from '@benjavicente/router-core';
+import { ParsedPath } from '@benjavicente/history';
+import { ParseRoute } from '@benjavicente/router-core';
+import { Provider } from '@angular/core';
+import { redirect } from '@benjavicente/router-core';
+import { Register } from '@benjavicente/router-core';
+import { RegisteredRouter } from '@benjavicente/router-core';
+import { ResolveFullPath } from '@benjavicente/router-core';
+import { ResolveId } from '@benjavicente/router-core';
+import { ResolveParams } from '@benjavicente/router-core';
+import { ResolveRoute } from '@benjavicente/router-core';
+import { ResolveUseLoaderData } from '@benjavicente/router-core';
+import { ResolveUseLoaderDeps } from '@benjavicente/router-core';
+import { ResolveUseParams } from '@benjavicente/router-core';
+import { ResolveUseSearch } from '@benjavicente/router-core';
+import { retainSearchParams } from '@benjavicente/router-core';
+import { RootRoute as RootRoute_2 } from '@benjavicente/router-core';
+import { RootRouteId } from '@benjavicente/router-core';
+import { RootRouteOptions } from '@benjavicente/router-core';
+import { Route as Route_2 } from '@benjavicente/router-core';
+import { RouteById } from '@benjavicente/router-core';
+import { RouteConstraints } from '@benjavicente/router-core';
+import { RouteIds } from '@benjavicente/router-core';
+import { RouteMask } from '@benjavicente/router-core';
+import { RouteOptions } from '@benjavicente/router-core';
+import { RoutePaths } from '@benjavicente/router-core';
+import { RouterContextOptions } from '@benjavicente/router-core';
+import { RouterCore } from '@benjavicente/router-core';
+import { RouterHistory } from '@benjavicente/history';
+import { RouterManagedTag } from '@benjavicente/router-core';
+import { RouterOptions } from '@benjavicente/router-core';
+import { RouterState } from '@benjavicente/router-core';
+import { RouteTypesById } from '@benjavicente/router-core';
+import { Signal } from '@angular/core';
+import { StrictOrFrom } from '@benjavicente/router-core';
+import { ThrowConstraint } from '@benjavicente/router-core';
+import { ThrowOrOptional } from '@benjavicente/router-core';
+import { ToMaskOptions } from '@benjavicente/router-core';
+import { ToSubOptionsProps } from '@benjavicente/router-core';
+import { TrailingSlashOption } from '@benjavicente/router-core';
+import { Type } from '@angular/core';
+import { UpdatableRouteOptions } from '@benjavicente/router-core';
+import { UseLoaderDataResult } from '@benjavicente/router-core';
+import { UseLoaderDepsResult } from '@benjavicente/router-core';
+import { UseNavigateResult } from '@benjavicente/router-core';
+import { UseParamsResult } from '@benjavicente/router-core';
+import { UseRouteContextBaseOptions } from '@benjavicente/router-core';
+import { UseRouteContextOptions } from '@benjavicente/router-core';
+import { UseRouteContextResult } from '@benjavicente/router-core';
+import { UseSearchResult } from '@benjavicente/router-core';
+import { WritableSignal } from '@angular/core';
+
+declare interface ActiveLinkOptionProps {
+    activeProps?: ActiveLinkProps;
+    inactiveProps?: ActiveLinkProps;
+}
+
+declare interface ActiveLinkProps {
+    class?: string;
+    style?: string;
+}
+
+export declare type AngularInjectFn = EnvironmentInjector['get'];
+
+declare type AngularRouterConstructorOptions<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'> & AngularRouterContextOptions<TRouteTree>;
+
+export declare type AngularRouterContext = {
+    inject: AngularInjectFn;
+};
+
+declare type AngularRouterContextInput<TContext> = Omit<TContext, keyof AngularRouterContext> & Partial<Pick<TContext, Extract<keyof TContext, keyof AngularRouterContext>>>;
+
+declare type AngularRouterContextOptions<TRouteTree extends AnyRoute> = {} extends Omit<InferAngularRouterContext<TRouteTree>, keyof AngularRouterContext> ? {
+    context?: AngularRouterContextInput<InferAngularRouterContext<TRouteTree>>;
+} : {
+    context: AngularRouterContextInput<InferAngularRouterContext<TRouteTree>>;
+};
+
+export declare type AnyRootRoute = RootRoute<any, any, any, any, any, any, any, any, any, any>;
+
+export { AnyRouter }
+
+export { BlockerFn }
+
+declare type BlockerResolver<TRouter extends AnyRouter = RegisteredRouter> = {
+    status: 'blocked';
+    current: MakeShouldBlockFnLocationUnion<TRouter>;
+    next: MakeShouldBlockFnLocationUnion<TRouter>;
+    action: HistoryAction;
+    proceed: () => void;
+    reset: () => void;
+} | {
+    status: 'idle';
+    current: undefined;
+    next: undefined;
+    action: undefined;
+    proceed: undefined;
+    reset: undefined;
+};
+
+/**
+ * Full managed document for a single snapshot: match-derived tags plus one
+ * `takeBufferedScripts()` read (for tests and tooling). Prefer composing
+ * `buildMatchManagedDocumentContent` + a one-time dehydration prefix in SSR, as
+ * the body managed-tags provider does.
+ */
+export declare function buildManagedDocumentContent(router: AnyRouter): ManagedDocumentContent;
+
+/**
+ * Document content from the current route tree only (meta, links, route body scripts, etc.).
+ * Does not call `takeBufferedScripts` — mirrors the route-derived arrays passed into
+ * `renderScripts` before the server-buffered script is unshifted in React/Solid/Vue.
+ */
+export declare function buildMatchManagedDocumentContent(router: AnyRouter): ManagedDocumentContent;
+
+export { createBrowserHistory }
+
+export { CreateFileRoute }
+
+export declare function createFileRoute<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'], TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'], TFullPath extends RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath']>(path?: TFilePath): InternalFileRouteFactory<TFilePath, TParentRoute, TId, TPath, TFullPath>['createRoute'];
+
+export { createHashHistory }
+
+export { createHistory }
+
+export { CreateLazyFileRoute }
+
+export declare function createLazyFileRoute<TFilePath extends keyof FileRoutesByPath, TRoute extends FileRoutesByPath[TFilePath]['preLoaderRoute']>(id: TFilePath): (opts: LazyRouteOptions) => LazyRoute<TRoute>;
+
+export declare function createLazyRoute<TRouter extends AnyRouter = RegisteredRouter, TId extends string = string, TRoute extends AnyRoute = RouteById<TRouter['routeTree'], TId>>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>): (opts: LazyRouteOptions) => LazyRoute<TRoute>;
+
+export { createMemoryHistory }
+
+export declare function createRootRoute<TRegister = Register, TSearchValidator = undefined, TRouterContext = {}, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TSSR = unknown, THandlers = undefined>(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, THandlers>): RootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, THandlers>;
+
+export declare function createRootRouteWithContext<TRouterContext extends {}>(): <TRegister = Register, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSearchValidator = undefined, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TSSR = unknown, THandlers = undefined>(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, THandlers>) => RootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, unknown, unknown, TSSR, THandlers>;
+
+export declare function createRoute<TRegister = unknown, TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, THandlers = undefined>(options: RouteOptions<TRegister, TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn, TSSR, THandlers>): Route<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, unknown, TSSR, THandlers>;
+
+export declare function createRouteMask<TRouteTree extends AnyRoute, TFrom extends string, TTo extends string>(opts: {
+    routeTree: TRouteTree;
+} & ToMaskOptions<RouterCore<TRouteTree, 'never', false>, TFrom, TTo>): RouteMask<TRouteTree>;
+
+export declare const createRouter: CreateRouterFn;
+
+export { createRouterConfig }
+
+declare type CreateRouterFn = <TRouteTree extends AnyRoute, TTrailingSlashOption extends TrailingSlashOption = 'never', TDefaultStructuralSharingOption extends boolean = false, TRouterHistory extends RouterHistory = RouterHistory, TDehydrated extends Record<string, any> = Record<string, any>>(options: undefined extends number ? 'strictNullChecks must be enabled in tsconfig.json' : AngularRouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>) => Router<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>;
+
+export declare type ErrorRouteComponent = () => Angular.Type<unknown>;
+
+export { FileRoutesByPath }
+
+export declare function getRouteApi<const TId, TRouter extends AnyRouter = RegisteredRouter>(id: ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>): RouteApi<TId, TRouter>;
+
+export { HistoryLocation }
+
+export { HistoryState }
+
+declare type InferAngularRouterContext<TRouteTree extends AnyRoute> = TRouteTree['types']['routerContext'];
+
+export declare function injectBlocker<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean>(opts: InjectBlockerOpts<TRouter, TWithResolver>): TWithResolver extends true ? Angular.Signal<BlockerResolver<TRouter>> : void;
+
+export declare type InjectBlockerOpts<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean> = {
+    shouldBlockFn: ShouldBlockFn<TRouter>;
+    enableBeforeUnload?: boolean | (() => boolean);
+    disabled?: boolean | (() => boolean);
+    withResolver?: TWithResolver;
+};
+
+export declare function injectCanGoBack(): Signal<boolean>;
+
+export declare function injectChildMatches<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectMatchesBaseOptions<TRouter, TSelected>): Angular.Signal<InjectMatchesResult<TRouter, TSelected>>;
+
+/**
+ * Injects the error state to the error componenet.
+ */
+export declare function injectErrorState(): {
+    error: Error;
+    reset: () => void;
+    info: {
+        componentStack: string;
+    };
+};
+
+export declare function injectLoaderData<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(opts: InjectLoaderDataOptions<TRouter, TFrom, TStrict, TSelected>): Angular.Signal<UseLoaderDataResult<TRouter, TFrom, TStrict, TSelected>>;
+
+export declare interface InjectLoaderDataBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> {
+    select?: (match: ResolveUseLoaderData<TRouter, TFrom, TStrict>) => TSelected;
+}
+
+export declare type InjectLoaderDataOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & InjectLoaderDataBaseOptions<TRouter, TFrom, TStrict, TSelected>;
+
+export declare type InjectLoaderDataRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectLoaderDataBaseOptions<TRouter, TFrom, true, TSelected>) => Angular.Signal<UseLoaderDataResult<TRouter, TFrom, true, TSelected>>;
+
+export declare function injectLoaderDeps<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TSelected = unknown>(opts: InjectLoaderDepsOptions<TRouter, TFrom, TSelected>): Angular.Signal<UseLoaderDepsResult<TRouter, TFrom, TSelected>>;
+
+export declare interface InjectLoaderDepsBaseOptions<TRouter extends AnyRouter, TFrom, TSelected> {
+    select?: (deps: ResolveUseLoaderDeps<TRouter, TFrom>) => TSelected;
+}
+
+export declare type InjectLoaderDepsOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TSelected> = StrictOrFrom<TRouter, TFrom> & InjectLoaderDepsBaseOptions<TRouter, TFrom, TSelected>;
+
+export declare type InjectLoaderDepsRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectLoaderDepsBaseOptions<TRouter, TFrom, TSelected>) => Angular.Signal<UseLoaderDepsResult<TRouter, TFrom, TSelected>>;
+
+export declare function injectLocation<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectLocationOptions<TRouter, TSelected>): Angular.Signal<InjectLocationResult<TRouter, TSelected>>;
+
+export declare interface InjectLocationOptions<TRouter extends AnyRouter, TSelected> {
+    select?: (location: RouterState<TRouter['routeTree']>['location']) => TSelected;
+}
+
+export declare type InjectLocationResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? RouterState<TRouter['routeTree']>['location'] : TSelected;
+
+export declare function injectMatch<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: InjectMatchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Angular.Signal<ThrowOrOptional<InjectMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;
+
+export declare interface InjectMatchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (match: MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+
+export declare function injectMatches<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectMatchesBaseOptions<TRouter, TSelected>): Angular.Signal<InjectMatchesResult<TRouter, TSelected>>;
+
+export declare interface InjectMatchesBaseOptions<TRouter extends AnyRouter, TSelected> {
+    select?: (matches: Array<MakeRouteMatchUnion<TRouter>>) => TSelected;
+}
+
+export declare type InjectMatchesResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? Array<MakeRouteMatchUnion<TRouter>> : TSelected;
+
+export declare type InjectMatchOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & InjectMatchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+
+export declare type InjectMatchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? TStrict extends true ? MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict> : MakeRouteMatchUnion<TRouter> : TSelected;
+
+export declare type InjectMatchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectMatchBaseOptions<TRouter, TFrom, true, true, TSelected>) => Angular.Signal<InjectMatchResult<TRouter, TFrom, true, TSelected>>;
+
+export declare function injectMatchRoute<TRouter extends AnyRouter = RegisteredRouter>(): <const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = "">(opts: InjectMatchRouteOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Angular.Signal<false | Expand<ResolveRoute<TRouter, TFrom, NoInfer_2<TTo>>["types"]["allParams"]>>;
+
+export declare type InjectMatchRouteOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends string = string, TTo extends string | undefined = undefined, TMaskFrom extends string = TFrom, TMaskTo extends string = ''> = ToSubOptionsProps<TRouter, TFrom, TTo> & DeepPartial<MakeOptionalSearchParams<TRouter, TFrom, TTo>> & DeepPartial<MakeOptionalPathParams<TRouter, TFrom, TTo>> & MaskOptions<TRouter, TMaskFrom, TMaskTo> & MatchRouteOptions;
+
+export declare function injectNavigate<TRouter extends AnyRouter = RegisteredRouter, TDefaultFrom extends string = string>(_defaultOpts?: {
+    from?: FromPathOption<TRouter, TDefaultFrom>;
+}): UseNavigateResult<TDefaultFrom>;
+
+export declare function injectParams<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: InjectParamsOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Angular.Signal<ThrowOrOptional<UseParamsResult<TRouter, TFrom, true, TSelected>, TThrow>>;
+
+export declare interface InjectParamsBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (params: ResolveUseParams<TRouter, TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+
+export declare type InjectParamsOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & InjectParamsBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+
+export declare type InjectParamsRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectParamsBaseOptions<TRouter, TFrom, true, true, TSelected>) => Angular.Signal<UseParamsResult<TRouter, TFrom, true, TSelected>>;
+
+export declare function injectParentMatches<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectMatchesBaseOptions<TRouter, TSelected>): Angular.Signal<InjectMatchesResult<TRouter, TSelected>>;
+
+declare function injectRender(renderValueFn: () => RenderValue): void;
+
+export declare function injectRouteContext<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(opts: UseRouteContextOptions<TRouter, TFrom, TStrict, TSelected>): Angular.Signal<UseRouteContextResult<TRouter, TFrom, TStrict, TSelected>>;
+
+export declare type InjectRouteContextRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseRouteContextBaseOptions<TRouter, TFrom, true, TSelected>) => Angular.Signal<UseRouteContextResult<TRouter, TFrom, true, TSelected>>;
+
+export declare function injectRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {
+    warn?: boolean;
+}): TRouter;
+
+export declare function injectRouterState<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectRouterStateOptions<TRouter, TSelected>): Angular.Signal<InjectRouterStateResult<TRouter, TSelected>>;
+
+export declare type InjectRouterStateOptions<TRouter extends AnyRouter, TSelected> = {
+    router?: TRouter;
+    select?: (state: RouterState<TRouter['routeTree']>) => TSelected;
+};
+
+export declare type InjectRouterStateResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? RouterState<TRouter['routeTree']> : TSelected;
+
+export declare function injectSearch<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: InjectSearchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Angular.Signal<ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;
+
+export declare interface InjectSearchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (state: ResolveUseSearch<TRouter, TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+
+export declare type InjectSearchOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & InjectSearchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+
+export declare type InjectSearchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: InjectSearchBaseOptions<TRouter, TFrom, true, true, TSelected>) => Angular.Signal<UseSearchResult<TRouter, TFrom, true, TSelected>>;
+
+/**
+ * Injects the same inline scroll-restore script Solid/React emit on SSR
+ * (`ScrollRestoration` + `ScriptOnce`), so hydration can align window scroll
+ * with sessionStorage before the client router runs.
+ */
+export declare function injectSsrScrollRestorationScript(): void;
+
+export declare function injectStore<TState, TSelected = NoInfer<TState>>(storeOrStoreSignal: ReadableStore<TState> | (() => ReadableStore<TState>), selector?: (state: NoInfer<TState>) => TSelected, options?: CreateSignalOptions<TSelected>): Signal<TSelected>;
+
+declare class InternalFileRouteFactory<TFilePath extends keyof FileRoutesByPath, TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'], TId extends RouteConstraints['TId'] = FileRoutesByPath[TFilePath]['id'], TPath extends RouteConstraints['TPath'] = FileRoutesByPath[TFilePath]['path'], TFullPath extends RouteConstraints['TFullPath'] = FileRoutesByPath[TFilePath]['fullPath']> {
+    createRoute: <TRegister = Register, TSearchValidator = undefined, TParams = ResolveParams<TPath>, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, TMiddlewares = unknown, THandlers = undefined>(options?: FileBaseRouteOptions<TRegister, TParentRoute, TId, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, AnyContext, TRouteContextFn, TBeforeLoadFn, AnyContext, TSSR, TMiddlewares, THandlers> & UpdatableRouteOptions<TParentRoute, TId, TFullPath, TParams, TSearchValidator, TLoaderFn, TLoaderDeps, AnyContext, TRouteContextFn, TBeforeLoadFn>) => Route_2<TRegister, TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchValidator, TParams, AnyContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, unknown, TSSR, TMiddlewares, THandlers>;
+}
+
+export { isRedirect }
+
+export { lazyFn }
+
+export declare class LazyRoute<TRoute extends AnyRoute> {
+    options: {
+        id: string;
+    } & LazyRouteOptions;
+    constructor(opts: {
+        id: string;
+    } & LazyRouteOptions);
+    injectMatch: InjectMatchRoute<TRoute['id']>;
+    injectRouteContext: InjectRouteContextRoute<TRoute['id']>;
+    injectSearch: InjectSearchRoute<TRoute['id']>;
+    injectParams: InjectParamsRoute<TRoute['id']>;
+    injectLoaderDeps: InjectLoaderDepsRoute<TRoute['id']>;
+    injectLoaderData: InjectLoaderDataRoute<TRoute['id']>;
+    injectNavigate: () => UseNavigateResult<TRoute["fullPath"]>;
+}
+
+export declare class Link<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = '.'> {
+    passiveEvents: void;
+    options: InputSignal<LinkInputOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>>;
+    protected router: AnyRouter;
+    protected isTransitioning: WritableSignal<boolean>;
+    protected from: Signal<(FromPathOption<TRouter, TFrom> & {}) | undefined>;
+    protected disabled: Signal<boolean>;
+    protected target: Signal<string | undefined>;
+    protected _options: Signal<LinkInputOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>>;
+    protected nextLocation: Signal<ParsedLocation<    {}>>;
+    protected hrefOption: Signal<    {
+    href: any;
+    external: boolean;
+    } | undefined>;
+    protected externalLink: Signal<any>;
+    protected preload: Signal<false | "intent" | "viewport" | "render" | undefined>;
+    protected preloadDelay: Signal<number>;
+    protected location: Signal<ParsedLocation<FullSearchSchema<TRouter["routeTree"]>>>;
+    protected isActiveProps: Signal<ActiveLinkProps | undefined>;
+    protected isActive: Signal<boolean>;
+    protected doPreload: () => void;
+    protected preloadViewportIoCallback: (entry: IntersectionObserverEntry | undefined) => void;
+    private viewportPreloader;
+    private hasRenderFetched;
+    private rendererPreloader;
+    protected handleClick: (event: MouseEvent) => void;
+    protected handleFocus: () => void;
+    protected handleTouchStart: () => void;
+    protected handleEnter: (event: MouseEvent) => void;
+    protected handleLeave: (event: MouseEvent) => void;
+}
+
+export declare type LinkInputOptions<TRouter extends AnyRouter = RegisteredRouter, TFrom extends RoutePaths<TRouter['routeTree']> | string = string, TTo extends string | undefined = '.', TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom, TMaskTo extends string = '.'> = LinkOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & ActiveLinkOptionProps;
+
+export { LinkOptions }
+
+declare type MakeShouldBlockFnLocationUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? ShouldBlockFnLocation<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema']> : never;
+
+declare type ManagedDocumentContent = {
+    title?: string;
+    head: Array<ManagedTag>;
+    body: Array<ManagedTag>;
+};
+
+/** Route-driven tag with stable hash id for DOM reconciliation. */
+declare type ManagedTag = Exclude<RouterManagedTag, {
+    tag: 'title';
+}> & {
+    id: ManagedTagId;
+};
+
+declare type ManagedTagId = string;
+
+export declare class Matches {
+    router: AnyRouter;
+    private matchId;
+    private ssrScrollRestoration;
+    transitioner: void;
+    render: void;
+}
+
+export { NavigateOptions }
+
+declare type NearestMatchContextValue = {
+    matchId: () => string | undefined;
+    routeId: () => string | undefined;
+    match: () => AnyRouteMatch | undefined;
+    hasPending: () => boolean;
+};
+
+export { notFound }
+
+export declare class NotFoundRoute<TRegister, TParentRoute extends AnyRootRoute, TRouterContext = AnyContext, TRouteContextFn = AnyContext, TBeforeLoadFn = AnyContext, TSearchValidator = undefined, TLoaderDeps extends Record<string, any> = {}, TLoaderFn = undefined, TChildren = unknown, TSSR = unknown, THandlers = undefined> extends Route<TRegister, TParentRoute, '/404', '/404', '404', '404', TSearchValidator, {}, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TSSR, THandlers> {
+    constructor(options: Omit<RouteOptions<TRegister, TParentRoute, string, string, string, string, TSearchValidator, {}, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TSSR, THandlers>, 'caseSensitive' | 'parseParams' | 'stringifyParams' | 'path' | 'id' | 'params'>);
+}
+
+export declare type NotFoundRouteComponent = () => Angular.Type<unknown>;
+
+export declare class Outlet {
+    router: AnyRouter;
+    nearestMatch: NearestMatchContextValue;
+    currentMatch: Signal<AnyRouteMatch | undefined>;
+    routeId: Signal<string>;
+    route: Signal<AnyRoute>;
+    parentGlobalNotFound: Signal<boolean>;
+    childMatchIdByRouteId: Signal<Record<string, string>>;
+    childMatchId: Signal<string | null>;
+    render: void;
+}
+
+export { ParsedPath }
+
+/** Same as `provideTanstackDocument(router)` (all features enabled). */
+export declare function provideHeadContent(router: AnyRouter): Angular.EnvironmentProviders;
+
+export declare function provideTanstackBodyManagedTags(router: AnyRouter): Angular.EnvironmentProviders;
+
+/**
+ * Composes document sync from route matches. When title, head, and body are all
+ * enabled, uses a single `activeMatches` effect (same churn as legacy
+ * `provideHeadContent`). Partial feature sets use separate installers each with
+ * their own effect.
+ */
+export declare function provideTanstackDocument(router: AnyRouter, features?: TanstackDocumentFeatures): Angular.EnvironmentProviders;
+
+export declare function provideTanstackDocumentTitle(router: AnyRouter): Angular.EnvironmentProviders;
+
+export declare function provideTanstackHeadManagedTags(router: AnyRouter): Angular.EnvironmentProviders;
+
+export declare function provideTanstackRouter({ router, context, options, }: TanstackRouterProviderOptions): ({
+    provide: InjectionToken<AnyRouter>;
+    useValue: AnyRouter;
+    useFactory?: undefined;
+} | {
+    provide: InjectionToken<Partial<any>>;
+    useFactory: () => Partial<any>;
+    useValue?: undefined;
+} | {
+    provide: InjectionToken<Omit<RouterInputs<AnyRouter, Record<string, any>>, "context" | "router">>;
+    useValue: Omit<RouterInputs<AnyRouter, Record<string, any>>, "context" | "router">;
+    useFactory?: undefined;
+})[];
+
+declare type ReadableStore<TState> = {
+    state: TState;
+};
+
+export { redirect }
+
+export { Register }
+
+export { RegisteredRouter }
+
+declare type RenderValue = {
+    key?: string;
+    component: Type<any> | null | undefined;
+    inputs?: Record<string, () => unknown>;
+    providers?: Array<Provider>;
+} | null | undefined;
+
+export { retainSearchParams }
+
+export declare class RootRoute<in out TRegister = Register, in out TSearchValidator = undefined, in out TRouterContext = {}, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TLoaderDeps extends Record<string, any> = {}, in out TLoaderFn = undefined, in out TChildren = unknown, in out TFileRouteTypes = unknown, in out TSSR = unknown, in out THandlers = undefined> extends BaseRootRoute<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, THandlers> implements RootRoute_2<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, THandlers> {
+    /**
+     * @deprecated `RootRoute` is now an internal implementation detail. Use `createRootRoute()` instead.
+     */
+    constructor(options?: RootRouteOptions<TRegister, TSearchValidator, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TSSR, THandlers>);
+    injectMatch: InjectMatchRoute<RootRouteId>;
+    injectRouteContext: InjectRouteContextRoute<RootRouteId>;
+    injectSearch: InjectSearchRoute<RootRouteId>;
+    injectParams: InjectParamsRoute<RootRouteId>;
+    injectLoaderDeps: InjectLoaderDepsRoute<RootRouteId>;
+    injectLoaderData: InjectLoaderDataRoute<RootRouteId>;
+    injectNavigate: () => UseNavigateResult<"/">;
+}
+
+export { RootRouteOptions }
+
+export declare class Route<in out TRegister = unknown, in out TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, in out TPath extends RouteConstraints['TPath'] = '/', in out TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, in out TCustomId extends RouteConstraints['TCustomId'] = string, in out TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, in out TSearchValidator = undefined, in out TParams = ResolveParams<TPath>, in out TRouterContext = AnyContext, in out TRouteContextFn = AnyContext, in out TBeforeLoadFn = AnyContext, in out TLoaderDeps extends Record<string, any> = {}, in out TLoaderFn = undefined, in out TChildren = unknown, in out TFileRouteTypes = unknown, in out TSSR = unknown, in out TMiddlewares = unknown, in out THandlers = undefined> extends BaseRoute<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TMiddlewares, THandlers> implements Route_2<TRegister, TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchValidator, TParams, TRouterContext, TRouteContextFn, TBeforeLoadFn, TLoaderDeps, TLoaderFn, TChildren, TFileRouteTypes, TSSR, TMiddlewares, THandlers> {
+    /**
+     * @deprecated Use the `createRoute` function instead.
+     */
+    constructor(options?: RouteOptions<TRegister, TParentRoute, TId, TCustomId, TFullPath, TPath, TSearchValidator, TParams, TLoaderDeps, TLoaderFn, TRouterContext, TRouteContextFn, TBeforeLoadFn, TSSR, TMiddlewares, THandlers>);
+    injectMatch: InjectMatchRoute<TId>;
+    injectRouteContext: InjectRouteContextRoute<TId>;
+    injectSearch: InjectSearchRoute<TId>;
+    injectParams: InjectParamsRoute<TId>;
+    injectLoaderDeps: InjectLoaderDepsRoute<TId>;
+    injectLoaderData: InjectLoaderDataRoute<TId>;
+    injectNavigate: () => UseNavigateResult<TFullPath>;
+}
+
+export declare class RouteApi<TId, TRouter extends AnyRouter = RegisteredRouter> extends BaseRouteApi<TId, TRouter> {
+    /**
+     * @deprecated Use the `getRouteApi` function instead.
+     */
+    constructor({ id }: {
+        id: TId;
+    });
+    injectMatch: InjectMatchRoute<TId>;
+    injectRouteContext: InjectRouteContextRoute<TId>;
+    injectSearch: InjectSearchRoute<TId>;
+    injectParams: InjectParamsRoute<TId>;
+    injectLoaderDeps: InjectLoaderDepsRoute<TId>;
+    injectLoaderData: InjectLoaderDataRoute<TId>;
+    injectNavigate: () => UseNavigateResult<RouteTypesById<TRouter, TId>["fullPath"]>;
+    notFound: (opts?: NotFoundError) => NotFoundError;
+}
+
+export declare type RouteComponent<TComponent = unknown> = () => Angular.Type<TComponent>;
+
+export declare class RouteMatch {
+    matchId: InputSignal<string>;
+    router: AnyRouter;
+    match: Signal<AnyRouteMatch | undefined>;
+    matchData: Signal<{
+        key: string | undefined;
+        route: AnyRoute;
+        match: AnyRouteMatch;
+        parentRouteId: any;
+    } | null>;
+    isFistRouteInRouteTree: Signal<boolean>;
+    resolvedNoSsr: Signal<boolean>;
+    shouldClientOnly: Signal<boolean>;
+    parentRouteIdSignal: Signal<any>;
+    rootRouteIdSignal: Signal<string>;
+    hasPendingMatch: Signal<boolean>;
+    pendingRouteIds: Signal<Record<string, boolean>>;
+    nearestMatchContext: NearestMatchContextValue;
+    isCatchingError: Signal<boolean>;
+    render: void;
+    onRendered: void;
+}
+
+export { RouteOptions }
+
+export declare class Router<in out TRouteTree extends AnyRoute, in out TTrailingSlashOption extends TrailingSlashOption = 'never', in out TDefaultStructuralSharingOption extends boolean = false, in out TRouterHistory extends RouterHistory = RouterHistory, in out TDehydrated extends Record<string, any> = Record<string, any>> extends RouterCore<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated> {
+    constructor(options: AngularRouterConstructorOptions<TRouteTree, TTrailingSlashOption, TDefaultStructuralSharingOption, TRouterHistory, TDehydrated>);
+}
+
+export { RouterContextOptions }
+
+export { RouterHistory }
+
+declare type RouterInputs<TRouter extends AnyRouter = RegisteredRouter, TDehydrated extends Record<string, any> = Record<string, any>> = Omit<RouterOptions<TRouter['routeTree'], NonNullable<TRouter['options']['trailingSlash']>, false, TRouter['history'], TDehydrated>, 'context'> & {
+    router: TRouter;
+    context?: Partial<RouterOptions<TRouter['routeTree'], NonNullable<TRouter['options']['trailingSlash']>, false, TRouter['history'], TDehydrated>['context']>;
+};
+
+export declare class RouterProvider<TRouter extends AnyRouter = RegisteredRouter> {
+    readonly injectedContext: RouterInputs<TRouter>['context'];
+    readonly injectedOptions: Omit<RouterInputs<TRouter>, 'router' | 'context'>;
+    readonly injectedRouter: AnyRouter | null;
+    readonly context: InputSignal<RouterInputs<TRouter>['context']>;
+    readonly options: InputSignal<Omit<RouterInputs<TRouter>, 'router' | 'context'>>;
+    readonly routerInput: InputSignal<TRouter | undefined>;
+    readonly router: Signal<TRouter>;
+    readonly updateRouter: EffectRef;
+    readonly render: ReturnType<typeof injectRender>;
+}
+
+export { RouterState }
+
+export declare type ShouldBlockFn<TRouter extends AnyRouter = RegisteredRouter> = (args: ShouldBlockFnArgs<TRouter>) => boolean | Promise<boolean>;
+
+declare type ShouldBlockFnArgs<TRouter extends AnyRouter = RegisteredRouter> = {
+    current: MakeShouldBlockFnLocationUnion<TRouter>;
+    next: MakeShouldBlockFnLocationUnion<TRouter>;
+    action: HistoryAction;
+};
+
+declare interface ShouldBlockFnLocation<out TRouteId, out TFullPath, out TAllParams, out TFullSearchSchema> {
+    routeId: TRouteId;
+    fullPath: TFullPath;
+    pathname: string;
+    params: TAllParams;
+    search: TFullSearchSchema;
+}
+
+export declare type TanstackDocumentFeatures = {
+    /** Sync `document.title` from route meta (default: true). */
+    title?: boolean;
+    /** Managed `<head>` tags from matches (default: true). */
+    headTags?: boolean;
+    /** Managed `<body>` scripts: route/manifest scripts plus one SSR `takeBufferedScripts()` read (default: true). */
+    bodyScripts?: boolean;
+};
+
+declare type TanstackRouterProviderOptions = {
+    router: AnyRouter;
+    context?: RouterInputs['context'];
+    options?: Omit<RouterInputs, 'router' | 'context'>;
+};
+
+export declare type UseBlockerOpts<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean> = {
+    shouldBlockFn: ShouldBlockFn<TRouter>;
+    enableBeforeUnload?: boolean | (() => boolean);
+    disabled?: boolean;
+    withResolver?: TWithResolver;
+};
+
+export { }
+
+
+declare module '@benjavicente/router-core' {
+    interface UpdatableRouteOptionsExtensions {
+        component?: RouteComponent;
+        errorComponent?: false | null | undefined | ErrorRouteComponent;
+        notFoundComponent?: NotFoundRouteComponent;
+        pendingComponent?: RouteComponent;
+    }
+    interface RootRouteOptionsExtensions {
+        shellComponent?: Angular.Type<{
+            children: any;
+        }>;
+    }
+    interface RouteExtensions<in out TId extends string, in out TFullPath extends string> {
+        injectMatch: InjectMatchRoute<TId>;
+        injectRouteContext: InjectRouteContextRoute<TId>;
+        injectSearch: InjectSearchRoute<TId>;
+        injectParams: InjectParamsRoute<TId>;
+        injectLoaderDeps: InjectLoaderDepsRoute<TId>;
+        injectLoaderData: InjectLoaderDataRoute<TId>;
+        injectNavigate: () => UseNavigateResult<TFullPath>;
+    }
+}
+
+
+declare module '@benjavicente/router-core' {
+    interface LazyRoute<in out TRoute extends AnyRoute> {
+        injectMatch: InjectMatchRoute<TRoute['id']>;
+        injectRouteContext: InjectRouteContextRoute<TRoute['id']>;
+        injectSearch: InjectSearchRoute<TRoute['id']>;
+        injectParams: InjectParamsRoute<TRoute['id']>;
+        injectLoaderDeps: InjectLoaderDepsRoute<TRoute['id']>;
+        injectLoaderData: InjectLoaderDataRoute<TRoute['id']>;
+        injectNavigate: () => UseNavigateResult<TRoute['fullPath']>;
+    }
+}
+
+
+declare module '@benjavicente/router-core' {
+    interface RouterOptionsExtensions {
+        /**
+         * The default `component` a route should use if no component is provided.
+         *
+         * @default Outlet
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaultcomponent-property)
+         */
+        defaultComponent?: RouteComponent;
+        /**
+         * The default `errorComponent` a route should use if no error component is provided.
+         *
+         * @default ErrorComponent
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaulterrorcomponent-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/solid/guide/data-loading#handling-errors-with-routeoptionserrorcomponent)
+         */
+        defaultErrorComponent?: ErrorRouteComponent;
+        /**
+         * The default `pendingComponent` a route should use if no pending component is provided.
+         *
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaultpendingcomponent-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/solid/guide/data-loading#showing-a-pending-component)
+         */
+        defaultPendingComponent?: RouteComponent;
+        /**
+         * The default `notFoundComponent` a route should use if no notFound component is provided.
+         *
+         * @default NotFound
+         * @link [API Docs](https://tanstack.com/router/latest/docs/framework/solid/api/router/RouterOptionsType#defaultnotfoundcomponent-property)
+         * @link [Guide](https://tanstack.com/router/latest/docs/framework/solid/guide/not-found-errors#default-router-wide-not-found-handling)
+         */
+        defaultNotFoundComponent?: RouteComponent;
+    }
+}
+
+
+declare module '@benjavicente/router-core' {
+    interface RouterStores<in out TRouteTree extends AnyRoute> {
+        childMatchIdByRouteId: RouterReadableStore<Record<string, string>>;
+        pendingRouteIds: RouterReadableStore<Record<string, boolean>>;
+    }
+}
+
+
+declare global {
+    interface Window {
+        __TSR_ROUTER_INJECTION_KEY__?: Angular.InjectionToken<AnyRouter>;
+    }
+}