next-intlayer 9.4.2 → 9.4.3

package/dist/cjs/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["_MarkdownProvider","_useMarkdownContext","_renderMarkdown","_useMarkdownRenderer","_MarkdownRenderer"],"sources":["../../src/index.ts"],"sourcesContent":["export {\n  type ConversionParams,\n  type ExperimentState,\n  getDictionary,\n  getIntlayer,\n  IntlayerClientContext,\n  type IntlayerNode,\n  IntlayerProvider,\n  type IntlayerProviderProps,\n  localeCookie,\n  localeInStorage,\n  setLocaleCookie,\n  setLocaleInStorage,\n  t,\n  useConversion,\n  useDictionary,\n  useDictionaryAsync,\n  useDictionaryDynamic,\n  useExperiment,\n  useI18n,\n  useIntl,\n  useIntlayer,\n  useLoadDynamic,\n  useLocaleCookie,\n  useLocaleStorage,\n} from 'react-intlayer';\nexport * from './client/index';\nexport { generateStaticParams } from './generateStaticParams';\nexport type {\n  LocalParams,\n  LocalPromiseParams,\n  Next14LayoutIntlayer,\n  Next14PageIntlayer,\n  Next15LayoutIntlayer,\n  Next15PageIntlayer,\n  NextLayoutIntlayer,\n  NextPageIntlayer,\n} from './types/index';\n\nimport type {\n  MarkdownProviderOptions as _MarkdownProviderOptions,\n  MarkdownRendererProps as _MarkdownRendererProps,\n  RenderMarkdownProps as _RenderMarkdownProps,\n} from './markdown';\nimport {\n  MarkdownProvider as _MarkdownProvider,\n  MarkdownRenderer as _MarkdownRenderer,\n  renderMarkdown as _renderMarkdown,\n  useMarkdownContext as _useMarkdownContext,\n  useMarkdownRenderer as _useMarkdownRenderer,\n} from './markdown';\n\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownProvider = _MarkdownProvider;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownContext = _useMarkdownContext;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownProviderOptions = _MarkdownProviderOptions;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const renderMarkdown = _renderMarkdown;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownRenderer = _useMarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownRenderer = _MarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type RenderMarkdownProps = _RenderMarkdownProps;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownRendererProps = _MarkdownRendererProps;\n"],"mappings":";;;;;;;;;;;;;AAuDA,MAAa,2DAAmBA;;;;AAIhC,MAAa,6DAAqBC;;;;AAQlC,MAAa,yDAAiBC;;;;AAI9B,MAAa,8DAAsBC;;;;AAInC,MAAa,2DAAmBC"}
+{"version":3,"file":"index.cjs","names":["_MarkdownProvider","_useMarkdownContext","_renderMarkdown","_useMarkdownRenderer","_MarkdownRenderer"],"sources":["../../src/index.ts"],"sourcesContent":["export {\n  type ConversionParams,\n  type ExperimentState,\n  getDictionary,\n  getIntlayer,\n  IntlayerClientContext,\n  type IntlayerNode,\n  IntlayerProvider,\n  type IntlayerProviderProps,\n  localeCookie,\n  localeInStorage,\n  setLocaleCookie,\n  setLocaleInStorage,\n  t,\n  useConversion,\n  useDictionary,\n  useDictionaryAsync,\n  useDictionaryDynamic,\n  useExperiment,\n  useI18n,\n  useIntl,\n  useIntlayer,\n  useLoadDynamic,\n  useLocaleCookie,\n  useLocaleStorage,\n} from 'react-intlayer';\nexport * from './client/index';\nexport { generateStaticParams } from './generateStaticParams';\nexport type {\n  LocalParams,\n  LocalPromiseParams,\n  Next14LayoutIntlayer,\n  Next14PageIntlayer,\n  Next15LayoutIntlayer,\n  Next15PageIntlayer,\n  NextLayoutIntlayer,\n  NextPageIntlayer,\n} from './types/index';\n\nimport type { FC } from 'react';\nimport type {\n  MarkdownContextValue as _MarkdownContextValue,\n  MarkdownProviderOptions as _MarkdownProviderOptions,\n  MarkdownProviderProps as _MarkdownProviderProps,\n  MarkdownRendererProps as _MarkdownRendererProps,\n  RenderMarkdownProps as _RenderMarkdownProps,\n} from './markdown';\nimport {\n  MarkdownProvider as _MarkdownProvider,\n  MarkdownRenderer as _MarkdownRenderer,\n  renderMarkdown as _renderMarkdown,\n  useMarkdownContext as _useMarkdownContext,\n  useMarkdownRenderer as _useMarkdownRenderer,\n} from './markdown';\n\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownProvider: FC<_MarkdownProviderProps> = _MarkdownProvider;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownContext: () => _MarkdownContextValue =\n  _useMarkdownContext;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownProviderOptions = _MarkdownProviderOptions;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const renderMarkdown = _renderMarkdown;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownRenderer = _useMarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownRenderer = _MarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type RenderMarkdownProps = _RenderMarkdownProps;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownRendererProps = _MarkdownRendererProps;\n"],"mappings":";;;;;;;;;;;;;AA0DA,MAAa,2DAA+CA;;;;AAI5D,MAAa,6DACXC;;;;AAQF,MAAa,yDAAiBC;;;;AAI9B,MAAa,8DAAsBC;;;;AAInC,MAAa,2DAAmBC"}

package/dist/cjs/server/prepareSwcOptimization.cjs

@@ -1,9 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
+let _intlayer_config_logger = require("@intlayer/config/logger");
 let node_path = require("node:path");
 let _intlayer_config_colors = require("@intlayer/config/colors");
 _intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
-let _intlayer_config_logger = require("@intlayer/config/logger");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_engine_utils = require("@intlayer/engine/utils");
 let node_fs = require("node:fs");

package/dist/cjs/server/withIntlayer.cjs

@@ -3,11 +3,11 @@ const require_runtime = require('../_virtual/_rolldown/runtime.cjs');
 const require_server_prepareSwcOptimization = require('./prepareSwcOptimization.cjs');
 const require_server_swcPluginCompatibility = require('./swcPluginCompatibility.cjs');
 let _intlayer_config_defaultValues = require("@intlayer/config/defaultValues");
+let _intlayer_config_logger = require("@intlayer/config/logger");
 let node_path = require("node:path");
 let _intlayer_config_colors = require("@intlayer/config/colors");
 _intlayer_config_colors = require_runtime.__toESM(_intlayer_config_colors);
 let _intlayer_config_envVars = require("@intlayer/config/envVars");
-let _intlayer_config_logger = require("@intlayer/config/logger");
 let _intlayer_config_node = require("@intlayer/config/node");
 let _intlayer_config_utils = require("@intlayer/config/utils");
 let _intlayer_core_dictionaryManipulator = require("@intlayer/core/dictionaryManipulator");

