@yoamigo.com/core 0.4.7 → 1.0.0

package/dist/lib.d.ts

@@ -1,6 +1,9 @@
 export { A as AssetResolverFn, C as ContentRegistry, c as contentRegistry, a as getAllContent, g as getContent, h as hasContent, r as registerContent, b as resolveAssetUrl, s as setAssetResolver } from './asset-resolver-BnIvDkVv.js';
-export { i as initBuilderSelection } from './builder-selection-CYP91nRu.js';
+import { C as ChangeSource } from './cart-storage-DFdGPcwm.js';
+export { o as CartItem, a as CollectionClient, d as CollectionClientConfig, b as CollectionRecord, L as ListOptions, c as ListResponse, Q as QueryFilter, S as SingleResponse, l as addLocalCartItem, j as clearLocalCart, f as clearSessionId, g as getCollectionClient, h as getLocalCart, n as getLocalCartItemCount, k as getLocalCartItems, e as getSessionId, i as initBuilderSelection, m as removeLocalCartItem, r as resetCollectionClient, s as saveLocalCart, u as updateLocalCartItem } from './cart-storage-DFdGPcwm.js';
 export { C as ContactFormData, S as SiteMetadata, g as getSiteMetadata, a as submitContactForm, s as subscribeToNewsletter } from './api-client-D8FkeBAI.js';
+import 'react/jsx-runtime';
+import 'react';
 
 /**
  * Image Cache - In-memory cache for preloaded images
@@ -81,4 +84,92 @@ declare function hasCachedImage(src: string): boolean;
  */
 declare function initImageCacheListener(): () => void;
 
-export { type CachedImageEntry, clearImageCache, getCacheStats, getCachedUrl, hasCachedImage, initImageCacheListener, setCachedImages };
+/**
+ * Collection Context Registry
+ *
+ * Global registry for active CollectionContentProvider contexts.
+ * Enables window.yaContentStore to route setValue/getValue calls
+ * to the correct collection context based on fieldId prefix.
+ *
+ * When a CollectionContentProvider mounts with edit props, it registers
+ * itself here. YaText/YaImage and the global API check this registry
+ * to determine if a fieldId belongs to a collection.
+ */
+
+/**
+ * Collection context value stored in registry
+ * Mirrors the context shape from CollectionContentProvider
+ */
+interface RegisteredCollectionContext {
+    /** Get a value from the collection record */
+    getValue: (fieldId: string) => string;
+    /** Set a value (triggers local update + backend save) */
+    setValue?: (fieldId: string, value: string, source?: ChangeSource) => void;
+    /** Save to backend (creates/updates StagedAppRecord) */
+    saveToBackend?: (fieldId: string, value: string) => Promise<void>;
+    /** The prefix used for field IDs (e.g., "product") */
+    prefix: string;
+    /** The record ID (for UPDATE) or undefined (for CREATE) */
+    recordId?: string;
+    /** Collection slug for API calls */
+    collectionSlug?: string;
+    /** App ID for API calls */
+    appId?: string;
+}
+/**
+ * Summary info about a registered collection context
+ * Used by listEditableFields() for AI discovery
+ */
+interface CollectionFieldInfo {
+    prefix: string;
+    recordId?: string;
+    collectionSlug?: string;
+    appId?: string;
+}
+/**
+ * Register a collection context.
+ * Called by CollectionContentProvider on mount when edit props are provided.
+ *
+ * @param prefix - The fieldId prefix (e.g., "product")
+ * @param context - The collection context value
+ */
+declare function registerCollectionContext(prefix: string, context: RegisteredCollectionContext): void;
+/**
+ * Unregister a collection context.
+ * Called by CollectionContentProvider on unmount.
+ *
+ * @param prefix - The fieldId prefix to remove
+ */
+declare function unregisterCollectionContext(prefix: string): void;
+/**
+ * Get the collection context for a given fieldId.
+ * Returns null if the fieldId doesn't belong to any registered collection.
+ *
+ * @param fieldId - The full fieldId (e.g., "product.name")
+ * @returns The collection context or null
+ */
+declare function getCollectionContextForField(fieldId: string): RegisteredCollectionContext | null;
+/**
+ * Check if a fieldId belongs to a collection.
+ *
+ * @param fieldId - The full fieldId to check
+ * @returns True if the fieldId is from a collection
+ */
+declare function isCollectionField(fieldId: string): boolean;
+/**
+ * Get summary info about all registered collection contexts.
+ * Used by window.yaContentStore.listEditableFields() for AI discovery.
+ *
+ * @returns Array of collection field info objects
+ */
+declare function getAllCollectionFields(): CollectionFieldInfo[];
+/**
+ * Get the number of registered contexts (for debugging)
+ */
+declare function getRegistrySize(): number;
+/**
+ * Clear all registered contexts (for testing)
+ */
+declare function clearRegistry(): void;
+
+export { type CachedImageEntry, type CollectionFieldInfo, type RegisteredCollectionContext, clearImageCache, clearRegistry, getAllCollectionFields, getCacheStats, getCachedUrl, getCollectionContextForField, getRegistrySize, hasCachedImage, initImageCacheListener, isCollectionField, registerCollectionContext, setCachedImages, unregisterCollectionContext };

