@intlayer/core 9.4.3 → 9.4.4

package/dist/cjs/formatters/list.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"list.cjs","names":["getCachedIntl","internationalization"],"sources":["../../../src/formatters/list.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../utils/intl';\n\n/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */\ntype ListFormatOptions = {\n  localeMatcher?: 'lookup' | 'best fit';\n  type?: 'conjunction' | 'disjunction' | 'unit';\n  style?: 'long' | 'short' | 'narrow';\n};\n\n/**\n * Formats an array of values into a localized list string using the Intl API.\n *\n * @example\n * list(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * @example\n * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });\n * // \"rouge, vert ou bleu\"\n *\n * @example\n * list([1, 2, 3], { type: 'unit' });\n * // \"1, 2, 3\"\n */\nexport const list = (\n  values: (string | number)[],\n  options?: ListFormatOptions & { locale?: LocalesValues }\n): string =>\n  getCachedIntl(\n    'ListFormat',\n    options?.locale ?? internationalization?.defaultLocale,\n\n    {\n      type: options?.type ?? 'conjunction',\n      style: options?.style ?? 'long',\n      ...options,\n    }\n  ).format(values.map(String));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,QACX,QACA,YAEAA,iCACE,cACA,SAAS,UAAUC,6CAAsB,eAEzC;CACE,MAAM,SAAS,QAAQ;CACvB,OAAO,SAAS,SAAS;CACzB,GAAG;AACL,CACF,CAAC,CAAC,OAAO,OAAO,IAAI,MAAM,CAAC"}
+{"version":3,"file":"list.cjs","names":["getCachedIntl","internationalization"],"sources":["../../../src/formatters/list.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../utils/intl';\n\n/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */\nexport type ListFormatOptions = {\n  localeMatcher?: 'lookup' | 'best fit';\n  type?: 'conjunction' | 'disjunction' | 'unit';\n  style?: 'long' | 'short' | 'narrow';\n};\n\n/**\n * Formats an array of values into a localized list string using the Intl API.\n *\n * @example\n * list(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * @example\n * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });\n * // \"rouge, vert ou bleu\"\n *\n * @example\n * list([1, 2, 3], { type: 'unit' });\n * // \"1, 2, 3\"\n */\nexport const list = (\n  values: (string | number)[],\n  options?: ListFormatOptions & { locale?: LocalesValues }\n): string =>\n  getCachedIntl(\n    'ListFormat',\n    options?.locale ?? internationalization?.defaultLocale,\n\n    {\n      type: options?.type ?? 'conjunction',\n      style: options?.style ?? 'long',\n      ...options,\n    }\n  ).format(values.map(String));\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,QACX,QACA,YAEAA,iCACE,cACA,SAAS,UAAUC,6CAAsB,eAEzC;CACE,MAAM,SAAS,QAAQ;CACvB,OAAO,SAAS,SAAS;CACzB,GAAG;AACL,CACF,CAAC,CAAC,OAAO,OAAO,IAAI,MAAM,CAAC"}

package/dist/esm/formatters/list.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"list.mjs","names":[],"sources":["../../../src/formatters/list.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../utils/intl';\n\n/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */\ntype ListFormatOptions = {\n  localeMatcher?: 'lookup' | 'best fit';\n  type?: 'conjunction' | 'disjunction' | 'unit';\n  style?: 'long' | 'short' | 'narrow';\n};\n\n/**\n * Formats an array of values into a localized list string using the Intl API.\n *\n * @example\n * list(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * @example\n * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });\n * // \"rouge, vert ou bleu\"\n *\n * @example\n * list([1, 2, 3], { type: 'unit' });\n * // \"1, 2, 3\"\n */\nexport const list = (\n  values: (string | number)[],\n  options?: ListFormatOptions & { locale?: LocalesValues }\n): string =>\n  getCachedIntl(\n    'ListFormat',\n    options?.locale ?? internationalization?.defaultLocale,\n\n    {\n      type: options?.type ?? 'conjunction',\n      style: options?.style ?? 'long',\n      ...options,\n    }\n  ).format(values.map(String));\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,MAAa,QACX,QACA,YAEA,cACE,cACA,SAAS,UAAU,sBAAsB,eAEzC;CACE,MAAM,SAAS,QAAQ;CACvB,OAAO,SAAS,SAAS;CACzB,GAAG;AACL,CACF,CAAC,CAAC,OAAO,OAAO,IAAI,MAAM,CAAC"}
+{"version":3,"file":"list.mjs","names":[],"sources":["../../../src/formatters/list.ts"],"sourcesContent":["import { internationalization } from '@intlayer/config/built';\nimport type { LocalesValues } from '@intlayer/types/module_augmentation';\nimport { getCachedIntl } from '../utils/intl';\n\n/** Locally defined subset of Intl.ListFormatOptions so consumers don't need ES2021.Intl in their lib. */\nexport type ListFormatOptions = {\n  localeMatcher?: 'lookup' | 'best fit';\n  type?: 'conjunction' | 'disjunction' | 'unit';\n  style?: 'long' | 'short' | 'narrow';\n};\n\n/**\n * Formats an array of values into a localized list string using the Intl API.\n *\n * @example\n * list(['apple', 'banana', 'orange']);\n * // \"apple, banana, and orange\"\n *\n * @example\n * list(['red', 'green', 'blue'], { locale: Locales.FRENCH, type: 'disjunction' });\n * // \"rouge, vert ou bleu\"\n *\n * @example\n * list([1, 2, 3], { type: 'unit' });\n * // \"1, 2, 3\"\n */\nexport const list = (\n  values: (string | number)[],\n  options?: ListFormatOptions & { locale?: LocalesValues }\n): string =>\n  getCachedIntl(\n    'ListFormat',\n    options?.locale ?? internationalization?.defaultLocale,\n\n    {\n      type: options?.type ?? 'conjunction',\n      style: options?.style ?? 'long',\n      ...options,\n    }\n  ).format(values.map(String));\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,MAAa,QACX,QACA,YAEA,cACE,cACA,SAAS,UAAU,sBAAsB,eAEzC;CACE,MAAM,SAAS,QAAQ;CACvB,OAAO,SAAS,SAAS;CACzB,GAAG;AACL,CACF,CAAC,CAAC,OAAO,OAAO,IAAI,MAAM,CAAC"}

package/dist/types/@intlayer/core/dist/types/@intlayer/core/dist/types/@intlayer/core/dist/types/interpreter/getPlural.d.ts

@@ -1 +1 @@
-import "../intlayer/dist/types/index.js";
+import "../../../../../intlayer/dist/types/index.js";

package/dist/types/deepTransformPlugins/getEditedContent.d.ts

@@ -17,7 +17,7 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  *   'en'
  * ); // → { title: { nodeType: 'translation', translation: { en: 'New' } } }
  */
-declare const getEditedContent: (previousContent: ContentNode | undefined, newContent: ContentNode, defaultLocale: LocalesValues) => ContentNode;
+export declare const getEditedContent: (previousContent: ContentNode | undefined, newContent: ContentNode, defaultLocale: LocalesValues) => ContentNode;
 /**
  * Dictionary-level wrapper around {@link getEditedContent}. Returns a partial
  * dictionary (same `key`) whose `content` holds only the changed source nodes.
@@ -26,7 +26,6 @@ declare const getEditedContent: (previousContent: ContentNode | undefined, newCo
  * @param newDictionary - Dictionary state after the edit.
  * @param defaultLocale - The source locale to diff against.
  */
-declare const getEditedDictionary: (previousDictionary: Dictionary | undefined, newDictionary: Dictionary, defaultLocale: LocalesValues) => Dictionary;
+export declare const getEditedDictionary: (previousDictionary: Dictionary | undefined, newDictionary: Dictionary, defaultLocale: LocalesValues) => Dictionary;
 //#endregion
-export { getEditedContent, getEditedDictionary };
 //# sourceMappingURL=getEditedContent.d.ts.map

package/dist/types/deepTransformPlugins/getEditedContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEditedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getEditedContent.ts"],"mappings":";;;;;;;;;;;;;;;;;;;cA2Ka,mBAAgB,iBACV,yBAAuB,YAC5B,aAAW,eACR,kBACd;;;;;;;;;cAeU,sBAAmB,oBACV,wBAAsB,eAC3B,YAAU,eACV,kBACd"}
+{"version":3,"file":"getEditedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getEditedContent.ts"],"mappings":";;;;;;;;;;;;;;;;;;;qBA2Ka,mBAAgB,iBACV,yBAAuB,YAC5B,aAAW,eACR,kBACd;;;;;;;;;qBAeU,sBAAmB,oBACV,wBAAsB,eAC3B,YAAU,eACV,kBACd"}