package/dist/esm/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["_MarkdownProvider","_useMarkdownContext","_renderMarkdown","_useMarkdownRenderer","_MarkdownRenderer"],"sources":["../../src/index.ts"],"sourcesContent":["export {\n  type ConversionParams,\n  type ExperimentState,\n  getDictionary,\n  getIntlayer,\n  IntlayerClientContext,\n  type IntlayerNode,\n  IntlayerProvider,\n  type IntlayerProviderProps,\n  localeCookie,\n  localeInStorage,\n  setLocaleCookie,\n  setLocaleInStorage,\n  t,\n  useConversion,\n  useDictionary,\n  useDictionaryAsync,\n  useDictionaryDynamic,\n  useExperiment,\n  useI18n,\n  useIntl,\n  useIntlayer,\n  useLoadDynamic,\n  useLocaleCookie,\n  useLocaleStorage,\n} from 'react-intlayer';\nexport * from './client/index';\nexport { generateStaticParams } from './generateStaticParams';\nexport type {\n  LocalParams,\n  LocalPromiseParams,\n  Next14LayoutIntlayer,\n  Next14PageIntlayer,\n  Next15LayoutIntlayer,\n  Next15PageIntlayer,\n  NextLayoutIntlayer,\n  NextPageIntlayer,\n} from './types/index';\n\nimport type {\n  MarkdownProviderOptions as _MarkdownProviderOptions,\n  MarkdownRendererProps as _MarkdownRendererProps,\n  RenderMarkdownProps as _RenderMarkdownProps,\n} from './markdown';\nimport {\n  MarkdownProvider as _MarkdownProvider,\n  MarkdownRenderer as _MarkdownRenderer,\n  renderMarkdown as _renderMarkdown,\n  useMarkdownContext as _useMarkdownContext,\n  useMarkdownRenderer as _useMarkdownRenderer,\n} from './markdown';\n\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownProvider = _MarkdownProvider;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownContext = _useMarkdownContext;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownProviderOptions = _MarkdownProviderOptions;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const renderMarkdown = _renderMarkdown;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownRenderer = _useMarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownRenderer = _MarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type RenderMarkdownProps = _RenderMarkdownProps;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownRendererProps = _MarkdownRendererProps;\n"],"mappings":";;;;;;;;;;;;;AAuDA,MAAa,mBAAmBA;;;;AAIhC,MAAa,qBAAqBC;;;;AAQlC,MAAa,iBAAiBC;;;;AAI9B,MAAa,sBAAsBC;;;;AAInC,MAAa,mBAAmBC"}
+{"version":3,"file":"index.mjs","names":["_MarkdownProvider","_useMarkdownContext","_renderMarkdown","_useMarkdownRenderer","_MarkdownRenderer"],"sources":["../../src/index.ts"],"sourcesContent":["export {\n  type ConversionParams,\n  type ExperimentState,\n  getDictionary,\n  getIntlayer,\n  IntlayerClientContext,\n  type IntlayerNode,\n  IntlayerProvider,\n  type IntlayerProviderProps,\n  localeCookie,\n  localeInStorage,\n  setLocaleCookie,\n  setLocaleInStorage,\n  t,\n  useConversion,\n  useDictionary,\n  useDictionaryAsync,\n  useDictionaryDynamic,\n  useExperiment,\n  useI18n,\n  useIntl,\n  useIntlayer,\n  useLoadDynamic,\n  useLocaleCookie,\n  useLocaleStorage,\n} from 'react-intlayer';\nexport * from './client/index';\nexport { generateStaticParams } from './generateStaticParams';\nexport type {\n  LocalParams,\n  LocalPromiseParams,\n  Next14LayoutIntlayer,\n  Next14PageIntlayer,\n  Next15LayoutIntlayer,\n  Next15PageIntlayer,\n  NextLayoutIntlayer,\n  NextPageIntlayer,\n} from './types/index';\n\nimport type { FC } from 'react';\nimport type {\n  MarkdownContextValue as _MarkdownContextValue,\n  MarkdownProviderOptions as _MarkdownProviderOptions,\n  MarkdownProviderProps as _MarkdownProviderProps,\n  MarkdownRendererProps as _MarkdownRendererProps,\n  RenderMarkdownProps as _RenderMarkdownProps,\n} from './markdown';\nimport {\n  MarkdownProvider as _MarkdownProvider,\n  MarkdownRenderer as _MarkdownRenderer,\n  renderMarkdown as _renderMarkdown,\n  useMarkdownContext as _useMarkdownContext,\n  useMarkdownRenderer as _useMarkdownRenderer,\n} from './markdown';\n\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownProvider: FC<_MarkdownProviderProps> = _MarkdownProvider;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownContext: () => _MarkdownContextValue =\n  _useMarkdownContext;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownProviderOptions = _MarkdownProviderOptions;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const renderMarkdown = _renderMarkdown;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const useMarkdownRenderer = _useMarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport const MarkdownRenderer = _MarkdownRenderer;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type RenderMarkdownProps = _RenderMarkdownProps;\n/**\n * @deprecated import from next-intlayer/markdown instead\n */\nexport type MarkdownRendererProps = _MarkdownRendererProps;\n"],"mappings":";;;;;;;;;;;;;AA0DA,MAAa,mBAA+CA;;;;AAI5D,MAAa,qBACXC;;;;AAQF,MAAa,iBAAiBC;;;;AAI9B,MAAa,sBAAsBC;;;;AAInC,MAAa,mBAAmBC"}

package/dist/esm/server/prepareSwcOptimization.mjs

@@ -1,6 +1,6 @@
+import { colorize, getAppLogger } from "@intlayer/config/logger";
 import { dirname, join } from "node:path";
 import * as ANSIColors from "@intlayer/config/colors";
-import { colorize, getAppLogger } from "@intlayer/config/logger";
 import { getProjectRequire } from "@intlayer/config/utils";
 import { runOnce } from "@intlayer/engine/utils";
 import { readFileSync, rmSync } from "node:fs";

package/dist/esm/server/withIntlayer.mjs

@@ -1,10 +1,10 @@
 import { getIsPurgePipelineAvailable, prepareSwcOptimization, resolveSwcLogLevel } from "./prepareSwcOptimization.mjs";
 import { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported } from "./swcPluginCompatibility.mjs";
 import { IMPORT_MODE } from "@intlayer/config/defaultValues";
+import { colorize, getAppLogger } from "@intlayer/config/logger";
 import { join, relative, resolve } from "node:path";
 import * as ANSIColors from "@intlayer/config/colors";
 import { formatDictionarySelectorEnvVar, formatNodeTypeToEnvVar, formatOptimizedNestingEnvVar, getConfigEnvVars } from "@intlayer/config/envVars";
-import { colorize, getAppLogger } from "@intlayer/config/logger";
 import { getConfiguration } from "@intlayer/config/node";
 import { compareVersions, getAlias, getHasDictionarySelector, getProjectRequire, getUnusedNodeTypes, normalizePath } from "@intlayer/config/utils";
 import { getNestedDictionaryGraph } from "@intlayer/core/dictionaryManipulator";

package/dist/types/@intlayer/babel/dist/types/babel-plugin-intlayer-field-rename.d.ts

@@ -8,14 +8,13 @@ import "/Users/aymericpineau/Documents/intlayer_/node_modules/.bun/@babel+types@
  * Mirrors `FieldRenameNode` in the `@intlayer/swc` crate — both sides must stay
  * in sync.
  */