package/dist/lib.js

@@ -854,7 +854,7 @@ var BuilderSelectionManager = class {
     const navLinks = document.querySelectorAll("nav a[href]");
     navLinks.forEach((link) => {
       const href = link.getAttribute("href");
-      if (href && href.startsWith("/")) {
+      if (href?.startsWith("/")) {
         const path = href.split("?")[0].replace(/\/$/, "") || "/";
         routes.add(path);
       }
@@ -866,7 +866,7 @@ var BuilderSelectionManager = class {
    * Non-blocking: uses requestIdleCallback between pages
    * Transfers ArrayBuffer directly (zero-copy) for performance
    */
-  async captureAllPagesScreenshots(checkpointId, viewport) {
+  async captureAllPagesScreenshots(checkpointId, _viewport) {
     console.log("[BuilderSelection] Starting multi-page capture for checkpoint:", checkpointId);
     const routes = this.getAllRoutes();
     const originalPath = window.location.pathname;
@@ -882,7 +882,8 @@ var BuilderSelectionManager = class {
       try {
         await new Promise((resolve) => {
           if ("requestIdleCallback" in window) {
-            requestIdleCallback(() => resolve(), { timeout: 1e3 });
+            ;
+            window.requestIdleCallback(() => resolve(), { timeout: 1e3 });
           } else {
             setTimeout(resolve, 50);
           }
@@ -1193,22 +1194,354 @@ async function getSiteMetadata() {
   const runtimeConfig = window.YOAMIGO_CONFIG;
   return runtimeConfig || null;
 }
+
+// src/lib/collection-client.ts
+function getEnvVar(key) {
+  try {
+    const env = import.meta.env;
+    return env?.[key];
+  } catch {
+    return void 0;
+  }
+}
+function getConfig() {
+  if (typeof window === "undefined") {
+    throw new Error("CollectionClient requires browser environment");
+  }
+  const runtimeConfig = window.YOAMIGO_CONFIG;
+  const appId = runtimeConfig?.appId || runtimeConfig?.siteId || getEnvVar("YA_APP_ID") || getEnvVar("YA_SITE_ID");
+  const apiUrl = runtimeConfig?.apiUrl || getEnvVar("YA_API_URL");
+  if (!appId) {
+    throw new Error("App ID not configured (check YOAMIGO_CONFIG.appId or YA_APP_ID)");
+  }
+  if (!apiUrl) {
+    throw new Error("API URL not configured (check YOAMIGO_CONFIG.apiUrl or YA_API_URL)");
+  }
+  return { apiUrl, appId };
+}
+var CollectionClient = class {
+  apiUrl;
+  appId;
+  constructor(config) {
+    this.apiUrl = config.apiUrl;
+    this.appId = config.appId;
+  }
+  /**
+   * List records from a collection with optional filtering, pagination, and sorting.
+   */
+  async list(collection, options = {}) {
+    const { filters, limit, offset, orderBy, orderDir } = options;
+    const url = new URL(`${this.apiUrl}/api/apps/${this.appId}/collections/${collection}/records`);
+    if (filters && filters.length > 0) {
+      url.searchParams.set("filters", JSON.stringify(filters));
+    }
+    if (limit !== void 0) {
+      url.searchParams.set("limit", String(limit));
+    }
+    if (offset !== void 0) {
+      url.searchParams.set("offset", String(offset));
+    }
+    if (orderBy) {
+      url.searchParams.set("orderBy", orderBy);
+    }
+    if (orderDir) {
+      url.searchParams.set("orderDir", orderDir);
+    }
+    try {
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: result.error || `HTTP ${response.status}`,
+          errorCode: result.errorCode
+        };
+      }
+      return {
+        success: true,
+        data: result.data,
+        totalCount: result.totalCount
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network error"
+      };
+    }
+  }
+  /**
+   * Get a single record by its ID.
+   */
+  async getById(collection, id) {
+    const url = `${this.apiUrl}/api/apps/${this.appId}/collections/${collection}/records/${id}`;
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        return {
+          success: false,
+          error: result.error || `HTTP ${response.status}`,
+          errorCode: result.errorCode
+        };
+      }
+      return {
+        success: true,
+        data: result.data
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Network error"
+      };
+    }
+  }
+  /**
+   * Get a single record by a slug field value.
+   * Convenience method that uses list with a filter.
+   */
+  async getBySlug(collection, slugField, slugValue) {
+    const result = await this.list(collection, {
+      filters: [
+        { field: slugField, operator: "eq", value: slugValue }
+      ],
+      limit: 1
+    });
+    if (!result.success) {
+      return {
+        success: false,
+        error: result.error,
+        errorCode: result.errorCode
+      };
+    }
+    if (!result.data || result.data.length === 0) {
+      return {
+        success: false,
+        error: "Record not found",
+        errorCode: "NOT_FOUND"
+      };
+    }
+    return {
+      success: true,
+      data: result.data[0]
+    };
+  }
+};
+var cachedClient = null;
+function getCollectionClient() {
+  if (!cachedClient) {
+    const config = getConfig();
+    cachedClient = new CollectionClient(config);
+  }
+  return cachedClient;
+}
+function resetCollectionClient() {
+  cachedClient = null;
+}
+
+// src/lib/cart-storage.ts
+var CART_STORAGE_KEY_PREFIX = "yoamigo_cart_";
+var SESSION_ID_KEY = "yoamigo_cart_session";
+var CART_EXPIRY_DAYS = 7;
+function generateSessionId() {
+  return `session_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+}
+function getSessionId() {
+  if (typeof window === "undefined") {
+    throw new Error("getSessionId requires browser environment");
+  }
+  let sessionId = localStorage.getItem(SESSION_ID_KEY);
+  if (!sessionId) {
+    sessionId = generateSessionId();
+    localStorage.setItem(SESSION_ID_KEY, sessionId);
+  }
+  return sessionId;
+}
+function clearSessionId() {
+  if (typeof window === "undefined") return;
+  localStorage.removeItem(SESSION_ID_KEY);
+}
+function getStorageKey(appId) {
+  return `${CART_STORAGE_KEY_PREFIX}${appId}`;
+}
+function getLocalCart(appId) {
+  if (typeof window === "undefined") return null;
+  try {
+    const key = getStorageKey(appId);
+    const data = localStorage.getItem(key);
+    if (!data) return null;
+    const cart = JSON.parse(data);
+    const updatedAt = new Date(cart.updatedAt);
+    const expiryDate = /* @__PURE__ */ new Date();
+    expiryDate.setDate(expiryDate.getDate() - CART_EXPIRY_DAYS);
+    if (updatedAt < expiryDate) {
+      localStorage.removeItem(key);
+      return null;
+    }
+    return cart;
+  } catch (error) {
+    console.warn("Failed to read cart from localStorage:", error);
+    return null;
+  }
+}
+function saveLocalCart(appId, items) {
+  if (typeof window === "undefined") return;
+  try {
+    const key = getStorageKey(appId);
+    const cart = {
+      sessionId: getSessionId(),
+      items,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    localStorage.setItem(key, JSON.stringify(cart));
+  } catch (error) {
+    console.warn("Failed to save cart to localStorage:", error);
+  }
+}
+function clearLocalCart(appId) {
+  if (typeof window === "undefined") return;
+  try {
+    const key = getStorageKey(appId);
+    localStorage.removeItem(key);
+  } catch (error) {
+    console.warn("Failed to clear cart from localStorage:", error);
+  }
+}
+function getLocalCartItems(appId) {
+  const cart = getLocalCart(appId);
+  return cart?.items || [];
+}
+function addLocalCartItem(appId, productId, collectionSlug, quantity = 1, variantId, data) {
+  const items = getLocalCartItems(appId);
+  const existingIndex = items.findIndex(
+    (item) => item.productId === productId && item.variantId === variantId
+  );
+  if (existingIndex >= 0) {
+    items[existingIndex].quantity += quantity;
+  } else {
+    items.push({
+      id: `local_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      productId,
+      collectionSlug,
+      quantity,
+      variantId,
+      addedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      data
+    });
+  }
+  saveLocalCart(appId, items);
+  return items;
+}
+function updateLocalCartItem(appId, itemId, quantity) {
+  const items = getLocalCartItems(appId);
+  const itemIndex = items.findIndex((item) => item.id === itemId);
+  if (itemIndex < 0) return items;
+  if (quantity === 0) {
+    items.splice(itemIndex, 1);
+  } else {
+    items[itemIndex].quantity = quantity;
+  }
+  saveLocalCart(appId, items);
+  return items;
+}
+function removeLocalCartItem(appId, itemId) {
+  const items = getLocalCartItems(appId);
+  const filteredItems = items.filter((item) => item.id !== itemId);
+  saveLocalCart(appId, filteredItems);
+  return filteredItems;
+}
+function getLocalCartItemCount(appId) {
+  const items = getLocalCartItems(appId);
+  return items.reduce((sum, item) => sum + item.quantity, 0);
+}
+
+// src/lib/collection-context-registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerCollectionContext(prefix, context) {
+  if (registry.has(prefix)) {
+    console.warn(
+      `[collection-registry] Overwriting existing context for prefix "${prefix}". This usually means multiple CollectionContentProviders with the same prefix are mounted.`
+    );
+  }
+  registry.set(prefix, context);
+}
+function unregisterCollectionContext(prefix) {
+  registry.delete(prefix);
+}
+function getCollectionContextForField(fieldId) {
+  for (const [prefix, context] of registry) {
+    if (fieldId === prefix || fieldId.startsWith(prefix + ".")) {
+      return context;
+    }
+  }
+  return null;
+}
+function isCollectionField(fieldId) {
+  return getCollectionContextForField(fieldId) !== null;
+}
+function getAllCollectionFields() {
+  const result = [];
+  for (const [prefix, context] of registry) {
+    result.push({
+      prefix,
+      recordId: context.recordId,
+      collectionSlug: context.collectionSlug,
+      appId: context.appId
+    });
+  }
+  return result;
+}
+function getRegistrySize() {
+  return registry.size;
+}
+function clearRegistry() {
+  registry.clear();
+}
 export {
+  CollectionClient,
+  addLocalCartItem,
   clearImageCache,
+  clearLocalCart,
+  clearRegistry,
+  clearSessionId,
   contentRegistry,
+  getAllCollectionFields,
   getAllContent,
   getCacheStats,
   getCachedUrl,
+  getCollectionClient,
+  getCollectionContextForField,
   getContent,
+  getLocalCart,
+  getLocalCartItemCount,
+  getLocalCartItems,
+  getRegistrySize,
+  getSessionId,
   getSiteMetadata,
   hasCachedImage,
   hasContent,
   initBuilderSelection,
   initImageCacheListener,
+  isCollectionField,
+  registerCollectionContext,
   registerContent,
+  removeLocalCartItem,
+  resetCollectionClient,
   resolveAssetUrl,
+  saveLocalCart,
   setAssetResolver,
   setCachedImages,
   submitContactForm,
-  subscribeToNewsletter
+  subscribeToNewsletter,
+  unregisterCollectionContext,
+  updateLocalCartItem
 };

package/dist/prod.d.ts

@@ -1,8 +1,8 @@
 export { a as ContentStore, E as ContentStoreMode, C as ContentStoreProvider, f as MarkdownText, g as MarkdownTextProps, P as PageInfo, c as StaticImage, d as StaticImageProps, M as StaticText, S as StaticTextProps, c as YaImage, d as YaImageProps, M as YaText, S as YaTextProps, b as background, e as embed, i as image, p as parseEmbedUrl, t as text, u as useContentStore, v as video } from './content-helpers-DOUKazMz.js';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import React, { CSSProperties, ReactNode } from 'react';
-export { Link, LinkProps, NavigateFunction, Router, RouterProps, ScrollRestoration, useNavigate } from './router.js';
-export { Route, Switch, useParams } from 'wouter';
+export { Link, LinkProps, NavigateFunction, RouteDefinition, Router, RouterProps, ScrollRestoration, createRouteDefinition, extractRouteParams, filePathToRoutePath, generatePath, sortRoutesBySpecificity, useNavigate } from './router.js';
+export { Route, Switch, useLocation, useParams } from 'wouter';
 export { A as AssetResolverFn, C as ContentRegistry, c as contentRegistry, a as getAllContent, g as getContent, h as hasContent, r as registerContent, b as resolveAssetUrl, s as setAssetResolver } from './asset-resolver-BnIvDkVv.js';
 
 interface StaticLinkProps {

package/dist/prod.js

@@ -1056,7 +1056,74 @@ function ScrollRestoration() {
 }
 
 // src/router/index.ts
-import { Route, Switch, useParams } from "wouter";
+import { Route, Switch, useParams, useLocation as useLocation4 } from "wouter";
+
+// src/router/route-utils.ts
+function filePathToRoutePath(filePath, options = {}) {
+  const {
+    pagesDir = "/src/pages",
+    extensions = [".tsx", ".ts", ".jsx", ".js"]
+  } = options;
+  let path = filePath;
+  if (path.startsWith(pagesDir)) {
+    path = path.slice(pagesDir.length);
+  }
+  for (const ext of extensions) {
+    if (path.endsWith(ext)) {
+      path = path.slice(0, -ext.length);
+      break;
+    }
+  }
+  if (path.endsWith("/index")) {
+    path = path.slice(0, -6) || "/";
+  }
+  path = path.replace(/\[\.\.\.([^\]]+)\]/g, ":$1*");
+  path = path.replace(/\[([^\]]+)\]/g, ":$1");
+  if (!path.startsWith("/")) {
+    path = "/" + path;
+  }
+  if (path === "" || path === "/index") {
+    return "/";
+  }
+  return path;
+}
+function extractRouteParams(filePath) {
+  const matches = filePath.matchAll(/\[\.\.\.([^\]]+)\]|\[([^\]]+)\]/g);
+  const params = [];
+  for (const match of matches) {
+    params.push(match[1] || match[2]);
+  }
+  return params;
+}
+function createRouteDefinition(filePath, options) {
+  const path = filePathToRoutePath(filePath, options);
+  const params = extractRouteParams(filePath);
+  return {
+    path,
+    filePath,
+    params,
+    isDynamic: params.length > 0
+  };
+}
+function sortRoutesBySpecificity(routes) {
+  return [...routes].sort((a, b) => {
+    if (!a.isDynamic && b.isDynamic) return -1;
+    if (a.isDynamic && !b.isDynamic) return 1;
+    const aSegments = a.path.split("/").filter(Boolean);
+    const bSegments = b.path.split("/").filter(Boolean);
+    if (aSegments.length !== bSegments.length) {
+      return bSegments.length - aSegments.length;
+    }
+    return a.params.length - b.params.length;
+  });
+}
+function generatePath(routePath, params) {
+  let path = routePath;
+  for (const [key, value] of Object.entries(params)) {
+    path = path.replace(new RegExp(`:${key}\\*?`, "g"), encodeURIComponent(value));
+  }
+  return path;
+}
 
 // src/lib/content-helpers.ts
 function text(content) {
@@ -1097,7 +1164,11 @@ export {
   StaticVideo as YaVideo,
   background,
   contentRegistry,
+  createRouteDefinition,
   embed,
+  extractRouteParams,
+  filePathToRoutePath,
+  generatePath,
   getAllContent,
   getContent,
   hasContent,
@@ -1110,8 +1181,10 @@ export {
   serializeEmbedValue,
   serializeVideoValue,
   setAssetResolver,
+  sortRoutesBySpecificity,
   text,
   useContentStore,
+  useLocation4 as useLocation,
   useNavigate,
   useParams,
   video

package/dist/router.d.ts

@@ -1,6 +1,6 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode, MouseEvent } from 'react';
-export { Route, Switch, useParams } from 'wouter';
+export { Route, Switch, useLocation, useParams } from 'wouter';
 
 /**
  * Router Abstraction - Shared Types
@@ -55,4 +55,82 @@ declare function Router({ children, base }: RouterProps): react_jsx_runtime.JSX.
  */
 declare function ScrollRestoration(): null;
 
-export { Link, type LinkProps, type NavigateFunction, Router, type RouterProps$1 as RouterProps, ScrollRestoration, useNavigate };
+/**
+ * Route Utilities
+ *
+ * Utilities for working with file-based routing conventions.
+ * Converts file paths with [param] syntax to wouter-compatible route paths.
+ *
+ * @example
+ * ```
+ * /src/pages/contact.tsx         → /contact
+ * /src/pages/products/index.tsx  → /products
+ * /src/pages/products/[slug].tsx → /products/:slug
+ * /src/pages/blog/[category]/[slug].tsx → /blog/:category/:slug
+ * ```
+ */
+interface RouteDefinition {
+    /** The wouter-compatible route path (e.g., '/products/:slug') */
+    path: string;
+    /** The original file path */
+    filePath: string;
+    /** Parameter names extracted from the path */
+    params: string[];
+    /** Whether this is a dynamic route (has params) */
+    isDynamic: boolean;
+}
+/**
+ * Convert a file path to a wouter-compatible route path.
+ *
+ * Supports:
+ * - `/src/pages/contact.tsx` → `/contact`
+ * - `/src/pages/index.tsx` → `/`
+ * - `/src/pages/products/index.tsx` → `/products`
+ * - `/src/pages/products/[slug].tsx` → `/products/:slug`
+ * - `/src/pages/blog/[category]/[slug].tsx` → `/blog/:category/:slug`
+ * - `/src/pages/[...rest].tsx` → `/:rest*` (catch-all)
+ *
+ * @param filePath - The file path (e.g., '/src/pages/products/[slug].tsx')
+ * @param options - Options for path conversion
+ * @returns The wouter-compatible route path
+ */
+declare function filePathToRoutePath(filePath: string, options?: {
+    /** Pages directory prefix to strip (default: '/src/pages') */
+    pagesDir?: string;
+    /** File extensions to remove (default: ['.tsx', '.ts', '.jsx', '.js']) */
+    extensions?: string[];
+}): string;
+/**
+ * Extract parameter names from a file path.
+ *
+ * @param filePath - The file path (e.g., '/src/pages/blog/[category]/[slug].tsx')
+ * @returns Array of parameter names (e.g., ['category', 'slug'])
+ */
+declare function extractRouteParams(filePath: string): string[];
+/**
+ * Create a RouteDefinition from a file path.
+ *
+ * @param filePath - The file path (e.g., '/src/pages/products/[slug].tsx')
+ * @param options - Options for path conversion
+ * @returns RouteDefinition object
+ */
+declare function createRouteDefinition(filePath: string, options?: Parameters<typeof filePathToRoutePath>[1]): RouteDefinition;
+/**
+ * Sort route definitions by specificity (most specific first).
+ * Static routes come before dynamic routes.
+ * More specific dynamic routes come before less specific ones.
+ *
+ * @param routes - Array of RouteDefinition objects
+ * @returns Sorted array (most specific first)
+ */
+declare function sortRoutesBySpecificity(routes: RouteDefinition[]): RouteDefinition[];
+/**
+ * Generate a path with parameters filled in.
+ *
+ * @param routePath - The route path with params (e.g., '/products/:slug')
+ * @param params - Object with parameter values (e.g., { slug: 'guitar' })
+ * @returns The filled path (e.g., '/products/guitar')
+ */
+declare function generatePath(routePath: string, params: Record<string, string>): string;
+
+export { Link, type LinkProps, type NavigateFunction, type RouteDefinition, Router, type RouterProps$1 as RouterProps, ScrollRestoration, createRouteDefinition, extractRouteParams, filePathToRoutePath, generatePath, sortRoutesBySpecificity, useNavigate };