@real-router/core 0.41.0 → 0.42.0

package/dist/esm/validation.d.mts

@@ -1,12 +1,14 @@
-import { L as Limits, R as RouterValidator } from './RouterValidator-CaIeCVeB.mjs';
-import { DefaultDependencies, Params, ForwardToCallback, GuardFnFactory, State, SimpleState, GuardFn, RouteTreeState, Options, EventName, Plugin, EventMethodMap, Unsubscribe, PluginFactory, Router } from '@real-router/types';
-import { a as RouteDefinition, R as RouteTree, M as Matcher, C as CreateMatcherOptions } from './index.d-y2b-8_3Y.mjs';
+import { a as Limits, d as RouteDefinition, f as RouteTree, i as GuardFnFactory, l as CreateMatcherOptions, o as PluginFactory, r as EventMethodMap, u as Matcher } from "./Router-4JRfQLMM.mjs";
+import { t as RouterValidator } from "./RouterValidator-DphcVMEp.mjs";
+import { DefaultDependencies, EventName, ForwardToCallback, GuardFn, Options, Params, Plugin, RouteTreeState, Router, SimpleState, State, Unsubscribe } from "@real-router/types";
 
+//#region src/namespaces/DependenciesNamespace/dependenciesStore.d.ts
 interface DependenciesStore<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    dependencies: Partial<Dependencies>;
-    limits: Limits;
+  dependencies: Partial<Dependencies>;
+  limits: Limits;
 }
-
+//#endregion
+//#region src/namespaces/RoutesNamespace/types.d.ts
 /**
  * Dependencies injected into RoutesNamespace.
  *
@@ -14,42 +16,44 @@ interface DependenciesStore<Dependencies extends DefaultDependencies = DefaultDe
  * avoiding the need to pass the entire Router object.
  */
 interface RoutesDependencies<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    /** Register canActivate handler for a route */
-    addActivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
-    /** Register canDeactivate handler for a route */
-    addDeactivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
-    /** Create state object */
-    makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P>;
-    /** Get current router state */
-    getState: () => State | undefined;
-    /** Compare two states for equality */
-    areStatesEqual: (state1: State | undefined, state2: State | undefined, ignoreQueryParams?: boolean) => boolean;
-    /** Get a dependency by name */
-    getDependency: <K extends keyof Dependencies>(name: K) => Dependencies[K];
-    /** Forward state through facade (allows plugin interception) */
-    forwardState: <P extends Params = Params>(name: string, params: P) => SimpleState<P>;
+  /** Register canActivate handler for a route */
+  addActivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
+  /** Register canDeactivate handler for a route */
+  addDeactivateGuard: (name: string, handler: GuardFnFactory<Dependencies>) => void;
+  /** Create state object */
+  makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P>;
+  /** Get current router state */
+  getState: () => State | undefined;
+  /** Compare two states for equality */
+  areStatesEqual: (state1: State | undefined, state2: State | undefined, ignoreQueryParams?: boolean) => boolean;
+  /** Get a dependency by name */
+  getDependency: <K extends keyof Dependencies>(name: K) => Dependencies[K];
+  /** Forward state through facade (allows plugin interception) */
+  forwardState: <P extends Params = Params>(name: string, params: P) => SimpleState<P>;
 }
 /**
  * Configuration storage for routes.
  * Stores decoders, encoders, default params, and forward mappings.
  */
 interface RouteConfig {
-    /** Custom param decoders per route */
-    decoders: Record<string, (params: Params) => Params>;
-    /** Custom param encoders per route */
-    encoders: Record<string, (params: Params) => Params>;
-    /** Default params per route */
-    defaultParams: Record<string, Params>;
-    /** Forward mappings (source -> target) */
-    forwardMap: Record<string, string>;
-    /** Dynamic forward callbacks (source -> callback) */
-    forwardFnMap: Record<string, ForwardToCallback<any>>;
+  /** Custom param decoders per route */
+  decoders: Record<string, (params: Params) => Params>;
+  /** Custom param encoders per route */
+  encoders: Record<string, (params: Params) => Params>;
+  /** Default params per route */
+  defaultParams: Record<string, Params>;
+  /** Forward mappings (source -> target) */
+  forwardMap: Record<string, string>;
+  /** Dynamic forward callbacks (source -> callback) */
+  forwardFnMap: Record<string, ForwardToCallback<any>>;
 }