-type SerializedFieldRenameEntry = {
+export type SerializedFieldRenameEntry = {
   /** Short alphabetic alias the field is renamed to (`'a'`, `'b'`, …). */
   shortName: string;
   /** Rename table of the fields nested inside this one. */
   children: SerializedFieldRenameMap;
 };
 /** JSON-serialisable form of a {@link NestedRenameMap}. */
-type SerializedFieldRenameMap = Record<string, SerializedFieldRenameEntry>;
+export type SerializedFieldRenameMap = Record<string, SerializedFieldRenameEntry>;
 //#endregion
-export { SerializedFieldRenameEntry, SerializedFieldRenameMap };
 //# sourceMappingURL=babel-plugin-intlayer-field-rename.d.ts.map

package/dist/types/@intlayer/babel/dist/types/babel-plugin-intlayer-field-rename.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../../../../../../@intlayer/babel/dist/types/babel-plugin-intlayer-field-rename.d.ts"],"mappings":";;;;;;;;;;KAuDK;;EAEH;;EAEA,UAAU;;;KAGP,2BAA2B,eAAe"}
+{"version":3,"file":"babel-plugin-intlayer-field-rename.d.ts","names":[],"sources":["../../../../../../../@intlayer/babel/dist/types/babel-plugin-intlayer-field-rename.d.ts"],"mappings":";;;;;;;;;;YAuDY;;EAEV;;EAEA,UAAU;;;YAGA,2BAA2B,eAAe"}

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

@@ -4,7 +4,7 @@ import { IntlayerProviderProps } from "react-intlayer";
 /**
  * @deprecated Use `IntlayerProviderProps` from `next-intlayer/server` instead.
  */
-type IntlayerClientProviderProps = IntlayerProviderProps;
+export type IntlayerClientProviderProps = IntlayerProviderProps;
 /**
  * Client boundary mounted by the unified `IntlayerProvider`.
  *
@@ -15,7 +15,7 @@ type IntlayerClientProviderProps = IntlayerProviderProps;
  * @param props - The provider props.
  * @returns The provider component.
  */
-declare const IntlayerClientProviderBase: FC<IntlayerProviderProps>;
+export declare const IntlayerClientProviderBase: FC<IntlayerProviderProps>;
 /**
  * @deprecated Use `IntlayerProvider` from `next-intlayer/server` instead
  *
@@ -31,7 +31,6 @@ declare const IntlayerClientProviderBase: FC<IntlayerProviderProps>;
  * };
  * ```
  */
-declare const IntlayerClientProvider: FC<IntlayerProviderProps>;
+export declare const IntlayerClientProvider: FC<IntlayerProviderProps>;
 //#endregion
-export { IntlayerClientProvider, IntlayerClientProviderBase, IntlayerClientProviderProps };
 //# sourceMappingURL=IntlayerClientProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IntlayerClientProvider.d.ts","names":[],"sources":["../../../src/client/IntlayerClientProvider.tsx"],"mappings":";;;;;;KASY,8BAA8B;;;;;;;;;;;cAY7B,4BAA4B,GAAG;;;;;;;;;;;;;;;;cAmB/B,wBAAsB,GAAA"}
+{"version":3,"file":"IntlayerClientProvider.d.ts","names":[],"sources":["../../../src/client/IntlayerClientProvider.tsx"],"mappings":";;;;;;YASY,8BAA8B;;;;;;;;;;;qBAY7B,4BAA4B,GAAG;;;;;;;;;;;;;;;;qBAmB/B,wBAAsB,GAAA"}

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

@@ -1,7 +1,7 @@
 import { UseLocaleResult as UseLocaleResult$1 } from "react-intlayer";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocale.d.ts
-type UseLocaleProps = {
+export type UseLocaleProps = {
   isCookieEnabled?: boolean;
   onLocaleChange?: (locale: DeclaredLocales) => void;
   onChange?: 'replace' | 'push' | 'none' | ((params: {
@@ -9,7 +9,7 @@ type UseLocaleProps = {
     path: string;
   }) => void);
 };
-type UseLocaleResult = UseLocaleResult$1 & {
+export type UseLocaleResult = UseLocaleResult$1 & {
   pathWithoutLocale: string;
 };
 /**
@@ -36,7 +36,6 @@ type UseLocaleResult = UseLocaleResult$1 & {
  * };
  * ```
  */
-declare const useLocale: ({ onChange, onLocaleChange, isCookieEnabled }?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocale: ({ onChange, onLocaleChange, isCookieEnabled }?: UseLocaleProps) => UseLocaleResult;
 //#endregion
-export { UseLocaleProps, UseLocaleResult, 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":";;;KAgBY;EACV;EACA,kBAAkB,QAAQ;EAC1B,2CAIM;IAAU,QAAQ;IAAe;;;KAG7B,kBAAkB;EAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;cA2BW,cAAS,UAAA,gBAAA,oBAInB,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;;YAgBY;EACV;EACA,kBAAkB,QAAQ;EAC1B,2CAIM;IAAU,QAAQ;IAAe;;;YAG7B,kBAAkB;EAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;qBA2BW,cAAS,UAAA,gBAAA,oBAInB,mBAAsB"}

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

@@ -21,7 +21,6 @@ import { UseLocaleProps, UseLocaleResult } from "./useLocale.js";
  * };
  * ```
  */
-declare const useLocalePageRouter: ({ onLocaleChange, isCookieEnabled }?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocalePageRouter: ({ onLocaleChange, isCookieEnabled }?: UseLocaleProps) => UseLocaleResult;
 //#endregion
-export { useLocalePageRouter };
 //# sourceMappingURL=useLocalePageRouter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocalePageRouter.d.ts","names":[],"sources":["../../../src/client/useLocalePageRouter.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cAqCa,wBAAmB,gBAAA,oBAG7B,mBAAsB"}
+{"version":3,"file":"useLocalePageRouter.d.ts","names":[],"sources":["../../../src/client/useLocalePageRouter.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBAqCa,wBAAmB,gBAAA,oBAG7B,mBAAsB"}

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

@@ -19,7 +19,6 @@
  * };
  * ```
  */
-declare const usePathname: () => string;
+export declare const usePathname: () => string;
 //#endregion
-export { usePathname };
 //# sourceMappingURL=usePathname.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;cA0Ba"}
+{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;qBA0Ba"}

package/dist/types/generateStaticParams.d.ts

@@ -17,7 +17,6 @@
  * }
  * ```
  */
-declare const generateStaticParams: () => any;
+export declare const generateStaticParams: () => any;
 //#endregion
-export { generateStaticParams };
 //# sourceMappingURL=generateStaticParams.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"generateStaticParams.d.ts","names":[],"sources":["../../src/generateStaticParams.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAsBa"}
+{"version":3,"file":"generateStaticParams.d.ts","names":[],"sources":["../../src/generateStaticParams.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAsBa"}

package/dist/types/index.d.ts

@@ -8,49 +8,41 @@ import { generateStaticParams } from "./generateStaticParams.js";
 import { LocalParams, LocalPromiseParams, Next14LayoutIntlayer, Next14PageIntlayer, Next15LayoutIntlayer, Next15PageIntlayer, NextLayoutIntlayer, NextPageIntlayer } from "./types/NextPage.js";
 import "./types/index.js";
 import { index_d_exports } from "./markdown/index.js";
+import { FC } from "react";
 import { ConversionParams, ExperimentState, IntlayerClientContext, IntlayerNode, IntlayerProvider, IntlayerProviderProps, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useConversion, useDictionary, useDictionaryAsync, useDictionaryDynamic, useExperiment, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocaleCookie, useLocaleStorage } from "react-intlayer";
 //#region src/index.d.ts
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-declare const MarkdownProvider: import("react").FC<index_d_exports.MarkdownProviderOptions & {
-  components?: import("react-intlayer/html").HTMLComponents<'permissive', {}>;
-  wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>;
-  renderMarkdown?: (markdown: string | import("react-intlayer/markdown").ParsedMarkdown, options?: index_d_exports.MarkdownProviderOptions, components?: import("react-intlayer/html").HTMLComponents<'permissive', {}>, wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>) => import("react").ReactNode | Promise<import("react").ReactNode>;
-} & {
-  children?: import("react").ReactNode | undefined;
-}>;
+export declare const MarkdownProvider: FC<index_d_exports.MarkdownProviderProps>;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-declare const useMarkdownContext: () => {
-  components?: import("react-intlayer/html").HTMLComponents<'permissive', {}>;
-  renderMarkdown: (markdown: string | import("react-intlayer/markdown").ParsedMarkdown, options?: index_d_exports.MarkdownProviderOptions, components?: import("react-intlayer/html").HTMLComponents<'permissive', {}>, wrapper?: import("react").FC<import("react").HTMLAttributes<HTMLElement>>) => import("react").ReactNode | Promise<import("react").ReactNode>;
-};
+export declare const useMarkdownContext: () => index_d_exports.MarkdownContextValue;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-type MarkdownProviderOptions = index_d_exports.MarkdownProviderOptions;
+export type MarkdownProviderOptions = index_d_exports.MarkdownProviderOptions;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-declare const renderMarkdown: (content: string | import("react-intlayer/markdown").ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: index_d_exports.RenderMarkdownProps) => import("react").JSX.Element;
+export declare const renderMarkdown: (content: string | import("react-intlayer/markdown").ParsedMarkdown, { components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: index_d_exports.RenderMarkdownProps) => import("react").JSX.Element;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: index_d_exports.RenderMarkdownProps) => (content: string | import("react-intlayer/markdown").ParsedMarkdown) => string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<import("react").ReactNode>;
+export declare const useMarkdownRenderer: ({ components, wrapper, forceBlock, forceInline, preserveFrontmatter, tagfilter }?: index_d_exports.RenderMarkdownProps) => (content: string | import("react-intlayer/markdown").ParsedMarkdown) => string | number | bigint | boolean | import("react").JSX.Element | Iterable<import("react").ReactNode> | Promise<import("react").ReactNode>;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-declare const MarkdownRenderer: import("react").FC<index_d_exports.MarkdownRendererProps>;
+export declare const MarkdownRenderer: FC<index_d_exports.MarkdownRendererProps>;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-type RenderMarkdownProps = index_d_exports.RenderMarkdownProps;
+export type RenderMarkdownProps = index_d_exports.RenderMarkdownProps;
 /**
  * @deprecated import from next-intlayer/markdown instead
  */
-type MarkdownRendererProps = index_d_exports.MarkdownRendererProps;
+export type MarkdownRendererProps = index_d_exports.MarkdownRendererProps;
 //#endregion
-export { type ConversionParams, type ExperimentState, IntlayerClientContext, IntlayerClientProvider, type IntlayerClientProviderProps, type IntlayerNode, IntlayerProvider, type IntlayerProviderProps, type LocalParams, type LocalPromiseParams, MarkdownProvider, MarkdownProviderOptions, MarkdownRenderer, MarkdownRendererProps, type Next14LayoutIntlayer, type Next14PageIntlayer, type Next15LayoutIntlayer, type Next15PageIntlayer, type NextLayoutIntlayer, type NextPageIntlayer, RenderMarkdownProps, generateStaticParams, getDictionary, getIntlayer, localeCookie, localeInStorage, renderMarkdown, setLocaleCookie, setLocaleInStorage, t, useConversion, useDictionary, useDictionaryAsync, useDictionaryDynamic, useExperiment, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale, useLocaleCookie, useLocalePageRouter, useLocaleStorage, useMarkdownContext, useMarkdownRenderer, usePathname, useRewriteURL };
+export { type ConversionParams, type ExperimentState, IntlayerClientContext, IntlayerClientProvider, type IntlayerClientProviderProps, type IntlayerNode, IntlayerProvider, type IntlayerProviderProps, type LocalParams, type LocalPromiseParams, type Next14LayoutIntlayer, type Next14PageIntlayer, type Next15LayoutIntlayer, type Next15PageIntlayer, type NextLayoutIntlayer, type NextPageIntlayer, generateStaticParams, getDictionary, getIntlayer, localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, t, useConversion, useDictionary, useDictionaryAsync, useDictionaryDynamic, useExperiment, useI18n, useIntl, useIntlayer, useLoadDynamic, useLocale, useLocaleCookie, useLocalePageRouter, useLocaleStorage, usePathname, useRewriteURL };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;cAuDa,kCAAgB,GAAA,gBAAA;;;;;;;;;;cAIhB;;;;;;;KAID,0BAA0B,gBAAA;;;;cAIzB,iBAAc,oDAAA,kBAAA,YAAA,SAAA,YAAA,aAAA,qBAAA,cAAA,gBAAA,wCAAA,IAAA;;;;cAId,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAAA,gBAAA,yBAAA,oDAAA,wEAAA,IAAA,UAAA,yBAAA,aAAA,wBAAA;;;;cAInB,kCAAgB,GAAA,gBAAA;;;;KAIjB,sBAAsB,gBAAA;;;;KAItB,wBAAwB,gBAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/index.ts"],"mappings":";;;;;;;;;;;;;;;;qBA0Da,kBAAkB,GAAG,gBAAA;;;;qBAIrB,0BAA0B,gBAAA;;;;YAK3B,0BAA0B,gBAAA;;;;qBAIzB,iBAAc,oDAAA,kBAAA,YAAA,SAAA,YAAA,aAAA,qBAAA,cAAA,gBAAA,wCAAA,IAAA;;;;qBAId,wBAAmB,YAAA,SAAA,YAAA,aAAA,qBAAA,cAAA,gBAAA,yBAAA,oDAAA,wEAAA,IAAA,UAAA,yBAAA,aAAA,wBAAA;;;;qBAInB,kBAAgB,GAAA,gBAAA;;;;YAIjB,sBAAsB,gBAAA;;;;YAItB,wBAAwB,gBAAA"}

package/dist/types/proxy/intlayerProxy.d.ts

@@ -24,7 +24,6 @@ import { NextFetchEvent, NextRequest, NextResponse } from "next/server";
  * @returns - The response to be returned to the client.
  *
  */
-declare const intlayerProxy: (request: NextRequest, _event?: NextFetchEvent, _response?: NextResponse) => NextResponse;
+export declare const intlayerProxy: (request: NextRequest, _event?: NextFetchEvent, _response?: NextResponse) => NextResponse;
 //#endregion
-export { intlayerProxy };
 //# sourceMappingURL=intlayerProxy.d.ts.map

package/dist/types/proxy/intlayerProxy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intlayerProxy.d.ts","names":[],"sources":["../../../src/proxy/intlayerProxy.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cAuNa,gBAAa,SACf,aAAW,SACX,gBAAc,YACX,iBACX"}
+{"version":3,"file":"intlayerProxy.d.ts","names":[],"sources":["../../../src/proxy/intlayerProxy.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBAuNa,gBAAa,SACf,aAAW,SACX,gBAAc,YACX,iBACX"}

package/dist/types/proxy/localeDetector.d.ts

@@ -6,7 +6,6 @@ import { NextRequest } from "next/server.js";
  *
  * Headers are provided by the browser and can be used to determine the user's preferred language
  */
-declare const localeDetector: (request: NextRequest) => LocalesValues;
+export declare const localeDetector: (request: NextRequest) => LocalesValues;
 //#endregion
-export { localeDetector };
 //# sourceMappingURL=localeDetector.d.ts.map

package/dist/types/proxy/localeDetector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/proxy/localeDetector.ts"],"mappings":";;;;;;;;cASa,iBAAc,SAAa,gBAAc"}
+{"version":3,"file":"localeDetector.d.ts","names":[],"sources":["../../../src/proxy/localeDetector.ts"],"mappings":";;;;;;;;qBASa,iBAAc,SAAa,gBAAc"}

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

@@ -27,8 +27,7 @@ import { multipleProxies } from "./multipleProxies.js";
  * @param response - The Next.js response object (optional).
  * @returns - The response to be returned to the client.
  */
-declare const intlayerMiddleware: typeof intlayerProxy;
-declare const multipleMiddlewares: typeof multipleProxies;
+export declare const intlayerMiddleware: typeof intlayerProxy;
+export declare const multipleMiddlewares: typeof multipleProxies;
 //#endregion
-export { intlayerMiddleware, multipleMiddlewares };
 //# sourceMappingURL=middleware.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../../src/proxy/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ba,2BAAkB;cAElB,4BAAmB"}
+{"version":3,"file":"middleware.d.ts","names":[],"sources":["../../../src/proxy/middleware.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA8Ba,2BAAkB;qBAElB,4BAAmB"}

package/dist/types/proxy/multipleProxies.d.ts

@@ -28,7 +28,6 @@ import { NextFetchEvent, NextRequest, NextResponse } from "next/server";
  * @param proxies - An array of proxy functions to execute in order.
  * @returns A single proxy function that runs all provided proxies.
  */
-declare const multipleProxies: (proxies: ((req: NextRequest, event?: NextFetchEvent, response?: NextResponse) => NextResponse | Promise<NextResponse>)[]) => (req: NextRequest, event?: NextFetchEvent, response?: NextResponse) => Promise<NextResponse<unknown>>;
+export declare const multipleProxies: (proxies: ((req: NextRequest, event?: NextFetchEvent, response?: NextResponse) => NextResponse | Promise<NextResponse>)[]) => (req: NextRequest, event?: NextFetchEvent, response?: NextResponse) => Promise<NextResponse<unknown>>;
 //#endregion
-export { multipleProxies };
 //# sourceMappingURL=multipleProxies.d.ts.map

package/dist/types/proxy/multipleProxies.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multipleProxies.d.ts","names":[],"sources":["../../../src/proxy/multipleProxies.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,kBAAe,WAGtB,KAAK,aACL,QAAQ,gBACR,WAAW,iBACR,eAAe,QAAQ,sBAAgB,KAElC,aAAW,QAAU,gBAAc,WAAa,iBAAY,QAAA"}
+{"version":3,"file":"multipleProxies.d.ts","names":[],"sources":["../../../src/proxy/multipleProxies.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,kBAAe,WAGtB,KAAK,aACL,QAAQ,gBACR,WAAW,iBACR,eAAe,QAAQ,sBAAgB,KAElC,aAAW,QAAU,gBAAc,WAAa,iBAAY,QAAA"}

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

@@ -2,7 +2,7 @@ import { FC } from "react";
 import { IntlayerProviderProps as IntlayerProviderProps$1 } from "react-intlayer";
 import { IntlayerServerProviderProps } from "react-intlayer/server";
 //#region src/server/IntlayerProvider.d.ts
-type IntlayerProviderProps = IntlayerProviderProps$1 & IntlayerServerProviderProps;
+export type IntlayerProviderProps = IntlayerProviderProps$1 & IntlayerServerProviderProps;
 /**
  * Unified Intlayer provider for the Next.js App Router.
  *
@@ -37,7 +37,6 @@ type IntlayerProviderProps = IntlayerProviderProps$1 & IntlayerServerProviderPro
  * seed it per request with `setVariant` when server components read it outside
  * a full render of this provider.
  */
-declare const IntlayerProvider: FC<IntlayerProviderProps>;
+export declare const IntlayerProvider: FC<IntlayerProviderProps>;
 //#endregion
-export { IntlayerProvider, IntlayerProviderProps };
 //# sourceMappingURL=IntlayerProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IntlayerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerProvider.tsx"],"mappings":";;;;KAQY,wBAAwB,0BAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAoCW,kBAAkB,GAAG"}
+{"version":3,"file":"IntlayerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerProvider.tsx"],"mappings":";;;;YAQY,wBAAwB,0BAClC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCW,kBAAkB,GAAG"}

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

@@ -3,7 +3,7 @@ import { IntlayerServerProviderProps as IntlayerServerProviderProps$1 } from "re
 /**
  * @deprecated Use `IntlayerProviderProps` from `next-intlayer/server` instead.
  */
-type IntlayerServerProviderProps = IntlayerServerProviderProps$1;
+export type IntlayerServerProviderProps = IntlayerServerProviderProps$1;
 /**
  * @deprecated Use `IntlayerProvider` from `next-intlayer/server` instead
  *
@@ -19,7 +19,6 @@ type IntlayerServerProviderProps = IntlayerServerProviderProps$1;
  * };
  * ```
  */
-declare const IntlayerServerProvider: import("react").FC<IntlayerServerProviderProps$1>;
+export declare const IntlayerServerProvider: import("react").FC<IntlayerServerProviderProps$1>;
 //#endregion
-export { IntlayerServerProvider, IntlayerServerProviderProps };
 //# sourceMappingURL=IntlayerServerProvider.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.ts"],"mappings":";;;;;KAQY,8BAA8B;;;;;;;;;;;;;;;;cAiB7B,wCAAsB,GAAA"}
+{"version":3,"file":"IntlayerServerProvider.d.ts","names":[],"sources":["../../../src/server/IntlayerServerProvider.ts"],"mappings":";;;;;YAQY,8BAA8B;;;;;;;;;;;;;;;;qBAiB7B,wCAAsB,GAAA"}

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

@@ -12,12 +12,12 @@ import { Locale } from "@intlayer/types/allLocales";
  * Suspends until the request storage resolves. Returns `undefined` when the
  * call site or the server context already carries the locale.
  */
-declare const resolveFallbackLocale: (localeOrSelector?: unknown) => Locale | undefined;
+export declare const resolveFallbackLocale: (localeOrSelector?: unknown) => Locale | undefined;
 /**
  * Asynchronous twin of {@link resolveFallbackLocale}, for the hooks that are
  * already async and can await the request storage instead of suspending on it.
  */
-declare const getFallbackLocale: (localeOrSelector?: unknown) => Promise<Locale | undefined>;
+export declare const getFallbackLocale: (localeOrSelector?: unknown) => Promise<Locale | undefined>;
 /**
  * Full ambient locale for the server APIs that take a plain locale argument
  * (or none at all): call site → server context → locale carried by the
@@ -28,7 +28,6 @@ declare const getFallbackLocale: (localeOrSelector?: unknown) => Promise<Locale
  * reimplemented here have no such fallback slot, so they need the resolved
  * value.
  */
-declare const resolveAmbientLocale: (locale?: LocalesValues) => LocalesValues | undefined;
+export declare const resolveAmbientLocale: (locale?: LocalesValues) => LocalesValues | undefined;
 //#endregion
-export { getFallbackLocale, resolveAmbientLocale, resolveFallbackLocale };
 //# sourceMappingURL=ambientLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ambientLocale.d.ts","names":[],"sources":["../../../src/server/ambientLocale.ts"],"mappings":";;;;;;;;;;;;;;cAiDa,wBAAqB,+BAE/B;;;;;cAOU,oBAAiB,+BAE3B,QAAQ;;;;;;;;;;;cAaE,uBAAoB,SACtB,kBACR"}
+{"version":3,"file":"ambientLocale.d.ts","names":[],"sources":["../../../src/server/ambientLocale.ts"],"mappings":";;;;;;;;;;;;;;qBAiDa,wBAAqB,+BAE/B;;;;;qBAOU,oBAAiB,+BAE3B,QAAQ;;;;;;;;;;;qBAaE,uBAAoB,SACtB,kBACR"}

package/dist/types/server/format/useCompact.d.ts

@@ -10,7 +10,6 @@ import { compact } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
+export declare const useCompact: () => (...args: Parameters<typeof compact>) => string;
 //#endregion
-export { useCompact };
 //# sourceMappingURL=useCompact.d.ts.map

package/dist/types/server/format/useCompact.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;;;;;;;;cAaa,sBAAU,MAGJ,kBAAkB"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/server/format/useCompact.ts"],"mappings":";;;;;;;;;;;;qBAaa,sBAAU,MAGJ,kBAAkB"}

package/dist/types/server/format/useCurrency.d.ts

@@ -10,7 +10,6 @@ import { currency } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
+export declare const useCurrency: () => (...args: Parameters<typeof currency>) => string;
 //#endregion
-export { useCurrency };
 //# sourceMappingURL=useCurrency.d.ts.map

package/dist/types/server/format/useCurrency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;cAaa,uBAAW,MAGL,kBAAkB"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/server/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;qBAaa,uBAAW,MAGL,kBAAkB"}

package/dist/types/server/format/useDate.d.ts

@@ -14,7 +14,6 @@ import { date } from "@intlayer/core/formatters";
  * preset is resolved before the locale is merged in — spreading the string
  * itself would scatter its characters and drop the preset.
  */
-declare const useDate: () => (...args: Parameters<typeof date>) => string;
+export declare const useDate: () => (...args: Parameters<typeof date>) => string;
 //#endregion
-export { useDate };
 //# sourceMappingURL=useDate.d.ts.map

package/dist/types/server/format/useDate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;cAiBa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useDate.d.ts","names":[],"sources":["../../../../src/server/format/useDate.ts"],"mappings":";;;;;;;;;;;;;;;;qBAiBa,mBAAO,MAGD,kBAAkB"}

package/dist/types/server/format/useList.d.ts

@@ -10,7 +10,6 @@ import { list } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const useList: () => (...args: Parameters<typeof list>) => string;
+export declare const useList: () => (...args: Parameters<typeof list>) => string;
 //#endregion
-export { useList };
 //# sourceMappingURL=useList.d.ts.map

package/dist/types/server/format/useList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;;;;;;;;cAaa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/server/format/useList.ts"],"mappings":";;;;;;;;;;;;qBAaa,mBAAO,MAGD,kBAAkB"}

package/dist/types/server/format/useNumber.d.ts

@@ -10,7 +10,6 @@ import { number } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const useNumber: () => (...args: Parameters<typeof number>) => string;
+export declare const useNumber: () => (...args: Parameters<typeof number>) => string;
 //#endregion
-export { useNumber };
 //# sourceMappingURL=useNumber.d.ts.map

package/dist/types/server/format/useNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"mappings":";;;;;;;;;;;;cAaa,qBAAS,MAGH,kBAAkB"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/server/format/useNumber.ts"],"mappings":";;;;;;;;;;;;qBAaa,qBAAS,MAGH,kBAAkB"}

package/dist/types/server/format/usePercentage.d.ts

@@ -10,7 +10,6 @@ import { percentage } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
+export declare const usePercentage: () => (...args: Parameters<typeof percentage>) => string;
 //#endregion
-export { usePercentage };
 //# sourceMappingURL=usePercentage.d.ts.map

package/dist/types/server/format/usePercentage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;cAaa,yBAAa,MAGP,kBAAkB"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/server/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;qBAaa,yBAAa,MAGP,kBAAkB"}

package/dist/types/server/format/useRelativeTime.d.ts

@@ -10,7 +10,6 @@ import { relativeTime } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
+export declare const useRelativeTime: () => (...args: Parameters<typeof relativeTime>) => string;
 //#endregion
-export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.d.ts.map

package/dist/types/server/format/useRelativeTime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;cAaa,2BAAe,MAGT,kBAAkB"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/server/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;qBAaa,2BAAe,MAGT,kBAAkB"}

