@intlayer/next-intl 8.12.5-canary.0

package/dist/types/createTranslator.d.ts

@@ -0,0 +1,40 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+import { ReactNode } from "react";
+import { MessageValues } from "@intlayer/core/messageFormat";
+
+//#region src/createTranslator.d.ts
+/** Chunk renderer used by `t.rich()` — maps tag children to a React node. */
+type RichChunkRenderer = (chunks: ReactNode) => ReactNode;
+/** Chunk renderer used by `t.markup()` — maps tag children to a string. */
+type MarkupChunkRenderer = (chunks: string) => string;
+declare const navigatePath: (objectValue: unknown, path: string) => unknown;
+/**
+ * The untyped runtime translator shared by `useTranslations` (client) and
+ * `getTranslations` (server).
+ *
+ * Behaviour matches next-intl:
+ * - namespace `'about'` → keys resolved inside the `about` dictionary
+ * - namespace `'about.counter'` → dictionary `about`, key prefix `counter`
+ * - no namespace → the first segment of each key is the dictionary key
+ * - messages support ICU syntax (plural, select, `#`, formatted arguments)
+ * - `t.rich` / `t.markup` map `<tag>chunks</tag>` through the provided
+ *   renderers; `t.raw` returns the raw value; `t.has` checks existence
+ */
+declare const createTranslator: (locale: LocalesValues, namespace?: string) => ((key: string, values?: MessageValues) => string) & {
+  /** Returns `true` if the given key exists in the namespace. */has: (key: string) => boolean; /** Returns the raw unprocessed content for the given key. */
+  raw: (key: string) => unknown;
+  /**
+   * Resolves a message containing `<tag>chunks</tag>` markup, mapping each
+   * tag through the matching renderer in `values`.
+   */
+  rich: (key: string, values?: Record<string, unknown>) => ReactNode;
+  /**
+   * Resolves a message containing `<tag>chunks</tag>` markup into a string,
+   * mapping each tag through the matching string renderer in `values`.
+   */
+  markup: (key: string, values?: Record<string, unknown>) => string;
+};
+type CompatTranslator = ReturnType<typeof createTranslator>;
+//#endregion
+export { CompatTranslator, MarkupChunkRenderer, RichChunkRenderer, createTranslator, navigatePath };
+//# sourceMappingURL=createTranslator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createTranslator.d.ts","names":[],"sources":["../../src/createTranslator.tsx"],"mappings":";;;;;;KAcY,iBAAA,IAAqB,MAAA,EAAQ,SAAA,KAAc,SAAA;AAAvD;AAAA,KAGY,mBAAA,IAAuB,MAAA;AAAA,cAEtB,YAAA,GAAgB,WAAA,WAAsB,IAAA;;;;;;;AAFnD;;;;;AAEA;cAqFa,gBAAA,GAAoB,MAAA,EAAQ,aAAA,EAAe,SAAA,gBAAkB,GAAA,UAsC1C,MAAA,GAAW,aAAA;gGA3HoB;;EA2J9D;;;;sBAlBqB,MAAA,GAAW,MAAA,sBAA0B,SAAA;EAAA;;;;wBAWnC,MAAA,GAAW,MAAA;AAAA;AAAA,KASvB,gBAAA,GAAmB,UAAA,QAAkB,gBAAA"}

package/dist/types/getDictionary.d.ts

@@ -0,0 +1,23 @@
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/getDictionary.d.ts
+/**
+ * Dictionary-accepting variant of `getTranslations`.
+ *
+ * Used internally by the SWC optimization: instead of looking up the dictionary
+ * at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time
+ * and passes it directly here. This enables tree-shaking of unused locale content.
+ *
+ * Runs on the server, where next-intl apps do not mount an `IntlayerServerProvider`.
+ * The request locale therefore cannot be read from a server context and is resolved
+ * asynchronously from the cookie/header via `getLocale()`. `getTranslations` is always
+ * awaited, so an async resolver is a drop-in replacement.
+ */
+declare const getDictionary: <T extends Dictionary>(dictionary: T, namespacePrefix?: string) => Promise<(<P extends ValidDotPathsFor<any>>(lookup: P, params?: Record<string, unknown>) => string) & {
+  has: <P extends ValidDotPathsFor<any>>(lookup: P) => boolean;
+  raw: <P extends ValidDotPathsFor<any>>(lookup: P) => unknown;
+}>;
+//#endregion
+export { getDictionary };
+//# sourceMappingURL=getDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getDictionary.d.ts","names":[],"sources":["../../src/getDictionary.ts"],"mappings":";;;;;;AAmCA;;;;;;;;;;cAAa,aAAA,aAAiC,UAAA,EAC5C,UAAA,EAAY,CAAA,EACZ,eAAA,cAAwB,OAAA,aASX,gBAAA,OAAqB,MAAA,EACtB,CAAA,EAAC,MAAA,GACA,MAAA;kBAUO,gBAAA,OAAqB,MAAA,EAAU,CAAA;kBAE/B,gBAAA,OAAqB,MAAA,EAAU,CAAA;AAAA"}

