next-intlayer 9.4.1 → 9.4.3

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;;;;;;;;;;;;;;;;;;;;;cAsB7B,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.1",
+  "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,27 +138,27 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/config": "9.4.1",
-    "@intlayer/core": "9.4.1",
-    "@intlayer/dictionaries-entry": "9.4.1",
-    "@intlayer/engine": "9.4.1",
-    "@intlayer/types": "9.4.1",
-    "@intlayer/webpack": "9.4.1",
+    "@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.1"
+    "react-intlayer": "9.4.3"
   },
   "devDependencies": {
-    "@types/node": "26.3.0",
+    "@types/node": "26.4.1",
     "@types/react": ">=16.0.0",
     "@types/react-dom": ">=16.0.0",
     "@utils/ts-config": "1.0.4",
     "@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",