package/dist/types/deepTransformPlugins/getFilterMissingTranslationsContent.d.ts

@@ -4,7 +4,7 @@ import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/deepTransformPlugins/getFilterMissingTranslationsContent.d.ts
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const filterMissingTranslationsOnlyPlugin: (localeToCheck: LocalesValues) => Plugins;
+export declare const filterMissingTranslationsOnlyPlugin: (localeToCheck: LocalesValues) => Plugins;
 /**
  * For each translation node, it compare is both localeToCheck and baseLocale are present.
  *
@@ -19,8 +19,8 @@ declare const filterMissingTranslationsOnlyPlugin: (localeToCheck: LocalesValues
  * { test2: t({ ar: 'Hello', en: 'Hello' }) } -> { test2: t({ ar: 'Hello', en: 'Hello' }) }
  *
  */
-declare const getFilterMissingTranslationsContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, localeToCheck: L, nodeProps: NodeProps) => any;
-declare const getFilterMissingTranslationsDictionary: (dictionary: Dictionary, localeToCheck: LocalesValues) => {
+export declare const getFilterMissingTranslationsContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, localeToCheck: L, nodeProps: NodeProps) => any;
+export declare const getFilterMissingTranslationsDictionary: (dictionary: Dictionary, localeToCheck: LocalesValues) => {
   $schema?: "https://intlayer.org/schema.json";
   id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
@@ -48,5 +48,4 @@ declare const getFilterMissingTranslationsDictionary: (dictionary: Dictionary, l
   content: any;
 };
 //#endregion
-export { filterMissingTranslationsOnlyPlugin, getFilterMissingTranslationsContent, getFilterMissingTranslationsDictionary };
 //# sourceMappingURL=getFilterMissingTranslationsContent.d.ts.map

package/dist/types/deepTransformPlugins/getFilterMissingTranslationsContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFilterMissingTranslationsContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilterMissingTranslationsContent.ts"],"mappings":";;;;;;cAoMa,sCAAmC,eAC/B,kBACd;;;;;;;;;;;;;;;cA6LU,sCACX,UAAU,aACV,UAAU,gBAAgB,iBAAe,MAEnC,GAAC,eACQ,GAAC,WACL;cAoBA,yCAAsC,YACrC,YAAU,eACP"}
+{"version":3,"file":"getFilterMissingTranslationsContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilterMissingTranslationsContent.ts"],"mappings":";;;;;;qBAoMa,sCAAmC,eAC/B,kBACd;;;;;;;;;;;;;;;qBA6LU,sCACX,UAAU,aACV,UAAU,gBAAgB,iBAAe,MAEnC,GAAC,eACQ,GAAC,WACL;qBAoBA,yCAAsC,YACrC,YAAU,eACP"}

