@securitydept/client-react 0.3.0-beta.1 → 0.3.0-beta.11

package/dist/tanstack-router/index.d.mts

@@ -1,428 +1,89 @@
-import { AuthRequirement, RequirementsClientSetComposition, RouteMatchNode } from "@securitydept/client/auth-coordination";
-import { AnyRoute, RegisteredRouter } from "@tanstack/react-router";
-
-//#region src/tanstack-router/index.d.ts
-/**
- * Minimal shape of a TanStack Router route match entry.
- *
- * Structurally compatible with the matches returned by `useMatches()`.
- * The adapter reads `staticData` (set via `beforeLoad` or `staticData` option)
- * to find auth requirements.
- */
-interface TanStackRouteMatch {
-  /** Route identifier (the route's `id` field). */
-  routeId: string;
-  /**
-   * Static route context, typically set via `beforeLoad` or `staticData`.
-   * Auth requirements should be declared here under a well-known key.
-   *
-   * Typed as `object` (not `Record<string, unknown>`) to remain structurally
-   * compatible with TanStack Router's open `StaticDataRouteOption` interface,
-   * which does not carry an index signature.
-   */
-  staticData?: object;
-  /** Route context merged from parent. */
-  context?: object;
-  /** Route loader data, if available. */
-  loaderData?: object;
+import { AuthRequirement, EnvironmentValidators, FoundationEnvironment, RequirementBehaviourWithRouteContext, RequirementPlannerHost, RequirementPlannerHostBehaviour, RequirementsComposition, RouteBehaviourContextExtra, RouteTreeSegment, RouterTrait, SecuritydeptInjectorTrait, WithTraitInputValidator } from "@securitydept/client";
+import { AnyRouter, NavigateOptions } from "@tanstack/react-router";
+//#region src/tanstack-router/auth-coordination/route-metadata.d.ts
+interface TanStackRouteMatchLike {
+  readonly id?: string;
+  readonly routeId?: string;
+  readonly pathname?: string;
+  readonly staticData?: object;
 }
-/** Default key for auth requirements in TanStack Router `staticData`. */
-declare const DEFAULT_REQUIREMENTS_KEY = "authRequirements";
-/** Default key for the composition strategy in TanStack Router `staticData`. */
-declare const DEFAULT_COMPOSITION_KEY = "authRequirementsComposition";
-/** Options for {@link projectTanStackRouteMatches} and {@link createTanStackRouteActivator}. */
-interface TanStackRouterAdapterOptions {
-  /**
-   * Key used to read auth requirements from `staticData`.
-   *
-   * @default "authRequirements"
-   */
-  requirementsKey?: string;
+declare function projectTanStackRouteSegments<TAuthRequirement extends AuthRequirement = AuthRequirement>(matches: readonly TanStackRouteMatchLike[]): RouteTreeSegment<TAuthRequirement>[];
+//#endregion
+//#region src/tanstack-router/auth-coordination/route-guard.d.ts
+interface SecuritydeptTanStackRouterContext {
+  readonly securitydeptInjector: SecuritydeptInjectorTrait;
+  readonly router?: {
+    readonly state: {
+      readonly matches: readonly TanStackRouteMatchLike[];
+    };
+  };
 }
-interface TanStackRouteLocation {
-  pathname: string;
-  href: string;
+interface TanStackBeforeLoadContextLike {
+  readonly context: SecuritydeptTanStackRouterContext;
+  readonly matches: readonly TanStackRouteMatchLike[];
+  readonly location: {
+    readonly href: string;
+  };
 }
-/**
- * Runtime context passed to route unauthenticated handlers.
- *
- * `attemptedUrl` is the TanStack Router target URL for the navigation being
- * guarded. Use it as `postAuthRedirectUri` when a handler starts a full-page
- * auth redirect; do not infer this from `window.location`, because the current
- * document URL can still point at the previously committed route.
- */
-interface TanStackRouteUnauthenticatedContext {
-  readonly location: TanStackRouteLocation;
-  readonly attemptedUrl: string;
-  readonly matches: readonly TanStackRouteMatch[];
-  readonly cause: string | undefined;
+interface CreateTanStackBeforeLoadWithPlannerHostOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> {
+  readonly plannerHost: RequirementPlannerHost<TBehaviour>;
+  readonly behaviour?: never;
 }
-type TanStackRouteUnauthenticatedAction = boolean | string;
-type TanStackRouteUnauthenticatedHandler = (requirement: AuthRequirement, context: TanStackRouteUnauthenticatedContext) => TanStackRouteUnauthenticatedAction | Promise<TanStackRouteUnauthenticatedAction>;
-type TanStackRouteAuthenticatedCheck = (requirement: AuthRequirement) => boolean | Promise<boolean>;
-/**
- * Options for {@link withTanStackRouteRequirements}.
- */
-interface WithTanStackRouteRequirementsOptions {
-  /**
-   * How this route segment composes with its parent route chain.
-   * @default RequirementsClientSetComposition.Merge
-   */
-  composition?: RequirementsClientSetComposition;
-  /**
-   * Additional staticData properties to merge into the returned object.
-   */
-  extra?: Record<string, unknown>;
+interface CreateTanStackBeforeLoadWithBehaviourOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> {
+  readonly plannerHost?: never;
+  readonly behaviour?: RequirementPlannerHostBehaviour<TAuthRequirement, RouteBehaviourContextExtra, TBehaviour>;
 }
-/**
- * Build a TanStack Router `staticData` object declaring auth requirements for
- * a single route segment.
- *
- * This is the TanStack Router equivalent of Angular's `withRouteRequirements()`.
- *
- * @example
- * ```ts
- * import { createRoute } from "@tanstack/react-router";
- * import { withTanStackRouteRequirements } from "@securitydept/client-react/tanstack-router";
- *
- * const dashboardRoute = createRoute({
- *   getParentRoute: () => rootRoute,
- *   path: "dashboard",
- *   staticData: withTanStackRouteRequirements([
- *     { id: "session", kind: "session" },
- *   ]),
- * });
- *
- * // Child route replaces parent requirements:
- * const publicRoute = createRoute({
- *   getParentRoute: () => dashboardRoute,
- *   path: "public",
- *   staticData: withTanStackRouteRequirements([], {
- *     composition: RequirementsClientSetComposition.Replace,
- *   }),
- * });
- * ```
- *
- * @param requirements - Auth requirements for this route segment.
- * @param options - Optional composition strategy and extra staticData.
- */
-declare function withTanStackRouteRequirements(requirements: AuthRequirement[], options?: WithTanStackRouteRequirementsOptions): Record<string, unknown>;
-/**
- * Extract and compose auth requirements from a TanStack Router matched route
- * chain, respecting merge/replace/inherit composition at each segment.
- *
- * This is the TanStack Router equivalent of Angular's
- * `extractFullRouteRequirements()`. It walks the matched route chain from root
- * to leaf and applies the composition strategy declared at each segment:
- *
- * - `inherit` — keep parent requirements unchanged
- * - `merge` — append child requirements, replacing same-id parent entries
- * - `replace` — discard parent chain, use only child's requirements
- *
- * @param matches - Matched route chain from root to leaf (as from `useMatches()`).
- * @param options - Optional key override.
- */
-declare function extractTanStackRouteRequirements(matches: readonly TanStackRouteMatch[], options?: TanStackRouterAdapterOptions): AuthRequirement[];
-/**
- * Route-level auth requirement declaration for composition resolution.
- */
-interface RouteRequirementsDeclaration {
-  requirements: readonly AuthRequirement[];
-  composition: RequirementsClientSetComposition;
+type CreateTanStackBeforeLoadOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> = CreateTanStackBeforeLoadWithPlannerHostOptions<TAuthRequirement, TBehaviour> | CreateTanStackBeforeLoadWithBehaviourOptions<TAuthRequirement, TBehaviour>;
+declare class TanStackRouteSecurityBlockedError extends Error {
+  readonly requirement: AuthRequirement;
+  constructor(requirement: AuthRequirement);
 }
-/**
- * Resolve the effective auth requirements by composing the parent chain with a
- * child route declaration.
- *
- * Composition semantics mirror Angular's `resolveEffectiveRequirements()`:
- * - `inherit` keeps the parent requirements unchanged
- * - `merge` appends child requirements and replaces same-id parent entries
- * - `replace` discards the parent chain and uses only the child's requirements
- */
-declare function resolveEffectiveRequirements(parentRequirements: readonly AuthRequirement[], child: RouteRequirementsDeclaration): AuthRequirement[];
-/**
- * Project TanStack Router matched route entries into the SDK's
- * `RouteMatchNode[]` contract.
- *
- * Each match entry is mapped to a `RouteMatchNode`:
- *   - `routeId` is taken from `match.routeId`
- *   - `requirements` is read from `match.staticData[requirementsKey]`
- *
- * Entries with no requirements produce nodes with an empty requirements array,
- * preserving the full chain for shared-prefix diffing.
- *
- * @example
- * ```ts
- * import { useMatches } from "@tanstack/react-router";
- * import { projectTanStackRouteMatches } from "@securitydept/client-react/tanstack-router";
- *
- * const matches = useMatches();
- * const routeChain = projectTanStackRouteMatches(matches);
- * orchestrator.activateMatchedRoutes(routeChain);
- * ```
- */
-declare function projectTanStackRouteMatches(matches: readonly TanStackRouteMatch[], options?: TanStackRouterAdapterOptions): RouteMatchNode[];
-/**
- * Create a route-change activator that projects TanStack Router matches and
- * activates them on the orchestrator.
- *
- * This is framework-agnostic (not a React hook) and can be called from a
- * `useEffect`, route subscriber, or any mechanism that notifies match changes.
- *
- * @example
- * ```ts
- * import { useMatches } from "@@tanstack/react-router";
- * import { createTanStackRouteActivator } from "@securitydept/client-react/tanstack-router";
- *
- * const activator = createTanStackRouteActivator(orchestrator);
- *
- * function RouteOrchestrationBridge() {
- *   const matches = useMatches();
- *   useEffect(() => activator.activate(matches), [matches]);
- *   return null;
- * }
- * ```
- */
-declare function createTanStackRouteActivator(orchestrator: {
-  activateMatchedRoutes(chain: readonly RouteMatchNode[]): void;
-  deactivateRoute(): void;
-}, options?: TanStackRouterAdapterOptions): {
-  /** Project matches and activate the route chain on the orchestrator. */activate(matches: readonly TanStackRouteMatch[]): void; /** Deactivate the current route (e.g. on unmount or navigation away). */
-  deactivate(): void;
-};
-/**
- * Root-level runtime policy for a secured TanStack Router route tree.
- *
- * This is the TanStack Router equivalent of Angular's
- * `SecureRouteRootSecurityOptions`. Non-serializable runtime callbacks
- * (planner host, onUnauthenticated handlers) live here, NOT in individual
- * route `staticData`.
- *
- * @example
- * ```ts
- * const routeSecurityPolicy = createTanStackRouteSecurityPolicy({
- *   requirementHandlers: {
- *     frontend_oidc: (failingRequirement) => {
- *       redirectToLogin(failingRequirement);
- *       return false;
- *     },
- *   },
- * });
- *
- * // Use in beforeLoad:
- * const protectedRoute = createRoute({
- *   beforeLoad: ({ matches }) => {
- *     routeSecurityPolicy.enforce(matches);
- *   },
- * });
- * ```
- */
-interface TanStackRouteSecurityPolicyOptions {
-  /**
-   * Per-requirement-kind handlers.
-   * Keys are `AuthRequirement.kind` strings.
-   */
-  requirementHandlers?: Record<string, TanStackRouteUnauthenticatedHandler>;
-  /**
-   * Fallback handler when no kind-specific handler matches.
-   */
-  defaultOnUnauthenticated?: TanStackRouteUnauthenticatedHandler;
-  /**
-   * Custom key for reading requirements from staticData.
-   * @default "authRequirements"
-   */
-  requirementsKey?: string;
+declare function createTanStackBeforeLoad<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(options?: CreateTanStackBeforeLoadOptions<TAuthRequirement, TBehaviour>): (context: TanStackBeforeLoadContextLike) => Promise<void>;
+//#endregion
+//#region src/tanstack-router/auth-coordination/secure-routes.d.ts
+interface CreateTanStackRouterContextOptions {
+  readonly environment?: FoundationEnvironment;
+  readonly injector?: SecuritydeptInjectorTrait;
 }
-/**
- * Route security evaluation result from
- * {@link createTanStackRouteSecurityPolicy}.
- */
-interface TanStackRouteSecurityResult {
-  /** All requirements are met — allow navigation. */
-  readonly allMet: boolean;
-  /** The first unmet requirement, if any. */
-  readonly pendingRequirement: AuthRequirement | undefined;
-  /** Handler action for the pending requirement (from policy). */
-  readonly action: TanStackRouteUnauthenticatedAction | Promise<TanStackRouteUnauthenticatedAction> | undefined;
-  /** The full effective requirements after composition. */
-  readonly effectiveRequirements: readonly AuthRequirement[];
+interface TanStackRouteSecurityOptions<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>> {
+  readonly requirements?: readonly TAuthRequirement[];
+  readonly composition?: RequirementsComposition;
+  readonly plannerHost?: RequirementPlannerHost<TBehaviour>;
+  readonly behaviour?: RequirementPlannerHostBehaviour<TAuthRequirement, RouteBehaviourContextExtra, TBehaviour>;
 }
-/**
- * Create a root-level route security policy that evaluates a TanStack Router
- * matched route chain and returns the enforcement decision.
- *
- * This is the TanStack Router equivalent of Angular's `secureRouteRoot()`.
- * It centralizes non-serializable runtime policy (handlers, redirects) at
- * the root level, while individual routes only declare serializable metadata
- * via `withTanStackRouteRequirements()`.
- *
- * The returned `evaluate()` function:
- * 1. Extracts requirements from the matched route chain (with composition)
- * 2. Finds the first unmet requirement using the provided `checkAuthenticated`
- * 3. Resolves the handler action (kind handler → default handler → block)
- *
- * @example
- * ```ts
- * import { createTanStackRouteSecurityPolicy } from "@securitydept/client-react/tanstack-router";
- *
- * const policy = createTanStackRouteSecurityPolicy({
- *   requirementHandlers: {
- *     frontend_oidc: (req) => {
- *       redirectToOidcLogin(req);
- *       return false;
- *     },
- *   },
- *   defaultOnUnauthenticated: () => "/login",
- * });
- *
- * // In a route's beforeLoad or a React effect:
- * const result = policy.evaluate(matches, (req) => isAuthenticated(req.kind));
- * if (!result.allMet && typeof result.action === "string") {
- *   navigate({ to: result.action });
- * }
- * ```
- */
-declare function createTanStackRouteSecurityPolicy(options?: TanStackRouteSecurityPolicyOptions): {
-  /**
-   * Evaluate the route security policy for a matched route chain.
-   *
-   * @param matches - The matched route chain (root → leaf).
-   * @param checkAuthenticated - Returns true if a requirement is met.
-   */
-  evaluate(matches: readonly TanStackRouteMatch[], checkAuthenticated: (requirement: AuthRequirement) => boolean, context?: TanStackRouteUnauthenticatedContext): TanStackRouteSecurityResult;
-  /**
-   * Async-capable evaluation for router guards that must wait for auth
-   * freshness checks before deciding whether navigation is allowed.
-   */
-  evaluateAsync(matches: readonly TanStackRouteMatch[], checkAuthenticated: TanStackRouteAuthenticatedCheck, context?: TanStackRouteUnauthenticatedContext): Promise<TanStackRouteSecurityResult>;
-};
-/**
- * Navigation-blocked error thrown by {@link createSecureBeforeLoad} when a
- * requirement is unmet and the handler returns `false`.
- */
-declare class RouteSecurityBlockedError extends Error {
-  readonly requirement: AuthRequirement;
-  readonly result: TanStackRouteSecurityResult;
-  constructor(requirement: AuthRequirement, result: TanStackRouteSecurityResult);
+interface CreateTanStackRouteSecurityPatchOptions {
+  readonly staticData?: object;
+}
+interface TanStackRouteSecurityPatch {
+  readonly staticData: Record<string, unknown>;
+}
+interface TanStackRouteRootSecurityPatch extends TanStackRouteSecurityPatch {
+  readonly beforeLoad: (context: TanStackBeforeLoadContextLike) => Promise<void>;
+}
+declare function createTanStackRouterContext(options?: CreateTanStackRouterContextOptions): Pick<SecuritydeptTanStackRouterContext, "securitydeptInjector">;
+declare function secureRoute<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(security: TanStackRouteSecurityOptions<TAuthRequirement, TBehaviour>, options?: CreateTanStackRouteSecurityPatchOptions): TanStackRouteSecurityPatch;
+declare function secureRouteRoot<TAuthRequirement extends AuthRequirement = AuthRequirement, TBehaviour extends Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>> = Partial<RequirementBehaviourWithRouteContext<TAuthRequirement>>>(security: TanStackRouteSecurityOptions<TAuthRequirement, TBehaviour>, options?: CreateTanStackRouteSecurityPatchOptions): TanStackRouteRootSecurityPatch;
+//#endregion
+//#region src/tanstack-router/router.d.ts
+interface TanStackRouterLocationLike {
+  readonly href: string;
+}
+interface TanStackRouterNavigationLike {
+  readonly state?: {
+    readonly location?: TanStackRouterLocationLike;
+  };
+  navigate(options: TanStackRouterNavigateOptions): Promise<unknown> | unknown;
 }
-/**
- * Minimal shape of TanStack Router's `beforeLoad` context.
- *
- * Only the fields actually consumed by {@link createSecureBeforeLoad} are
- * required. The full TanStack Router context has many more fields; this
- * interface lets the helper stay structurally compatible without importing
- * the full framework type.
- */
-interface SecureBeforeLoadContext {
-  /** URL location of the target route. */
-  location: TanStackRouteLocation;
-  /**
-   * Matched route entries for the current navigation.
-   * Shape matches {@link TanStackRouteMatch}.
-   */
-  matches: readonly TanStackRouteMatch[];
-  /** Navigation cause ("enter", "stay", "push", "replace", etc.). */
-  cause: string;
+type TanStackRouterNavigateOptions = NavigateOptions<AnyRouter, string, string | undefined, string, "">;
+interface CreateRouterForTanStackRouterOptions {
+  readonly router: TanStackRouterNavigationLike;
+  readonly currentUrl?: string | null;
 }
-/**
- * Options for {@link createSecureBeforeLoad}.
- */
-interface CreateSecureBeforeLoadOptions extends TanStackRouteSecurityPolicyOptions {
-  /**
-   * Returns true if the given auth requirement is currently satisfied.
-   *
-   * This is the auth-state bridge: the adopter supplies a function that
-   * checks their auth store / context.
-   */
-  checkAuthenticated: TanStackRouteAuthenticatedCheck;
-  /**
-   * TanStack Router's `redirect()` function.
-   *
-   * When a handler returns a string (redirect path), `createSecureBeforeLoad`
-   * throws `redirect({ to: path })` to trigger TanStack Router's redirect
-   * mechanism.
-   *
-   * Pass `redirect` from `@tanstack/react-router` here:
-   * ```ts
-   * import { redirect } from "@tanstack/react-router";
-   * createSecureBeforeLoad({ redirect, ... });
-   * ```
-   *
-   * If omitted, string actions cause a {@link RouteSecurityBlockedError}
-   * with the redirect path in the error message.
-   */
-  redirect?: (opts: {
-    to: string;
-  }) => never;
+interface ResolvedRouterForTanStackRouterCreateOptions {
+  readonly router: TanStackRouterNavigationLike;
+  readonly currentUrl: string | null;
 }
-/**
- * Create a `beforeLoad`-compatible function that enforces route-security
- * requirements inside TanStack Router's execution semantics.
- *
- * **This is the canonical TanStack Router adopter-facing entry** — the
- * equivalent of Angular's `secureRouteRoot()`.
- *
- * How it works:
- * 1. Receives TanStack Router's `beforeLoad` context (including `matches`)
- * 2. Extracts the full requirement chain with composition semantics
- * 3. Finds the first unmet requirement
- * 4. Calls the handler (kind handler → default → block)
- * 5. If the handler returns a string path, throws `redirect({ to: path })`
- * 6. If the handler returns `false`, throws {@link RouteSecurityBlockedError}
- * 7. If all requirements are met, returns normally (navigation proceeds)
- *
- * @example
- * ```ts
- * import { redirect, createRoute } from "@tanstack/react-router";
- * import {
- *   createSecureBeforeLoad,
- *   withTanStackRouteRequirements,
- * } from "@securitydept/client-react/tanstack-router";
- *
- * // Root-level: non-serializable runtime policy
- * const securedBeforeLoad = createSecureBeforeLoad({
- *   redirect,
- *   checkAuthenticated: (req) => authStore.isAuthenticated(req.kind),
- *   requirementHandlers: {
- *     frontend_oidc: (req) => "/login/oidc",
- *     session: () => "/login",
- *   },
- * });
- *
- * // Root route — attach the beforeLoad
- * const rootRoute = createRootRoute({
- *   beforeLoad: securedBeforeLoad,
- * });
- *
- * // Child routes — serializable declaration only
- * const dashboardRoute = createRoute({
- *   getParentRoute: () => rootRoute,
- *   path: "dashboard",
- *   staticData: withTanStackRouteRequirements([
- *     { id: "session", kind: "session" },
- *   ]),
- * });
- *
- * const adminRoute = createRoute({
- *   getParentRoute: () => dashboardRoute,
- *   path: "admin",
- *   staticData: withTanStackRouteRequirements([
- *     { id: "admin-oidc", kind: "frontend_oidc" },
- *   ]),
- * });
- * ```
- */
-declare function createSecureBeforeLoad(options: CreateSecureBeforeLoadOptions): (ctx: SecureBeforeLoadContext) => void | Promise<void>;
-/**
- * Build a route-security handler for full-page external redirects.
- *
- * The callback should start the browser navigation, typically by calling an
- * auth client's `loginWithRedirect({ postAuthRedirectUri: context.attemptedUrl })`.
- * After that navigation has been started, the returned guard result never
- * settles so TanStack Router does not finalize an in-app blocked navigation
- * while the page is leaving for an external IdP.
- */
-declare function createExternalRedirectBeforeLoadHandler(startRedirect: (requirement: AuthRequirement, context: TanStackRouteUnauthenticatedContext) => void | Promise<void>): TanStackRouteUnauthenticatedHandler;
+declare function createRouterForTanStackRouter(options: CreateRouterForTanStackRouterOptions & WithTraitInputValidator<Pick<EnvironmentValidators, "router">>): RouterTrait;
 //#endregion
-export { type AnyRoute, type AuthRequirement, CreateSecureBeforeLoadOptions, DEFAULT_COMPOSITION_KEY, DEFAULT_REQUIREMENTS_KEY, type RegisteredRouter, RequirementsClientSetComposition, type RouteMatchNode, RouteRequirementsDeclaration, RouteSecurityBlockedError, SecureBeforeLoadContext, TanStackRouteAuthenticatedCheck, TanStackRouteLocation, TanStackRouteMatch, TanStackRouteSecurityPolicyOptions, TanStackRouteSecurityResult, TanStackRouteUnauthenticatedAction, TanStackRouteUnauthenticatedContext, TanStackRouteUnauthenticatedHandler, TanStackRouterAdapterOptions, WithTanStackRouteRequirementsOptions, createExternalRedirectBeforeLoadHandler, createSecureBeforeLoad, createTanStackRouteActivator, createTanStackRouteSecurityPolicy, extractTanStackRouteRequirements, projectTanStackRouteMatches, resolveEffectiveRequirements, withTanStackRouteRequirements };
+export { CreateRouterForTanStackRouterOptions, CreateTanStackBeforeLoadOptions, CreateTanStackBeforeLoadWithBehaviourOptions, CreateTanStackBeforeLoadWithPlannerHostOptions, CreateTanStackRouteSecurityPatchOptions, CreateTanStackRouterContextOptions, ResolvedRouterForTanStackRouterCreateOptions, SecuritydeptTanStackRouterContext, TanStackBeforeLoadContextLike, TanStackRouteMatchLike, TanStackRouteRootSecurityPatch, TanStackRouteSecurityBlockedError, TanStackRouteSecurityOptions, TanStackRouteSecurityPatch, TanStackRouterLocationLike, TanStackRouterNavigateOptions, TanStackRouterNavigationLike, createRouterForTanStackRouter, createTanStackBeforeLoad, createTanStackRouterContext, projectTanStackRouteSegments, secureRoute, secureRouteRoot };
 //# sourceMappingURL=index.d.mts.map