fimo 0.8.0 → 0.9.0-experimental.2

package/dist/runtime/app/FimoProviders.d.ts

@@ -1,15 +1,5 @@
 import React from 'react';
-export interface ParamInfo {
-    schema: string;
-    queryField: string;
-    displayField: string;
-}
-export interface DisplayRoute {
-    id: string;
-    name: string;
-    path: string;
-    params?: Record<string, ParamInfo>;
-}
+export type { DisplayRoute, ParamInfo } from '../shared/display-routes.js';
 export interface FimoProvidersProps {
     children?: React.ReactNode;
     locale?: string;

package/dist/runtime/app/FimoProviders.js

@@ -11,31 +11,10 @@ import { ViteLifecycles } from '../core/ViteLifecycles.js';
 import { FimoLocaleProvider } from '../i18n/FimoLocaleContext.js';
 import { getFimoTextDirection, resolveFimoLocale, toHtmlLang } from '../i18n/locale.js';
 import { ScreenshotProvider } from '../iframe/ScreenshotProvider.js';
+import { getDisplayRoutes as getDisplayRoutesFromConfig } from '../shared/display-routes.js';
 import { OptionalTracking } from '../t/OptionalTracking.js';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-const generateRouteName = (path) => {
-    if (path === '/') {
-        return 'Home';
-    }
-    const firstSegment = path.replace(/^\//, '').split('/')[0];
-    return titleCase(firstSegment);
-};
 function getDisplayRoutes() {
-    const configRoutes = fimoConfig.routes ?? {};
-    return Object.entries(configRoutes)
-        .filter(([, route]) => route.path)
-        .map(([id, route]) => ({
-        id,
-        path: route.path,
-        name: route.name || generateRouteName(route.path),
-        params: route.params,
-    }));
+    return getDisplayRoutesFromConfig(fimoConfig);
 }
 function PreviewBridge() {
     const navigate = useNavigate();

package/dist/runtime/astro/index.d.ts

@@ -0,0 +1,2 @@
+export * from './server.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/astro/index.js

@@ -0,0 +1,3 @@
+// fimo/astro — see ./server.js (Astro is server-loader + DOM-attrs based;
+// no client component set in v1).
+export * from './server.js';

package/dist/runtime/astro/server.d.ts

@@ -0,0 +1,3 @@
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/astro/server.js

@@ -0,0 +1,6 @@
+// fimo/astro/server — Astro adapter, server surface. The loaders are
+// framework-neutral (Astro needs no React): call them in server-side code
+// (frontmatter / load functions / useAsyncData) and render values with the
+// DOM attribute helpers so edit mode can select the elements.
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';

package/dist/runtime/content/client/internal.js

@@ -179,6 +179,7 @@ function wrapReference(value, uid, resolve) {
 function wrapField(field, value, source, resolve) {
     switch (field.type) {
         case 'string':
+        case 'text':
             return value != null ? new FimoString(value, source) : value;
         case 'richtext':
             return value != null ? new FimoRichText(value, source) : value;

package/dist/runtime/content/client/types.d.ts

@@ -18,6 +18,7 @@ export type ContentResult<T extends {
 export interface ContentSchemaField {
     type?: string;
     required?: boolean;
+    default?: unknown;
     /** Media fields: multiple assets. */
     multiple?: boolean;
     /** Reference fields: to-many. */
@@ -26,6 +27,21 @@ export interface ContentSchemaField {
     target?: string;
     /** Polymorphic reference fields: allowed target schema uids. */
     targets?: readonly string[];
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+    schema?: {
+        fields: Readonly<Record<string, ContentSchemaField>>;
+    } | {
+        oneOf: readonly {
+            uid: string;
+            label: string;
+            description?: string;
+            fields: Readonly<Record<string, ContentSchemaField>>;
+        }[];
+    };
 }
 export interface ContentSchema {
     uid: string;

package/dist/runtime/i18n/FimoLocaleContext.js

@@ -1,3 +1,4 @@
+'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext } from 'react';
 const fallbackLocale = {

package/dist/runtime/next/FimoNextProviders.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { FimoConfig } from '../shared/fimo-config.types.js';
+import type { WrappedMediaEntry, WrappedRichTextEntry } from '../wrapped/WrappedContentContext.js';
+import { type WrappedLabels } from '../wrapped/WrappedProviders.js';
+export type FimoNextLabels = WrappedLabels;
+export interface FimoNextProvidersProps {
+    config: FimoConfig;
+    labels?: FimoNextLabels;
+    media?: Record<string, WrappedMediaEntry>;
+    richText?: Record<string, WrappedRichTextEntry>;
+    locale?: string;
+    children?: React.ReactNode;
+}
+/**
+ * Fimo providers for wrapped Next.js apps — the Next adapter supplies only
+ * the navigation hooks; everything else lives in the framework-neutral
+ * WrappedProviders. Mount once in the root layout:
+ *
+ *   const config = loadFimoConfig();
+ *   const labels = await loadFimoLabels();
+ *   <FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>
+ */
+export declare function FimoNextProviders(props: FimoNextProvidersProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=FimoNextProviders.d.ts.map

package/dist/runtime/next/FimoNextProviders.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { usePathname, useRouter } from 'next/navigation';
+import { useMemo } from 'react';
+import { WrappedProviders } from '../wrapped/WrappedProviders.js';
+/**
+ * Fimo providers for wrapped Next.js apps — the Next adapter supplies only
+ * the navigation hooks; everything else lives in the framework-neutral
+ * WrappedProviders. Mount once in the root layout:
+ *
+ *   const config = loadFimoConfig();
+ *   const labels = await loadFimoLabels();
+ *   <FimoNextProviders config={config} labels={labels}>{children}</FimoNextProviders>
+ */
+export function FimoNextProviders(props) {
+    const router = useRouter();
+    const pathname = usePathname();
+    const navigation = useMemo(() => ({ pathname, navigate: (to) => router.push(to) }), [pathname, router]);
+    return _jsx(WrappedProviders, { ...props, navigation: navigation });
+}

package/dist/runtime/next/FimoNextScripts.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Renders the Fimo preview client script in development so the Fimo Studio
+ * preview can select/edit elements. Mount inside <head> in the root layout.
+ *
+ * The script URL comes from NEXT_PUBLIC_FIMO_PREVIEW_SCRIPT_URL (written by
+ * `fimo init` for wrapped projects, pointing at `<apiUrl>/preview.js`).
+ * Renders nothing in production builds.
+ */
+export declare function FimoNextScripts(): import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=FimoNextScripts.d.ts.map

package/dist/runtime/next/FimoNextScripts.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Renders the Fimo preview client script in development so the Fimo Studio
+ * preview can select/edit elements. Mount inside <head> in the root layout.
+ *
+ * The script URL comes from NEXT_PUBLIC_FIMO_PREVIEW_SCRIPT_URL (written by
+ * `fimo init` for wrapped projects, pointing at `<apiUrl>/preview.js`).
+ * Renders nothing in production builds.
+ */
+export function FimoNextScripts() {
+    if (process.env.NODE_ENV !== 'development') {
+        return null;
+    }
+    const previewScriptUrl = process.env.NEXT_PUBLIC_FIMO_PREVIEW_SCRIPT_URL;
+    if (!previewScriptUrl) {
+        return null;
+    }
+    return _jsx("script", { type: "module", src: previewScriptUrl });
+}

package/dist/runtime/next/index.d.ts

@@ -0,0 +1,14 @@
+export { FimoNextProviders } from './FimoNextProviders.js';
+export type { FimoNextLabels, FimoNextProvidersProps } from './FimoNextProviders.js';
+export { FimoNextScripts } from './FimoNextScripts.js';
+export { FimoText } from '../wrapped/FimoText.js';
+export { FimoRichTextBlock } from '../wrapped/FimoRichTextBlock.js';
+export { FimoMediaImage } from '../wrapped/FimoMediaImage.js';
+export { FimoMediaVideo } from '../wrapped/FimoMediaVideo.js';
+export { FimoFileLink } from '../wrapped/FimoFileLink.js';
+export { useWrappedMedia, useWrappedRichText } from '../wrapped/WrappedContentContext.js';
+export type { WrappedMediaEntry, WrappedRichTextEntry } from '../wrapped/WrappedContentContext.js';
+export { useLabels, useTranslations } from '../primitives/labels-hook.js';
+export { Text, Image, Video, RichText } from '../react/index.js';
+export type { FimoConfig } from '../shared/fimo-config.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/next/index.js

@@ -0,0 +1,14 @@
+// fimo/next — the Next.js adapter for wrapped (migrated) sites.
+// Client components; server loaders live in fimo/next/server.
+export { FimoNextProviders } from './FimoNextProviders.js';
+export { FimoNextScripts } from './FimoNextScripts.js';
+export { FimoText } from '../wrapped/FimoText.js';
+export { FimoRichTextBlock } from '../wrapped/FimoRichTextBlock.js';
+export { FimoMediaImage } from '../wrapped/FimoMediaImage.js';
+export { FimoMediaVideo } from '../wrapped/FimoMediaVideo.js';
+export { FimoFileLink } from '../wrapped/FimoFileLink.js';
+export { useWrappedMedia, useWrappedRichText } from '../wrapped/WrappedContentContext.js';
+// Framework-neutral React surface, re-exported for convenience so wrapped
+// apps import everything from fimo/next.
+export { useLabels, useTranslations } from '../primitives/labels-hook.js';
+export { Text, Image, Video, RichText } from '../react/index.js';

package/dist/runtime/next/server.d.ts

@@ -0,0 +1,2 @@
+export * from '../wrapped/server.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/next/server.js

@@ -0,0 +1,4 @@
+// fimo/next/server — the Next.js adapter's server surface. The loaders are
+// framework-neutral and live in ../wrapped/server.js; this module is the
+// adapter-facing entry so future adapters (fimo/astro) mirror it.
+export * from '../wrapped/server.js';

package/dist/runtime/nuxt/composables.d.ts

@@ -0,0 +1,9 @@
+export declare function useFimoLabels(locale?: string): Promise<Record<string, string>>;
+/**
+ * Server-loaded, hydration-safe label accessor for `<script setup>`:
+ *
+ *   const t = await useFimoT();
+ *   <h1 v-bind="fimoLabelAttrs('hero.title')">{{ t('hero.title', 'Fallback') }}</h1>
+ */
+export declare function useFimoT(locale?: string): Promise<(key: string, fallback?: string) => string>;
+//# sourceMappingURL=composables.d.ts.map

package/dist/runtime/nuxt/composables.js

@@ -0,0 +1,57 @@
+// Nuxt composables over the PURE label-fetch core. Constraints proven by the
+// nuxtship dogfood, in order:
+//  - no node builtins anywhere in this module graph (`<script setup>` imports
+//    land in the client bundle; named imports from externalized builtins hard-
+//    fail `nuxt build`);
+//  - no `#app` import (Vite's dep optimizer prebundles node_modules with no
+//    knowledge of Nuxt aliases);
+//  - no `nuxt/app` import either (server-side the package is a nitro external
+//    resolved by raw node, where nuxt/app's internal `#build/*` imports do not
+//    exist).
+// So: import only from 'vue', reach the Nuxt app via the current component
+// instance, and hand labels to the client through `nuxtApp.payload.data` —
+// the exact bucket useAsyncData serializes into the page payload.
+import { getCurrentInstance } from 'vue';
+import { fetchLabelDictionary, resolveTenantApiUrl } from '../shared/labels-fetch.pure.js';
+function currentNuxtApp() {
+    const instance = getCurrentInstance();
+    const vueApp = instance?.appContext?.app;
+    return vueApp?.$nuxt ?? vueApp?.config?.globalProperties?.$nuxt ?? instance?.proxy?.$nuxt;
+}
+export async function useFimoLabels(locale = 'en') {
+    const key = `__fimo_labels_${locale}`;
+    const payloadData = currentNuxtApp()?.payload?.data;
+    const cached = payloadData?.[key];
+    if (cached) {
+        return cached;
+    }
+    // `typeof window` (not import.meta.server): as a nitro external this module
+    // runs as plain node ESM where Nuxt's import.meta flags do not exist.
+    if (typeof window !== 'undefined') {
+        return {};
+    }
+    const apiUrl = resolveTenantApiUrl(process.env);
+    if (!apiUrl) {
+        return {};
+    }
+    try {
+        const { labels } = await fetchLabelDictionary(apiUrl, locale);
+        if (payloadData) {
+            payloadData[key] = labels;
+        }
+        return labels;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Server-loaded, hydration-safe label accessor for `<script setup>`:
+ *
+ *   const t = await useFimoT();
+ *   <h1 v-bind="fimoLabelAttrs('hero.title')">{{ t('hero.title', 'Fallback') }}</h1>
+ */
+export async function useFimoT(locale = 'en') {
+    const labels = await useFimoLabels(locale);
+    return (key, fallback = '') => labels[key] ?? fallback;
+}

package/dist/runtime/nuxt/index.d.ts

@@ -0,0 +1,3 @@
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { useFimoLabels, useFimoT } from './composables.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/nuxt/index.js

@@ -0,0 +1,6 @@
+// fimo/nuxt — CLIENT-SAFE surface for universal Vue SFCs. Never re-export
+// the server barrel here: a `<script setup>` import lands in the client
+// bundle, and the server loaders read fs/env (the nuxtship dogfood broke
+// `nuxt build` exactly this way). Server routes import fimo/nuxt/server.
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { useFimoLabels, useFimoT } from './composables.js';

package/dist/runtime/nuxt/server.d.ts

@@ -0,0 +1,3 @@
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/nuxt/server.js

@@ -0,0 +1,6 @@
+// fimo/nuxt/server — Nuxt adapter, server surface. The loaders are
+// framework-neutral (Nuxt needs no React): call them in server-side code
+// (frontmatter / load functions / useAsyncData) and render values with the
+// DOM attribute helpers so edit mode can select the elements.
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';

package/dist/runtime/primitives/labels-hook.d.ts

@@ -0,0 +1,33 @@
+import { FimoString } from './lib/index.js';
+/**
+ * Hook to provide a label function (`t`).
+ *
+ * Returns FimoString with source tracking for inline editing.
+ * Use with <Text> component for rendering, or String() for escape hatch.
+ *
+ * The optional `fallback` renders when the key has no value in the store —
+ * used by wrapped (migrated) projects where the original hardcoded string
+ * stays in code as a resilience fallback. Template projects keep the
+ * single-argument form (labels are DB-owned there).
+ *
+ * @example
+ * const { t } = useLabels();
+ *
+ * // With Text component (recommended)
+ * <Text value={t('welcome')} />
+ *
+ * // Escape hatch for attributes
+ * <input placeholder={String(t('email.placeholder'))} />
+ */
+export declare function useLabels(): {
+    t: (fullKey: string, fallback?: string) => FimoString;
+    locale: string;
+};
+/**
+ * Legacy alias for older projects. Prefer useLabels() in new code.
+ */
+export declare function useTranslations(): {
+    t: (fullKey: string, fallback?: string) => FimoString;
+    locale: string;
+};
+//# sourceMappingURL=labels-hook.d.ts.map

package/dist/runtime/primitives/labels-hook.js

@@ -0,0 +1,41 @@
+import { useSyncExternalStore } from 'react';
+import { useLocale } from '../i18n/FimoLocaleContext.js';
+import { getLabelSnapshot, subscribeLabels } from './labels-store.js';
+import { FimoString } from './lib/index.js';
+/**
+ * Hook to provide a label function (`t`).
+ *
+ * Returns FimoString with source tracking for inline editing.
+ * Use with <Text> component for rendering, or String() for escape hatch.
+ *
+ * The optional `fallback` renders when the key has no value in the store —
+ * used by wrapped (migrated) projects where the original hardcoded string
+ * stays in code as a resilience fallback. Template projects keep the
+ * single-argument form (labels are DB-owned there).
+ *
+ * @example
+ * const { t } = useLabels();
+ *
+ * // With Text component (recommended)
+ * <Text value={t('welcome')} />
+ *
+ * // Escape hatch for attributes
+ * <input placeholder={String(t('email.placeholder'))} />
+ */
+export function useLabels() {
+    const localeContext = useLocale();
+    const labels = useSyncExternalStore(subscribeLabels, getLabelSnapshot, getLabelSnapshot);
+    const t = (fullKey, fallback) => {
+        const locale = localeContext.locale || labels.defaultLocale || 'en';
+        const dictionary = labels.dictionaries[locale] ?? labels.dictionaries[labels.defaultLocale] ?? {};
+        const text = dictionary[fullKey] ?? fallback ?? '';
+        return new FimoString(text, `__labels.${locale}.${fullKey}.value`);
+    };
+    return { t, locale: localeContext.locale };
+}
+/**
+ * Legacy alias for older projects. Prefer useLabels() in new code.
+ */
+export function useTranslations() {
+    return useLabels();
+}

package/dist/runtime/primitives/labels-store.d.ts

@@ -0,0 +1,12 @@
+export interface LabelState {
+    dictionaries: Record<string, Record<string, string>>;
+    defaultLocale: string;
+    signature: string;
+    updatedAt: string | null;
+}
+export declare function subscribeLabels(listener: () => void): () => void;
+export declare function getLabelSnapshot(): LabelState;
+export declare function setLabelState(next: LabelState): void;
+export declare function hydrateLabels(bundle: LabelState): void;
+export declare function applyLabelUpdate(payload: unknown): void;
+//# sourceMappingURL=labels-store.d.ts.map

package/dist/runtime/primitives/labels-store.js

@@ -0,0 +1,60 @@
+// Framework-neutral label store. No Vite virtual modules, no HMR, no React:
+// adapters (fimo/ui via ./translations.ts, fimo/next, ...) hydrate it with
+// their own label source and the hook layer subscribes to it.
+const labelListeners = new Set();
+let labelState = {
+    dictionaries: {},
+    defaultLocale: 'en',
+    signature: '__fimo-labels-uninitialized__',
+    updatedAt: null,
+};
+export function subscribeLabels(listener) {
+    labelListeners.add(listener);
+    return () => {
+        labelListeners.delete(listener);
+    };
+}
+export function getLabelSnapshot() {
+    return labelState;
+}
+export function setLabelState(next) {
+    if (next.signature === labelState.signature) {
+        return;
+    }
+    labelState = next;
+    for (const listener of labelListeners) {
+        listener();
+    }
+}
+export function hydrateLabels(bundle) {
+    setLabelState(bundle);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeDictionaries(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const dictionaries = {};
+    for (const [locale, labels] of Object.entries(value)) {
+        if (!isRecord(labels)) {
+            continue;
+        }
+        dictionaries[locale] = Object.fromEntries(Object.entries(labels).filter((entry) => typeof entry[1] === 'string'));
+    }
+    return dictionaries;
+}
+export function applyLabelUpdate(payload) {
+    if (!isRecord(payload)) {
+        return;
+    }
+    const dictionaries = normalizeDictionaries(payload.dictionaries);
+    if (!dictionaries) {
+        return;
+    }
+    const defaultLocale = typeof payload.defaultLocale === 'string' ? payload.defaultLocale : labelState.defaultLocale;
+    const signature = typeof payload.signature === 'string' ? payload.signature : JSON.stringify({ dictionaries, defaultLocale });
+    const updatedAt = typeof payload.updatedAt === 'string' ? payload.updatedAt : null;
+    setLabelState({ dictionaries, defaultLocale, signature, updatedAt });
+}

package/dist/runtime/primitives/lib/useFimoLiveValue.d.ts

@@ -9,9 +9,11 @@ import { type RefObject } from 'react';
  * preview knows to dispatch events instead of falling back to raw DOM writes,
  * and updates internal state when a mutation arrives.
  *
- * In prod (published app): Vite statically inlines `import.meta.env.DEV`, so
- * `useFimoLiveValueProd` is the only implementation linked and the listener
- * machinery is dead-code-eliminated.
+ * In prod (published app): only `useFimoLiveValueProd` is linked. The dev
+ * check must work under any bundler (Vite, webpack, Turbopack) and plain
+ * Node SSR: `import.meta.env.DEV` only exists under Vite, and
+ * `process.env.NODE_ENV` is statically replaced by Next/webpack — checking
+ * both keeps the hook correct across adapters.
  */
 declare function useFimoLiveValueDev<T, E extends HTMLElement = HTMLElement>(external: T): {
     value: T;

package/dist/runtime/primitives/lib/useFimoLiveValue.js

@@ -10,9 +10,11 @@ import { useEffect, useRef, useState } from 'react';
  * preview knows to dispatch events instead of falling back to raw DOM writes,
  * and updates internal state when a mutation arrives.
  *
- * In prod (published app): Vite statically inlines `import.meta.env.DEV`, so
- * `useFimoLiveValueProd` is the only implementation linked and the listener
- * machinery is dead-code-eliminated.
+ * In prod (published app): only `useFimoLiveValueProd` is linked. The dev
+ * check must work under any bundler (Vite, webpack, Turbopack) and plain
+ * Node SSR: `import.meta.env.DEV` only exists under Vite, and
+ * `process.env.NODE_ENV` is statically replaced by Next/webpack — checking
+ * both keeps the hook correct across adapters.
  */
 function useFimoLiveValueDev(external) {
     const ref = useRef(null);
@@ -46,4 +48,9 @@ function useFimoLiveValueProd(external) {
     const ref = useRef(null);
     return { value: external, ref };
 }
-export const useFimoLiveValue = (import.meta.env.DEV ? useFimoLiveValueDev : useFimoLiveValueProd);
+// globalThis lookup, not a bare `process` reference: this file is part of the
+// browser-facing runtime surface, which must typecheck without node types
+// (the generated-types gate enforces it).
+const isDevRuntime = import.meta.env?.DEV === true ||
+    globalThis.process?.env?.NODE_ENV === 'development';
+export const useFimoLiveValue = (isDevRuntime ? useFimoLiveValueDev : useFimoLiveValueProd);

package/dist/runtime/primitives/translations.d.ts

@@ -1,28 +1,2 @@
-import { FimoString } from './lib/index.js';
-/**
- * Hook to provide a label function (`t`).
- *
- * Returns FimoString with source tracking for inline editing.
- * Use with <Text> component for rendering, or String() for escape hatch.
- *
- * @example
- * const { t } = useLabels();
- *
- * // With Text component (recommended)
- * <Text value={t('welcome')} />
- *
- * // Escape hatch for attributes
- * <input placeholder={String(t('email.placeholder'))} />
- */
-export declare function useLabels(): {
-    t: (fullKey: string) => FimoString;
-    locale: string;
-};
-/**
- * Legacy alias for older projects. Prefer useLabels() in new code.
- */
-export declare function useTranslations(): {
-    t: (fullKey: string) => FimoString;
-    locale: string;
-};
+export { useLabels, useTranslations } from './labels-hook.js';
 //# sourceMappingURL=translations.d.ts.map