package/dist/types/getDictionaryDynamic.d.ts

@@ -0,0 +1,15 @@
+import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/getDictionaryDynamic.d.ts
+/**
+ * Dynamic dictionary-accepting variant of `getTranslations`.
+ */
+declare const getDictionaryDynamic: <const T extends Dictionary, const K extends string>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, namespacePrefix?: string) => Promise<(<P extends ValidDotPathsFor<any>>(lookup: P, params?: Record<string, unknown>) => string) & {
+  has: <P extends ValidDotPathsFor<any>>(lookup: P) => boolean;
+  raw: <P extends ValidDotPathsFor<any>>(lookup: P) => unknown;
+}>;
+//#endregion
+export { getDictionaryDynamic };
+//# sourceMappingURL=getDictionaryDynamic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getDictionaryDynamic.d.ts","names":[],"sources":["../../src/getDictionaryDynamic.ts"],"mappings":";;;;;;;AAyBA;cAAa,oBAAA,mBACK,UAAA,0BAGhB,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,eAAA,cAAwB,OAAA,aAWX,gBAAA,OAAqB,MAAA,EACtB,CAAA,EAAC,MAAA,GACA,MAAA;kBAUO,gBAAA,OAAqB,MAAA,EAAU,CAAA;kBAE/B,gBAAA,OAAqB,MAAA,EAAU,CAAA;AAAA"}

package/dist/types/getTranslationsDictionary.d.ts

@@ -0,0 +1,15 @@
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/getTranslationsDictionary.d.ts
+/**
+ * Dictionary-accepting variant of `getTranslations`.
+ *
+ * Used internally by the SWC optimization: instead of looking up the dictionary
+ * at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time
+ * and passes it directly here. This enables tree-shaking of unused locale content.
+ */
+declare const getTranslationsDictionary: <T extends Dictionary>(dictionary: T, namespacePrefix?: string) => Promise<(<P extends ValidDotPathsFor<any>>(lookup: P, params?: Record<string, unknown>) => string)>;
+//#endregion
+export { getTranslationsDictionary };
+//# sourceMappingURL=getTranslationsDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslationsDictionary.d.ts","names":[],"sources":["../../src/getTranslationsDictionary.ts"],"mappings":";;;;;;AAWA;;;;;cAAa,yBAAA,aAA6C,UAAA,EACxD,UAAA,EAAY,CAAA,EACZ,eAAA,cAAwB,OAAA,aAIN,gBAAA,OAAqB,MAAA,EAC7B,CAAA,EAAC,MAAA,GACA,MAAA"}

package/dist/types/getTranslationsDictionaryDynamic.d.ts

@@ -0,0 +1,12 @@
+import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/getTranslationsDictionaryDynamic.d.ts
+/**
+ * Dynamic dictionary-accepting variant of `getTranslations`.
+ */
+declare const getTranslationsDictionaryDynamic: <const T extends Dictionary, const K extends string>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, namespacePrefix?: string) => Promise<(<P extends ValidDotPathsFor<any>>(lookup: P, params?: Record<string, unknown>) => string)>;
+//#endregion
+export { getTranslationsDictionaryDynamic };
+//# sourceMappingURL=getTranslationsDictionaryDynamic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslationsDictionaryDynamic.d.ts","names":[],"sources":["../../src/getTranslationsDictionaryDynamic.ts"],"mappings":";;;;;;;AAQA;cAAa,gCAAA,mBACK,UAAA,0BAGhB,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,eAAA,cAAwB,OAAA,aAON,gBAAA,OAAqB,MAAA,EAC7B,CAAA,EAAC,MAAA,GACA,MAAA"}