package/dist/types/server/format/useUnit.d.ts

@@ -10,7 +10,6 @@ import { units } from "@intlayer/core/formatters";
  * locale — it would read the server context alone and format with the default
  * locale on any render the provider did not reach.
  */
-declare const useUnit: () => (...args: Parameters<typeof units>) => string;
+export declare const useUnit: () => (...args: Parameters<typeof units>) => string;
 //#endregion
-export { useUnit };
 //# sourceMappingURL=useUnit.d.ts.map

package/dist/types/server/format/useUnit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"mappings":";;;;;;;;;;;;cAaa,mBAAO,MAGD,kBAAkB"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/server/format/useUnit.ts"],"mappings":";;;;;;;;;;;;qBAaa,mBAAO,MAGD,kBAAkB"}

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

@@ -18,7 +18,6 @@ import { Locale } from "@intlayer/types/allLocales";
  * }
  * ```
  */
-declare const getLocale: () => Promise<Locale>;
+export declare const getLocale: () => Promise<Locale>;
 //#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":";;;;;;;;;;;;;;;;;;;;cA0Ba,iBAAsB,QAAQ"}
+{"version":3,"file":"getLocale.d.ts","names":[],"sources":["../../../src/server/getLocale.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBA0Ba,iBAAsB,QAAQ"}

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

@@ -9,9 +9,9 @@ import { IntlayerConfig } from "@intlayer/types/config";
  * Field-rename tables keyed by dictionary key, forwarded to the
  * `@intlayer/swc` plugin's `fieldRenameMap` option.
  */
-type FieldRenameMapByDictionaryKey = Record<string, SerializedFieldRenameMap>;
+export type FieldRenameMapByDictionaryKey = Record<string, SerializedFieldRenameMap>;
 /** Verbosity forwarded to the `@intlayer/swc` plugin's `logLevel` option. */
-type SwcLogLevel = 'off' | 'info' | 'debug';
+export type SwcLogLevel = 'off' | 'info' | 'debug';
 /**
  * Resolves the verbosity the `@intlayer/swc` plugin should report at.
  *
@@ -19,7 +19,7 @@ type SwcLogLevel = 'off' | 'info' | 'debug';
  * the purge and minify reporting, which the pipeline emits in Node so the
  * Next.js build reads the same as the Vite one.
  */
-declare const resolveSwcLogLevel: (intlayerConfig: IntlayerConfig) => SwcLogLevel;
+export declare const resolveSwcLogLevel: (intlayerConfig: IntlayerConfig) => SwcLogLevel;
 /**
  * Whether the purge / minify pipeline can run at all, i.e. whether a usable
  * `@intlayer/babel` is resolvable from the project.
@@ -28,7 +28,7 @@ declare const resolveSwcLogLevel: (intlayerConfig: IntlayerConfig) => SwcLogLeve
  * `Dictionary minification enabled` while the pipeline cannot load would describe a
  * pass that never happens.
  */
-declare const getIsPurgePipelineAvailable: (intlayerConfig: IntlayerConfig) => boolean;
+export declare const getIsPurgePipelineAvailable: (intlayerConfig: IntlayerConfig) => boolean;
 type PrepareSwcOptimizationParams = {
   /** Options forwarded to the intlayer configuration loader. */
   configOptions?: GetConfigurationOptions;
@@ -62,7 +62,6 @@ type PrepareSwcOptimizationParams = {
  * @returns The field-rename tables, keyed by dictionary key. Empty when the
  *   pipeline is disabled, unavailable, or renamed nothing.
  */
-declare const prepareSwcOptimization: (intlayerConfig: IntlayerConfig, params: PrepareSwcOptimizationParams) => Promise<FieldRenameMapByDictionaryKey>;
+export declare const prepareSwcOptimization: (intlayerConfig: IntlayerConfig, params: PrepareSwcOptimizationParams) => Promise<FieldRenameMapByDictionaryKey>;
 //#endregion
-export { FieldRenameMapByDictionaryKey, SwcLogLevel, getIsPurgePipelineAvailable, prepareSwcOptimization, resolveSwcLogLevel };
 //# sourceMappingURL=prepareSwcOptimization.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"prepareSwcOptimization.d.ts","names":[],"sources":["../../../src/server/prepareSwcOptimization.ts"],"mappings":";;;;;;;;;;;KAsBY,gCAAgC,eAE1C;;KAIU;;;;;;;;cAoDC,qBAAkB,gBACb,mBACf;;;;;;;;;cAqGU,8BAA2B,gBACtB;KAkGb;;EAEH,gBAAgB;;EAEhB,eAAe;;EAEf,kBAAkB;;;;;EAKlB;;;;;;;;;;;;;;;;;;;;;;cAuBW,yBAAsB,gBACjB,gBAAc,QACtB,iCACP,QAAQ"}
+{"version":3,"file":"prepareSwcOptimization.d.ts","names":[],"sources":["../../../src/server/prepareSwcOptimization.ts"],"mappings":";;;;;;;;;;;YAsBY,gCAAgC,eAE1C;;YAIU;;;;;;;;qBAoDC,qBAAkB,gBACb,mBACf;;;;;;;;;qBAqGU,8BAA2B,gBACtB;KAkGb;;EAEH,gBAAgB;;EAEhB,eAAe;;EAEf,kBAAkB;;;;;EAKlB;;;;;;;;;;;;;;;;;;;;;;qBAuBW,yBAAsB,gBACjB,gBAAc,QACtB,iCACP,QAAQ"}

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

@@ -16,7 +16,6 @@
  * the reader reports `undefined` so callers fall back to the default locale,
  * matching the previous behavior.
  */
-declare const createSuspendingReader: <T>(load: () => Promise<T | undefined>) => (() => T | undefined);
+export declare const createSuspendingReader: <T>(load: () => Promise<T | undefined>) => (() => T | undefined);
 //#endregion
-export { createSuspendingReader };
 //# sourceMappingURL=suspendingReader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"suspendingReader.d.ts","names":[],"sources":["../../../src/server/suspendingReader.ts"],"mappings":";;;;;;;;;;;;;;;;;;cA0Ba,yBAA0B,GAAC,YAC1B,QAAQ,0BACZ"}
+{"version":3,"file":"suspendingReader.d.ts","names":[],"sources":["../../../src/server/suspendingReader.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBA0Ba,yBAA0B,GAAC,YAC1B,QAAQ,0BACZ"}

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

@@ -28,7 +28,7 @@
  * `swc_ecma_ast` version this Next.js release ships, never a newer one, or the
  * floor moves up with it.
  */
-declare const MINIMUM_SWC_PLUGIN_NEXT_VERSION = "16.1.0";
+export declare const MINIMUM_SWC_PLUGIN_NEXT_VERSION = "16.1.0";
 /**
  * Whether `nextVersion` bundles an SWC able to load the `@intlayer/swc` Wasm
  * plugin.
@@ -46,7 +46,6 @@ declare const MINIMUM_SWC_PLUGIN_NEXT_VERSION = "16.1.0";
  * getIsSwcPluginSupported('15.5.18'); // false
  * ```
  */