package/dist/types/deepTransformPlugins/getFilterTranslationsOnlyContent.d.ts

@@ -4,15 +4,15 @@ import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/deepTransformPlugins/getFilterTranslationsOnlyContent.d.ts
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const filterTranslationsOnlyPlugin: (locale: LocalesValues, fallback?: LocalesValues) => Plugins;
+export declare const filterTranslationsOnlyPlugin: (locale: LocalesValues, fallback?: LocalesValues) => Plugins;
 /**
  * Return the content of a node with only the translation plugin.
  *
  * @param node The node to transform.
  * @param locale The locale to use if your transformers need it (e.g. for translations).
  */
-declare const getFilterTranslationsOnlyContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, locale: L, nodeProps: NodeProps, fallback?: LocalesValues) => DeepTransformContent<T>;
-declare const getFilterTranslationsOnlyDictionary: (dictionary: Dictionary, locale?: LocalesValues, fallback?: LocalesValues) => {
+export declare const getFilterTranslationsOnlyContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, locale: L, nodeProps: NodeProps, fallback?: LocalesValues) => DeepTransformContent<T>;
+export declare const getFilterTranslationsOnlyDictionary: (dictionary: Dictionary, locale?: LocalesValues, fallback?: LocalesValues) => {
   $schema?: "https://intlayer.org/schema.json";
   id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
@@ -40,5 +40,4 @@ declare const getFilterTranslationsOnlyDictionary: (dictionary: Dictionary, loca
   content: any;
 };
 //#endregion
-export { filterTranslationsOnlyPlugin, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary };
 //# sourceMappingURL=getFilterTranslationsOnlyContent.d.ts.map

package/dist/types/deepTransformPlugins/getFilterTranslationsOnlyContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFilterTranslationsOnlyContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilterTranslationsOnlyContent.ts"],"mappings":";;;;;;cAqCa,+BAA4B,QAC/B,eAAa,WACV,kBACV;;;;;;;cAoFU,mCACX,UAAU,aACV,UAAU,gBAAgB,iBAAe,MAEnC,GAAC,QACC,GAAC,WAEE,WAAS,WACT,kBAUL,qBAAqB;cAGhB,sCAAmC,YAClC,YAAU,SACd,eAAa,WAEV"}
+{"version":3,"file":"getFilterTranslationsOnlyContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilterTranslationsOnlyContent.ts"],"mappings":";;;;;;qBAqCa,+BAA4B,QAC/B,eAAa,WACV,kBACV;;;;;;;qBAoFU,mCACX,UAAU,aACV,UAAU,gBAAgB,iBAAe,MAEnC,GAAC,QACC,GAAC,WAEE,WAAS,WACT,kBAUL,qBAAqB;qBAGhB,sCAAmC,YAClC,YAAU,SACd,eAAa,WAEV"}

package/dist/types/deepTransformPlugins/getFilteredLocalesContent.d.ts

@@ -3,8 +3,8 @@ import "../interpreter/index.js";
 import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 //#region src/deepTransformPlugins/getFilteredLocalesContent.d.ts
-declare const getFilteredLocalesContent: (node: ContentNode, locales: LocalesValues | LocalesValues[], nodeProps: NodeProps) => any;
-declare const getFilteredLocalesDictionary: (dictionary: Dictionary, locale: LocalesValues | LocalesValues[]) => {
+export declare const getFilteredLocalesContent: (node: ContentNode, locales: LocalesValues | LocalesValues[], nodeProps: NodeProps) => any;
+export declare const getFilteredLocalesDictionary: (dictionary: Dictionary, locale: LocalesValues | LocalesValues[]) => {
   $schema?: "https://intlayer.org/schema.json";
   id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
@@ -32,5 +32,4 @@ declare const getFilteredLocalesDictionary: (dictionary: Dictionary, locale: Loc
   content: any;
 };
 //#endregion
-export { getFilteredLocalesContent, getFilteredLocalesDictionary };
 //# sourceMappingURL=getFilteredLocalesContent.d.ts.map

package/dist/types/deepTransformPlugins/getFilteredLocalesContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFilteredLocalesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilteredLocalesContent.ts"],"mappings":";;;;;cAuCa,4BAAyB,MAC9B,aAAW,SACR,gBAAgB,iBAAe,WAC7B;cAwBA,+BAA4B,YAC3B,YAAU,QACd,gBAAgB"}
+{"version":3,"file":"getFilteredLocalesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilteredLocalesContent.ts"],"mappings":";;;;;qBAuCa,4BAAyB,MAC9B,aAAW,SACR,gBAAgB,iBAAe,WAC7B;qBAwBA,+BAA4B,YAC3B,YAAU,QACd,gBAAgB"}

package/dist/types/deepTransformPlugins/getLocalizedContent.d.ts

@@ -11,8 +11,7 @@ import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentat
  * @param node The node to transform.
  * @param locale The locale to use if your transformers need it (e.g. for translations).
  */
-declare const getLocalizedContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, locale: L, nodeProps: NodeProps, fallback?: LocalesValues) => DeepTransformContent<T>;
-declare const getPerLocaleDictionary: <T extends Dictionary, L extends LocalesValues>(dictionary: T, locale: L, fallback?: LocalesValues) => Dictionary;
+export declare const getLocalizedContent: <T extends ContentNode, L extends LocalesValues = DeclaredLocales>(node: T, locale: L, nodeProps: NodeProps, fallback?: LocalesValues) => DeepTransformContent<T>;
+export declare const getPerLocaleDictionary: <T extends Dictionary, L extends LocalesValues>(dictionary: T, locale: L, fallback?: LocalesValues) => Dictionary;
 //#endregion