-
+//#endregion
+//#region src/namespaces/RouteLifecycleNamespace/types.d.ts
 interface RouteLifecycleDependencies<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    compileFactory: (factory: GuardFnFactory<Dependencies>) => GuardFn;
+  compileFactory: (factory: GuardFnFactory<Dependencies>) => GuardFn;
 }
-
+//#endregion
+//#region src/namespaces/RouteLifecycleNamespace/RouteLifecycleNamespace.d.ts
 /**
  * Independent namespace for managing route lifecycle handlers.
  *
@@ -57,128 +61,125 @@ interface RouteLifecycleDependencies<Dependencies extends DefaultDependencies =
  * Instance methods handle state-dependent validation, storage and business logic.
  */
 declare class RouteLifecycleNamespace<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    #private;
-    setDependencies(deps: RouteLifecycleDependencies<Dependencies>): void;
-    /**
-     * Updates handler registration limits (max lifecycle handlers threshold).
-     *
-     * @param limits - Limits configuration with maxLifecycleHandlers
-     */
-    setLimits(limits: Limits): void;
-    setValidatorGetter(getter: () => RouterValidator | null): void;
-    getHandlerCount(type: "activate" | "deactivate"): number;
-    /**
-     * Adds a canActivate guard for a route.
-     * Handles overwrite detection and registration.
-     *
-     * @param name - Route name (input-validated by facade)
-     * @param handler - Guard function or boolean (input-validated by facade)
-     * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
-     */
-    addCanActivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
-    /**
-     * Adds a canDeactivate guard for a route.
-     * Handles overwrite detection and registration.
-     *
-     * @param name - Route name (input-validated by facade)
-     * @param handler - Guard function or boolean (input-validated by facade)
-     * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
-     */
-    addCanDeactivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
-    /**
-     * Removes a canActivate guard for a route.
-     * Input already validated by facade (not registering).
-     *
-     * @param name - Route name (already validated by facade)
-     */
-    clearCanActivate(name: string): void;
-    /**
-     * Removes a canDeactivate guard for a route.
-     * Input already validated by facade (not registering).
-     *
-     * @param name - Route name (already validated by facade)
-     */
-    clearCanDeactivate(name: string): void;
-    /**
-     * Clears all lifecycle handlers (canActivate and canDeactivate).
-     * Used by clearRoutes to reset all lifecycle state.
-     */
-    clearAll(): void;
-    /**
-     * Clears only lifecycle handlers that were registered from route definitions.
-     * Used by HMR to remove definition-sourced guards without touching externally-added guards.
-     */
-    clearDefinitionGuards(): void;
-    /**
-     * Returns lifecycle factories as records for cloning.
-     *
-     * @returns Tuple of [canDeactivateFactories, canActivateFactories]
-     */
-    getFactories(): [
-        Record<string, GuardFnFactory<Dependencies>>,
-        Record<string, GuardFnFactory<Dependencies>>
-    ];
-    /**
-     * Returns compiled lifecycle functions for transition execution.
-     *
-     * @returns Tuple of [canDeactivateFunctions, canActivateFunctions] as Maps
-     */
-    getFunctions(): [Map<string, GuardFn>, Map<string, GuardFn>];
-    canNavigateTo(toDeactivate: string[], toActivate: string[], toState: State, fromState: State | undefined): boolean;
+  #private;
+  setDependencies(deps: RouteLifecycleDependencies<Dependencies>): void;
+  /**
+   * Updates handler registration limits (max lifecycle handlers threshold).
+   *
+   * @param limits - Limits configuration with maxLifecycleHandlers
+   */
+  setLimits(limits: Limits): void;
+  setValidatorGetter(getter: () => RouterValidator | null): void;
+  getHandlerCount(type: "activate" | "deactivate"): number;
+  /**
+   * Adds a canActivate guard for a route.
+   * Handles overwrite detection and registration.
+   *
+   * @param name - Route name (input-validated by facade)
+   * @param handler - Guard function or boolean (input-validated by facade)
+   * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
+   */
+  addCanActivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
+  /**
+   * Adds a canDeactivate guard for a route.
+   * Handles overwrite detection and registration.
+   *
+   * @param name - Route name (input-validated by facade)
+   * @param handler - Guard function or boolean (input-validated by facade)
+   * @param isFromDefinition - True when guard comes from route definition (tracked for HMR replace)
+   */
+  addCanDeactivate(name: string, handler: GuardFnFactory<Dependencies> | boolean, isFromDefinition?: boolean): void;
+  /**
+   * Removes a canActivate guard for a route.
+   * Input already validated by facade (not registering).
+   *
+   * @param name - Route name (already validated by facade)
+   */
+  clearCanActivate(name: string): void;
+  /**
+   * Removes a canDeactivate guard for a route.
+   * Input already validated by facade (not registering).
+   *
+   * @param name - Route name (already validated by facade)
+   */
+  clearCanDeactivate(name: string): void;
+  /**
+   * Clears all lifecycle handlers (canActivate and canDeactivate).
+   * Used by clearRoutes to reset all lifecycle state.
+   */
+  clearAll(): void;
+  /**
+   * Clears only lifecycle handlers that were registered from route definitions.
+   * Used by HMR to remove definition-sourced guards without touching externally-added guards.
+   */
+  clearDefinitionGuards(): void;
+  /**
+   * Returns lifecycle factories as records for cloning.
+   *
+   * @returns Tuple of [canDeactivateFactories, canActivateFactories]
+   */
+  getFactories(): [Record<string, GuardFnFactory<Dependencies>>, Record<string, GuardFnFactory<Dependencies>>];
+  /**
+   * Returns compiled lifecycle functions for transition execution.
+   *
+   * @returns Tuple of [canDeactivateFunctions, canActivateFunctions] as Maps
+   */
+  getFunctions(): [Map<string, GuardFn>, Map<string, GuardFn>];
+  canNavigateTo(toDeactivate: string[], toActivate: string[], toState: State, fromState: State | undefined): boolean;
 }