package/dist/types/hasLocale.d.ts

@@ -0,0 +1,20 @@
+import { hasLocale as hasLocale$1 } from "next-intl";
+
+//#region src/hasLocale.d.ts
+/**
+ * Drop-in for next-intl's `hasLocale`.
+ *
+ * Checks that a locale candidate is part of the given locales list (or, when
+ * the list is read from routing, the locales configured in intlayer).
+ *
+ * @example
+ * ```ts
+ * import { routing } from '@/i18n/routing';
+ *
+ * if (hasLocale(routing.locales, requested)) { … }
+ * ```
+ */
+declare const hasLocale: typeof hasLocale$1;
+//#endregion
+export { hasLocale };
+//# sourceMappingURL=hasLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hasLocale.d.ts","names":[],"sources":["../../src/hasLocale.ts"],"mappings":";;;;;AAgBA;;;;;;;;;;;cAAa,SAAA,SAAkB,WAAA"}

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+import { NextIntlClientProvider, NextIntlClientProviderProps } from "./client/NextIntlClientProvider.js";
+import { IntlProvider, useExtracted, useFormatter, useMessages, useNow, useTimeZone } from "./client/helpers.js";
+import { useDictionary } from "./useDictionary.js";
+import { useDictionaryDynamic } from "./useDictionaryDynamic.js";
+import { useLocale } from "./client/useLocale.js";
+import { useTranslations } from "./client/useTranslations.js";
+import { hasLocale } from "./hasLocale.js";
+import { Routing, defineRouting } from "./routing.js";
+export { IntlProvider, NextIntlClientProvider, NextIntlClientProviderProps, type Routing, defineRouting, hasLocale, useDictionary, useDictionaryDynamic, useExtracted, useFormatter, useLocale, useMessages, useNow, useTimeZone, useTranslations };

package/dist/types/middleware.d.ts

@@ -0,0 +1,22 @@
+import _createMiddleware from "next-intl/middleware";
+
+//#region src/middleware.d.ts
+/**
+ * Drop-in replacement for next-intl's `createMiddleware`.
+ *
+ * Returns Intlayer's proxy/middleware, which handles locale detection and
+ * routing from the Intlayer configuration. The `routing` argument is accepted
+ * for API compatibility but ignored — locales come from `intlayer.config`.
+ *
+ * @example
+ * ```ts
+ * // proxy.ts (or middleware.ts on Next <= 15)
+ * import createMiddleware from 'next-intl/middleware';
+ * export default createMiddleware(routing);
+ * export const config = { matcher: ['/((?!api|_next|.*\\..*).*)'] };
+ * ```
+ */
+declare const createMiddleware: typeof _createMiddleware;
+//#endregion
+export { createMiddleware, createMiddleware as default };
+//# sourceMappingURL=middleware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../src/middleware.ts"],"mappings":";;;;;AAmBA;;;;;;;;;;;;;cAAa,gBAAA,SAAyB,iBAAA"}

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

@@ -0,0 +1,29 @@
+import { NextIntlHref } from "./localizeHref.js";
+import * as _$react from "react";
+import { ComponentPropsWithoutRef } from "react";
+import * as _$next_link0 from "next/link";
+import NextLink from "next/link";
+
+//#region src/navigation/Link.d.ts
+/**
+ * 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'> & {
+  href: NextIntlHref;
+  locale?: string;
+};
+/**
+ * Drop-in for the `Link` returned by next-intl's `createNavigation`. Prefixes
+ * `href` with the active locale (or the `locale` prop) before delegating to
+ * `next/link`.
+ */
+declare const Link: _$react.ForwardRefExoticComponent<Omit<Omit<Omit<_$react.AnchorHTMLAttributes<HTMLAnchorElement>, keyof _$next_link0.LinkProps<any>> & _$next_link0.LinkProps<any> & {
+  children?: React.ReactNode | undefined;
+} & _$react.RefAttributes<HTMLAnchorElement>, "ref">, "href" | "locale"> & {
+  href: NextIntlHref;
+  locale?: string;
+} & _$react.RefAttributes<HTMLAnchorElement>>;
+//#endregion
+export { Link, LinkProps };
+//# sourceMappingURL=Link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Link.d.ts","names":[],"sources":["../../../src/navigation/Link.tsx"],"mappings":";;;;;;;;;;;KAWY,SAAA,GAAY,IAAA,CACtB,wBAAA,QAAgC,QAAA;EAGhC,IAAA,EAAM,YAAA;EACN,MAAA;AAAA;;;;;;cAQW,IAAA,UAAI,yBAAA,CAAA,IAAA,CAAA,IAAA,CAAA,IAAA,CAAA,OAAA,CAAA,oBAAA,CAAA,iBAAA,SAAA,YAAA,CAAA,SAAA,SAAA,YAAA,CAAA,SAAA;;;QATT,YAAA"}

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