-export { getLocalizedContent, getPerLocaleDictionary };
 //# sourceMappingURL=getLocalizedContent.d.ts.map

package/dist/types/deepTransformPlugins/getLocalizedContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getLocalizedContent.ts"],"mappings":";;;;;;;;;;;;;cAqBa,sBACX,UAAU,aACV,UAAU,gBAAgB,iBAAe,MAEnC,GAAC,QACC,GAAC,WACE,WAAS,WACT,kBAUL,qBAAqB;cAGhB,yBACX,UAAU,YACV,UAAU,eAAa,YAEX,GAAC,QACL,GAAC,WACE,kBACV"}
+{"version":3,"file":"getLocalizedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getLocalizedContent.ts"],"mappings":";;;;;;;;;;;;;qBAqBa,sBACX,UAAU,aACV,UAAU,gBAAgB,iBAAe,MAEnC,GAAC,QACC,GAAC,WACE,WAAS,WACT,kBAUL,qBAAqB;qBAGhB,yBACX,UAAU,YACV,UAAU,eAAa,YAEX,GAAC,QACL,GAAC,WACE,kBACV"}

package/dist/types/deepTransformPlugins/getMaskContent.d.ts

@@ -3,8 +3,7 @@ import "../interpreter/index.js";
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/deepTransformPlugins/getMaskContent.d.ts
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const buildMaskPlugin: Plugins;
-declare const getMaskContent: (source: Dictionary) => any;
+export declare const buildMaskPlugin: Plugins;
+export declare const getMaskContent: (source: Dictionary) => any;
 //#endregion
-export { buildMaskPlugin, getMaskContent };
 //# sourceMappingURL=getMaskContent.d.ts.map

package/dist/types/deepTransformPlugins/getMaskContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMaskContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMaskContent.ts"],"mappings":";;;;;cAYa,iBAAiB;cAMjB,iBAAc,QAAY"}
+{"version":3,"file":"getMaskContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMaskContent.ts"],"mappings":";;;;;qBAYa,iBAAiB;qBAMjB,iBAAc,QAAY"}

package/dist/types/deepTransformPlugins/getMissingLocalesContent.d.ts

@@ -5,15 +5,14 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { Locale } from "@intlayer/types/allLocales";
 //#region src/deepTransformPlugins/getMissingLocalesContent.d.ts
 /** Translation plugin. Replaces node with a locale string if nodeType = Translation. */
-declare const checkMissingLocalesPlugin: (locales: Locale[], onMissingLocale: (locale: Locale) => void) => Plugins;
+export declare const checkMissingLocalesPlugin: (locales: Locale[], onMissingLocale: (locale: Locale) => void) => Plugins;
 /**
  * Return the content of a node with only the translation plugin.
  *
  * @param node The node to transform.
  * @param locales The locales to check for missing translations.
  */
-declare const getMissingLocalesContent: <T extends ContentNode>(node: T, locales: LocalesValues[], nodeProps: NodeProps) => Locale[];
-declare const getMissingLocalesContentFromDictionary: (dictionary: Dictionary, locales?: LocalesValues[]) => Locale[];
+export declare const getMissingLocalesContent: <T extends ContentNode>(node: T, locales: LocalesValues[], nodeProps: NodeProps) => Locale[];
+export declare const getMissingLocalesContentFromDictionary: (dictionary: Dictionary, locales?: LocalesValues[]) => Locale[];
 //#endregion
-export { checkMissingLocalesPlugin, getMissingLocalesContent, getMissingLocalesContentFromDictionary };
 //# sourceMappingURL=getMissingLocalesContent.d.ts.map

package/dist/types/deepTransformPlugins/getMissingLocalesContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMissingLocalesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMissingLocalesContent.ts"],"mappings":";;;;;;;cAiGa,4BAAyB,SAC3B,UAAQ,kBACC,QAAQ,oBACzB;;;;;;;cAuGU,2BAA4B,UAAU,aAAW,MACtD,GAAC,SACE,iBAAe,WAEb,cACV;cAuBU,yCAAsC,YACrC,YAAU,UACb,oBAAe"}
+{"version":3,"file":"getMissingLocalesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMissingLocalesContent.ts"],"mappings":";;;;;;;qBAiGa,4BAAyB,SAC3B,UAAQ,kBACC,QAAQ,oBACzB;;;;;;;qBAuGU,2BAA4B,UAAU,aAAW,MACtD,GAAC,SACE,iBAAe,WAEb,cACV;qBAuBU,yCAAsC,YACrC,YAAU,UACb,oBAAe"}