-
+//#endregion
+//#region src/namespaces/RoutesNamespace/routesStore.d.ts
 interface RoutesStore<Dependencies extends DefaultDependencies = DefaultDependencies> {
-    readonly definitions: RouteDefinition[];
-    readonly config: RouteConfig;
-    tree: RouteTree;
-    matcher: Matcher;
-    resolvedForwardMap: Record<string, string>;
-    routeCustomFields: Record<string, Record<string, unknown>>;
-    rootPath: string;
-    readonly matcherOptions: CreateMatcherOptions | undefined;
-    depsStore: RoutesDependencies<Dependencies> | undefined;
-    lifecycleNamespace: RouteLifecycleNamespace<Dependencies> | undefined;
-    readonly pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>;
-    readonly pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>;
-    readonly treeOperations: {
-        readonly commitTreeChanges: (store: RoutesStore<Dependencies>) => void;
-        readonly resetStore: (store: RoutesStore<Dependencies>) => void;
-        readonly nodeToDefinition: (node: RouteTree) => RouteDefinition;
-    };
+  readonly definitions: RouteDefinition[];
+  readonly config: RouteConfig;
+  tree: RouteTree;
+  matcher: Matcher;
+  resolvedForwardMap: Record<string, string>;
+  routeCustomFields: Record<string, Record<string, unknown>>;
+  rootPath: string;
+  readonly matcherOptions: CreateMatcherOptions | undefined;
+  depsStore: RoutesDependencies<Dependencies> | undefined;
+  lifecycleNamespace: RouteLifecycleNamespace<Dependencies> | undefined;
+  readonly pendingCanActivate: Map<string, GuardFnFactory<Dependencies>>;
+  readonly pendingCanDeactivate: Map<string, GuardFnFactory<Dependencies>>;
+  readonly treeOperations: {
+    readonly commitTreeChanges: (store: RoutesStore<Dependencies>) => void;
+    readonly resetStore: (store: RoutesStore<Dependencies>) => void;
+    readonly nodeToDefinition: (node: RouteTree) => RouteDefinition;
+  };
 }