@@ -0,0 +1,21 @@
+import { createNavigation as createNavigation$1 } from "next-intl/navigation";
+
+//#region src/navigation/createNavigation.d.ts
+/**
+ * Drop-in replacement for next-intl's `createNavigation`.
+ *
+ * Returns locale-aware navigation APIs (`Link`, `usePathname`, `useRouter`,
+ * `getPathname`, `redirect`, `permanentRedirect`) backed by Intlayer's routing
+ * configuration. The `routing` argument is accepted for API compatibility;
+ * locales come from the Intlayer configuration.
+ *
+ * @example
+ * ```ts
+ * export const { Link, redirect, usePathname, useRouter, getPathname } =
+ *   createNavigation();
+ * ```
+ */
+declare const createNavigation: typeof createNavigation$1;
+//#endregion
+export { createNavigation, createNavigation as default };
+//# sourceMappingURL=createNavigation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createNavigation.d.ts","names":[],"sources":["../../../src/navigation/createNavigation.ts"],"mappings":";;;;;AA6BA;;;;;;;;;;;;cAAa,gBAAA,SAAyB,kBAAA"}

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

@@ -0,0 +1,33 @@
+import { NextIntlHref } from "./localizeHref.js";
+import * as _$next_dist_shared_lib_app_router_context_shared_runtime0 from "next/dist/shared/lib/app-router-context.shared-runtime";
+
+//#region src/navigation/hooks.d.ts
+/**
+ * Options accepted by the locale-aware router methods: the standard Next.js
+ * navigate options plus an optional target `locale`.
+ */
+type NavigateOptions = {
+  locale?: string;
+} & Record<string, unknown>;
+/**
+ * Drop-in for the `usePathname` returned by next-intl's `createNavigation`.
+ * Returns the current pathname with the locale prefix stripped.
+ */
+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: () => {
+  push: (href: NextIntlHref, options?: NavigateOptions) => void;
+  replace: (href: NextIntlHref, options?: NavigateOptions) => void;
+  prefetch: (href: NextIntlHref, options?: NavigateOptions) => void;
+  back(): void;
+  forward(): void;
+  refresh(): void;
+  experimental_gesturePush?(href: string, options?: _$next_dist_shared_lib_app_router_context_shared_runtime0.NavigateOptions): void;
+};
+//#endregion
+export { usePathname, useRouter };
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../../../src/navigation/hooks.ts"],"mappings":";;;;;;;AAOiE;KAM5D,eAAA;EAAoB,MAAA;AAAA,IAAoB,MAAA;;AAM7C;;;cAAa,WAAA;;AAeb;;;;cAAa,SAAA;eASI,YAAA,EAAY,OAAA,GAAY,eAAA;kBAKrB,YAAA,EAAY,OAAA,GAAY,eAAA;mBAKvB,YAAA,EAAY,OAAA,GAAY,eAAA;;;;oDAAe,yDAAA,CAAA,eAAA;AAAA"}

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

@@ -0,0 +1,5 @@
+import { NextIntlHref } from "./localizeHref.js";
+import { Link, LinkProps } from "./Link.js";
+import { createNavigation } from "./createNavigation.js";
+import { usePathname, useRouter } from "./hooks.js";
+export { Link, type LinkProps, type NextIntlHref, createNavigation, createNavigation as default, usePathname, useRouter };

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