package/dist/types/deepTransformPlugins/getMultilingualDictionary.d.ts

@@ -25,7 +25,6 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * }
  * ```
  */
-declare const getMultilingualDictionary: (dictionary: Dictionary) => Dictionary;
+export declare const getMultilingualDictionary: (dictionary: Dictionary) => Dictionary;
 //#endregion
-export { getMultilingualDictionary };
 //# sourceMappingURL=getMultilingualDictionary.d.ts.map

package/dist/types/deepTransformPlugins/getMultilingualDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMultilingualDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCa,4BAAyB,YACxB,eACX"}
+{"version":3,"file":"getMultilingualDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMultilingualDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmCa,4BAAyB,YACxB,eACX"}

package/dist/types/deepTransformPlugins/getReplacedValuesContent.d.ts

@@ -2,7 +2,6 @@ import { NodeProps } from "../interpreter/getContent/plugins.js";
 import "../interpreter/index.js";
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/deepTransformPlugins/getReplacedValuesContent.d.ts
-declare const getReplacedValuesContent: (node: ContentNode, value: string | number | boolean, nodeProps: NodeProps) => any;
+export declare const getReplacedValuesContent: (node: ContentNode, value: string | number | boolean, nodeProps: NodeProps) => any;
 //#endregion
-export { getReplacedValuesContent };
 //# sourceMappingURL=getReplacedValuesContent.d.ts.map

package/dist/types/deepTransformPlugins/getReplacedValuesContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getReplacedValuesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getReplacedValuesContent.ts"],"mappings":";;;;cA8Da,2BAAwB,MAC7B,aAAW,kCACe,WACrB"}
+{"version":3,"file":"getReplacedValuesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getReplacedValuesContent.ts"],"mappings":";;;;qBA8Da,2BAAwB,MAC7B,aAAW,kCACe,WACrB"}

package/dist/types/deepTransformPlugins/getSplittedContent.d.ts

@@ -4,7 +4,7 @@ import { DeclaredLocales } from "@intlayer/types/module_augmentation";
 type SplittedContentOutput<T = ContentNode> = Record<DeclaredLocales, T> & {
   common: T;
 };
-declare const getSplittedContent: (content: ContentNode) => SplittedContentOutput;
+export declare const getSplittedContent: (content: ContentNode) => SplittedContentOutput;
 /**
  * Splits the `content` field of a Dictionary into "common" and per-locale buckets.
  *
@@ -36,7 +36,6 @@ declare const getSplittedContent: (content: ContentNode) => SplittedContentOutpu
  * @param dictionary - The input dictionary object with possible multilingual or common content.
  * @returns An object mapping "common" and each locale to their corresponding content subtrees.
  */
-declare const getSplittedDictionaryContent: (dictionary: Dictionary) => SplittedContentOutput<Dictionary['content']>;
+export declare const getSplittedDictionaryContent: (dictionary: Dictionary) => SplittedContentOutput<Dictionary['content']>;
 //#endregion
-export { getSplittedContent, getSplittedDictionaryContent };
 //# sourceMappingURL=getSplittedContent.d.ts.map

package/dist/types/deepTransformPlugins/getSplittedContent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getSplittedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getSplittedContent.ts"],"mappings":";;;KAIK,sBAAsB,IAAI,eAAe,OAAO,iBAAiB;EACpE,QAAQ;;cAsKG,qBAAkB,SACpB,gBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDU,+BAA4B,YAC3B,eACX,sBAAsB"}
+{"version":3,"file":"getSplittedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getSplittedContent.ts"],"mappings":";;;KAIK,sBAAsB,IAAI,eAAe,OAAO,iBAAiB;EACpE,QAAQ;;qBAsKG,qBAAkB,SACpB,gBACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAkDU,+BAA4B,YAC3B,eACX,sBAAsB"}

package/dist/types/deepTransformPlugins/insertContentInDictionary.d.ts

@@ -18,7 +18,6 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * // With locale - insert content for specific locale
  * insertContentInDictionary(dictionary, { title: 'このページ' }, 'ja')
  */
-declare const insertContentInDictionary: (dictionary: Dictionary, content: Dictionary['content'], locale?: LocalesValues) => Dictionary;
+export declare const insertContentInDictionary: (dictionary: Dictionary, content: Dictionary['content'], locale?: LocalesValues) => Dictionary;
 //#endregion
-export { insertContentInDictionary };
 //# sourceMappingURL=insertContentInDictionary.d.ts.map

package/dist/types/deepTransformPlugins/insertContentInDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insertContentInDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/insertContentInDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAkQa,4BAAyB,YACxB,YAAU,SACb,uBAAqB,SACrB,kBACR"}
+{"version":3,"file":"insertContentInDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/insertContentInDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAkQa,4BAAyB,YACxB,YAAU,SACb,uBAAqB,SACrB,kBACR"}

package/dist/types/dictionaryManipulator/editDictionaryByKeyPath.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/editDictionaryByKeyPath.d.ts
-declare const editDictionaryByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], newValue: ContentNode) => ContentNode;
+export declare const editDictionaryByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], newValue: ContentNode) => ContentNode;
 //#endregion
-export { editDictionaryByKeyPath };
 //# sourceMappingURL=editDictionaryByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/editDictionaryByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"editDictionaryByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"mappings":";;;cAMa,0BAAuB,mBACf,aAAW,SACrB,WAAS,UACR,gBACT"}
+{"version":3,"file":"editDictionaryByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"mappings":";;;qBAMa,0BAAuB,mBACf,aAAW,SACrB,WAAS,UACR,gBACT"}

package/dist/types/dictionaryManipulator/getContentNodeByKeyPath.d.ts

@@ -2,7 +2,6 @@ import { ContentNode } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { KeyPath } from "@intlayer/types/keyPath";
 //#region src/dictionaryManipulator/getContentNodeByKeyPath.d.ts
-declare const getContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], fallbackLocale?: LocalesValues) => ContentNode;
+export declare const getContentNodeByKeyPath: (dictionaryContent: ContentNode, keyPath: KeyPath[], fallbackLocale?: LocalesValues) => ContentNode;
 //#endregion
-export { getContentNodeByKeyPath };
 //# sourceMappingURL=getContentNodeByKeyPath.d.ts.map

package/dist/types/dictionaryManipulator/getContentNodeByKeyPath.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"mappings":";;;;cAKa,0BAAuB,mBACf,aAAW,SACrB,WAAS,iBACD,kBAChB"}
+{"version":3,"file":"getContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"mappings":";;;;qBAKa,0BAAuB,mBACf,aAAW,SACrB,WAAS,iBACD,kBAChB"}

package/dist/types/dictionaryManipulator/getDefaultNode.d.ts

@@ -2,7 +2,6 @@ import { ContentNode } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
 import { NodeType } from "@intlayer/types/nodeType";
 //#region src/dictionaryManipulator/getDefaultNode.d.ts
-declare const getDefaultNode: (nodeType: NodeType, locales: LocalesValues[], content?: ContentNode) => ContentNode;
+export declare const getDefaultNode: (nodeType: NodeType, locales: LocalesValues[], content?: ContentNode) => ContentNode;
 //#endregion
-export { getDefaultNode };
 //# sourceMappingURL=getDefaultNode.d.ts.map

package/dist/types/dictionaryManipulator/getDefaultNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;cAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}
+{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;qBAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}

package/dist/types/dictionaryManipulator/getEmptyNode.d.ts

@@ -1,6 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/getEmptyNode.d.ts
-declare const getEmptyNode: (section: ContentNode) => ContentNode;
+export declare const getEmptyNode: (section: ContentNode) => ContentNode;
 //#endregion
-export { getEmptyNode };
 //# sourceMappingURL=getEmptyNode.d.ts.map

package/dist/types/dictionaryManipulator/getEmptyNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getEmptyNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"mappings":";;cAIa,eAAY,SAAa,gBAAc"}
+{"version":3,"file":"getEmptyNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getEmptyNode.ts"],"mappings":";;qBAIa,eAAY,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/getNestedDictionaryReferences.d.ts

@@ -7,7 +7,7 @@
  * (`nest('common')` without a path), so no field of that dictionary may be
  * dropped.
  */
-type NestedFieldReferences = Set<string> | 'all';
+export type NestedFieldReferences = Set<string> | 'all';
 /**
  * Walks a dictionary tree and collects every dictionary referenced through a
  * `nest()` node, together with the top-level fields those references read.
@@ -26,14 +26,14 @@ type NestedFieldReferences = Set<string> | 'all';
  * // Map { 'common' => Set { 'period' } }
  * ```
  */
