react-intlayer 9.4.3 → 9.5.0

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

@@ -1 +1 @@
-{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/client/format/useCompact.ts"],"mappings":";;;;;;;;;;;;cAgBa,mBAAU,wBAAA,UAAA,KAAA;WAAA"}
+{"version":3,"file":"useCompact.d.ts","names":[],"sources":["../../../../src/client/format/useCompact.ts"],"mappings":";;;;;;;;;;;qBAgBa,mBAAU,wBAAA,UAAA,KAAA"}

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useCurrency.d.ts
 /**
  * React client hook that provides a currency formatter
@@ -24,9 +23,8 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  * // "¥9,876,543"
  * ```
  */
-declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useCurrency: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useCurrency };
 //# sourceMappingURL=useCurrency.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/client/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cA8Ba,oBAAW,wBAAA,UAAA,KAAA;WAAA"}
+{"version":3,"file":"useCurrency.d.ts","names":[],"sources":["../../../../src/client/format/useCurrency.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;qBA8Ba,oBAAW,wBAAA,UAAA,KAAA"}

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

@@ -26,7 +26,6 @@ import { date } from "@intlayer/core/formatters";
  *
  * @see createDate
  */
-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/client/format/useDate.d.ts.map

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

package/dist/types/client/format/useIntl.d.ts

@@ -29,7 +29,6 @@ import { WrappedIntl } from "@intlayer/core/formatters";
  * const date2 = new intl.DateTimeFormat('fr-FR').format(new Date());
  * ```
  */
-declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
+export declare const useIntl: (locale?: LocalesValues) => WrappedIntl;
 //#endregion
-export { useIntl };
 //# sourceMappingURL=useIntl.d.ts.map

package/dist/types/client/format/useIntl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/client/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCa,UAAO,SAAa,kBAAa"}
+{"version":3,"file":"useIntl.d.ts","names":[],"sources":["../../../../src/client/format/useIntl.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCa,UAAO,SAAa,kBAAa"}

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useList.d.ts
 /**
  * React client hook that provides a list formatter
@@ -21,13 +20,8 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  * // "1, 2 und 3"
  * ```
  */
-declare const useList: () => (values: (string | number)[], options?: {
-  localeMatcher?: 'lookup' | 'best fit';
-  type?: 'conjunction' | 'disjunction' | 'unit';
-  style?: 'long' | 'short' | 'narrow';
-} & {
-  locale?: LocalesValues;
+export declare const useList: () => (values: (string | number)[], options?: import("@intlayer/core/formatters").ListFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useList };
 //# sourceMappingURL=useList.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/client/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA2Ba,gBAAO,6BAAA;;;;;WAAP"}
+{"version":3,"file":"useList.d.ts","names":[],"sources":["../../../../src/client/format/useList.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBA2Ba,gBAAO,6BAAA,8CAAA"}

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useNumber.d.ts
 /**
  * React client hook that provides a localized number formatter.
@@ -22,9 +21,8 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  * @returns {(value: string | number, options?: import("../createNumber").NumberProps) => string}
  * A number formatting function bound to the active locale.
  */
-declare const useNumber: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useNumber: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useNumber };
 //# sourceMappingURL=useNumber.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/client/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;cA4Ba,kBAAS,wBAAA,SAAA,KAAA;WAAA"}
+{"version":3,"file":"useNumber.d.ts","names":[],"sources":["../../../../src/client/format/useNumber.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA4Ba,kBAAS,wBAAA,SAAA,KAAA"}

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/usePercentage.d.ts
 /**
  * React hook to provide a percentage formatter function
@@ -18,9 +17,8 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  * @returns {(value: string | number, options?: Omit<PercentageOptions, "value">) => string}
  * A function that formats numbers or numeric strings into localized percentages.
  */
-declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const usePercentage: () => (value: string | number, args_1?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { usePercentage };
 //# sourceMappingURL=usePercentage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/client/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAwBa,sBAAa,wBAAA,SAAA,KAAA;WAAA"}
+{"version":3,"file":"usePercentage.d.ts","names":[],"sources":["../../../../src/client/format/usePercentage.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAwBa,sBAAa,wBAAA,SAAA,KAAA"}

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useRelativeTime.d.ts
 /**
  * Client-side React hook for accessing a localized relative time formatter.
@@ -18,10 +17,9 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  * @returns {ReturnType<typeof createRelativeTime>} A relative time formatting function
  *          bound to the current client locale.
  */
-declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
-  locale?: LocalesValues;
+export declare const useRelativeTime: () => (from: string | number | Date, to?: string | number | Date, options?: Intl.RelativeTimeFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
   unit?: Intl.RelativeTimeFormatUnit;
 }) => string;
 //#endregion
-export { useRelativeTime };
 //# sourceMappingURL=useRelativeTime.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/client/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAwBa,wBAAe,wBAAA,MAAA,uBAAA,MAAA,UAAA,KAAA;WAAA"}
+{"version":3,"file":"useRelativeTime.d.ts","names":[],"sources":["../../../../src/client/format/useRelativeTime.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAwBa,wBAAe,wBAAA,MAAA,uBAAA,MAAA,UAAA,KAAA"}

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

@@ -1,4 +1,3 @@
-import { LocalesValues } from "../../intlayer/dist/types/index.js";
 //#region src/client/format/useUnit.d.ts
 /**
  * React hook that provides a unit formatting function
@@ -17,9 +16,8 @@ import { LocalesValues } from "../../intlayer/dist/types/index.js";
  *
  * @returns {Function} A unit formatting function that accepts a value and optional formatting options.
  */
-declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
-  locale?: LocalesValues;
+export declare const useUnit: () => (value: string | number, options?: Intl.NumberFormatOptions & {
+  locale?: import("@intlayer/types").LocalesValues;
 }) => string;
 //#endregion
-export { useUnit };
 //# sourceMappingURL=useUnit.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/client/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cAuBa,gBAAO,wBAAA,UAAA,KAAA;WAAA"}
+{"version":3,"file":"useUnit.d.ts","names":[],"sources":["../../../../src/client/format/useUnit.ts"],"mappings":";;;;;;;;;;;;;;;;;;qBAuBa,gBAAO,wBAAA,UAAA,KAAA"}

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

@@ -24,7 +24,6 @@ import { LocalesValues, StrictModeLocaleMap } from "@intlayer/types/module_augme
  * };
  * ```
  */
-declare const t: <Content = string>(multilangContent: StrictModeLocaleMap<Content>, locale?: LocalesValues) => Content;
+export declare const t: <Content = string>(multilangContent: StrictModeLocaleMap<Content>, locale?: LocalesValues) => Content;
 //#endregion
-export { t };
 //# sourceMappingURL=t.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/client/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;cAkCa,IAAK,kBAAgB,kBACd,oBAAoB,UAAQ,SACrC,kBAAa"}
+{"version":3,"file":"t.d.ts","names":[],"sources":["../../../src/client/t.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;qBAkCa,IAAK,kBAAgB,kBACd,oBAAoB,UAAQ,SACrC,kBAAa"}

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

@@ -10,7 +10,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup } from
  * use the locale from the client context. The same applies to the variant,
  * which falls back to the provider's ambient `variant`.
  */
-declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
+export declare const useDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").ResolveQualifiedDictionaryContent<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
-export { useDictionary };
 //# sourceMappingURL=useDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;;cA2Ba,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,2CAAC,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useDictionary.d.ts","names":[],"sources":["../../../src/client/useDictionary.ts"],"mappings":";;;;;;;;;;;;qBA2Ba,sBACL,UAAU,aAAa,gCACvB,UACF,gBACA,2BAA2B,KAAK,iBAAe,YAEvC,GAAC,mBACM,2CAAC,+CAAA,kCAAA,GAAA,IAAA,mDAAA,sBAAA"}

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

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

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

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

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

@@ -13,7 +13,6 @@ import { QualifiedDynamicLoaderMap } from "@intlayer/core/dictionaryManipulator"
  * If the locale is not provided (directly or through the selector), the client
  * context locale is used.
  */
-declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => any;
+export declare const useDictionaryDynamic: <const T extends Dictionary, const K extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<K> = DeclaredLocales>(dictionaryPromise: StrictModeLocaleMap<() => Promise<T>> | QualifiedDynamicLoaderMap, key: K, localeOrSelector?: A) => any;
 //#endregion
-export { useDictionaryDynamic };
 //# sourceMappingURL=useDictionaryDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;cAsCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}
+{"version":3,"file":"useDictionaryDynamic.d.ts","names":[],"sources":["../../../src/client/useDictionaryDynamic.ts"],"mappings":";;;;;;;;;;;;;;;qBAsCa,6BACL,UAAU,kBACV,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,mBAGzE,0BAA0B,QAAQ,MAClC,2BAAyB,KACxB,GAAC,mBACa"}

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

@@ -1,7 +1,7 @@
 import { DeepTransformContent } from "../plugins.js";
 import { DeclaredLocales, DictionaryKeys, DictionaryRegistryContent } from "@intlayer/types/module_augmentation";
-import { GetSubPath } from "@intlayer/types/dictionary";
 import { ValidDotPathsFor } from "@intlayer/core/transpiler";
+import { GetSubPath } from "@intlayer/types/dictionary";
 //#region src/client/useI18n.d.ts
 /**
  * Hook that provides a translation function `t()` for accessing nested content by key.
@@ -20,7 +20,6 @@ import { ValidDotPathsFor } from "@intlayer/core/transpiler";
  * const ariaLabel = t('button.ariaLabel').value; // 'Close modal'
  * ```
  */
-declare const useI18n: <T extends DictionaryKeys, L extends DeclaredLocales = DeclaredLocales>(namespace: T, locale?: L) => <P extends ValidDotPathsFor<T>>(path: P) => GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P>;
+export declare const useI18n: <T extends DictionaryKeys, L extends DeclaredLocales = DeclaredLocales>(namespace: T, locale?: L) => <P extends ValidDotPathsFor<T>>(path: P) => GetSubPath<DeepTransformContent<DictionaryRegistryContent<T>>, P>;
 //#endregion
-export { useI18n };
 //# sourceMappingURL=useI18n.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/client/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;cA+Ba,UACX,UAAU,gBACV,UAAU,kBAAkB,iBAAe,WAEhC,GAAC,SACH,OAkBE,UAAU,iBAAiB,IAAE,MAChC,MAEL,WAAW,qBAAqB,0BAA0B,KAAK"}
+{"version":3,"file":"useI18n.d.ts","names":[],"sources":["../../../src/client/useI18n.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;qBA+Ba,UACX,UAAU,gBACV,UAAU,kBAAkB,iBAAe,WAEhC,GAAC,SACH,OAkBE,UAAU,iBAAiB,IAAE,MAChC,MAEL,WAAW,qBAAqB,0BAA0B,KAAK"}

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

@@ -29,7 +29,6 @@ import { DeclaredLocales, DictionaryKeys, DictionarySelectorForKey, LocalesValue
  * };
  * ```
  */
-declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
+export declare const useIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => import("@intlayer/core/interpreter").DeepTransformContent<import("@intlayer/types").DictionaryRegistryResult<T, A>, IInterpreterPluginState, import("@intlayer/types").ExtractSelectorLocale<A>>;
 //#endregion
-export { useIntlayer };
 //# sourceMappingURL=useIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA4Ca,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,2CAAC,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}
+{"version":3,"file":"useIntlayer.d.ts","names":[],"sources":["../../../src/client/useIntlayer.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA4Ca,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,2CAAC,+CAAA,yBAAA,GAAA,IAAA,mDAAA,sBAAA"}

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

@@ -1,5 +1,5 @@
 //#region src/client/useLoadDynamic.d.ts
-declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
+export declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
 /**
  * Fills the same cache {@link useLoadDynamic} reads, ahead of render.
  *
@@ -19,7 +19,6 @@ declare const useLoadDynamic: <T>(key: string, promise: Promise<T>) => T;
  *                 dictionary twice never issues a second request.
  * @returns A promise that settles — never rejects — once the entry is readable.
  */
-declare const preloadDynamic: <T>(key: string, loader: () => Promise<T>) => Promise<void>;
+export declare const preloadDynamic: <T>(key: string, loader: () => Promise<T>) => Promise<void>;
 //#endregion
-export { preloadDynamic, useLoadDynamic };
 //# sourceMappingURL=useLoadDynamic.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";cAqCa,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;cA2BxD,iBAAkB,GAAC,aACnB,cACG,QAAQ,OACrB"}
+{"version":3,"file":"useLoadDynamic.d.ts","names":[],"sources":["../../../src/client/useLoadDynamic.ts"],"mappings":";qBAqCa,iBAAkB,GAAC,aAAa,SAAW,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;qBA2BxD,iBAAkB,GAAC,aACnB,cACG,QAAQ,OACrB"}

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

@@ -1,10 +1,10 @@
 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;
 };
-type UseLocaleResult = {
+export type UseLocaleResult = {
   locale: DeclaredLocales;
   defaultLocale: DeclaredLocales;
   availableLocales: DeclaredLocales[];
@@ -33,7 +33,6 @@ type UseLocaleResult = {
  * };
  * ```
  */
-declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: UseLocaleProps) => UseLocaleResult;
+export declare const useLocale: ({ isCookieEnabled, onLocaleChange }?: 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":";;KAWY;EACV;EACA,kBAAkB,QAAQ;;KAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;cA0BT,cAAS,iBAAA,mBAGnB,mBAAsB"}
+{"version":3,"file":"useLocale.d.ts","names":[],"sources":["../../../src/client/useLocale.ts"],"mappings":";;YAWY;EACV;EACA,kBAAkB,QAAQ;;YAGhB;EACV,QAAQ;EACR,eAAe;EACf,kBAAkB;EAClB,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;qBA0BT,cAAS,iBAAA,mBAGnB,mBAAsB"}

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

@@ -1,14 +1,12 @@
-import { LocalesValues } from "../intlayer/dist/types/index.js";
 //#region src/client/useLocaleBase.d.ts
 /**
  * On the client side, hook to get the current locale and all related fields
  */
-declare const useLocaleBase: () => {
-  locale: LocalesValues;
+export declare const useLocaleBase: () => {
+  locale: import("@intlayer/types").LocalesValues;
   defaultLocale: any;
   availableLocales: any;
-  setLocale: (newLocale: LocalesValues) => void;
+  setLocale: (newLocale: import("@intlayer/types").LocalesValues) => void;
 };
 //#endregion
-export { useLocaleBase };
 //# sourceMappingURL=useLocaleBase.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;;cAWa;UAAA;;;yBAAA"}
+{"version":3,"file":"useLocaleBase.d.ts","names":[],"sources":["../../../src/client/useLocaleBase.ts"],"mappings":";;;;qBAWa"}

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

@@ -1,4 +1,3 @@
-import { Locale } from "../intlayer/dist/types/index.js";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/client/useLocaleStorage.d.ts
 /**
@@ -7,28 +6,28 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 /**
  * Get the locale cookie
  */
-declare const localeInStorage: Locale;
+export declare const localeInStorage: import("@intlayer/types").Locale;
 /**
  * @deprecated Use localeInStorage instead
  *
  * Get the locale cookie
  */
-declare const localeCookie: Locale;
+export declare const localeCookie: import("@intlayer/types").Locale;
 /**
  * Set the locale cookie
  */
-declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled?: boolean) => void;
+export declare const setLocaleInStorage: (locale: LocalesValues, isCookieEnabled?: boolean) => void;
 /**
  * @deprecated Use setLocaleInStorage instead
  *
  * Set the locale cookie
  */
-declare const setLocaleCookie: typeof setLocaleInStorage;
+export declare const setLocaleCookie: typeof setLocaleInStorage;
 /**
  * Hook that provides the locale cookie and a function to set it
  */
-declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
-  getLocale: () => Locale;
+export declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
+  getLocale: () => import("@intlayer/types").Locale;
   setLocale: (locale: LocalesValues) => void;
 };
 /**
@@ -38,7 +37,6 @@ declare const useLocaleStorage: (isCookieEnabled?: boolean) => {
  *
  * Hook that provides the locale cookie and a function to set it
  */
-declare const useLocaleCookie: typeof useLocaleStorage;
+export declare const useLocaleCookie: typeof useLocaleStorage;
 //#endregion
-export { localeCookie, localeInStorage, setLocaleCookie, setLocaleInStorage, useLocaleCookie, useLocaleStorage };
 //# sourceMappingURL=useLocaleStorage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;;cAea,iBAAA;;;;;;cAMA,cAAA;;;;cAKA,qBAAkB,QACrB,eAAa;;;;;;cAaV,wBAAe;;;;cAKf,mBAAgB;mBAAhB;sBAAA;;;;;;;;;cAiBA,wBAAe"}
+{"version":3,"file":"useLocaleStorage.d.ts","names":[],"sources":["../../../src/client/useLocaleStorage.ts"],"mappings":";;;;;;;;qBAea,2CAAe;;;;;;qBAMf,wCAAY;;;;qBAKZ,qBAAkB,QACrB,eAAa;;;;;;qBAaV,wBAAe;;;;qBAKf,mBAAgB;;sBAAhB;;;;;;;;;qBAiBA,wBAAe"}

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

@@ -17,7 +17,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":";;;;;;;;;;;;;;;;;;;cAuBa"}
+{"version":3,"file":"usePathname.d.ts","names":[],"sources":["../../../src/client/usePathname.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBAuBa"}

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

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

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

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

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

@@ -21,7 +21,6 @@ import { StrictModeLocaleMap } from "@intlayer/types/module_augmentation";
  * - this function will require each locale to be defined if defined in the project configuration.
  * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
  */
-declare const useTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
+export declare const useTranslation: <const Content = string>(languageContent: StrictModeLocaleMap<Content>) => Content;
 //#endregion
-export { useTranslation };
 //# sourceMappingURL=useTraduction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;cA0Ba,uBAAwB,kBAAgB,iBAClC,oBAAoB,aACpC"}
+{"version":3,"file":"useTraduction.d.ts","names":[],"sources":["../../../src/client/useTraduction.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;qBA0Ba,uBAAwB,kBAAgB,iBAClC,oBAAoB,aACpC"}

package/dist/types/editor/ContentSelector.d.ts

@@ -1,8 +1,7 @@
 import { NodeProps } from "@intlayer/core/interpreter";
 import { FC, HTMLAttributes } from "react";
 //#region src/editor/ContentSelector.d.ts
-type ContentSelectorProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
-declare const ContentSelector: FC<ContentSelectorProps>;
+export type ContentSelectorProps = NodeProps & Omit<HTMLAttributes<HTMLDivElement>, 'children'>;
+export declare const ContentSelector: FC<ContentSelectorProps>;
 //#endregion
-export { ContentSelector, ContentSelectorProps };
 //# sourceMappingURL=ContentSelector.d.ts.map

package/dist/types/editor/ContentSelector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;KAMY,uBAAuB,YACjC,KAAK,eAAe;cAET,iBAAiB,GAAG"}
+{"version":3,"file":"ContentSelector.d.ts","names":[],"sources":["../../../src/editor/ContentSelector.tsx"],"mappings":";;;YAMY,uBAAuB,YACjC,KAAK,eAAe;qBAET,iBAAiB,GAAG"}

package/dist/types/editor/EditorProvider.d.ts

@@ -1,6 +1,5 @@
 import { FC, PropsWithChildren } from "react";
 //#region src/editor/EditorProvider.d.ts
-declare const EditorProvider: FC<PropsWithChildren>;
+export declare const EditorProvider: FC<PropsWithChildren>;
 //#endregion
-export { EditorProvider };
 //# sourceMappingURL=EditorProvider.d.ts.map

package/dist/types/editor/EditorProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;cAGa,gBAAgB,GAAG"}
+{"version":3,"file":"EditorProvider.d.ts","names":[],"sources":["../../../src/editor/EditorProvider.tsx"],"mappings":";;qBAGa,gBAAgB,GAAG"}

package/dist/types/editor/useEditor.d.ts

@@ -4,7 +4,6 @@
  * Syncs the current locale from the Intlayer context into the editor manager so
  * the editor always knows which locale the app is displaying.
  */
-declare const useEditor: () => void;
+export declare const useEditor: () => void;
 //#endregion
-export { useEditor };
 //# sourceMappingURL=useEditor.d.ts.map

package/dist/types/editor/useEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.tsx"],"mappings":";;;;;;cAaa"}
+{"version":3,"file":"useEditor.d.ts","names":[],"sources":["../../../src/editor/useEditor.tsx"],"mappings":";;;;;;qBAaa"}

package/dist/types/getDictionary.d.ts

@@ -7,7 +7,6 @@ import { Dictionary, DictionarySelectorForGroup, QualifiedDictionaryGroup, Resol
  * content for the given locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
-declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
+export declare const getDictionary: <const T extends Dictionary | QualifiedDictionaryGroup, const A extends LocalesValues | DictionarySelectorForGroup<T> = DeclaredLocales>(dictionary: T, localeOrSelector?: A) => DeepTransformContent<ResolveQualifiedDictionaryContent<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
-export { getDictionary };
 //# sourceMappingURL=getDictionary.d.ts.map

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

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

package/dist/types/getIntlayer.d.ts

@@ -6,7 +6,6 @@ import { DeclaredLocales, DictionaryKeys, DictionaryRegistryResult, DictionarySe
  * locale or selector (`{ item }`, `{ variant }`,
  * optionally combined with `locale`).
  */
-declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
+export declare const getIntlayer: <const T extends DictionaryKeys, const A extends LocalesValues | DictionarySelectorForKey<T> = DeclaredLocales>(key: T, localeOrSelector?: A) => DeepTransformContent<DictionaryRegistryResult<T, A>, ExtractSelectorLocale<A>>;
 //#endregion
-export { getIntlayer };
 //# sourceMappingURL=getIntlayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;;;cAgBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,qBACD,yBAAyB,GAAG,IAC5B,sBAAsB"}
+{"version":3,"file":"getIntlayer.d.ts","names":[],"sources":["../../src/getIntlayer.ts"],"mappings":";;;;;;;;qBAgBa,oBACL,UAAU,sBACV,UAAU,gBAAgB,yBAAyB,KAAK,iBAAe,KAExE,GAAC,mBACa,MAClB,qBACD,yBAAyB,GAAG,IAC5B,sBAAsB"}

package/dist/types/html/HTMLComponentTypes.d.ts

@@ -26,16 +26,15 @@ type RestHTMLComponents<T> = { [K in Exclude<keyof HTMLTagsType, keyof T>]?: FC<
 /**
  * The supported modes for the HTMLComponents type.
  */
-type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
+export type HTMLComponentMode = 'permissive' | 'optional' | 'inclusive' | 'strict';
 /**
  * The main component definition with Mode support.
  */
-type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' // Inclusive: Keys in T are required. Rest of HTML is optional.
+export type HTMLComponents<Mode extends HTMLComponentMode = 'optional', T = {}> = Mode extends 'strict' ? DefinedComponents<T, true> : Mode extends 'inclusive' // Inclusive: Keys in T are required. Rest of HTML is optional.
  ? DefinedComponents<T, true> & RestHTMLComponents<T> : Mode extends 'permissive' // Permissive: Keys in T optional. Rest of HTML optional. Any other string allowed.
  ? DefinedComponents<T, false> & RestHTMLComponents<T> & {
   [key: string]: FC<any>;
 } // Optional (Default): Keys in T optional. Rest of HTML optional.
  : DefinedComponents<T, false> & RestHTMLComponents<T>;
 //#endregion
-export { HTMLComponentMode, HTMLComponents };
 //# sourceMappingURL=HTMLComponentTypes.d.ts.map

package/dist/types/html/HTMLComponentTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/html/HTMLComponentTypes.tsx"],"mappings":";;;;;;KAMK,YAAY,KAAK,8BAElB,8BAEE,gCAEE;;;;KAKH,gBAAgB,SAAS,0BAE1B,0BACK,KAAK,cAAc,sBAAsB,YAAY,MAAM;;;;KAM/D,aAAa,KAAK,gBAAgB,IAAI,oBACvC,eAAe,KACf,eAAe;;;;;KAMd,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,GAAG,aAAa,KAAK,gBAAgB,EAAE,aAItD,WAAW,KAAK,GAAG,aAAa,KAAK,gBAAgB,EAAE;;;;;KAOzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,GAC5C,gBAAgB,IAAI,oBAChB,eAAe,KACf,eAAe;;;;KAOX;;;;KASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;;GAGnB,kBAAkB,YAAY,mBAAmB"}
+{"version":3,"file":"HTMLComponentTypes.d.ts","names":[],"sources":["../../../src/html/HTMLComponentTypes.tsx"],"mappings":";;;;;;KAMK,YAAY,KAAK,8BAElB,8BAEE,gCAEE;;;;KAKH,gBAAgB,SAAS,0BAE1B,0BACK,KAAK,cAAc,sBAAsB,YAAY,MAAM;;;;KAM/D,aAAa,KAAK,gBAAgB,IAAI,oBACvC,eAAe,KACf,eAAe;;;;;KAMd,kBAAkB,GAAG,8BAA8B,6BAGjD,WAAW,IAAI,GAAG,aAAa,KAAK,gBAAgB,EAAE,aAItD,WAAW,KAAK,GAAG,aAAa,KAAK,gBAAgB,EAAE;;;;;KAOzD,mBAAmB,QACrB,KAAK,cAAc,oBAAoB,MAAM,GAC5C,gBAAgB,IAAI,oBAChB,eAAe,KACf,eAAe;;;;YAOX;;;;YASA,eACV,aAAa,gCACb,UACE,wBAEA,kBAAkB,WAClB;GAEE,kBAAkB,WAAW,mBAAmB,KAChD;GAEE,kBAAkB,YAChB,mBAAmB;GAChB,cAAc;;GAGnB,kBAAkB,YAAY,mBAAmB"}

package/dist/types/html/HTMLProvider.d.ts

@@ -10,8 +10,7 @@ type HTMLProviderProps = PropsWithChildren<{
    */
   components?: HTMLComponents<'permissive', {}>;
 }>;
-declare const useHTMLContext: () => HTMLContextValue;
-declare const HTMLProvider: FC<HTMLProviderProps>;
+export declare const useHTMLContext: () => HTMLContextValue;
+export declare const HTMLProvider: FC<HTMLProviderProps>;
 //#endregion
-export { HTMLProvider, useHTMLContext };
 //# sourceMappingURL=HTMLProvider.d.ts.map

package/dist/types/html/HTMLProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;cAKF,sBAAc;cAEd,cAAc,GAAG"}
+{"version":3,"file":"HTMLProvider.d.ts","names":[],"sources":["../../../src/html/HTMLProvider.tsx"],"mappings":";;;KAUK;EACH,aAAa;;KAGV,oBAAoB;;;;EAIvB,aAAa;;qBAKF,sBAAc;qBAEd,cAAc,GAAG"}