@@ -0,0 +1,23 @@
+//#region src/navigation/localizeHref.d.ts
+/**
+ * A `next-intl` navigation href: either a pathname string or an object with a
+ * `pathname` and optional `query`. The `pathnames` (typed routes) feature is
+ * accepted for API compatibility but not interpolated.
+ */
+type NextIntlHref = string | {
+  pathname: string;
+  query?: Record<string, string | number | (string | number)[]>;
+  params?: Record<string, string | number | (string | number)[]>;
+};
+/**
+ * Prefix a `next-intl` href with the given locale using Intlayer's
+ * `getLocalizedUrl`, preserving any query parameters.
+ *
+ * @param href - The target href (string or `{ pathname, query }`).
+ * @param locale - The locale to localize the href for.
+ * @returns The localized URL string.
+ */
+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

@@ -0,0 +1 @@
+{"version":3,"file":"localizeHref.d.ts","names":[],"sources":["../../../src/navigation/localizeHref.ts"],"mappings":";;AAQA;;;;KAAY,YAAA;EAGN,QAAA;EACA,KAAA,GAAQ,MAAA;EACR,MAAA,GAAS,MAAA;AAAA;;;AAWf;;;;;;cAAa,YAAA,GAAgB,IAAA,EAAM,YAAA,EAAc,MAAA"}

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

@@ -0,0 +1,12 @@
+import { NextConfig } from "next";
+
+//#region src/plugin/index.d.ts
+/**
+ * A Next.js plugin for next-intl compat that wraps next-intlayer's plugin
+ * and configures resolve aliases so `next-intl` imports are served by
+ * `@intlayer/next-intl`.
+ */
+declare const createNextIntlPlugin: (_i18nPath?: string) => (nextConfig?: NextConfig) => Promise<NextConfig>;
+//#endregion
+export { createNextIntlPlugin, createNextIntlPlugin as default };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../../src/plugin/index.ts"],"mappings":";;;;;AA0HA;;;cAAa,oBAAA,GAAwB,SAAA,eACrB,UAAA,GAAY,UAAA,KAAkB,OAAA,CAAQ,UAAA"}

package/dist/types/routing.d.ts

@@ -0,0 +1,28 @@
+import { LocalesValues } from "@intlayer/types/module_augmentation";
+
+//#region src/routing.d.ts
+type Routing = {
+  locales: LocalesValues[];
+  defaultLocale: LocalesValues;
+  localePrefix?: 'always' | 'as-needed' | 'never';
+  pathnames?: Record<string, string | Record<string, string>>;
+};
+/**
+ * Drop-in replacement for next-intl's `defineRouting()`.
+ *
+ * Merges the provided config with Intlayer's own routing / internationalization
+ * configuration so you don't have to repeat locale lists. All fields are
+ * optional — omitted values are read from the Intlayer config at runtime.
+ *
+ * @example
+ * ```ts
+ * export default defineRouting({
+ *   locales: ['en', 'fr'],
+ *   defaultLocale: 'en',
+ * });
+ * ```
+ */
+declare const defineRouting: (config?: Partial<Routing>) => Routing;
+//#endregion
+export { Routing, defineRouting };
+//# sourceMappingURL=routing.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","names":[],"sources":["../../src/routing.ts"],"mappings":";;;KAGY,OAAA;EACV,OAAA,EAAS,aAAA;EACT,aAAA,EAAe,aAAA;EACf,YAAA;EACA,SAAA,GAAY,MAAA,kBAAwB,MAAA;AAAA;;;;;;;;;;;;;;;;cAkBzB,aAAA,GAAgB,MAAA,GAAS,OAAA,CAAQ,OAAA,MAAa,OAAA"}

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

@@ -0,0 +1,10 @@
+import { getLocale as getLocale$1 } from "next-intl/server";
+
+//#region src/server/getLocale.d.ts
+/**
+ * Drop-in for next-intl's `getLocale()` server function.
+ */
+declare const getLocale: typeof getLocale$1;
+//#endregion
+export { getLocale };
+//# sourceMappingURL=getLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;AAMA;cAAa,SAAA,SAAkB,WAAA"}

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