-declare const getNestedDictionaryReferences: (dictionaries: Iterable<unknown>) => Map<string, NestedFieldReferences>;
+export declare const getNestedDictionaryReferences: (dictionaries: Iterable<unknown>) => Map<string, NestedFieldReferences>;
 /**
  * Keys of every dictionary referenced through a `nest()` node.
  *
  * @param dictionaries - Dictionary objects (or any content subtree) to scan.
  * @returns Set of nest-target dictionary keys.
  */
-declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>) => Set<string>;
+export declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>) => Set<string>;
 /**
  * Builds the `nest()` dependency graph of a set of dictionaries: for each
  * dictionary key, the keys of every dictionary it needs in order to resolve its
@@ -56,7 +56,6 @@ declare const getNestedDictionaryKeys: (dictionaries: Iterable<unknown>) => Set<
  * // Map { 'dashboard' => Set { 'common', 'labels' }, 'common' => Set { 'labels' } }
  * ```
  */
-declare const getNestedDictionaryGraph: (dictionaries: Iterable<unknown>) => Map<string, Set<string>>;
+export declare const getNestedDictionaryGraph: (dictionaries: Iterable<unknown>) => Map<string, Set<string>>;
 //#endregion
-export { NestedFieldReferences, getNestedDictionaryGraph, getNestedDictionaryKeys, getNestedDictionaryReferences };
 //# sourceMappingURL=getNestedDictionaryReferences.d.ts.map

package/dist/types/dictionaryManipulator/getNestedDictionaryReferences.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNestedDictionaryReferences.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"mappings":";;;;;;;;;KAUY,wBAAwB;;;;;;;;;;;;;;;;;;;cAkEvB,gCAA6B,cAC1B,sBACb,YAAY;;;;;;;cAkDF,0BAAuB,cACpB,sBACb;;;;;;;;;;;;;;;;;;;;;;;cAyDU,2BAAwB,cACrB,sBACb,YAAY"}
+{"version":3,"file":"getNestedDictionaryReferences.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNestedDictionaryReferences.ts"],"mappings":";;;;;;;;;YAUY,wBAAwB;;;;;;;;;;;;;;;;;;;qBAkEvB,gCAA6B,cAC1B,sBACb,YAAY;;;;;;;qBAkDF,0BAAuB,cACpB,sBACb;;;;;;;;;;;;;;;;;;;;;;;qBAyDU,2BAAwB,cACrB,sBACb,YAAY"}

