boltdocs 3.3.6 → 3.4.0

package/dist/{index-DLaHgD-i.d.cts → index-Bx0CUd7Q.d.ts}

@@ -1,8 +1,8 @@
 
-import { Q as CreateRoutesResult, _t as StructuredData$1, ct as BoltdocsIntegrationsConfig, ft as BoltdocsRoutePathWithFallback, gt as JsonLdObject, ht as BoltdocsVersion, lt as BoltdocsLocale, ot as BadgeValue, pt as BoltdocsSocialLink, st as BoltdocsConfig, ut as BoltdocsMdxComponents } from "./index-CgWkOCCn.cjs";
+import { Q as CreateRoutesResult, ct as BoltdocsIntegrationsConfig, ft as BoltdocsRoutePathWithFallback, gt as JsonLdObject, ht as BoltdocsVersion, lt as BoltdocsLocale, ot as BadgeValue, pt as BoltdocsSocialLink, st as BoltdocsConfig, ut as BoltdocsMdxComponents, yt as StructuredData$1 } from "./index--xbYbT8N.js";
+import { ViteReactSSG } from "@bdocs/ssg";
 import * as React$2 from "react";
 import React$1, { ComponentType, JSXElementConstructor, ReactNode, SVGProps } from "react";
-import { ViteReactSSG } from "@bdocs/ssg";
 import * as _$react_jsx_runtime0 from "react/jsx-runtime";
 import { ClassValue } from "clsx";
 
@@ -272,19 +272,45 @@ type MdxPageProps = {
   MDXComponent: React.ComponentType<React.PropsWithChildren<unknown>>;
   mdxComponents: Record<string, React.ComponentType<HTMLElement>>;
   collectionPostComponent?: React.ComponentType<any>;
+  /**
+   * Name of the collection this route belongs to, when it has one.
+   *
+   * The layout must not depend on data that arrives asynchronously. Route
+   * metadata is known synchronously from the route table, whereas the loader
+   * data is not: on the client the first render happens with no loader data,
+   * because the generated entry declares `hasLoaderData={false}`. Deciding the
+   * layout from the loader therefore picked the documentation layout for a
+   * collection post, while the server had rendered the collection layout. React
+   * saw two different first children and discarded the whole page (error #418).
+   *
+   * A project that declares a collection should not have to know this, so the
+   * route table supplies the answer directly and the loader is only a fallback
+   * for callers that render `MdxPage` directly.
+   */
+  collection?: string;
+  /**
+   * Route metadata for the current page, when known synchronously.
+   *
+   * `usePost()` reads from `CurrentPostProvider`, and a collection layout calls
+   * it on its first render. Passing the route keeps that first render complete
+   * instead of rendering a header with no title and then filling it in.
+   */
+  route?: ComponentRoute;
 };
 /**
  * Renders an MDX page by consuming pre-loaded route data.
  *
- * - If the route belongs to a collection (`data.collection` is set), wraps
- *   the content with `CurrentPostProvider` so that `usePost()` (called without
- *   a slug) can read the current post's data from context.
+ * - If the route belongs to a collection, wraps the content with
+ *   `CurrentPostProvider` so that `usePost()` (called without a slug) can read
+ *   the current post's data from context.
  * - Otherwise, renders the standard `DocPage` layout.
  */
 declare function MdxPage({
   MDXComponent,
   mdxComponents: propComponents,
-  collectionPostComponent: CollectionPost
+  collectionPostComponent: CollectionPost,
+  collection,
+  route: routeProp
 }: MdxPageProps): _$react_jsx_runtime0.JSX.Element | null;
 //#endregion
 //#region src/client/ssg/boltdocs-shell.d.ts
@@ -302,6 +328,50 @@ declare function BoltdocsShell({
   contentClassName?: string;
 }): _$react_jsx_runtime0.JSX.Element;
 //#endregion