-
+//#endregion
+//#region src/internals.d.ts
 interface RouterInternals<D extends DefaultDependencies = DefaultDependencies> {
-    readonly makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P>;
-    readonly forwardState: <P extends Params = Params>(routeName: string, routeParams: P) => SimpleState<P>;
-    readonly buildStateResolved: (resolvedName: string, resolvedParams: Params) => RouteTreeState | undefined;
-    readonly matchPath: <P extends Params = Params>(path: string, options?: Options) => State<P> | undefined;
-    readonly getOptions: () => Options;
-    readonly addEventListener: <E extends EventName>(eventName: E, cb: Plugin[EventMethodMap[E]]) => Unsubscribe;
-    readonly buildPath: (route: string, params?: Params) => string;
-    readonly start: (path: string) => Promise<State>;
-    readonly interceptors: Map<string, ((next: (...args: any[]) => any, ...args: any[]) => any)[]>;
-    readonly setRootPath: (rootPath: string) => void;
-    readonly getRootPath: () => string;
-    readonly getTree: () => RouteTree;
-    readonly isDisposed: () => boolean;
-    validator: RouterValidator | null;
-    readonly dependenciesGetStore: () => DependenciesStore<D>;
-    readonly cloneOptions: () => Options;
-    readonly cloneDependencies: () => Record<string, unknown>;
-    readonly getLifecycleFactories: () => [
-        Record<string, GuardFnFactory<D>>,
-        Record<string, GuardFnFactory<D>>
-    ];
-    readonly getPluginFactories: () => PluginFactory<D>[];
-    readonly routeGetStore: () => RoutesStore<D>;
-    readonly getStateName: () => string | undefined;
-    readonly isTransitioning: () => boolean;
-    readonly clearState: () => void;
-    readonly setState: (state: State) => void;
-    readonly routerExtensions: {
-        keys: string[];
-    }[];
+  readonly makeState: <P extends Params = Params>(name: string, params?: P, path?: string, meta?: Record<string, Record<string, "url" | "query">>) => State<P>;
+  readonly forwardState: <P extends Params = Params>(routeName: string, routeParams: P) => SimpleState<P>;
+  readonly buildStateResolved: (resolvedName: string, resolvedParams: Params) => RouteTreeState | undefined;
+  readonly matchPath: <P extends Params = Params>(path: string, options?: Options) => State<P> | undefined;
+  readonly getOptions: () => Options;
+  readonly addEventListener: <E extends EventName>(eventName: E, cb: Plugin[EventMethodMap[E]]) => Unsubscribe;
+  readonly buildPath: (route: string, params?: Params) => string;
+  readonly start: (path: string) => Promise<State>;
+  readonly interceptors: Map<string, ((next: (...args: any[]) => any, ...args: any[]) => any)[]>;
+  readonly setRootPath: (rootPath: string) => void;
+  readonly getRootPath: () => string;
+  readonly getTree: () => RouteTree;
+  readonly isDisposed: () => boolean;
+  validator: RouterValidator | null;
+  readonly dependenciesGetStore: () => DependenciesStore<D>;
+  readonly cloneOptions: () => Options;
+  readonly cloneDependencies: () => Record<string, unknown>;
+  readonly getLifecycleFactories: () => [Record<string, GuardFnFactory<D>>, Record<string, GuardFnFactory<D>>];
+  readonly getPluginFactories: () => PluginFactory<D>[];
+  readonly routeGetStore: () => RoutesStore<D>;
+  readonly getStateName: () => string | undefined;
+  readonly isTransitioning: () => boolean;
+  readonly clearState: () => void;
+  readonly setState: (state: State) => void;
+  readonly routerExtensions: {
+    keys: string[];
+  }[];
 }
 declare function getInternals<D extends DefaultDependencies>(router: Router<D>): RouterInternals<D>;