package/dist/types/dictionaryManipulator/getNodeChildren.d.ts

@@ -1,6 +1,5 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/getNodeChildren.d.ts
-declare const getNodeChildren: (section: ContentNode) => ContentNode;
+export declare const getNodeChildren: (section: ContentNode) => ContentNode;
 //#endregion
-export { getNodeChildren };
 //# sourceMappingURL=getNodeChildren.d.ts.map

package/dist/types/dictionaryManipulator/getNodeChildren.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"mappings":";;cAIa,kBAAe,SAAa,gBAAc"}
+{"version":3,"file":"getNodeChildren.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeChildren.ts"],"mappings":";;qBAIa,kBAAe,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/getNodeType.d.ts

@@ -1,7 +1,6 @@
 import { ContentNode } from "@intlayer/types/dictionary";
 import { NodeType } from "@intlayer/types/nodeType";
 //#region src/dictionaryManipulator/getNodeType.d.ts
-declare const getNodeType: (content: ContentNode) => NodeType;
+export declare const getNodeType: (content: ContentNode) => NodeType;
 //#endregion
-export { getNodeType };
 //# sourceMappingURL=getNodeType.d.ts.map

package/dist/types/dictionaryManipulator/getNodeType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;cAsDa,cAAW,SAAa,gBAAc"}
+{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;qBAsDa,cAAW,SAAa,gBAAc"}

package/dist/types/dictionaryManipulator/mergeDictionaries.d.ts

@@ -1,6 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 //#region src/dictionaryManipulator/mergeDictionaries.d.ts
-declare const mergeDictionaries: (dictionaries: Dictionary[]) => Dictionary;
+export declare const mergeDictionaries: (dictionaries: Dictionary[]) => Dictionary;
 //#endregion
-export { mergeDictionaries };
 //# sourceMappingURL=mergeDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/mergeDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";;cAqKa,oBAAiB,cAAkB,iBAAe"}
+{"version":3,"file":"mergeDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeDictionaries.ts"],"mappings":";;qBAqKa,oBAAiB,cAAkB,iBAAe"}

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts

@@ -18,7 +18,6 @@ import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary
  * Every qualified entry must declare ALL dimensions of the group; an entry that
  * declares only a subset is ambiguous and is rejected with an error log.
  */
-declare const mergeQualifiedDictionaries: (dictionaries: Dictionary[]) => Dictionary | QualifiedDictionaryGroup;
+export declare const mergeQualifiedDictionaries: (dictionaries: Dictionary[]) => Dictionary | QualifiedDictionaryGroup;
 //#endregion
-export { mergeQualifiedDictionaries };
 //# sourceMappingURL=mergeQualifiedDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/mergeQualifiedDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAoCa,6BAA0B,cACvB,iBACb,aAAa"}