+//#region src/client/collections/utils.d.ts
+/**
+ * Formats a date to a human-readable string.
+ *
+ * Locale and time zone are pinned so the server and the browser produce
+ * identical text during hydration. See `formatDeterministicDate`.
+ */
+declare function formatDate(date: string | Date | undefined | null, options?: {
+  month?: 'numeric' | '2-digit' | 'long' | 'short';
+  day?: 'numeric' | '2-digit';
+}): string;
+//#endregion
+//#region src/client/utils/date.d.ts
+/**
+ * Deterministic date formatting for server-rendered output.
+ *
+ * `toLocaleDateString` with no locale resolves against the *runtime* default,
+ * which is not the same in Node and in a browser: the server rendered
+ * "26 de septiembre de 2026" from an `es` system locale while the client
+ * produced "September 26, 2026". That is a text mismatch during hydration and
+ * React throws away the server HTML and re-renders the whole page.
+ *
+ * The time zone has to be pinned for the same reason. A frontmatter date such
+ * as `2026-09-27` parses as UTC midnight, so any zone behind UTC renders the
+ * previous day and any zone ahead renders the correct one, which is a second,
+ * environment-dependent mismatch.
+ *
+ * Both are therefore explicit here. Callers that genuinely want a different
+ * locale can pass one, and it is still deterministic because it is fixed in
+ * the markup rather than inferred.
+ */
+/**
+ * Formats a date as a stable, locale- and zone-pinned string.
+ *
+ * Returns an empty string for values that are not real dates so callers can
+ * render nothing rather than "Invalid Date".
+ */
+declare function formatDeterministicDate(date: string | number | Date | undefined | null, options?: {
+  locale?: string;
+  timeZone?: string;
+  month?: 'numeric' | '2-digit' | 'long' | 'short' | 'narrow';
+  day?: 'numeric' | '2-digit';
+}): string;
+//#endregion
 //#region src/client/app/config-context.d.ts
 /**
  * Hook to access the Boltdocs configuration.
@@ -339,7 +409,13 @@ declare function useUI(): {
 declare function useNavbar(): {
   links: NavbarLink[];
   title: string;
-  logo: string | null;
+  logo: {
+    light: string;
+    dark: null;
+  } | {
+    light: string;
+    dark: string;
+  } | null;
   logoProps: {
     alt: string;
     width: number | undefined;
@@ -1220,10 +1296,13 @@ interface ViewTransitionRunner {
   enabled: boolean;
   /** Whether the current browser exposes the native API. */
   supported: boolean;