-
-export { type RouterInternals, RouterValidator, getInternals };
+//#endregion
+export { type RouterInternals, type RouterValidator, getInternals };
+//# sourceMappingURL=validation.d.mts.map

package/dist/esm/validation.mjs

@@ -1 +1 @@
-export{getInternals}from"./chunk-UUG7DSTN.mjs";//# sourceMappingURL=validation.mjs.map
+import{r as e}from"./internals-CCymabFj.mjs";export{e as getInternals};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@real-router/core",
-  "version": "0.41.0",
+  "version": "0.42.0",
   "type": "commonjs",
   "description": "A simple, powerful, view-agnostic, modular and extensible router",
   "main": "./dist/cjs/index.js",
@@ -85,20 +85,18 @@
     "url": "https://github.com/greydragon888/real-router/issues"
   },
   "homepage": "https://github.com/greydragon888/real-router",
-  "sideEffects": [
-    "./dist/esm/chunk-*.mjs"
-  ],
+  "sideEffects": false,
   "dependencies": {
     "@real-router/fsm": "^0.2.2",
     "@real-router/logger": "^0.2.1",
-    "@real-router/types": "^0.27.0"
+    "@real-router/types": "^0.28.0"
   },
   "devDependencies": {
     "event-emitter": "^0.1.2",
     "route-tree": "^0.3.4"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown --config-loader unrun",
     "test": "vitest run functional/",
     "test:properties": "vitest run --config vitest.config.properties.mts",
     "test:coverage": "vitest run functional/ --coverage",
@@ -109,6 +107,6 @@
     "lint": "eslint --cache --ext .ts src/ tests/ --fix --max-warnings 0",
     "lint:package": "publint",
     "lint:types": "attw --pack .",
-    "build:dist-only": "tsup"
+    "build:dist-only": "tsdown --config-loader unrun"
   }
 }

package/src/helpers.ts