-declare const getIsSwcPluginSupported: (nextVersion: string) => boolean;
+export declare const getIsSwcPluginSupported: (nextVersion: string) => boolean;
 //#endregion
-export { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported };
 //# sourceMappingURL=swcPluginCompatibility.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"swcPluginCompatibility.d.ts","names":[],"sources":["../../../src/server/swcPluginCompatibility.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+Ba;;;;;;;;;;;;;;;;;;cAmBA,0BAAuB"}
+{"version":3,"file":"swcPluginCompatibility.d.ts","names":[],"sources":["../../../src/server/swcPluginCompatibility.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+Ba;;;;;;;;;;;;;;;;;;qBAmBA,0BAAuB"}

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

@@ -7,7 +7,6 @@ import { t as t$1 } from "react-intlayer/server";
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const t: <Content = string, L extends LocalesValues = DeclaredLocales>(multilangContent: StrictModeLocaleMap<Content>, locale?: L) => ReturnType<typeof t$1<Content, L>>;
+export declare const t: <Content = string, L extends LocalesValues = DeclaredLocales>(multilangContent: StrictModeLocaleMap<Content>, locale?: L) => ReturnType<typeof t$1<Content, L>>;
 //#endregion
-export { t };
 //# sourceMappingURL=t.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;cAca,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MACR,kBAAkB,IAAM,SAAS"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/server/t.ts"],"mappings":";;;;;;;;;qBAca,IAAK,kBAAkB,UAAU,gBAAgB,iBAAe,kBACzD,oBAAoB,UAAQ,SACrC,MACR,kBAAkB,IAAM,SAAS"}

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

@@ -9,7 +9,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => ReturnType<typeof useDictionary$1<T, A>>;
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => ReturnType<typeof useDictionary$1<T, A>>;
 //#endregion
-export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;cAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,kBAAkB,gBAAkB,GAAG"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/server/useDictionary.ts"],"mappings":";;;;;;;;;;;qBAmBa,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,MAClB,kBAAkB,gBAAkB,GAAG"}

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