+  /** Whether the visitor asked the OS to reduce motion. */
+  reducedMotion: boolean;
 }
 /**
- * Starts a native document transition when the browser supports it. On older
- * browsers, the update still runs normally and the function returns null.
+ * Starts a native document transition when the browser supports it and the
+ * visitor has not asked for reduced motion. Otherwise the update still runs
+ * normally and the function returns null.
  */
 declare function startViewTransition(update: ViewTransitionUpdate, options?: ViewTransitionOptions): ViewTransitionHandle | null;
 /**
@@ -1371,4 +1450,4 @@ declare function useCodeBlockFeedback(options?: UseCodeBlockFeedbackOptions): {
   enabled: boolean;
 };
 //#endregion
-export { SidebarItem as $, cn as A, useUI as At, NotFound as B, CollectionsData as Bt, createArticleStructuredData as C, usePageNav as Ct, defineStructuredData as D, useSearch as Dt, createWebSiteStructuredData as E, useTabs as Et, TimelineVariant as F, BoltdocsShell as Ft, Breadcrumbs as G, ComponentRoute as Gt, CopyMarkdown as H, BoltdocsTab as Ht, usePost as I, MdxPage as It, Sidebar$1 as J, OnThisPageProps as Jt, OnThisPage as K, LayoutProps as Kt, usePosts as L, createRoutes as Lt, TimelineBadgeConfig as M, useTheme as Mt, TimelineItemProps as N, useConfig as Nt, getTranslated as O, useSidebar as Ot, TimelineProps as P, ViteReactSSG as Pt, SidebarHeader as Q, useRecentPosts as R, CollectionPost$1 as Rt, WebSiteStructuredDataOptions as S, useBreadcrumbs as St, createStructuredData as T, useVersion as Tt, ErrorBoundary as U, CollectionListLoaderData as Ut, SearchDialog as V, CurrentPostProvider as Vt, PageNav as W, CollectionPostLoaderData as Wt, SidebarGroup as X, SiteConfig as Xt, SidebarContent as Y, SidebarProps$1 as Yt, SidebarGroupRenderProps as Z, TabsProps as Zt, StructuredData as _, useTrackEvent as _t, useExpandable as a, SidebarLinkProps as at, BreadcrumbStructuredDataItem as b, useLocalizedTo as bt, getStarsRepo as c, SidebarSlots as ct, ViewTransitionHandle as d, Navbar as dt, SidebarItemProps as et, ViewTransitionOptions as f, DocsLayoutComponent as ft, useViewTransition as g, useAnalytics as gt, startViewTransition as h, useHeadings as ht, UseExpandableOptions as i, SidebarLink as it, Timeline as j, useMdxComponents as jt, resolvePublicAssetUrl as k, useNavbar as kt, copyToClipboard as l, SidebarSubGroup as lt, ViewTransitionUpdate as m, useMergedComponents as mt, UseCodeBlockFeedbackOptions as n, SidebarItems$1 as nt, useCopyButton as o, SidebarMobile as ot, ViewTransitionRunner as p, useFeedback as pt, Sidebar as q, NavbarLink as qt, useCodeBlockFeedback as r, SidebarItemsProps as rt, useCodeBlock as s, SidebarRoot as st, CodeBlockFeedbackPayload as t, SidebarItemRenderProps as tt, reactToText as u, ComponentBase as ut, StructuredDataProps as v, useTrackPageView as vt, createBreadcrumbStructuredData as w, useI18n as wt, StructuredDataFactoryOptions as x, useRoutes as xt, ArticleStructuredDataOptions as y, useSearchHighlight as yt, Banner as z, CollectionsContext as zt };
+export { SidebarItem as $, TabsProps as $t, cn as A, useUI as At, NotFound as B, CollectionPost$1 as Bt, createArticleStructuredData as C, usePageNav as Ct, defineStructuredData as D, useSearch as Dt, createWebSiteStructuredData as E, useTabs as Et, TimelineVariant as F, formatDate as Ft, Breadcrumbs as G, CollectionListLoaderData as Gt, CopyMarkdown as H, CollectionsData as Ht, usePost as I, ViteReactSSG as It, Sidebar$1 as J, LayoutProps as Jt, OnThisPage as K, CollectionPostLoaderData as Kt, usePosts as L, BoltdocsShell as Lt, TimelineBadgeConfig as M, useTheme as Mt, TimelineItemProps as N, useConfig as Nt, getTranslated as O, useSidebar as Ot, TimelineProps as P, formatDeterministicDate as Pt, SidebarHeader as Q, SiteConfig as Qt, useRecentPosts as R, MdxPage as Rt, WebSiteStructuredDataOptions as S, useBreadcrumbs as St, createStructuredData as T, useVersion as Tt, ErrorBoundary as U, CurrentPostProvider as Ut, SearchDialog as V, CollectionsContext as Vt, PageNav as W, BoltdocsTab as Wt, SidebarGroup as X, OnThisPageProps as Xt, SidebarContent as Y, NavbarLink as Yt, SidebarGroupRenderProps as Z, SidebarProps$1 as Zt, StructuredData as _, useTrackEvent as _t, useExpandable as a, SidebarLinkProps as at, BreadcrumbStructuredDataItem as b, useLocalizedTo as bt, getStarsRepo as c, SidebarSlots as ct, ViewTransitionHandle as d, Navbar as dt, SidebarItemProps as et, ViewTransitionOptions as f, DocsLayoutComponent as ft, useViewTransition as g, useAnalytics as gt, startViewTransition as h, useHeadings as ht, UseExpandableOptions as i, SidebarLink as it, Timeline as j, useMdxComponents as jt, resolvePublicAssetUrl as k, useNavbar as kt, copyToClipboard as l, SidebarSubGroup as lt, ViewTransitionUpdate as m, useMergedComponents as mt, UseCodeBlockFeedbackOptions as n, SidebarItems$1 as nt, useCopyButton as o, SidebarMobile as ot, ViewTransitionRunner as p, useFeedback as pt, Sidebar as q, ComponentRoute as qt, useCodeBlockFeedback as r, SidebarItemsProps as rt, useCodeBlock as s, SidebarRoot as st, CodeBlockFeedbackPayload as t, SidebarItemRenderProps as tt, reactToText as u, ComponentBase as ut, StructuredDataProps as v, useTrackPageView as vt, createBreadcrumbStructuredData as w, useI18n as wt, StructuredDataFactoryOptions as x, useRoutes as xt, ArticleStructuredDataOptions as y, useSearchHighlight as yt, Banner as z, createRoutes as zt };

package/dist/index-RK7W_Fxy.d.cts

@@ -0,0 +1,343 @@
+
+import * as _$react from "react";
+import React$1, { ComponentType, ReactNode } from "react";
+import { IncomingMessage, ServerResponse } from "node:http";
+import { AliasOptions, Plugin, UserConfig } from "vite";
+import { BadgeValue, BoltdocsCollectionsConfig, BoltdocsConfigContract, BoltdocsI18nConfig, BoltdocsIntegrationsConfig, BoltdocsVersionsConfig, CodeHighlightConfig, CodeTheme, JsonLdObject, PluginDefinition, RedirectConfig, RedirectStatus, StructuredData } from "@bdocs/contracts";
+
+//#region src/shared/types.d.ts
+/**
+ * Represents a single social link in the configuration.
+ */
+interface BoltdocsSocialLink {
+  icon: 'discord' | 'x' | 'github' | 'bluesky' | string;
+  link: string;
+}
+/**
+ * Theme-specific configuration options.
+ */
+interface BoltdocsThemeConfig {
+  title?: string | Record<string, string>;
+  description?: string | Record<string, string>;
+  logo?: string | {
+    dark: string;
+    light: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+  };
+  navbar?: Array<{
+    label: string | Record<string, string>;
+    href: BoltdocsRoutePathWithFallback;
+    items?: Array<{
+      label: string | Record<string, string>;
+      href: BoltdocsRoutePathWithFallback;
+    }>;
+  }>;
+  sidebar?: Record<string, Array<{
+    text: string;
+    link: BoltdocsRoutePathWithFallback;
+  }>>;
+  sidebarGroups?: Record<string, {
+    title?: string | Record<string, string>;
+    icon?: string;
+  }>;
+  socialLinks?: BoltdocsSocialLink[];
+  editLink?: string;
+  communityHelp?: string;
+  version?: string;
+  githubRepo?: string;
+  favicon?: string;
+  tabs?: Array<{
+    id: string;
+    text: string | Record<string, string>;
+    icon?: string;
+  }>;
+  /**
+   * Legacy alias for `codeHighlighting.theme`. Kept for backwards
+   * compatibility — prefer `codeHighlighting`.
+   * @deprecated Use `codeHighlighting` instead.
+   */
+  codeTheme?: CodeTheme;
+  /**
+   * Configures the markdown code highlighting engine. The engine is
+   * engine-agnostic: `engine` accepts a registry id (`'shiki'` by default),
+   * an adapter instance, or an adapter factory — so any highlighter can be
+   * plugged in without changes to the core.
+   *
+   * Shorthand: a plain string is a registry id, i.e. `'shiki'` is
+   * equivalent to `{ engine: 'shiki' }` (resolved by
+   * `normalizeCodeHighlightConfig()` at every read site).
+   */
+  codeHighlighting?: CodeHighlightConfig | string;
+}
+interface BoltdocsPlugin extends PluginDefinition<BoltdocsConfig, IncomingMessage, ServerResponse> {
+  vitePlugins?: Plugin[];
+}
+/**
+ * The root configuration object for Boltdocs.
+ */
+interface BoltdocsConfig extends BoltdocsConfigContract<BoltdocsPlugin> {
+  theme?: BoltdocsThemeConfig;
+  aliases?: AliasOptions;
+  vite?: UserConfig;
+}
+/**
+ * Global namespace for Boltdocs types that can be augmented by generated code.
+ * This allows for strictly typed locales and versions based on the project configuration.
+ */
+declare global {
+  namespace Boltdocs {
+    interface Types {}
+    /**
+     * Marker interface augmented by generated code to provide strict route path typing.
+     * When no types have been generated (e.g., before first dev server start),
+     * keyof is never, and BoltdocsRoutePath falls back to string.
+     */
+    interface RoutePaths {}
+  }
+}
+type BoltdocsTypes = Boltdocs.Types;
+type BoltdocsRoutePath = keyof Boltdocs.RoutePaths;
+type ExternalRouteReference = `/${string}` | `#${string}` | `?${string}` | `site:/${string}` | `site:${string}` | `http://${string}` | `https://${string}` | `//${string}`;
+type BoltdocsRoutePathWithFallback = BoltdocsRoutePath | ExternalRouteReference | string;
+type BoltdocsLocale = Boltdocs.Types extends {
+  Locale: infer L;
+} ? L : string;
+type BoltdocsVersion = Boltdocs.Types extends {
+  Version: infer V;
+} ? V : string;
+type UnpackMdxComponents<T> = T extends {
+  default: infer D;
+} ? D : T;
+type TransformMdxComponents<T> = { [K in keyof T as K extends `Frontmatter_${string}` ? never : K]: T[K] } & {
+  Frontmatter: { [K in keyof T as K extends `Frontmatter_${infer Name}` ? Name : never]: T[K] };
+};
+type BoltdocsMdxComponents = Boltdocs.Types extends {
+  MdxComponents: infer M;
+} ? TransformMdxComponents<UnpackMdxComponents<M>> : Omit<Record<string, ComponentType<unknown>>, 'Frontmatter'> & {
+  Frontmatter: Record<string, ComponentType<unknown>>;
+};
+//#endregion
+//#region src/client/router/types.d.ts
+interface LoaderFunctionArgs {
+  request: Request;
+  params: Record<string, string>;
+}
+type LoaderFunction<T = unknown> = (args: LoaderFunctionArgs) => Promise<T> | T;
+type PrefetchFunction$1 = (to: string) => Promise<void>;
+interface RouteMatch {
+  route: RouteRecord;
+  params: Record<string, string>;
+  pathname: string;
+  pathnameBase: string;
+  data?: Record<string, unknown>;
+}
+interface LazyRouteResult {
+  Component?: ComponentType<any>;
+  element?: ReactNode;
+  loader?: LoaderFunction;
+  ErrorBoundary?: ComponentType<any>;
+}
+/** Structurally compatible with react-router-dom's route objects */
+interface RouteRecord {
+  path?: string;
+  index?: boolean;
+  id?: string;
+  element?: ReactNode;
+  Component?: ComponentType<any>;
+  loader?: LoaderFunction;
+  action?: (...args: any[]) => any;
+  ErrorBoundary?: ComponentType<any>;
+  hasErrorBoundary?: boolean;
+  HydrateFallback?: ComponentType<any>;
+  children?: RouteRecord[];
+  lazy?: () => Promise<LazyRouteResult>;
+  caseSensitive?: boolean;
+  shouldRevalidate?: (...args: any[]) => boolean;
+  getStaticPaths?: () => string[] | Promise<string[]>;
+  entry?: string;
+  /** Locale this route belongs to (used by i18n fallbacks) */
+  locale?: string;
+}
+interface RouterOptions {
+  routes: RouteRecord[];
+  basename?: string;
+  future?: Record<string, boolean>;
+}
+interface RouteRendererProps {
+  routes: RouteRecord[];
+  pathname?: string;
+  loaderData?: Record<string, unknown> | null;
+  /** Whether loaderData was explicitly produced for the initial SSR route. */
+  hasLoaderData?: boolean;
+  /** Resolved branch supplied by SSR so lazy MDX routes render without effects. */
+  resolvedBranch?: RouteRecord[];
+  basename?: string;
+  /** Default locale is omitted from external URLs. */
+  defaultLocale?: string;
+  /** Optional route prefetcher used by Link hover/focus interactions. */
+  prefetch?: PrefetchFunction$1;
+  /** Enables native View Transitions for route updates. */
+  viewTransitions?: boolean | {
+    enabled?: boolean;
+    types?: string[];
+  };
+}
+interface CreateRoutesResult {
+  routes: RouteRecord[];
+  RouteRenderer: ComponentType<RouteRendererProps>;
+  matchRouteBranch: (routes: RouteRecord[], pathname: string) => RouteRecord[];
+  matchRouteBranchWithParams: (routes: RouteRecord[], pathname: string, basename?: string) => Array<{
+    route: RouteRecord;
+    params: Record<string, string>;
+  }>;
+  resolveRouteBranch: (branch: RouteRecord[]) => Promise<RouteRecord[]>;
+}
+//#endregion
+//#region src/client/router/context.d.ts
+interface LocationState {
+  pathname: string;
+  search: string;
+  hash: string;
+}
+type PrefetchFunction = (to: string) => Promise<void>;
+type NavigateFunction = (to: string, options?: {
+  replace?: boolean;
+  state?: unknown; /** Disable the router transition when an outer transition owns the update. */
+  viewTransition?: boolean;
+}) => void;
+declare const defaultNavigate: NavigateFunction;
+declare const LocationContext: _$react.Context<LocationState>;
+declare const NavigateContext: _$react.Context<NavigateFunction>;
+declare const PrefetchContext: _$react.Context<PrefetchFunction>;
+declare const RouteDataContext: _$react.Context<Record<string, unknown> | null>;
+declare const MatchesContext: _$react.Context<RouteMatch[]>;
+interface LocationProviderProps {
+  pathname?: string;
+  children: React.ReactNode;
+  loaderData?: Record<string, unknown> | null;
+  matches?: RouteMatch[];
+  /** Base path of the application. Only links under this path are handled as SPA navigation. */
+  basename?: string;
+  /** Default locale is omitted from external URLs. */
+  defaultLocale?: string;
+  /** Optional route prefetcher used by Link hover/focus interactions. */
+  prefetch?: PrefetchFunction;
+  /** Enables the native View Transition API for route updates. */
+  viewTransitions?: boolean | {
+    enabled?: boolean;
+    types?: string[];
+  };
+}
+declare const LocationProvider: React.FC<LocationProviderProps>;
+//#endregion
+//#region src/client/router/hooks.d.ts
+declare function useLocation(): LocationState;
+declare function useNavigate(): NavigateFunction;
+declare function usePrefetch(): (to: string) => Promise<void>;
+declare function useRouteData<T = Record<string, unknown>>(): T;
+/** Alias for useRouteData — parity with react-router-dom's useLoaderData */
+declare function useLoaderData<T = Record<string, unknown>>(): T;
+declare function useMatches(): RouteMatch[];
+//#endregion
+//#region src/client/router/outlet.d.ts
+declare const OutletContext: _$react.Context<_$react.ReactNode>;
+declare const Outlet: React.FC;
+//#endregion
+//#region src/client/router/renderer.d.ts
+interface RouteBranchMatch {
+  route: RouteRecord;
+  params: Record<string, string>;
+}
+declare function matchRouteBranchWithParams(routes: RouteRecord[], pathname: string, basename?: string): RouteBranchMatch[];
+declare function matchRouteBranch(routes: RouteRecord[], pathname: string, basename?: string): RouteRecord[];
+declare function resolveRouteBranch(branch: RouteRecord[]): Promise<RouteRecord[]>;
+declare const RouteRenderer: React$1.FC<RouteRendererProps>;
+//#endregion
+//#region src/client/router/utils.d.ts
+declare function normalizeBasename(basename?: string): string;
+declare function hasBasename(path: string, basename: string): boolean;
+declare function stripBasename(path: string, basename: string): string;
+declare function addBasename(path: string, basename: string): string;
+//#endregion
+//#region src/client/router/url-contract.d.ts
+type UrlRouteKind = 'doc' | 'external' | 'collection';
+interface UrlContractConfig {
+  base?: string;
+  i18n?: Pick<BoltdocsI18nConfig, 'defaultLocale' | 'locales'>;
+  versions?: Pick<BoltdocsVersionsConfig, 'defaultVersion' | 'prefix' | 'versions'>;
+  collections?: readonly string[] | BoltdocsCollectionsConfig;
+}
+interface UrlRouteHint {
+  path: string;
+  kind?: UrlRouteKind;
+  collection?: string;
+}
+interface ParsedUrl {
+  /** The normalized pathname, without query string or hash. */
+  pathname: string;
+  /** The normalized route content after removing structural prefixes. */
+  routePath: string;
+  /** Query string including `?`, when present. */
+  search: string;
+  /** Hash including `#`, when present. */
+  hash: string;
+  kind: UrlRouteKind;
+  locale?: string;
+  version?: string;
+  collection?: string;
+  /** Whether the input used the explicit `site:` protocol. */
+  siteProtocol: boolean;
+  /** Whether the input pathname contained the configured documentation base. */
+  hadBase: boolean;
+}
+interface BuildUrlOptions {
+  kind: UrlRouteKind;
+  /** Route content, e.g. `/guides/start`, `/about`, or `/my-post`. */
+  path?: string;
+  locale?: string;
+  version?: string;
+  collection?: string;
+  search?: string;
+  hash?: string;
+  /** The input pathname already contained the configured base. */
+  hadBase?: boolean;
+}
+interface ResolveUrlOptions {
+  /** Explicitly choose the route family when the path is ambiguous. */
+  kind?: UrlRouteKind;
+  /** Known route metadata used to classify paths outside `base`. */
+  routes?: readonly UrlRouteHint[];
+  /** Locale/version to apply when building a canonical target. */
+  locale?: string;
+  version?: string;
+}
+declare function normalizeUrlBase(base?: string): string;
+declare function normalizeUrlPath(path: string): string;
+declare function hasUrlBase(pathname: string, base?: string): boolean;
+declare function stripUrlBase(pathname: string, base?: string): string;
+declare function addUrlBase(pathname: string, base?: string): string;
+declare function getConfiguredLocales(config: UrlContractConfig): string[];
+declare function getConfiguredVersions(config: UrlContractConfig): string[];
+declare function getVersionPrefixSegments(config: UrlContractConfig): string[];
+declare function getVersionSegments(version: string | undefined, config: UrlContractConfig): string[];
+declare function isConfiguredLocale(value: string | undefined, config: UrlContractConfig): value is string;
+declare function isConfiguredVersion(value: string | undefined, config: UrlContractConfig): value is string;
+declare function splitUrlReference(to: string): {
+  pathname: string;
+  search: string;
+  hash: string;
+};
+declare function stripSiteProtocol(to: string): {
+  value: string;
+  siteProtocol: boolean;
+};
+/** Returns true for URI schemes such as `mailto:`, `tel:`, or `data:`. */
+declare function hasUriScheme(value: string): boolean;
+declare function classifyUrlPath(pathname: string, config: UrlContractConfig, options?: Pick<ResolveUrlOptions, 'kind' | 'routes'>): UrlRouteKind;
+declare function parseUrlReference(to: string, config: UrlContractConfig, options?: Pick<ResolveUrlOptions, 'kind' | 'routes'>): ParsedUrl;
+declare function buildUrl(options: BuildUrlOptions, config: UrlContractConfig): string;
+declare function resolveUrlReference(to: string, config: UrlContractConfig, options?: ResolveUrlOptions): string;
+//#endregion
+export { LazyRouteResult as $, matchRouteBranch as A, useRouteData as B, stripSiteProtocol as C, normalizeBasename as D, hasBasename as E, useLoaderData as F, MatchesContext as G, LocationProvider as H, useLocation as I, PrefetchContext as J, NavigateContext as K, useMatches as L, resolveRouteBranch as M, Outlet as N, stripBasename as O, OutletContext as P, CreateRoutesResult as Q, useNavigate as R, splitUrlReference as S, addBasename as T, LocationProviderProps as U, LocationContext as V, LocationState as W, RouteDataContext as X, PrefetchFunction as Y, defaultNavigate as Z, isConfiguredVersion as _, RedirectConfig as _t, UrlRouteHint as a, RouterOptions as at, parseUrlReference as b, buildUrl as c, BoltdocsIntegrationsConfig as ct, getConfiguredVersions as d, BoltdocsRoutePath as dt, LoaderFunction as et, getVersionPrefixSegments as f, BoltdocsRoutePathWithFallback as ft, isConfiguredLocale as g, JsonLdObject as gt, hasUrlBase as h, BoltdocsVersion as ht, UrlContractConfig as i, RouteRendererProps as it, matchRouteBranchWithParams as j, RouteRenderer as k, classifyUrlPath as l, BoltdocsLocale as lt, hasUriScheme as m, BoltdocsTypes as mt, ParsedUrl as n, RouteMatch as nt, UrlRouteKind as o, BadgeValue as ot, getVersionSegments as p, BoltdocsSocialLink as pt, NavigateFunction as q, ResolveUrlOptions as r, RouteRecord as rt, addUrlBase as s, BoltdocsConfig as st, BuildUrlOptions as t, LoaderFunctionArgs as tt, getConfiguredLocales as u, BoltdocsMdxComponents as ut, normalizeUrlBase as v, RedirectStatus as vt, stripUrlBase as w, resolveUrlReference as x, normalizeUrlPath as y, StructuredData as yt, usePrefetch as z };