@@ -0,0 +1,22 @@
+import { getMessages as getMessages$1 } from "next-intl/server";
+
+//#region src/server/getMessages.d.ts
+/**
+ * Drop-in replacement for next-intl's `getMessages()` server function.
+ *
+ * Returns all compiled dictionary content for the current locale as a flat
+ * record keyed by dictionary name. Useful when you need to pass messages
+ * to a `NextIntlClientProvider`.
+ *
+ * @example
+ * ```ts
+ * const messages = await getMessages();
+ * ```
+ *
+ * @deprecated getMessages has no use case with intlayer.
+ * Messages are loaded automatically under the hood
+ */
+declare const getMessages: typeof getMessages$1;
+//#endregion
+export { getMessages };
+//# sourceMappingURL=getMessages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMessages.d.ts","names":[],"sources":["../../../src/server/getMessages.ts"],"mappings":";;;;;AAoBA;;;;;;;;;;;;;cAAa,WAAA,SAAoB,aAAA"}

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

@@ -0,0 +1,85 @@
+import { MarkupChunkRenderer, RichChunkRenderer } from "../createTranslator.js";
+import { DictionaryKeys, LocalesValues } from "@intlayer/types/module_augmentation";
+import { ReactNode } from "react";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+
+//#region src/server/getTranslations.d.ts
+/**
+ * Options accepted by the options-object overload of {@link getTranslations}.
+ */
+type GetTranslationsOptions<N extends DictionaryKeys> = {
+  /** The dictionary namespace to scope translations to. */namespace?: N; /** Override the locale instead of reading it from the current request. */
+  locale?: LocalesValues;
+};
+/**
+ * The translation function returned by {@link getTranslations}.
+ *
+ * Beyond the plain call signature, the function exposes:
+ * - `has(key)` — returns `true` when the key exists in the namespace.
+ * - `raw(key)` — returns the unprocessed message value.
+ * - `rich(key, values)` — resolves `<tag>chunks</tag>` markup to React nodes.
+ * - `markup(key, values)` — resolves `<tag>chunks</tag>` markup to a string.
+ */
+type TranslateFunction<N extends DictionaryKeys> = {
+  /** Translate a key to a string, with optional ICU interpolation params. */<P extends ValidDotPathsFor<N>>(key: P, params?: Record<string, unknown>): string; /** Returns `true` if the given key exists in the namespace. */
+  has<P extends ValidDotPathsFor<N>>(key: P): boolean; /** Returns the raw unprocessed message for the given key. */
+  raw<P extends ValidDotPathsFor<N>>(key: P): unknown; /** Resolves rich-text markup, mapping tags through React renderers. */
+  rich<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode; /** Resolves rich-text markup, mapping tags through string renderers. */
+  markup<P extends ValidDotPathsFor<N>>(key: P, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+/** Loosely-typed function returned for nested `'dict.scope'` namespaces. */
+type LooseTranslateFunction = {
+  (key: string, params?: Record<string, unknown>): string;
+  has(key: string): boolean;
+  raw(key: string): unknown;
+  rich(key: string, values?: Record<string, RichChunkRenderer | ReactNode>): ReactNode;
+  markup(key: string, values?: Record<string, MarkupChunkRenderer | string | number>): string;
+};
+/**
+ * Overload set for {@link getTranslations}:
+ *
+ * 1. A bare dictionary key → fully-typed `t()` (autocompleted dot-paths).
+ * 2. An options object `{ namespace?, locale? }` → typed when namespace is
+ *    a known `DictionaryKeys` value.
+ * 3. A nested namespace `'dictionary.sub.scope'` → `t()` accepts relative
+ *    `string` paths, matching next-intl's scoped-namespace behaviour.
+ * 4. No namespace → root scope; the first segment of each key designates
+ *    the dictionary (`t('about.title')`).
+ */
+type GetTranslations = {
+  <N extends DictionaryKeys>(namespace: N): Promise<TranslateFunction<N>>;
+  <N extends DictionaryKeys>(options: GetTranslationsOptions<N>): Promise<TranslateFunction<N>>;
+  (namespace: `${string}.${string}`): Promise<LooseTranslateFunction>;
+  (): Promise<LooseTranslateFunction>;
+};
+/**
+ * Drop-in for next-intl's server `getTranslations()`.
+ *
+ * Messages support ICU MessageFormat syntax: simple arguments (`{name}`),
+ * plural (`{count, plural, one {…} other {…}}`, `#`), select, and formatted
+ * arguments (`{value, number}`). Rich text is available through `t.rich()`
+ * and `t.markup()`.
+ *
+ * Also accepts an options object `{ namespace, locale }` to match next-intl's
+ * full server API surface.
+ *
+ * @example
+ * ```ts
+ * // Bare namespace — fully typed dot-paths
+ * const t = await getTranslations('about');
+ * return <h1>{t('counter.label')}</h1>;
+ *
+ * // ICU plural
+ * t('items', { count: 3 });
+ *
+ * // Options object with locale override
+ * const t = await getTranslations({ namespace: 'about', locale: 'fr' });
+ *
+ * // Rich text
+ * t.rich('terms', { link: (chunks) => <a href="/terms">{chunks}</a> });
+ * ```
+ */
+declare const getTranslations: GetTranslations;
+//#endregion
+export { getTranslations };
+//# sourceMappingURL=getTranslations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getTranslations.d.ts","names":[],"sources":["../../../src/server/getTranslations.ts"],"mappings":";;;;;;;;AAU6B;KAMxB,sBAAA,WAAiC,cAAA;EAAX,yDAEzB,SAAA,GAAY,CAAA,EAAA;EAEZ,MAAA,GAAS,aAAA;AAAA;;;;;;;;;;KAYN,iBAAA,WAA4B,cAAA;EAAX,sFAET,gBAAA,CAAiB,CAAA,GAC1B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,4BAJoB;EAO/B,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAL7B;EAOX,GAAA,WAAc,gBAAA,CAAiB,CAAA,GAAI,GAAA,EAAK,CAAA,YAL7B;EAOX,IAAA,WAAe,gBAAA,CAAiB,CAAA,GAC9B,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA,EAPW;EASd,MAAA,WAAiB,gBAAA,CAAiB,CAAA,GAChC,GAAA,EAAK,CAAA,EACL,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;KAKvB,sBAAA;EAAA,CACF,GAAA,UAAa,MAAA,GAAS,MAAA;EACvB,GAAA,CAAI,GAAA;EACJ,GAAA,CAAI,GAAA;EACJ,IAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,iBAAA,GAAoB,SAAA,IAC3C,SAAA;EACH,MAAA,CACE,GAAA,UACA,MAAA,GAAS,MAAA,SAAe,mBAAA;AAAA;;;;;;;;;;;;KAevB,eAAA;EAAA,WACQ,cAAA,EAAgB,SAAA,EAAW,CAAA,GAAI,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,WACzD,cAAA,EACT,OAAA,EAAS,sBAAA,CAAuB,CAAA,IAC/B,OAAA,CAAQ,iBAAA,CAAkB,CAAA;EAAA,CAC5B,SAAA,0BAAmC,OAAA,CAAQ,sBAAA;EAAA,IACxC,OAAA,CAAQ,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BD,eAAA,EAAiB,eAAA"}

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

@@ -0,0 +1,21 @@
+import { getFormatter as getFormatter$1, getNow as getNow$1, getTimeZone as getTimeZone$1 } from "next-intl/server";
+
+//#region src/server/helpers.d.ts
+/**
+ * Drop-in for next-intl's server `getFormatter()`.
+ * Returns locale-aware formatters backed by the native `Intl.*` APIs.
+ */
+declare const getFormatter: typeof getFormatter$1;
+/**
+ * Drop-in for next-intl's server `getNow()`.
+ * Returns the current `Date`.
+ */
+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;
+//#endregion
+export { getFormatter, getNow, getTimeZone };
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","names":[],"sources":["../../../src/server/helpers.ts"],"mappings":";;;;;AAYA;;cAAa,YAAA,SAAqB,cAAA;;;AAWlC;;cAAa,MAAA,SAAe,QAAA;;;AAO5B;;cAAa,WAAA,SAAoB,aAAA"}

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

@@ -0,0 +1,8 @@
+import { getDictionary } from "../getDictionary.js";
+import { getDictionaryDynamic } from "../getDictionaryDynamic.js";
+import { getLocale } from "./getLocale.js";
+import { getMessages } from "./getMessages.js";
+import { getTranslations } from "./getTranslations.js";
+import { getFormatter, getNow, getTimeZone } from "./helpers.js";
+import { setLocale } from "./setLocale.js";
+export { getDictionary, getDictionaryDynamic, getFormatter, getLocale, getMessages, getNow, getTimeZone, getTranslations, setLocale };

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

@@ -0,0 +1,21 @@
+//#region src/server/setLocale.d.ts
+/**
+ * Drop-in replacement for next-intl's `setLocale()` server action.
+ *
+ * Writes the locale to whichever cookie(s) the active `routing.storage`
+ * configuration specifies. When `createNextIntlPlugin` is used (the default),
+ * this is `NEXT_LOCALE`; when the user has configured a custom storage in
+ * `intlayer.config.ts`, that name is used instead.
+ *
+ * Must be called inside a Server Action.
+ *
+ * @example
+ * ```ts
+ * 'use server';
+ * await setLocale('fr');
+ * ```
+ */
+declare const setLocale: (locale: string) => Promise<void>;
+//#endregion
+export { setLocale };
+//# sourceMappingURL=setLocale.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setLocale.d.ts","names":[],"sources":["../../../src/server/setLocale.ts"],"mappings":";;AAoBA;;;;;;;;;;;;;;;cAAa,SAAA,GAAmB,MAAA,aAAiB,OAAA"}

package/dist/types/useDictionary.d.ts

@@ -0,0 +1,22 @@
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/useDictionary.d.ts
+/**
+ * Dictionary-accepting variant of `useTranslations`.
+ *
+ * Used internally by the SWC optimization: instead of looking up the dictionary
+ * at runtime by key, the SWC plugin pre-imports the dictionary JSON at build time
+ * and passes it directly here. This enables tree-shaking of unused locale content.
+ *
+ * @example (generated by SWC, not written manually)
+ * import _abc from '.intlayer/dictionaries/about.json' with { type: 'json' };
+ * const t = useDictionary(_abc);
+ */
+declare const useDictionary: <T extends Dictionary>(dictionary: T, namespacePrefix?: string) => (<P extends ValidDotPathsFor<any>>(lookup: P, params?: Record<string, unknown>) => string) & {
+  has: <P extends ValidDotPathsFor<any>>(lookup: P) => boolean;
+  raw: <P extends ValidDotPathsFor<any>>(lookup: P) => unknown;
+};
+//#endregion
+export { useDictionary };
+//# sourceMappingURL=useDictionary.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../src/useDictionary.ts"],"mappings":";;;;;;AAkCA;;;;;;;;;cAAa,aAAA,aAA2B,UAAA,EACtC,UAAA,EAAY,CAAA,EACZ,eAAA,0BAQa,gBAAA,OAAqB,MAAA,EACtB,CAAA,EAAC,MAAA,GACA,MAAA;kBAUO,gBAAA,OAAqB,MAAA,EAAU,CAAA;kBAE/B,gBAAA,OAAqB,MAAA,EAAU,CAAA;AAAA"}

package/dist/types/useDictionaryDynamic.d.ts

@@ -0,0 +1,15 @@
+import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
+import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { Dictionary } from "@intlayer/types/dictionary";
+
+//#region src/useDictionaryDynamic.d.ts
+/**
+ * Dynamic dictionary-accepting variant of `useTranslations`.
+ */
+declare const useDictionaryDynamic: <const T extends Dictionary, const K extends string>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, key: K, namespacePrefix?: string) => (<P extends ValidDotPathsFor<any>>(lookup: P, params?: Record<string, unknown>) => string) & {
+  has: <P extends ValidDotPathsFor<any>>(lookup: P) => boolean;
+  raw: <P extends ValidDotPathsFor<any>>(lookup: P) => unknown;
+};
+//#endregion
+export { useDictionaryDynamic };
+//# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../src/useDictionaryDynamic.ts"],"mappings":";;;;;;;AA2BA;cAAa,oBAAA,mBACK,UAAA,0BAGhB,iBAAA,EAAmB,mBAAA,OAA0B,OAAA,CAAQ,CAAA,IACrD,GAAA,EAAK,CAAA,EACL,eAAA,0BAWa,gBAAA,OAAqB,MAAA,EACtB,CAAA,EAAC,MAAA,GACA,MAAA;kBAUO,gBAAA,OAAqB,MAAA,EAAU,CAAA;kBAE/B,gBAAA,OAAqB,MAAA,EAAU,CAAA;AAAA"}