@@ -91,12 +91,15 @@ export function deepFreezeState<T extends State>(state: T): T {
     // Freeze the object/array itself
     Object.freeze(obj);
 
-    // Get all values to freeze recursively
-    const values = Array.isArray(obj) ? obj : Object.values(obj);
-
-    // Recursively freeze nested values
-    for (const value of values) {
-      freezeClonedRecursive(value);
+    // Iterate without Object.values() allocation
+    if (Array.isArray(obj)) {
+      for (const item of obj) {
+        freezeClonedRecursive(item);
+      }
+    } else {
+      for (const key in obj) {
+        freezeClonedRecursive((obj as Record<string, unknown>)[key]);
+      }
     }
   }
 

package/src/namespaces/OptionsNamespace/constants.ts

@@ -14,6 +14,7 @@ export const defaultOptions: Options = {
     arrayFormat: "none",
     booleanFormat: "none",
     nullFormat: "default",
+    numberFormat: "none",
   },
   urlParamsEncoding: "default",
   allowNotFound: true,

package/dist/cjs/Router-DoJ3NWsT.d.ts

@@ -1,46 +0,0 @@
-import { DefaultDependencies, Router as Router$1, Route, Options, Params, State, PluginFactory, Unsubscribe, SubscribeFn, NavigationOptions } from '@real-router/types';
-
-/**
- * Router class with integrated namespace architecture.
- *
- * All functionality is provided by namespace classes:
- * - OptionsNamespace: getOptions (immutable)
- * - DependenciesStore: get/set/remove dependencies
- * - EventEmitter: subscribe
- * - StateNamespace: state storage (getState, setState, getPreviousState)
- * - RoutesNamespace: route tree operations
- * - RouteLifecycleNamespace: canActivate/canDeactivate guards
- * - PluginsNamespace: plugin lifecycle
- * - NavigationNamespace: navigate
- * - RouterLifecycleNamespace: start, stop, isStarted
- *
- * @internal This class implementation is internal. Use createRouter() instead.
- */
-declare class Router<Dependencies extends DefaultDependencies = DefaultDependencies> implements Router$1<Dependencies> {
-    #private;
-    [key: string]: unknown;
-    /**
-     * @param routes - Route definitions
-     * @param options - Router options
-     * @param dependencies - DI dependencies
-     */
-    constructor(routes?: Route<Dependencies>[], options?: Partial<Options>, dependencies?: Dependencies);
-    isActiveRoute(name: string, params?: Params, strictEquality?: boolean, ignoreQueryParams?: boolean): boolean;
-    buildPath(route: string, params?: Params): string;
-    getState<P extends Params = Params>(): State<P> | undefined;
-    getPreviousState(): State | undefined;
-    areStatesEqual(state1: State | undefined, state2: State | undefined, ignoreQueryParams?: boolean): boolean;
-    shouldUpdateNode(nodeName: string): (toState: State, fromState?: State) => boolean;
-    isActive(): boolean;
-    start(startPath: string): Promise<State>;
-    stop(): this;
-    dispose(): void;
-    canNavigateTo(name: string, params?: Params): boolean;
-    usePlugin(...plugins: (PluginFactory<Dependencies> | false | null | undefined)[]): Unsubscribe;
-    subscribe(listener: SubscribeFn): Unsubscribe;
-    navigate(routeName: string, routeParams?: Params, options?: NavigationOptions): Promise<State>;
-    navigateToDefault(options?: NavigationOptions): Promise<State>;
-    navigateToNotFound(path?: string): State;
-}
-
-export { Router as R };

package/dist/cjs/RouterValidator-CaIeCVeB.d.ts

@@ -1,136 +0,0 @@
-import { Params, RouteTreeState, LimitsConfig } from '@real-router/types';
-
-/**
- * Core-internal types + re-exports from @real-router/types.
- *
- * Factory types (PluginFactory, GuardFnFactory) and
- * route config types (Route, RouteConfigUpdate) are canonical in @real-router/types
- * and re-exported here for backward compatibility.
- */
-
-/**
- * Immutable limits configuration type.
- */
-type Limits = Readonly<LimitsConfig>;
-/**
- * Extended build result that includes segments for path building.
- * Used internally to avoid duplicate getSegmentsByName calls.
- *
- * @param segments - Route segments from getSegmentsByName (typed as unknown[] for cross-package compatibility)
- * @internal
- */
-interface BuildStateResultWithSegments<P extends Params = Params> {
-    readonly state: RouteTreeState<P>;
-    readonly segments: readonly unknown[];
-}
-
-/**
- * RouterValidator interface - defines all validation methods used by the router.
- *
- * This interface is implemented by the validation plugin and injected into RouterInternals.
- * When ctx.validator is null (default), validation is skipped.
- * When ctx.validator is set (by validation plugin), all methods are called.
- *
- * All parameters use `unknown` type to avoid coupling to internal type names.
- */
-interface RouterValidator {
-    /**
-     * Route validation methods
-     */
-    routes: {
-        validateBuildPathArgs: (route: unknown) => void;
-        validateMatchPathArgs: (path: unknown) => void;
-        validateIsActiveRouteArgs: (name: unknown, params: unknown, strict: unknown, ignoreQP: unknown) => void;
-        validateShouldUpdateNodeArgs: (name: unknown) => void;
-        validateStateBuilderArgs: (name: unknown, params: unknown, caller: string) => void;
-        validateAddRouteArgs: (routes: unknown) => void;
-        validateRoutes: (routes: unknown[], tree: unknown) => void;
-        validateRemoveRouteArgs: (name: unknown) => void;
-        validateUpdateRouteBasicArgs: (name: unknown, updates: unknown) => void;
-        validateUpdateRoutePropertyTypes: (name: string, updates: unknown) => void;
-        validateUpdateRoute: (name: string, updates: unknown, tree: unknown) => void;
-        validateParentOption: (parent: unknown, tree: unknown) => void;
-        validateRouteName: (name: unknown, caller: string) => void;
-        throwIfInternalRoute: (name: unknown, caller: string) => void;
-        throwIfInternalRouteInArray: (routes: unknown[], caller: string) => void;
-        validateExistingRoutes: (store: unknown) => void;
-        validateForwardToConsistency: (store: unknown) => void;
-        validateSetRootPathArgs: (rootPath: unknown) => void;
-        guardRouteCallbacks: (route: unknown) => void;
-        guardNoAsyncCallbacks: (route: unknown) => void;
-    };
-    /**
-     * Options validation methods
-     */
-    options: {
-        validateLimitValue: (name: string, value: unknown) => void;
-        validateLimits: (limits: unknown) => void;
-        validateOptions: (options: unknown, methodName: string) => void;
-    };
-    /**
-     * Dependencies validation methods
-     */
-    dependencies: {
-        validateDependencyName: (name: unknown, caller: string) => void;
-        validateSetDependencyArgs: (name: unknown, value: unknown, caller: string) => void;
-        validateDependenciesObject: (deps: unknown, caller: string) => void;
-        validateDependencyExists: (name: string, store: unknown) => void;
-        validateDependencyLimit: (store: unknown, limits: unknown) => void;
-        validateDependenciesStructure: (store: unknown) => void;
-        validateDependencyCount: (store: unknown, methodName: string) => void;
-        validateCloneArgs: (dependencies: unknown) => void;
-        warnOverwrite: (name: string, methodName: string) => void;
-        warnBatchOverwrite: (keys: string[], methodName: string) => void;
-        warnRemoveNonExistent: (name: unknown) => void;
-    };
-    /**
-     * Plugin validation methods
-     */
-    plugins: {
-        validatePluginLimit: (count: number, limits: unknown) => void;
-        validateNoDuplicatePlugins: (factory: unknown, factories: unknown[]) => void;
-        validatePluginKeys: (plugin: unknown) => void;
-        validateCountThresholds: (count: number) => void;
-        warnBatchDuplicates: (plugins: unknown[]) => void;
-        warnPluginMethodType: (methodName: string) => void;
-        warnPluginAfterStart: (methodName: string) => void;
-        validateAddInterceptorArgs: (method: unknown, fn: unknown) => void;
-    };
-    /**
-     * Lifecycle guard validation methods
-     */
-    lifecycle: {
-        validateHandler: (handler: unknown, caller: string) => void;
-        validateNotRegistering: (name: string, guards: unknown, caller: string) => void;
-        validateHandlerLimit: (count: number, limits: unknown, caller: string) => void;
-        validateCountThresholds: (count: number, methodName: string) => void;
-        warnOverwrite: (name: string, type: string, methodName: string) => void;
-        warnAsyncGuardSync: (name: string, methodName: string) => void;
-    };
-    /**
-     * Navigation validation methods
-     */
-    navigation: {
-        validateNavigateArgs: (name: unknown) => void;
-        validateNavigateToDefaultArgs: (options: unknown) => void;
-        validateNavigationOptions: (options: unknown, caller: string) => void;
-        validateParams: (params: unknown, methodName: string) => void;
-        validateStartArgs: (path: unknown) => void;
-    };
-    /**
-     * State validation methods
-     */
-    state: {
-        validateMakeStateArgs: (name: unknown, params: unknown, path: unknown) => void;
-        validateAreStatesEqualArgs: (s1: unknown, s2: unknown, ignoreQP: unknown) => void;
-    };
-    /**
-     * Event bus validation methods
-     */
-    eventBus: {
-        validateEventName: (name: unknown) => void;
-        validateListenerArgs: (name: unknown, cb: unknown) => void;
-    };
-}
-
-export type { BuildStateResultWithSegments as B, Limits as L, RouterValidator as R };