@@ -8,7 +8,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => ReturnType<typeof useDictionaryAsync$1<T, L>>;
+export declare const useDictionaryAsync: <const T extends Dictionary, const L extends LocalesValues = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>>, locale?: L) => ReturnType<typeof useDictionaryAsync$1<T, L>>;
 //#endregion
-export { useDictionaryAsync };
 //# sourceMappingURL=useDictionaryAsync.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;;cAea,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,MACR,kBAAkB,qBAAuB,GAAG"}
+{"version":3,"file":"useDictionaryAsync.d.ts","names":[],"sources":["../../../src/server/useDictionaryAsync.ts"],"mappings":";;;;;;;;;;qBAea,2BACL,UAAU,kBACV,UAAU,gBAAgB,iBAAe,mBAE5B,0BAA0B,QAAQ,KAAG,SAC/C,MACR,kBAAkB,qBAAuB,GAAG"}

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

@@ -10,7 +10,6 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A) => ReturnType<typeof useDictionaryDynamic$1<T, A>>;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const A extends LocalesValues | DictionarySelector = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: string, localeOrSelector?: A) => ReturnType<typeof useDictionaryDynamic$1<T, A>>;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;cAoBa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,MAClB,kBAAkB,uBAAyB,GAAG"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/server/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;qBAoBa,6BACL,UAAU,kBACV,UAAU,gBAAgB,qBAAqB,iBAAe,mBAGhE,0BAA0B,QAAQ,MAClC,2BAAyB,aAClB,mBACQ,MAClB,kBAAkB,uBAAyB,GAAG"}

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

