@intlayer/next-intl 9.4.3 → 9.5.0

package/dist/types/client/useLocale.d.ts

@@ -3,7 +3,6 @@ import { useLocale as useLocale$1 } from "next-intl";
 /**
  * Drop-in for next-intl's `useLocale`.
  */
-declare const useLocale: typeof useLocale$1;
+export declare const useLocale: typeof useLocale$1;
 //#endregion
-export { useLocale };
 //# sourceMappingURL=useLocale.d.ts.map

package/dist/types/client/useLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;;;cAQa,kBAAkB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;;;qBAQa,kBAAkB"}

package/dist/types/getDictionary.d.ts

@@ -29,7 +29,6 @@ type GetDictionary = {
  * `getTranslations` is always awaited, so an async resolver is a drop-in
  * replacement.
  */
-declare const getDictionary: GetDictionary;
+export declare const getDictionary: GetDictionary;
 //#endregion
-export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

package/dist/types/getDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;;;;KAkCK;GACF,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,QAAQ,wBAAwB,WAAW,gBAAgB;GAC7D,UAAU,YACT,YAAY,GACZ;IAAY,SAAS;MACpB,QAAQ,kBAAkB,WAAW;;;;;;;;;;;;;;;;;cAkB7B,eASP"}
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;;;;;KAkCK;GACF,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,QAAQ,wBAAwB,WAAW,gBAAgB;GAC7D,UAAU,YACT,YAAY,GACZ;IAAY,SAAS;MACpB,QAAQ,kBAAkB,WAAW;;;;;;;;;;;;;;;;;qBAkB7B,eASP"}

package/dist/types/getDictionaryDynamic.d.ts

@@ -17,7 +17,6 @@ type GetDictionaryDynamic = {
  * Counterpart to {@link getDictionary} for dictionaries imported lazily per
  * locale. Used internally by the build-time optimization.
  */
-declare const getDictionaryDynamic: GetDictionaryDynamic;
+export declare const getDictionaryDynamic: GetDictionaryDynamic;
 //#endregion
-export { getDictionaryDynamic };
 //# sourceMappingURL=getDictionaryDynamic.d.ts.map

package/dist/types/getDictionaryDynamic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDictionaryDynamic.d.ts","names":[],"sources":["../../src/getDictionaryDynamic.ts"],"mappings":";;;;;;;;;KAmBK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,IACJ,QAAQ,kBAAkB;GAC5B,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,GACL,iBAAiB,SAChB,QAAQ,wBAAwB,GAAG;;;;;;;;cAS3B,sBAYP"}
+{"version":3,"file":"getDictionaryDynamic.d.ts","names":[],"sources":["../../src/getDictionaryDynamic.ts"],"mappings":";;;;;;;;;KAmBK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,IACJ,QAAQ,kBAAkB;GAC5B,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,0BAA0B,QAAQ,KACrD,KAAK,GACL,iBAAiB,SAChB,QAAQ,wBAAwB,GAAG;;;;;;;;qBAS3B,sBAYP"}

package/dist/types/middleware.d.ts

@@ -15,7 +15,7 @@ import _createMiddleware from "next-intl/middleware";
  * export const config = { matcher: ['/((?!api|_next|.*\\..*).*)'] };
  * ```
  */
-declare const createMiddleware: typeof _createMiddleware;
+export declare const createMiddleware: typeof _createMiddleware;
 //#endregion
-export { createMiddleware, createMiddleware as default };
+export { createMiddleware as default };
 //# sourceMappingURL=middleware.d.ts.map

package/dist/types/middleware.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;cAmBa,yBAAyB"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAmBa,yBAAyB"}

package/dist/types/navigation/Link.d.ts

@@ -6,7 +6,7 @@ import NextLink from "next/link";
  * Props for the compat `Link`: identical to `next/link` except `href` accepts a
  * `next-intl` href and an optional `locale` overrides the current one.
  */
-type LinkProps = Omit<ComponentPropsWithoutRef<typeof NextLink>, 'href' | 'locale'> & {
+export type LinkProps = Omit<ComponentPropsWithoutRef<typeof NextLink>, 'href' | 'locale'> & {
   href: NextIntlHref;
   locale?: string;
 };
@@ -15,12 +15,11 @@ type LinkProps = Omit<ComponentPropsWithoutRef<typeof NextLink>, 'href' | 'local
  * `href` with the active locale (or the `locale` prop) before delegating to
  * `next/link`.
  */
-declare const Link: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, keyof import("next/link").LinkProps<any>> & import("next/link").LinkProps<any> & {
+export declare const Link: import("react").ForwardRefExoticComponent<Omit<Omit<Omit<import("react").AnchorHTMLAttributes<HTMLAnchorElement>, keyof import("next/link").LinkProps<any>> & import("next/link").LinkProps<any> & {
   children?: React.ReactNode | undefined;
 } & import("react").RefAttributes<HTMLAnchorElement>, "ref">, "href" | "locale"> & {
   href: NextIntlHref;
   locale?: string;
 } & import("react").RefAttributes<HTMLAnchorElement>>;
 //#endregion
-export { Link, LinkProps };
 //# sourceMappingURL=Link.d.ts.map

package/dist/types/navigation/Link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../src/navigation/Link.tsx"],"mappings":";;;;;;;;KAWY,YAAY,KACtB,gCAAgC;EAGhC,MAAM;EACN;;;;;;;cAQW,sBAAI,0BAAA,KAAA,KAAA,qBAAA,qBAAA,8CAAA,sCAAA;;;EATT,MAAA;EACG;oBAiBV,cAAA"}
+{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../src/navigation/Link.tsx"],"mappings":";;;;;;;;YAWY,YAAY,KACtB,gCAAgC;EAGhC,MAAM;EACN;;;;;;;qBAQW,sBAAI,0BAAA,KAAA,KAAA,qBAAA,qBAAA,8CAAA,sCAAA;;;EATT,MAAA;EACG;oBAiBV,cAAA"}

package/dist/types/navigation/createNavigation.d.ts

@@ -14,7 +14,7 @@ import { createNavigation as createNavigation$1 } from "next-intl/navigation";
  *   createNavigation();
  * ```
  */
-declare const createNavigation: typeof createNavigation$1;
+export declare const createNavigation: typeof createNavigation$1;
 //#endregion
-export { createNavigation, createNavigation as default };
+export { createNavigation as default };
 //# sourceMappingURL=createNavigation.d.ts.map

package/dist/types/navigation/createNavigation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createNavigation.d.ts","names":[],"sources":["../../../src/navigation/createNavigation.ts"],"mappings":";;;;;;;;;;;;;;;;cA6Ba,yBAAyB"}
+{"version":3,"file":"createNavigation.d.ts","names":[],"sources":["../../../src/navigation/createNavigation.ts"],"mappings":";;;;;;;;;;;;;;;;qBA6Ba,yBAAyB"}

package/dist/types/navigation/hooks.d.ts

@@ -11,13 +11,13 @@ type NavigateOptions = {
  * Drop-in for the `usePathname` returned by next-intl's `createNavigation`.
  * Returns the current pathname with the locale prefix stripped.
  */
-declare const usePathname: () => string;
+export declare const usePathname: () => string;
 /**
  * Drop-in for the `useRouter` returned by next-intl's `createNavigation`.
  * Wraps the Next.js router so `push`/`replace`/`prefetch` localize their href
  * (honouring an optional `locale` option) before navigating.
  */
-declare const useRouter: () => {
+export declare const useRouter: () => {
   back(): void;
   forward(): void;
   refresh(): void;
@@ -28,5 +28,4 @@ declare const useRouter: () => {
   prefetch: (href: NextIntlHref, options?: NavigateOptions) => void;
 };
 //#endregion
-export { usePathname, useRouter };
 //# sourceMappingURL=hooks.d.ts.map

package/dist/types/navigation/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../src/navigation/hooks.ts"],"mappings":";;;;;;KAaK;EAAoB;IAAoB;;;;;cAMhC;;;;;;cAeA;;;;;;EASI,OAAA,MAAA,cAAY,UAAY;EAKrB,UAAA,MAAA,cAAY,UAAY;EAKvB,WAAA,MAAA,cAAY,UAAY"}
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../src/navigation/hooks.ts"],"mappings":";;;;;;KAaK;EAAoB;IAAoB;;;;;qBAMhC;;;;;;qBAeA;;;;;;EASI,OAAA,MAAA,cAAY,UAAY;EAKrB,UAAA,MAAA,cAAY,UAAY;EAKvB,WAAA,MAAA,cAAY,UAAY"}

package/dist/types/navigation/localizeHref.d.ts

@@ -4,7 +4,7 @@
  * `pathname` and optional `query`. The `pathnames` (typed routes) feature is
  * accepted for API compatibility but not interpolated.
  */
-type NextIntlHref = string | {
+export type NextIntlHref = string | {
   pathname: string;
   query?: Record<string, string | number | (string | number)[]>;
   params?: Record<string, string | number | (string | number)[]>;
@@ -17,7 +17,6 @@ type NextIntlHref = string | {
  * @param locale - The locale to localize the href for.
  * @returns The localized URL string.
  */
-declare const localizeHref: (href: NextIntlHref, locale: string) => string;
+export declare const localizeHref: (href: NextIntlHref, locale: string) => string;
 //#endregion
-export { NextIntlHref, localizeHref };
 //# sourceMappingURL=localizeHref.d.ts.map

package/dist/types/navigation/localizeHref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localizeHref.d.ts","names":[],"sources":["../../../src/navigation/localizeHref.ts"],"mappings":";;;;;;KAQY;EAGN;EACA,QAAQ;EACR,SAAS;;;;;;;;;;cAWF,eAAY,MAAU,cAAY"}
+{"version":3,"file":"localizeHref.d.ts","names":[],"sources":["../../../src/navigation/localizeHref.ts"],"mappings":";;;;;;YAQY;EAGN;EACA,QAAQ;EACR,SAAS;;;;;;;;;;qBAWF,eAAY,MAAU,cAAY"}

package/dist/types/plugin/index.d.ts

@@ -5,7 +5,7 @@ import { NextConfig } from "next";
  * and configures resolve aliases so `next-intl` imports are served by
  * `@intlayer/next-intl`.
  */
-declare const createNextIntlPlugin: (_i18nPath?: string) => (nextConfig?: NextConfig) => Promise<NextConfig>;
+export declare const createNextIntlPlugin: (_i18nPath?: string) => (nextConfig?: NextConfig) => Promise<NextConfig>;
 //#endregion
-export { createNextIntlPlugin, createNextIntlPlugin as default };
+export { createNextIntlPlugin as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/types/plugin/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;cAiHa,uBAAoB,wBAAsB,aAC3B,eAAkB,QAAQ"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;;;qBA0Ia,uBAAoB,wBAAsB,aAC3B,eAAkB,QAAQ"}

package/dist/types/react-server/helpers.d.ts

@@ -0,0 +1,12 @@
+//#region src/react-server/helpers.d.ts
+/**
+ * Server counterparts of use-intl's ambient hooks. They mirror the client
+ * versions' signatures so the same component code type-checks on both sides.
+ */
+export declare const useFormatter: typeof import('@intlayer/use-intl').useFormatter;
+/** Current time on the server render. */
+export declare const useNow: typeof import('@intlayer/use-intl').useNow;
+/** Time zone used by the formatters; UTC unless the app overrides it. */
+export declare const useTimeZone: typeof import('@intlayer/use-intl').useTimeZone;
+//#endregion
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/react-server/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/react-server/helpers.ts"],"mappings":";;;;;qBAOa,kDAAkD;;qBAIlD,4CAA4C;;qBAI5C,iDAAiD"}

package/dist/types/react-server/index.d.ts

@@ -0,0 +1,9 @@
+import { NextIntlClientProvider, NextIntlClientProviderProps } from "../client/NextIntlClientProvider.js";
+import { Routing, defineRouting } from "../routing.js";
+import { useFormatter, useNow, useTimeZone } from "./helpers.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { useLocale } from "./useLocale.js";
+import { useTranslations } from "./useTranslations.js";
+import { IntlError, IntlErrorCode, createFormatter, createTranslator, hasLocale, initializeConfig, useMessages } from "@intlayer/use-intl";
+export { IntlError, IntlErrorCode, NextIntlClientProvider, type NextIntlClientProviderProps, type Routing, createFormatter, createTranslator, defineRouting, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/react-server/resolveLocale.d.ts

@@ -0,0 +1,14 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/react-server/resolveLocale.d.ts
+/**
+ * Locale for a synchronous server hook, resolved the same way `getLocale()`
+ * resolves it — so server-rendered content and the client provider never
+ * disagree about which locale the request is in.
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment), which is next-intl's source of truth for URL routing.
+ * 2. Otherwise Intlayer's ambient locale (server context, then the request).
+ */
+export declare const resolveServerLocale: () => LocalesValues;
+//#endregion
+//# sourceMappingURL=resolveLocale.d.ts.map

package/dist/types/react-server/resolveLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLocale.d.ts","names":[],"sources":["../../../src/react-server/resolveLocale.ts"],"mappings":";;;;;;;;;;;qBAaa,2BAA0B"}

package/dist/types/react-server/useDictionary.d.ts

@@ -0,0 +1,24 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/react-server/useDictionary.d.ts
+/**
+ * Overload set mirroring the client `useDictionary` exactly, so the optimize
+ * pass can emit the same call shape whichever side of the boundary the
+ * component ends up on.
+ */
+type UseDictionary = {
+  <T extends Dictionary>(dictionary: T): TranslateFunction<T['key'] & DictionaryKeys>;
+  <T extends Dictionary, Prefix extends string>(dictionary: T, namespacePrefix: Prefix): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;
+};
+/**
+ * Server counterpart of `@intlayer/use-intl`'s `useDictionary`.
+ *
+ * The optimize pass rewrites every `useTranslations(...)` call to this helper
+ * with the dictionary pre-imported. Resolving it here — rather than in a client
+ * component — keeps the dictionary out of the client bundle entirely: the
+ * server renders the text and only the rendered output crosses the boundary.
+ */
+export declare const useDictionary: UseDictionary;
+//#endregion
+//# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/react-server/useDictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/react-server/useDictionary.ts"],"mappings":";;;;;;;;;KAkBK;GACF,UAAU,YACT,YAAY,IACX,kBAAkB,WAAW;GAC/B,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,wBAAwB,WAAW,gBAAgB;;;;;;;;;;qBAW3C,eAYP"}

package/dist/types/react-server/useDictionaryDynamic.d.ts

@@ -0,0 +1,15 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/react-server/useDictionaryDynamic.d.ts
+type UseDictionaryDynamic = {
+  <T extends Dictionary, K extends DictionaryKeys>(dictionaryPromise: Record<string, () => Promise<T>>, key: K): TranslateFunction<K>;
+  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(dictionaryPromise: Record<string, () => Promise<T>>, key: K, namespacePrefix: Prefix): ScopedTranslateFunction<K, Prefix>;
+};
+/**
+ * Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass
+ * for dictionaries on the per-locale loader.
+ */
+export declare const useDictionaryDynamic: UseDictionaryDynamic;
+//#endregion
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/react-server/useDictionaryDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/react-server/useDictionaryDynamic.ts"],"mappings":";;;;KAaK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,IACJ,kBAAkB;GACpB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,GACL,iBAAiB,SAChB,wBAAwB,GAAG;;;;;;qBAOnB,sBAiBP"}

package/dist/types/react-server/useLocale.d.ts

@@ -0,0 +1,9 @@
+import { useLocale as useLocale$1 } from "next-intl";
+//#region src/react-server/useLocale.d.ts
+/**
+ * Server counterpart of `useLocale`, resolved from the `[locale]` route segment
+ * forwarded through `setRequestLocale` when the app provides one.
+ */
+export declare const useLocale: typeof useLocale$1;
+//#endregion
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/react-server/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/react-server/useLocale.ts"],"mappings":";;;;;;qBAOa,kBAAkB"}

package/dist/types/react-server/useTranslations.d.ts

@@ -0,0 +1,23 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "@intlayer/use-intl";
+//#region src/react-server/useTranslations.d.ts
+type UseTranslations = {
+  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
+  <N extends `${string}.${string}`>(namespace: N): TranslateFunctionForNamespace<N>;
+  (): LooseTranslateFunction;
+};
+/**
+ * Server counterpart of `useTranslations`.
+ *
+ * next-intl's `useTranslations` is isomorphic — the same component code runs in
+ * a Server or a Client Component — so the adapter has to be too. Without this
+ * every component calling it is forced across the client boundary, which drags
+ * its dictionary into a client chunk that Next shares across every locale.
+ *
+ * The optimize pass normally rewrites these calls to `useDictionary` with the
+ * dictionary inlined; this runtime path covers the calls it could not resolve
+ * statically (a dynamic namespace, or an unoptimized build).
+ */
+export declare const useTranslations: UseTranslations;
+//#endregion
+//# sourceMappingURL=useTranslations.d.ts.map

package/dist/types/react-server/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../src/react-server/useTranslations.ts"],"mappings":";;;KAUK;GACF,UAAU,gBAAgB,WAAW,IAAI,kBAAkB;GAC3D,iCACC,WAAW,IACV,8BAA8B;MAC7B;;;;;;;;;;;;;;qBAsBO,iBAmBP"}

package/dist/types/routing.d.ts

@@ -1,6 +1,6 @@
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/routing.d.ts
-type Routing = {
+export type Routing = {
   locales: LocalesValues[];
   defaultLocale: LocalesValues;
   localePrefix?: 'always' | 'as-needed' | 'never';
@@ -21,7 +21,6 @@ type Routing = {
  * });
  * ```
  */
-declare const defineRouting: (config?: Partial<Routing>) => Routing;
+export declare const defineRouting: (config?: Partial<Routing>) => Routing;
 //#endregion
-export { Routing, defineRouting };
 //# sourceMappingURL=routing.d.ts.map

package/dist/types/routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routing.d.ts","names":[],"sources":["../../src/routing.ts"],"mappings":";;KAGY;EACV,SAAS;EACT,eAAe;EACf;EACA,YAAY,wBAAwB;;;;;;;;;;;;;;;;;cAkBzB,gBAAgB,SAAS,QAAQ,aAAa"}
+{"version":3,"file":"routing.d.ts","names":[],"sources":["../../src/routing.ts"],"mappings":";;YAGY;EACV,SAAS;EACT,eAAe;EACf;EACA,YAAY,wBAAwB;;;;;;;;;;;;;;;;;qBAkBzB,gBAAgB,SAAS,QAAQ,aAAa"}

package/dist/types/server/getLocale.d.ts

@@ -12,7 +12,6 @@ import { getLocale as getLocale$1 } from "next-intl/server";
  * 2. Otherwise Intlayer's own resolution (cookie / header / Accept-Language),
  *    for apps that drive the locale from storage rather than the route.
  */
-declare const getLocale: typeof getLocale$1;
+export declare const getLocale: typeof getLocale$1;
 //#endregion
-export { getLocale };
 //# sourceMappingURL=getLocale.d.ts.map

package/dist/types/server/getLocale.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;;;;;;;;;;cAgBa,kBAAkB"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;;;;;;;;;;qBAgBa,kBAAkB"}

package/dist/types/server/getMessages.d.ts

@@ -15,7 +15,6 @@ import { getMessages as getMessages$1 } from "next-intl/server";
  * @deprecated getMessages has no use case with intlayer.
  * Messages are loaded automatically under the hood
  */
-declare const getMessages: typeof getMessages$1;
+export declare const getMessages: typeof getMessages$1;
 //#endregion
-export { getMessages };
 //# sourceMappingURL=getMessages.d.ts.map

package/dist/types/server/getMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMessages.d.ts","names":[],"sources":["../../../src/server/getMessages.ts"],"mappings":";;;;;;;;;;;;;;;;;cAoBa,oBAAoB"}
+{"version":3,"file":"getMessages.d.ts","names":[],"sources":["../../../src/server/getMessages.ts"],"mappings":";;;;;;;;;;;;;;;;;qBAoBa,oBAAoB"}

package/dist/types/server/getRequestConfig.d.ts

@@ -12,7 +12,7 @@ import { getRequestConfig as getRequestConfig$1 } from "next-intl/server";
  * @deprecated getRequestConfig has no use case with intlayer. The locale and
  * messages are resolved automatically; the file can be removed.
  */
-declare const getRequestConfig: typeof getRequestConfig$1;
+export declare const getRequestConfig: typeof getRequestConfig$1;
 //#endregion
-export { getRequestConfig as default, getRequestConfig };
+export { getRequestConfig as default };
 //# sourceMappingURL=getRequestConfig.d.ts.map

package/dist/types/server/getRequestConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getRequestConfig.d.ts","names":[],"sources":["../../../src/server/getRequestConfig.ts"],"mappings":";;;;;;;;;;;;;;cAiBa,yBAAyB"}
+{"version":3,"file":"getRequestConfig.d.ts","names":[],"sources":["../../../src/server/getRequestConfig.ts"],"mappings":";;;;;;;;;;;;;;qBAiBa,yBAAyB"}

package/dist/types/server/getTranslations.d.ts

@@ -59,7 +59,6 @@ type GetTranslations = {
  * t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
  * ```
  */
-declare const getTranslations: GetTranslations;
+export declare const getTranslations: GetTranslations;
 //#endregion
-export { getTranslations };
 //# sourceMappingURL=getTranslations.d.ts.map

package/dist/types/server/getTranslations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;KAeK,uBAAuB,UAAU;;EAEpC,YAAY;;EAEZ,SAAS;;;;;;;;;;;;;;;;;KAkBN;GACF,UAAU,gBAAgB,WAAW,IAAI,QAAQ,kBAAkB;GACnE,UAAU,gBACT,SAAS,uBAAuB,KAC/B,QAAQ,kBAAkB;GAC5B,iCACC,WAAW,IACV,QAAQ,8BAA8B;MACrC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BD,iBAAiB"}
+{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;KAeK,uBAAuB,UAAU;;EAEpC,YAAY;;EAEZ,SAAS;;;;;;;;;;;;;;;;;KAkBN;GACF,UAAU,gBAAgB,WAAW,IAAI,QAAQ,kBAAkB;GACnE,UAAU,gBACT,SAAS,uBAAuB,KAC/B,QAAQ,kBAAkB;GAC5B,iCACC,WAAW,IACV,QAAQ,8BAA8B;MACrC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+BD,iBAAiB"}

package/dist/types/server/helpers.d.ts

@@ -5,17 +5,16 @@ import { getFormatter as getFormatter$1, getNow as getNow$1, getTimeZone as getT
  * Returns locale-aware formatters backed by the native `Intl.*` APIs,
  * built by `@intlayer/use-intl`'s `createFormatter`.
  */
-declare const getFormatter: typeof getFormatter$1;
+export declare const getFormatter: typeof getFormatter$1;
 /**
  * Drop-in for next-intl's server `getNow()`.
  * Returns the current `Date`.
  */
-declare const getNow: typeof getNow$1;
+export declare const getNow: typeof getNow$1;
 /**
  * Drop-in for next-intl's server `getTimeZone()`.
  * Returns the system time zone resolved from `Intl.DateTimeFormat`.
  */
-declare const getTimeZone: typeof getTimeZone$1;
+export declare const getTimeZone: typeof getTimeZone$1;
 //#endregion
-export { getFormatter, getNow, getTimeZone };
 //# sourceMappingURL=helpers.d.ts.map

package/dist/types/server/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;;;cAaa,qBAAqB;;;;;cAWrB,eAAe;;;;;cAOf,oBAAoB"}
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;;;qBAaa,qBAAqB;;;;;qBAWrB,eAAe;;;;;qBAOf,oBAAoB"}

package/dist/types/server/react/helpers.d.ts

@@ -0,0 +1,15 @@
+//#region src/server/react/helpers.d.ts
+/**
+ * Server counterparts of use-intl's ambient hooks. They mirror the client
+ * versions' signatures so the same component code type-checks on both sides.
+ */
+export declare const useFormatter: typeof import('@intlayer/use-intl').useFormatter;
+/** Current time on the server render. */
+export declare const useNow: typeof import('@intlayer/use-intl').useNow;
+/**
+ * Time zone the formatters resolve against — the same value the async
+ * `getTimeZone()` reports, so both server surfaces agree.
+ */
+export declare const useTimeZone: typeof import('@intlayer/use-intl').useTimeZone;
+//#endregion
+//# sourceMappingURL=helpers.d.ts.map

package/dist/types/server/react/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../../src/server/react/helpers.ts"],"mappings":";;;;;qBAOa,kDAAkD;;qBAIlD,4CAA4C;;;;;qBAO5C,iDAAiD"}

package/dist/types/server/react/index.d.ts

@@ -0,0 +1,9 @@
+import { NextIntlClientProvider, NextIntlClientProviderProps } from "../../client/NextIntlClientProvider.js";
+import { Routing, defineRouting } from "../../routing.js";
+import { useFormatter, useNow, useTimeZone } from "./helpers.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { useLocale } from "./useLocale.js";
+import { useTranslations } from "./useTranslations.js";
+import { IntlError, IntlErrorCode, createFormatter, createTranslator, hasLocale, initializeConfig, useMessages } from "@intlayer/use-intl";
+export { IntlError, IntlErrorCode, NextIntlClientProvider, type NextIntlClientProviderProps, type Routing, createFormatter, createTranslator, defineRouting, hasLocale, initializeConfig, useDictionary, useDictionaryDynamic, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/server/react/resolveLocale.d.ts

@@ -0,0 +1,18 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+//#region src/server/react/resolveLocale.d.ts
+/**
+ * Locale for the synchronous server hooks, resolved the way `getLocale()`
+ * resolves it — so server-rendered output and the client provider never
+ * disagree about which locale the request is in.
+ *
+ * 1. The locale forwarded through `setRequestLocale(locale)` (the `[locale]`
+ *    route segment), which is next-intl's source of truth for URL routing.
+ * 2. Otherwise Intlayer's ambient locale (server context, then the request).
+ *
+ * The second rung must stay lazy. It ends in `headers()` / `cookies()`, which
+ * opts the route into dynamic rendering: evaluating it eagerly took this
+ * package's own benchmark app from 14 prerendered pages to 0.
+ */
+export declare const resolveServerLocale: () => LocalesValues;
+//#endregion
+//# sourceMappingURL=resolveLocale.d.ts.map

package/dist/types/server/react/resolveLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveLocale.d.ts","names":[],"sources":["../../../../src/server/react/resolveLocale.ts"],"mappings":";;;;;;;;;;;;;;;qBAsBa,2BAA0B"}

package/dist/types/server/react/useDictionary.d.ts

@@ -0,0 +1,24 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/server/react/useDictionary.d.ts
+/**
+ * Overload set mirroring the client `useDictionary` exactly, so the optimize
+ * pass can emit the same call shape whichever side of the boundary the
+ * component ends up on.
+ */
+type UseDictionary = {
+  <T extends Dictionary>(dictionary: T): TranslateFunction<T['key'] & DictionaryKeys>;
+  <T extends Dictionary, Prefix extends string>(dictionary: T, namespacePrefix: Prefix): ScopedTranslateFunction<T['key'] & DictionaryKeys, Prefix>;
+};
+/**
+ * Server counterpart of `@intlayer/use-intl`'s `useDictionary`.
+ *
+ * The optimize pass rewrites every `useTranslations(...)` call to this helper
+ * with the dictionary pre-imported. Resolving it here — rather than in a client
+ * component — keeps the dictionary out of the client bundle entirely: the
+ * server renders the text and only the rendered output crosses the boundary.
+ */
+export declare const useDictionary: UseDictionary;
+//#endregion
+//# sourceMappingURL=useDictionary.d.ts.map

package/dist/types/server/react/useDictionary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../../src/server/react/useDictionary.ts"],"mappings":";;;;;;;;;KAeK;GACF,UAAU,YACT,YAAY,IACX,kBAAkB,WAAW;GAC/B,UAAU,YAAY,uBACrB,YAAY,GACZ,iBAAiB,SAChB,wBAAwB,WAAW,gBAAgB;;;;;;;;;;qBAW3C,eAQP"}

package/dist/types/server/react/useDictionaryDynamic.d.ts

@@ -0,0 +1,15 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { ScopedTranslateFunction, TranslateFunction } from "@intlayer/use-intl";
+import { Dictionary } from "@intlayer/types/dictionary";
+//#region src/server/react/useDictionaryDynamic.d.ts
+type UseDictionaryDynamic = {
+  <T extends Dictionary, K extends DictionaryKeys>(dictionaryPromise: Record<string, () => Promise<T>>, key: K): TranslateFunction<K>;
+  <T extends Dictionary, K extends DictionaryKeys, Prefix extends string>(dictionaryPromise: Record<string, () => Promise<T>>, key: K, namespacePrefix: Prefix): ScopedTranslateFunction<K, Prefix>;
+};
+/**
+ * Server counterpart of `useDictionaryDynamic`, emitted by the optimize pass
+ * for dictionaries on the per-locale loader.
+ */
+export declare const useDictionaryDynamic: UseDictionaryDynamic;
+//#endregion
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

package/dist/types/server/react/useDictionaryDynamic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../../src/server/react/useDictionaryDynamic.ts"],"mappings":";;;;KAUK;GACF,UAAU,YAAY,UAAU,gBAC/B,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,IACJ,kBAAkB;GACpB,UAAU,YAAY,UAAU,gBAAgB,uBAC/C,mBAAmB,qBAAqB,QAAQ,KAChD,KAAK,GACL,iBAAiB,SAChB,wBAAwB,GAAG;;;;;;qBAOnB,sBAaP"}

package/dist/types/server/react/useLocale.d.ts

@@ -0,0 +1,9 @@
+import { useLocale as useLocale$1 } from "next-intl";
+//#region src/server/react/useLocale.d.ts
+/**
+ * Server counterpart of `useLocale`, resolved from the `[locale]` route segment
+ * forwarded through `setRequestLocale` when the app provides one.
+ */
+export declare const useLocale: typeof useLocale$1;
+//#endregion
+//# sourceMappingURL=useLocale.d.ts.map

package/dist/types/server/react/useLocale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../../src/server/react/useLocale.ts"],"mappings":";;;;;;qBAOa,kBAAkB"}

package/dist/types/server/react/useTranslations.d.ts

@@ -0,0 +1,23 @@
+import { DictionaryKeys } from "@intlayer/types/module_augmentation";
+import { LooseTranslateFunction, TranslateFunction, TranslateFunctionForNamespace } from "@intlayer/use-intl";
+//#region src/server/react/useTranslations.d.ts
+type UseTranslations = {
+  <N extends DictionaryKeys>(namespace: N): TranslateFunction<N>;
+  <N extends `${string}.${string}`>(namespace: N): TranslateFunctionForNamespace<N>;
+  (): LooseTranslateFunction;
+};
+/**
+ * Server counterpart of `useTranslations`.
+ *
+ * next-intl's `useTranslations` is isomorphic — the same component code runs in
+ * a Server or a Client Component — so the adapter has to be too. Without this
+ * every component calling it is forced across the client boundary, which drags
+ * its dictionary into a client chunk that Next shares across every locale.
+ *
+ * The optimize pass normally rewrites these calls to `useDictionary` with the
+ * dictionary inlined; this runtime path covers the calls it could not resolve
+ * statically (a dynamic namespace, or an unoptimized build).
+ */
+export declare const useTranslations: UseTranslations;
+//#endregion
+//# sourceMappingURL=useTranslations.d.ts.map

package/dist/types/server/react/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","names":[],"sources":["../../../../src/server/react/useTranslations.ts"],"mappings":";;;KAUK;GACF,UAAU,gBAAgB,WAAW,IAAI,kBAAkB;GAC3D,iCACC,WAAW,IACV,8BAA8B;MAC7B;;;;;;;;;;;;;;qBAsBO,iBAmBP"}

package/dist/types/server/requestLocaleCache.d.ts

@@ -4,13 +4,12 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * Read the locale stored for the current request, or `undefined` when
  * `setRequestLocale` has not been called.
  */
-declare const getCachedRequestLocale: () => LocalesValues | undefined;
+export declare const getCachedRequestLocale: () => LocalesValues | undefined;
 /**
  * Store the locale for the current request. Called by `setRequestLocale`.
  *
  * @param locale - The locale resolved from the `[locale]` route segment.
  */
-declare const setCachedRequestLocale: (locale: LocalesValues) => void;
+export declare const setCachedRequestLocale: (locale: LocalesValues) => void;
 //#endregion
-export { getCachedRequestLocale, setCachedRequestLocale };
 //# sourceMappingURL=requestLocaleCache.d.ts.map

package/dist/types/server/requestLocaleCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"requestLocaleCache.d.ts","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"mappings":";;;;;;cAuBa,8BAA6B;;;;;;cAQ7B,yBAAsB,QAAY"}
+{"version":3,"file":"requestLocaleCache.d.ts","names":[],"sources":["../../../src/server/requestLocaleCache.ts"],"mappings":";;;;;;qBAuBa,8BAA6B;;;;;;qBAQ7B,yBAAsB,QAAY"}

package/dist/types/server/setLocale.d.ts

@@ -15,7 +15,6 @@
  * await setLocale('fr');
  * ```
  */
-declare const setLocale: (locale: string) => Promise<void>;
+export declare const setLocale: (locale: string) => Promise<void>;
 //#endregion
-export { setLocale };
 //# sourceMappingURL=setLocale.d.ts.map