@ubean/client 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,486 @@
+import { A as CreateUbeanRouterOptions, C as useUnheadHead, D as definePage, E as defineMiddleware, O as UbeanVuePage, S as useSeoMeta, T as defineMeta, _ as VueHeadClient$1, h as UbeanAppOptions, j as createUbeanRouter, k as usePage, m as UbeanAppInstance, n as Head, v as createUbeanClientApp, y as createUbeanSSRApp } from "./app-BknjDM9j.js";
+import { AppPluginConfig, DefineAppOptions, ResolvedAppConfig, applyAppConfig, createDefaultAppConfig, defineApp, mergeAppConfig } from "./define-app.js";
+import { ComputedRef, Ref, ShallowRef } from "vue";
+import { useRouter } from "vue-router";
+import { ERROR_KEY, ErrorBoundary, LAYOUT_CHAIN_KEY, LOADING_KEY, LOCALIZE_PATH_KEY, LayoutChainContext, LayoutChainRenderer, Link, PAGE_KEY, PageView, RouteLocation, RouteLocationRaw, SSR_KEY, SlotView, TRANSITION_KEY, TypedLinkProps, UbeanVueOptions, UbeanVuePageData, UseCacheViewsReturn, UsePageTransitionReturn, UseReloadSignalReturn, ViewTransitionOptions, clearPageTransition, disablePageCache, enablePageCache, excludePageCache, getCacheEnabled, getCachedViewNames, getExcludedViewNames, getNamedPageWrapper, getNavigationType, getPageTransitionName, getReloadCounter, includePageCache, initCachedViewsFromRoutes, invalidatePageCache, isActiveRoute, isCacheEnabled, isPageCached, isPageExcluded, isReloading, reloadPage, resetNamedPageWrappers, resetRouteCache, resolveRoute, setPageTransition, supportsViewTransitions, ubeanVue, useCacheViews, usePageTransition, useReloadSignal, useViewTransition, useViewTransitionState, withViewTransition } from "@ubean/vue";
+import { VueHeadClient, injectHead } from "@unhead/vue";
+import { createHead as createClientHead } from "@unhead/vue/client";
+import { PageObject } from "@ubean/pages";
+import { I18nConfig, LocaleChangeCallback, LocaleDefinition, LocaleMessages } from "@ubean/i18n";
+import { HydrateIslandsOptions, IslandHydrateOptions, IslandRecord, collectIslands, hydrateIsland, hydrateIslands } from "@ubean/islands/runtime";
+import { LinkTag, MetaTag, SeoMetadata } from "@ubean/seo";
+//#region src/client.d.ts
+declare function getInitialPageData<T = Record<string, unknown>>(): PageObject<T> | null;
+/**
+ * 从 DOM 中的 `<script id="__UBEAN_STATE__">` 读取 SSR 序列化的状态。
+ *
+ * 该状态由服务端 `defineApp({ serializeState })` 产生,用于在客户端 mount 前
+ * 水合到对应的库实例(如 Pinia 的 `pinia.state.value`)。
+ *
+ * 必须在 `app.mount()` 之前调用(在 `defineApp({ hydrateState })` 内部使用)。
+ *
+ * @returns 解析后的状态对象,或 `null`(无状态 / 解析失败 / 非 DOM 环境)
+ */
+declare function getInitialState(): Record<string, unknown> | null;
+//#endregion
+//#region src/head.d.ts
+declare function useHeadInstance(): import("@unhead/vue").VueHeadClient;
+//#endregion
+//#region src/composables.d.ts
+interface UbeanVueContext {
+  __ubean_router?: import('vue-router').Router;
+  __ubean_data_cache?: DataCacheStore;
+}
+interface LinkProps {
+  href: string;
+  replace?: boolean;
+  prefetch?: boolean;
+}
+interface DataCacheStore {
+  get: <T = unknown>(key: string | symbol) => T | undefined;
+  set: <T = unknown>(key: string | symbol, value: T, tags?: string[]) => void;
+  has: (key: string | symbol) => boolean;
+  invalidate: (keyOrTag: string | symbol) => number;
+  clear: () => void;
+  subscribe: (fn: () => void) => () => void;
+  getTimestamp: (key: string | symbol) => number | undefined;
+}
+declare function createDataCacheStore(): DataCacheStore;
+interface UseAsyncDataOptions<T> {
+  key?: string;
+  tags?: string[];
+  lazy?: boolean;
+  server?: boolean;
+  default?: () => T;
+  transform?: (input: unknown) => T;
+}
+interface UseAsyncDataReturn<T> {
+  data: {
+    value: T | undefined;
+  };
+  error: {
+    value: Error | null;
+  };
+  loading: {
+    value: boolean;
+  };
+  refresh: () => Promise<void>;
+  invalidate: () => void;
+}
+declare function createUseAsyncData(store: DataCacheStore): <T = unknown>(keyOrFetcher: string | (() => Promise<T>), fetcherOrOptions?: (() => Promise<T>) | UseAsyncDataOptions<T>, options?: UseAsyncDataOptions<T>) => UseAsyncDataReturn<T>;
+declare function invalidateCache(store: DataCacheStore, keyOrTag: string): number;
+declare function clearCache(store: DataCacheStore): void;
+declare function defineDataKey(key: string): symbol;
+declare function createLinkHandler(ctx: UbeanVueContext): {
+  getProps: () => {};
+  navigate(href: string, opts?: {
+    replace?: boolean;
+  }): Promise<void>;
+  prefetch(_href: string): Promise<void>;
+};
+declare function extractPageData<T = Record<string, unknown>>(): PageObject<T> | null;
+declare function useServerData<T>(fetcher: () => Promise<T>): Promise<T>;
+declare function getInvalidatedKeysForAction(actionName: string, invalidationMap: Record<string, Array<string | symbol>>, store: DataCacheStore): number;
+//#endregion
+//#region src/i18n.d.ts
+declare function initClientI18n(): void;
+interface VueI18nInstance {
+  locale: {
+    value: string;
+  };
+  fallbackLocale: string;
+  availableLocales: string[];
+  t: (key: string, params?: Record<string, string | number>) => string;
+  setLocale: (locale: string) => void;
+  getLocale: () => string;
+  onLocaleChange: (callback: LocaleChangeCallback) => () => void;
+  getLocaleDir: (locale?: string) => 'ltr' | 'rtl';
+  getLocaleName: (locale?: string) => string | undefined;
+  localeDir: {
+    value: 'ltr' | 'rtl';
+  };
+  localeName: {
+    value: string | undefined;
+  };
+}
+declare function useI18n(): VueI18nInstance;
+declare function defineLocale(definition: LocaleDefinition): LocaleDefinition;
+declare function t(key: string, params?: Record<string, string | number>): string;
+declare function setLocale(locale: string): void;
+declare function getLocale(): string;
+declare function onLocaleChange(callback: LocaleChangeCallback): () => void;
+declare function getLocaleDir(locale?: string): 'ltr' | 'rtl';
+declare function getLocaleName(locale?: string): string | undefined;
+declare function getRegisteredLocales(): string[];
+declare function detectLocale(acceptLanguage?: string): string;
+declare function detectBrowserLocale(): string;
+declare function addLocale(code: string, messages: LocaleMessages, options?: {
+  name?: string;
+  dir?: 'ltr' | 'rtl';
+}): void;
+declare function mergeLocale(code: string, messages: LocaleMessages): void;
+declare function clearLocales(): void;
+declare function getI18nConfig(): I18nConfig;
+declare function setI18nConfig(config: Partial<I18nConfig>): void;
+declare function localizePath(path: string, locale?: string): string;
+declare function switchLocalePath(newLocale: string, currentPath?: string): string;
+declare function getDefaultLocale(): string;
+declare function extractLocaleFromPath(path: string): {
+  locale: string | null;
+  pathWithoutLocale: string;
+};
+declare function useSwitchLocalePath(): import("vue").ComputedRef<(newLocale: string) => any>;
+declare function useLocalePath(): import("vue").ComputedRef<(path: string, locale?: string) => any>;
+//#endregion
+//#region src/color-mode.d.ts
+interface ColorModeConfig {
+  /** Default preference: 'system' | 'light' | 'dark' | string (default: 'system'). */
+  preference: string;
+  /** Fallback when system preference can't be determined (default: 'light'). */
+  fallback: string;
+  /** Class prefix for the html element (default: ''). */
+  classPrefix: string;
+  /** Class suffix (default: '-mode' → 'light-mode', 'dark-mode'). */
+  classSuffix: string;
+  /** localStorage key for persisting user preference (default: 'ubean-color-mode'). */
+  storageKey: string;
+  /** Cookie name for SSR (default: 'ubean-color-mode'). */
+  cookieName: string;
+  /**
+   * Use a `data-color-mode` attribute on `<html>` instead of a class.
+   * When `true`, no class is added; instead `data-color-mode="<value>"` is set.
+   * (default: `false`)
+   */
+  dataValue: boolean;
+  /** List of all possible color mode values (default: ['light', 'dark']). */
+  modes: string[];
+}
+interface ColorMode {
+  /** User's preference ('system', 'light', 'dark', or custom). */
+  preference: Ref<string>;
+  /** Resolved mode ('light', 'dark', or custom — never 'system'). */
+  value: ComputedRef<string>;
+  /** Whether the system preference is unknown (e.g. no `prefers-color-scheme`). */
+  unknown: Ref<boolean>;
+  /** Whether the color mode is forced (e.g. by route meta). */
+  forced: Ref<boolean>;
+  /** Set the preference and persist it. */
+  set: (mode: string) => void;
+  /** Cycle to the next mode in the modes list. */
+  toggle: () => void;
+}
+/** Merge user config with defaults. */
+declare function resolveColorModeConfig(config?: Partial<ColorModeConfig>): ColorModeConfig;
+/**
+ * Generate the no-FOUC inline script that resolves the color mode and sets
+ * the `<html>` class/attribute **before** the page renders.
+ *
+ * The script:
+ * 1. Reads the user's preference from a cookie (SSR-friendly) or localStorage.
+ * 2. If preference is 'system', checks `prefers-color-scheme`.
+ * 3. Falls back to `config.fallback` if system preference is unknown.
+ * 4. Sets the class or `data-*` attribute on `<html>`.
+ *
+ * This script is injected into `<head>` and runs synchronously.
+ */
+declare function getColorModeScript(config: ColorModeConfig): string;
+/** Configure the color mode module (called once during app initialization). */
+declare function configureColorMode(config?: Partial<ColorModeConfig>): ColorModeConfig;
+/** Get the current color mode config. */
+declare function getColorModeConfig(): ColorModeConfig;
+/**
+ * Reactively access and control the color mode.
+ *
+ * Returns a `ColorMode` object with reactive refs and methods:
+ * - `preference` — the user's preference ('system', 'light', 'dark', ...)
+ * - `value` — the resolved mode (never 'system')
+ * - `unknown` — whether the system preference is unknown
+ * - `forced` — whether the mode is forced (e.g. by route meta)
+ * - `set(mode)` — set the preference and persist it
+ * - `toggle()` — cycle to the next mode
+ *
+ * @example
+ * ```typescript
+ * const colorMode = useColorMode();
+ * console.log(colorMode.value); // 'dark'
+ * colorMode.set('light');
+ * colorMode.toggle(); // cycles: light → dark → light
+ * ```
+ */
+declare function useColorMode(): ColorMode;
+/**
+ * Force a color mode (e.g. from route meta `colorMode: 'dark'`).
+ * When forced, user changes are ignored until `unforceColorMode()` is called.
+ */
+declare function forceColorMode(mode: string): void;
+/**
+ * Remove the forced color mode, returning to user preference.
+ */
+declare function unforceColorMode(): void;
+/**
+ * Reset the color mode module state (for testing).
+ * @internal
+ */
+declare function _resetColorMode(): void;
+//#endregion
+//#region src/party-town.d.ts
+interface PartyTownConfig {
+  /** Enable Partytown for third-party scripts (default: false, opt-in). */
+  enabled: boolean;
+  /**
+   * Path where Partytown lib files are served (default: '~partytown').
+   * The Vite plugin copies partytown lib files to `public/<libPath>/`.
+   */
+  libPath: string;
+  /**
+   * Forward calls to main thread (e.g. `['dataLayer.push']`).
+   * These are global functions/objects that Partytown should forward
+   * from the Web Worker to the main thread.
+   */
+  forward: string[];
+  /** Main thread accessors (e.g. `['document.cookie']`). */
+  mainAccess?: string[];
+  /** Enable debug mode (default: false). */
+  debug: boolean;
+  /** Log script execution errors (default: false). */
+  logScriptExecution: boolean;
+  /** Whether to load scripts in a non-blocking way (default: true). */
+  nonBlocking: boolean;
+}
+/** Merge user config with defaults. */
+declare function resolvePartyTownConfig(config?: Partial<PartyTownConfig>): PartyTownConfig;
+/**
+ * Generate the inline Partytown config script for `<head>`.
+ *
+ * This script configures `window.partytown` **before** the Partytown lib
+ * snippet loads. The Partytown lib is loaded via a separate `<script>`
+ * tag that reads `window.partytown` for configuration.
+ *
+ * Returns an empty string if Partytown is not enabled.
+ */
+declare function getPartyTownScript(config: PartyTownConfig): string;
+/**
+ * Generate the full HTML for Partytown initialization.
+ * Used by the Vite plugin to inject into `<head>`.
+ */
+declare function getPartyTownHeadContent(config: PartyTownConfig): string;
+type ScriptTrigger = 'load' | 'idle' | 'visible' | 'manual';
+interface UseScriptOptions {
+  /** When to load the script (default: 'load'). */
+  trigger?: ScriptTrigger;
+  /**
+   * Run the script in Partytown (Web Worker).
+   * When `true`, sets `type="text/partytown"` on the script tag.
+   * (default: false)
+   */
+  partytown?: boolean;
+  /** Script `async` attribute (default: true for non-module scripts). */
+  async?: boolean;
+  /** Script `defer` attribute (default: false). */
+  defer?: boolean;
+  /** Script `type` attribute (e.g. 'module', 'application/json'). */
+  type?: string;
+  /** Additional HTML attributes for the `<script>` tag. */
+  attrs?: Record<string, string>;
+  /** Element ref to observe for `trigger: 'visible'`. Required when trigger is 'visible'. */
+  target?: Ref<HTMLElement | null | undefined>;
+  /** Root element for IntersectionObserver (default: viewport). */
+  rootMargin?: string;
+  /** Threshold for IntersectionObserver (default: 0). */
+  threshold?: number;
+  /** Crossorigin attribute. */
+  crossorigin?: 'anonymous' | 'use-credentials';
+  /** Referrer policy. */
+  referrerPolicy?: ReferrerPolicy;
+  /** Whether to remove the script when the component unmounts (default: false). */
+  removeOnUnmount?: boolean;
+}
+interface UseScriptReturn {
+  /** The script element (null until loaded). */
+  script: Ref<HTMLScriptElement | null>;
+  /** Whether the script has been loaded. */
+  loaded: Ref<boolean>;
+  /** Whether the script failed to load. */
+  error: Ref<boolean>;
+  /** Manually trigger loading (for `trigger: 'manual'`). */
+  load: () => void;
+  /** Remove the script from the DOM. */
+  remove: () => void;
+  /** Wait for the script to load. Returns a promise that resolves on load. */
+  waitForLoad: () => Promise<void>;
+}
+/**
+ * Load a third-party script with a loading strategy.
+ *
+ * @param src - The script URL
+ * @param options - Loading options
+ * @returns Script control object with `load()`, `remove()`, and reactive state
+ *
+ * @example
+ * ```typescript
+ * // Load immediately with Partytown
+ * useScript('https://www.googletagmanager.com/gtag/js?id=GA_ID', {
+ *   partytown: true,
+ *   trigger: 'load'
+ * });
+ *
+ * // Load when browser is idle
+ * const { load } = useScript('/heavy-script.js', { trigger: 'idle' });
+ *
+ * // Load when element is visible
+ * const targetRef = ref<HTMLElement | null>(null);
+ * useScript('/analytics.js', { trigger: 'visible', target: targetRef });
+ * ```
+ */
+declare function useScript(src: string, options?: UseScriptOptions): UseScriptReturn;
+/** Configure the Partytown module globally. */
+declare function configurePartyTown(config?: Partial<PartyTownConfig>): PartyTownConfig;
+/** Get the current Partytown config. */
+declare function getPartyTownConfig(): PartyTownConfig;
+/** Check if Partytown is enabled. */
+declare function isPartyTownEnabled(): boolean;
+/** Reset Partytown module state (for testing). @internal */
+declare function _resetPartyTown(): void;
+//#endregion
+//#region src/search.d.ts
+/** A single search result from Pagefind. */
+interface SearchResult {
+  /** Unique internal ID of the result. */
+  id: number;
+  /** The URL of the page this result points to. */
+  url: string;
+  /** HTML excerpt with matched terms highlighted (via `<mark>`). */
+  excerpt: string;
+  /** Page metadata extracted during indexing (title, description, etc.). */
+  meta: Record<string, string>;
+  /** Weighted relevance score (higher = more relevant). */
+  score: number;
+  /** Word count of the matched content. */
+  wordCount?: number;
+  /** Raw data reference (advanced use). */
+  data?: unknown;
+}
+/** Filter options passed to `pagefind.search()`. */
+interface SearchFilters {
+  /** Key-value filters (e.g. `{ tags: 'guide' }` matches `data-pagefind-filter`). */
+  filters?: Record<string, string | string[]>;
+  /** Sort results by a meta field instead of relevance. */
+  sort?: Record<string, 'asc' | 'desc'>;
+}
+/** Options for the `useSearch` composable. */
+interface UseSearchOptions {
+  /** Debounce delay in ms (default: 150). Set to 0 for no debounce. */
+  debounce?: number;
+  /** Max number of results to return (default: 10). */
+  limit?: number;
+  /** Filters/sort passed to every search call. */
+  filters?: SearchFilters;
+  /** Path to the Pagefind browser bundle (default: '/pagefind/pagefind-modern.js'). */
+  pagefindPath?: string;
+  /** Auto-search on mount with an initial query (default: ''). */
+  immediate?: string;
+}
+/** Return type of `useSearch()`. */
+interface UseSearchReturn {
+  /** Current search query (reactive). */
+  query: Ref<string>;
+  /** Search results (reactive, shallow — each update replaces the array). */
+  results: ShallowRef<SearchResult[]>;
+  /** Whether a search is in progress. */
+  loading: Ref<boolean>;
+  /** Error message if the search failed (null on success). */
+  error: Ref<string | null>;
+  /** Whether the Pagefind library has been loaded. */
+  ready: Ref<boolean>;
+  /** Execute a search. Pass an empty string to clear. */
+  search: (query: string, filters?: SearchFilters) => Promise<void>;
+  /** Clear results and reset query. */
+  clear: () => void;
+  /** Preload the Pagefind library without searching. */
+  preload: () => Promise<void>;
+}
+/** Runtime search configuration (subset of build-time SearchConfig). */
+interface SearchRuntimeConfig {
+  /** Path to the Pagefind browser bundle. */
+  pagefindPath: string;
+  /** Default debounce in ms. */
+  debounce: number;
+  /** Default result limit. */
+  limit: number;
+}
+/**
+ * Configure the search runtime globally. Call this in `app.ts` (client-side)
+ * to override defaults before any `useSearch()` call.
+ */
+declare function configureSearch(config: Partial<SearchRuntimeConfig>): void;
+/** Get the current runtime search config. */
+declare function getSearchConfig(): SearchRuntimeConfig;
+/** Resolve a user-provided config object into a full SearchRuntimeConfig. */
+declare function resolveSearchConfig(config?: Partial<SearchRuntimeConfig> | true): SearchRuntimeConfig;
+/** The loaded Pagefind browser module (cached after first load). */
+type PagefindModule = any;
+/**
+ * Dynamically import the Pagefind browser library.
+ *
+ * The library is generated at build time into `<outputDir>/pagefind/` and
+ * served at `/pagefind/pagefind-modern.js`. In dev mode or when Pagefind is
+ * not enabled, the import will fail — callers should catch and show a message.
+ */
+declare function initPagefind(options?: {
+  pagefindPath?: string;
+}): Promise<PagefindModule>;
+/** Check whether the Pagefind browser library has been loaded. */
+declare function isPagefindLoaded(): boolean;
+/**
+ * Execute a raw Pagefind search. Returns normalized `SearchResult[]`.
+ *
+ * Exposed for advanced use cases where the reactive composable is not needed
+ * (e.g. server-side API routes that proxy search requests).
+ */
+declare function executeSearch(query: string, options?: {
+  filters?: SearchFilters;
+  limit?: number;
+  pagefindPath?: string;
+}): Promise<SearchResult[]>;
+/**
+ * `useSearch` — reactive Pagefind search composable.
+ *
+ * Lazily loads the Pagefind browser library on first search and provides
+ * reactive `results`, `loading`, and `error` state. Built-in debounce
+ * prevents excessive searches while the user is typing.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * const { search, results, loading } = useSearch({ debounce: 200 });
+ * </script>
+ *
+ * <template>
+ *   <input
+ *     type="search"
+ *     placeholder="Search..."
+ *     @input="search($event.target.value)"
+ *   />
+ *   <div v-if="loading">Searching...</div>
+ *   <ul v-else>
+ *     <li v-for="r in results" :key="r.id">
+ *       <a :href="r.url" v-html="r.meta.title || r.url" />
+ *       <p v-html="r.excerpt" />
+ *     </li>
+ *   </ul>
+ * </template>
+ * ```
+ */
+declare function useSearch(options?: UseSearchOptions): UseSearchReturn;
+/** Reset all internal state (for unit tests only). */
+declare function _resetSearch(): void;
+/**
+ * Inject a mock Pagefind module for testing.
+ *
+ * The mock replaces the dynamic `import()` so tests can simulate search
+ * results without a real Pagefind build. Also calls `mock.init()` to mimic
+ * the real library's initialization.
+ */
+declare function _setPagefindMock(mock: any): void;
+//#endregion
+export { type AppPluginConfig, type ColorMode, type ColorModeConfig, type CreateUbeanRouterOptions, type DataCacheStore, type DefineAppOptions, ERROR_KEY, ErrorBoundary, Head, type VueHeadClient as HeadClient, type HydrateIslandsOptions, type IslandHydrateOptions, type IslandRecord, LAYOUT_CHAIN_KEY, LOADING_KEY, LOCALIZE_PATH_KEY, type LayoutChainContext, LayoutChainRenderer, Link, type LinkProps, type LinkTag, type MetaTag, PAGE_KEY, PageView, type PartyTownConfig, type ResolvedAppConfig, type RouteLocation, type RouteLocationRaw, SSR_KEY, type ScriptTrigger, type SearchFilters, type SearchResult, type SearchRuntimeConfig, type SeoMetadata, SlotView, TRANSITION_KEY, type TypedLinkProps, type UbeanAppInstance, type UbeanAppOptions, type UbeanVueContext, type UbeanVueOptions, type UbeanVuePage, type UbeanVuePageData, type UseAsyncDataOptions, type UseAsyncDataReturn, type UseCacheViewsReturn, type UsePageTransitionReturn, type UseReloadSignalReturn, type UseScriptOptions, type UseScriptReturn, type UseSearchOptions, type UseSearchReturn, type ViewTransitionOptions, type VueHeadClient$1 as VueHeadClient, type VueI18nInstance, _resetColorMode, _resetPartyTown, _resetSearch, _setPagefindMock, addLocale, applyAppConfig, clearCache, clearLocales, clearPageTransition, collectIslands, configureColorMode, configurePartyTown, configureSearch, createClientHead, createDataCacheStore, createDefaultAppConfig, createLinkHandler, createUbeanClientApp, createUbeanRouter, createUbeanSSRApp, createUseAsyncData, defineApp, defineDataKey, defineLocale, defineMeta, defineMiddleware, definePage, detectBrowserLocale, detectLocale, disablePageCache, enablePageCache, excludePageCache, executeSearch, extractLocaleFromPath, extractPageData, forceColorMode, getCacheEnabled, getCachedViewNames, getColorModeConfig, getColorModeScript, getDefaultLocale, getExcludedViewNames, getI18nConfig, getInitialPageData, getInitialState, getInvalidatedKeysForAction, getLocale, getLocaleDir, getLocaleName, getNamedPageWrapper, getNavigationType, getPageTransitionName, getPartyTownConfig, getPartyTownHeadContent, getPartyTownScript, getRegisteredLocales, getReloadCounter, getSearchConfig, hydrateIsland, hydrateIslands, includePageCache, initCachedViewsFromRoutes, initClientI18n, initPagefind, injectHead, invalidateCache, invalidatePageCache, isActiveRoute, isCacheEnabled, isPageCached, isPageExcluded, isPagefindLoaded, isPartyTownEnabled, isReloading, localizePath, mergeAppConfig, mergeLocale, onLocaleChange, reloadPage, resetNamedPageWrappers, resetRouteCache, resolveColorModeConfig, resolvePartyTownConfig, resolveRoute, resolveSearchConfig, setI18nConfig, setLocale, setPageTransition, supportsViewTransitions, switchLocalePath, t, ubeanVue, unforceColorMode, useCacheViews, useColorMode, useUnheadHead as useHead, useHeadInstance, useI18n, useLocalePath, usePage, usePageTransition, useReloadSignal, useRouter, useScript, useSearch, useSeoMeta, useServerData, useSwitchLocalePath, useViewTransition, useViewTransitionState, withViewTransition };