@@ -8,7 +8,6 @@ import { useI18n as useI18n$1 } from "react-intlayer/server";
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const useI18n: <T extends DictionaryKeys>(namespace: T, locale?: LocalesValues) => ReturnType<typeof useI18n$1<T>>;
+export declare const useI18n: <T extends DictionaryKeys>(namespace: T, locale?: LocalesValues) => ReturnType<typeof useI18n$1<T>>;
 //#endregion
-export { useI18n };
 //# sourceMappingURL=useI18n.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;cAca,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,kBACR,kBAAkB,UAAY"}
+{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/server/useI18n.ts"],"mappings":";;;;;;;;;;qBAca,UAAW,UAAU,gBAAc,WACnC,GAAC,SACH,kBACR,kBAAkB,UAAY"}

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

@@ -7,7 +7,6 @@ import { WrappedIntl } from "@intlayer/core/formatters";
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
+export declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
 //#endregion
-export { useIntl };
 //# sourceMappingURL=useIntl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/server/useIntl.ts"],"mappings":";;;;;;;;;cAWa,UAAO,SAAa,kBAAgB"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../src/server/useIntl.ts"],"mappings":";;;;;;;;;qBAWa,UAAO,SAAa,kBAAgB"}

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

@@ -9,7 +9,6 @@ import { useIntlayer as useIntlayer$1 } from "react-intlayer/server";
  * If the locale is not provided, it will use the locale from the server
  * context, falling back to the locale carried by the request.
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => ReturnType<typeof useIntlayer$1<T, A>>;
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => ReturnType<typeof useIntlayer$1<T, A>>;
 //#endregion
-export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;cAiBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,kBAAkB,cAAgB,GAAG"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/server/useIntlayer.ts"],"mappings":";;;;;;;;;;;qBAiBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,kBAAkB,cAAgB,GAAG"}

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