+{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;qBAoCa,6BAA0B,cACvB,iBACb,aAAa"}

package/dist/types/dictionaryManipulator/normalizeDictionary.d.ts

@@ -1,8 +1,7 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { IntlayerConfig } from "@intlayer/types/config";
 //#region src/dictionaryManipulator/normalizeDictionary.d.ts
-declare const normalizeDictionary: (dictionary: Dictionary, configuration: IntlayerConfig) => Dictionary;
-declare const normalizeDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Dictionary[];
+export declare const normalizeDictionary: (dictionary: Dictionary, configuration: IntlayerConfig) => Dictionary;
+export declare const normalizeDictionaries: (dictionaries: Dictionary[], configuration: IntlayerConfig) => Dictionary[];
 //#endregion
-export { normalizeDictionaries, normalizeDictionary };
 //# sourceMappingURL=normalizeDictionary.d.ts.map

package/dist/types/dictionaryManipulator/normalizeDictionary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;cAOa,sBAAmB,YAClB,YAAU,eACP,mBACd;cAmCU,wBAAqB,cAClB,cAAY,eACX,mBACd"}
+{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;qBAOa,sBAAmB,YAClB,YAAU,eACP,mBACd;qBAmCU,wBAAqB,cAClB,cAAY,eACX,mBACd"}

package/dist/types/dictionaryManipulator/orderDictionaries.d.ts

@@ -7,11 +7,10 @@ import { Dictionary } from "@intlayer/types/dictionary";
  * @param priorityStrategy - The priority strategy ('local_first' or 'distant_first')
  * @returns Ordered array of dictionaries
  */
-declare const orderDictionaries: (dictionaries: Dictionary[], config?: {
+export declare const orderDictionaries: (dictionaries: Dictionary[], config?: {
   editor: {
     dictionaryPriorityStrategy: 'local_first' | 'distant_first';
   };
 }) => Dictionary[];
 //#endregion
-export { orderDictionaries };
 //# sourceMappingURL=orderDictionaries.d.ts.map

package/dist/types/dictionaryManipulator/orderDictionaries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;;cAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}
+{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;;qBAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}

package/dist/types/dictionaryManipulator/plainDynamicLoader.d.ts

@@ -5,11 +5,11 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * Default export shape of a generated dynamic entry point for a plain (non
  * qualified) key: one lazy chunk loader per emitted locale.
  */
-type PlainDynamicLoaderMap<T extends Dictionary = Dictionary> = {
+export type PlainDynamicLoaderMap<T extends Dictionary = Dictionary> = {
   [locale: string]: (() => Promise<T>) | undefined;
 };
 /** A chunk loader together with the locale it was emitted for. */
-type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {
+export type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {
   /**
    * Locale the returned loader actually serves, which differs from the
    * requested one whenever the fallback chain was walked.
@@ -31,7 +31,7 @@ type ResolvedDynamicLoader<T extends Dictionary = Dictionary> = {
  * @returns The loader to invoke and the locale its chunk holds, or `undefined`
  *          when the map holds no chunk for the locale nor for any fallback.
  */
-declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, locale: LocalesValues) => ResolvedDynamicLoader<T> | undefined;
+export declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, locale: LocalesValues) => ResolvedDynamicLoader<T> | undefined;
 /**
  * {@link findPlainDynamicLoader}, for callers that cannot render without a
  * chunk and would otherwise fail on an `undefined` loader with an error naming
@@ -44,7 +44,6 @@ declare const findPlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDyn
  * @throws When neither the locale nor any of its fallbacks has a chunk, which
  *         only happens on a malformed or empty entry point.
  */
-declare const resolvePlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, key: string, locale: LocalesValues) => ResolvedDynamicLoader<T>;
+export declare const resolvePlainDynamicLoader: <T extends Dictionary>(loaderMap: PlainDynamicLoaderMap<T>, key: string, locale: LocalesValues) => ResolvedDynamicLoader<T>;
 //#endregion
-export { PlainDynamicLoaderMap, ResolvedDynamicLoader, findPlainDynamicLoader, resolvePlainDynamicLoader };
 //# sourceMappingURL=plainDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/plainDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plainDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"mappings":";;;;;;;KAUY,sBAAsB,UAAU,aAAa;GACtD,wBAAwB,QAAQ;;;KAIvB,sBAAsB,UAAU,aAAa;;;;;EAKvD,QAAQ;EACR,cAAc,QAAQ;;;;;;;;;;;;;;;;cA4CX,yBAA0B,UAAU,YAAU,WAC9C,sBAAsB,IAAE,QAC3B,kBACP,sBAAsB;;;;;;;;;;;;;cAgCZ,4BAA6B,UAAU,YAAU,WACjD,sBAAsB,IAAE,aACxB,QACH,kBACP,sBAAsB"}
+{"version":3,"file":"plainDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/plainDynamicLoader.ts"],"mappings":";;;;;;;YAUY,sBAAsB,UAAU,aAAa;GACtD,wBAAwB,QAAQ;;;YAIvB,sBAAsB,UAAU,aAAa;;;;;EAKvD,QAAQ;EACR,cAAc,QAAQ;;;;;;;;;;;;;;;;qBA4CX,yBAA0B,UAAU,YAAU,WAC9C,sBAAsB,IAAE,QAC3B,kBACP,sBAAsB;;;;;;;;;;;;;qBAgCZ,4BAA6B,UAAU,YAAU,WACjD,sBAAsB,IAAE,aACxB,QACH,kBACP,sBAAsB"}

package/dist/types/dictionaryManipulator/preloadedDynamicLoader.d.ts

@@ -10,12 +10,12 @@ import { PRELOADED_DYNAMIC_KEY } from "@intlayer/config/defaultValues";
  * (a client-side locale switch, or a resolution the provider overrode) falls
  * back to loading rather than serving content in the wrong language.
  */
-type PreloadedDynamicEntry = {
+export type PreloadedDynamicEntry = {
   locale: LocalesValues;
   dictionary: Dictionary;
 };
 /** A plain dynamic loader map that may carry a preloaded entry. */
-type PreloadableDynamicLoaderMap = {
+export type PreloadableDynamicLoaderMap = {
   [PRELOADED_DYNAMIC_KEY]?: PreloadedDynamicEntry;
 };
 /**
@@ -32,7 +32,7 @@ type PreloadableDynamicLoaderMap = {
  * @param locale - Locale the caller is about to render.
  * @returns The dictionary when it was preloaded for `locale`, else `undefined`.
  */
-declare const getPreloadedDictionary: (loaderMap: unknown, locale: LocalesValues) => Dictionary | undefined;
+export declare const getPreloadedDictionary: (loaderMap: unknown, locale: LocalesValues) => Dictionary | undefined;
 //#endregion
-export { PRELOADED_DYNAMIC_KEY, PreloadableDynamicLoaderMap, PreloadedDynamicEntry, getPreloadedDictionary };
+export { PRELOADED_DYNAMIC_KEY };
 //# sourceMappingURL=preloadedDynamicLoader.d.ts.map

package/dist/types/dictionaryManipulator/preloadedDynamicLoader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;;KAoBY;EACV,QAAQ;EACR,YAAY;;;KAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;cAiBf,yBAAsB,oBACf,QACV,kBACP"}
+{"version":3,"file":"preloadedDynamicLoader.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/preloadedDynamicLoader.ts"],"mappings":";;;;;;;;;;;;YAoBY;EACV,QAAQ;EACR,YAAY;;;YAIF;GACT,yBAAyB;;;;;;;;;;;;;;;;qBAiBf,yBAAsB,oBACf,QACV,kBACP"}