@@ -1,6 +1,6 @@
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 //#region src/server/useLocale.d.ts
-type UseLocaleResult = {
+export type UseLocaleResult = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
   availableLocales: DeclaredLocales[];
@@ -14,7 +14,6 @@ type UseLocaleResult = {
  * it would read the server context alone and report the default locale on any
  * render the provider did not reach.
  */
-declare const useLocale: () => UseLocaleResult;
+export declare const useLocale: () => UseLocaleResult;
 //#endregion
-export { UseLocaleResult, useLocale };
 //# sourceMappingURL=useLocale.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";;KAIY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;;;;;cAYP,iBAAgB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/server/useLocale.ts"],"mappings":";;YAIY;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;;;;;;;;;;;qBAYP,iBAAgB"}

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

@@ -28,7 +28,7 @@ type WithIntlayerOptions = GetConfigurationOptions & {
  * export default withIntlayerSync(nextConfig)
  * ```
  */
-declare const withIntlayerSync: <T extends Partial<NextConfig>>(nextConfig?: T, configOptions?: WithIntlayerOptions) => NextConfig & T;
+export declare const withIntlayerSync: <T extends Partial<NextConfig>>(nextConfig?: T, configOptions?: WithIntlayerOptions) => NextConfig & T;
 /**
  * A Next.js plugin that adds the intlayer configuration to the webpack configuration
  * and sets the environment variables
@@ -44,7 +44,7 @@ declare const withIntlayerSync: <T extends Partial<NextConfig>>(nextConfig?: T,
  * > Using the promise allows to prepare the intlayer dictionaries before the build starts.
  *
  */
-declare const withIntlayer: <T extends NextConfig | Partial<NextConfig>>(nextConfig?: T | Promise<T>, configOptions?: WithIntlayerOptions) => Promise<NextConfig & T>;
+export declare const withIntlayer: <T extends NextConfig | Partial<NextConfig>>(nextConfig?: T | Promise<T>, configOptions?: WithIntlayerOptions) => Promise<NextConfig & T>;
 //#endregion
-export { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported, withIntlayer, withIntlayerSync };
+export { MINIMUM_SWC_PLUGIN_NEXT_VERSION, getIsSwcPluginSupported };
 //# sourceMappingURL=withIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"withIntlayer.d.ts","names":[],"sources":["../../../src/server/withIntlayer.ts"],"mappings":";;;;;;KA4XK,sBAAsB;EACzB;EACA,kBAAkB;;;;;;;;;EAUlB,iBAAiB;;;;;;;;;;;;;cAuDN,mBAAoB,UAAU,QAAQ,aAAW,aAChD,GAAC,gBACG,wBACf,aAAa;;;;;;;;;;;;;;;;cA4QH,eAAsB,UAAU,aAAa,QAAQ,aAAW,aAC/D,IAAI,QAAQ,IAAE,gBACV,wBACf,QAAQ,aAAa"}
+{"version":3,"file":"withIntlayer.d.ts","names":[],"sources":["../../../src/server/withIntlayer.ts"],"mappings":";;;;;;KA4XK,sBAAsB;EACzB;EACA,kBAAkB;;;;;;;;;EAUlB,iBAAiB;;;;;;;;;;;;;qBAuDN,mBAAoB,UAAU,QAAQ,aAAW,aAChD,GAAC,gBACG,wBACf,aAAa;;;;;;;;;;;;;;;;qBA4QH,eAAsB,UAAU,aAAa,QAAQ,aAAW,aAC/D,IAAI,QAAQ,IAAE,gBACV,wBACf,QAAQ,aAAa"}

package/dist/types/types/NextPage.d.ts

@@ -2,22 +2,21 @@ import { PropsWithChildren, ReactNode } from "react";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { NextPage } from "next";
 //#region src/types/NextPage.d.ts
-type LocalParams<T = {}> = {
+export type LocalParams<T = {}> = {
   params: {
     locale?: LocalesValues;
   } & T;
 };
-type LocalPromiseParams<T = {}> = {
+export type LocalPromiseParams<T = {}> = {
   params: Promise<{
     locale?: LocalesValues;
   } & T>;
 };
-type Next14PageIntlayer<T = {}> = NextPage<LocalParams<T>>;
-type Next15PageIntlayer<T = {}> = (props: LocalPromiseParams<T>) => ReactNode | Promise<ReactNode>;
-type NextPageIntlayer<T = {}> = Next15PageIntlayer<T>;
-type Next14LayoutIntlayer<T = {}> = NextPage<PropsWithChildren<LocalParams<T>>>;
-type Next15LayoutIntlayer<T = {}> = (props: PropsWithChildren<LocalPromiseParams<T>>) => ReactNode | Promise<ReactNode>;
-type NextLayoutIntlayer<T = {}> = (props: PropsWithChildren<LocalPromiseParams<T>>) => ReactNode | Promise<ReactNode>;
+export type Next14PageIntlayer<T = {}> = NextPage<LocalParams<T>>;
+export type Next15PageIntlayer<T = {}> = (props: LocalPromiseParams<T>) => ReactNode | Promise<ReactNode>;
+export type NextPageIntlayer<T = {}> = Next15PageIntlayer<T>;
+export type Next14LayoutIntlayer<T = {}> = NextPage<PropsWithChildren<LocalParams<T>>>;
+export type Next15LayoutIntlayer<T = {}> = (props: PropsWithChildren<LocalPromiseParams<T>>) => ReactNode | Promise<ReactNode>;
+export type NextLayoutIntlayer<T = {}> = (props: PropsWithChildren<LocalPromiseParams<T>>) => ReactNode | Promise<ReactNode>;
 //#endregion
-export { LocalParams, LocalPromiseParams, Next14LayoutIntlayer, Next14PageIntlayer, Next15LayoutIntlayer, Next15PageIntlayer, NextLayoutIntlayer, NextPageIntlayer };
 //# sourceMappingURL=NextPage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"NextPage.d.ts","names":[],"sources":["../../../src/types/NextPage.ts"],"mappings":";;;;KAIY,YAAY;EACtB;IAAU,SAAS;MAAkB;;KAG3B,mBAAmB;EAC7B,QAAQ;IAEJ,SAAS;MACP;;KAII,mBAAmB,UAAU,SAAS,YAAY;KAClD,mBAAmB,WAC7B,OAAO,mBAAmB,OACvB,YAAY,QAAQ;KACb,iBAAiB,UAAU,mBAAmB;KAE9C,qBAAqB,UAAU,SACzC,kBAAkB,YAAY;KAEpB,qBAAqB,WAC/B,OAAO,kBAAkB,mBAAmB,QACzC,YAAY,QAAQ;KAEb,mBAAmB,WAC7B,OAAO,kBAAkB,mBAAmB,QACzC,YAAY,QAAQ"}
+{"version":3,"file":"NextPage.d.ts","names":[],"sources":["../../../src/types/NextPage.ts"],"mappings":";;;;YAIY,YAAY;EACtB;IAAU,SAAS;MAAkB;;YAG3B,mBAAmB;EAC7B,QAAQ;IAEJ,SAAS;MACP;;YAII,mBAAmB,UAAU,SAAS,YAAY;YAClD,mBAAmB,WAC7B,OAAO,mBAAmB,OACvB,YAAY,QAAQ;YACb,iBAAiB,UAAU,mBAAmB;YAE9C,qBAAqB,UAAU,SACzC,kBAAkB,YAAY;YAEpB,qBAAqB,WAC/B,OAAO,kBAAkB,mBAAmB,QACzC,YAAY,QAAQ;YAEb,mBAAmB,WAC7B,OAAO,kBAAkB,mBAAmB,QACzC,YAAY,QAAQ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-intlayer",
-  "version": "9.4.2",
+  "version": "9.4.3",
   "private": false,
   "description": "Simplify internationalization i18n in Next.js with context providers, hooks, locale detection, and multilingual content integration.",
   "keywords": [
@@ -138,15 +138,15 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.2",
-    "@intlayer/core": "9.4.2",
-    "@intlayer/dictionaries-entry": "9.4.2",
-    "@intlayer/engine": "9.4.2",
-    "@intlayer/types": "9.4.2",
-    "@intlayer/webpack": "9.4.2",
+    "@intlayer/config": "9.4.3",
+    "@intlayer/core": "9.4.3",
+    "@intlayer/dictionaries-entry": "9.4.3",
+    "@intlayer/engine": "9.4.3",
+    "@intlayer/types": "9.4.3",
+    "@intlayer/webpack": "9.4.3",
     "defu": "6.1.7",
     "node-loader": "2.1.0",
-    "react-intlayer": "9.4.2"
+    "react-intlayer": "9.4.3"
   },
   "devDependencies": {
     "@types/node": "26.4.1",
@@ -156,9 +156,9 @@
     "@utils/ts-config-types": "1.0.4",
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
-    "tsdown": "0.22.14",
+    "tsdown": "0.23.0",
     "typescript": "7.0.2",
-    "vitest": "4.1.11"
+    "vitest": "5.0.0"
   },
   "peerDependencies": {
     "next": ">=14.0.0",