@intlayer/core 9.4.2 → 9.4.4

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"}

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

@@ -5,13 +5,13 @@ import { LocalesValues } from "@intlayer/types/module_augmentation";
  * Separator joining per-dimension ids into a composite entry id. Also used as
  * the chunk path separator in dynamic mode.
  */
-declare const COMPOSITE_ID_SEPARATOR = "/";
+export declare const COMPOSITE_ID_SEPARATOR = "/";
 /**
  * Identity of the implicit fallback variant. A selector that pins no variant
  * resolves to it, and a variant that declares no entry of its own falls back to
  * it — so a key only has to ship the entries that actually differ.
  */
-declare const DEFAULT_VARIANT_ID = "default";
+export declare const DEFAULT_VARIANT_ID = "default";
 /**
  * Canonical serialization of a single variant value into its identity string —
  * the variant segment of a composite id, the chunk directory name in dynamic
@@ -30,7 +30,7 @@ declare const DEFAULT_VARIANT_ID = "default";
  * Two variants resolve to the same entry iff their serializations are equal, so
  * an object variant in a selector must equal the one declared on the dictionary.
  */
-declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
+export declare const serializeVariant: (variant: DictionaryVariantValue | undefined) => string;
 /**
  * Serializes the variant coordinate of a selector into the ordered list of
  * candidate ids to try, so a single value and a preference chain share one code
@@ -43,7 +43,7 @@ declare const serializeVariant: (variant: DictionaryVariantValue | undefined) =>
  * An empty chain is treated as "no variant pinned" (`['default']`) rather than
  * as an unsatisfiable request.
  */
-declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
+export declare const serializeVariantChain: (variant: DictionaryVariantChain | undefined) => string[];
 /**
  * Resolves the variant id a selector actually targets among the ids a key
  * declares — the sparse-override fallback.
@@ -59,13 +59,13 @@ declare const serializeVariantChain: (variant: DictionaryVariantChain | undefine
  *                              list).
  * @param isVariantIdDeclared - Whether the key declares an entry for an id.
  */
-declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
+export declare const resolveEffectiveVariantId: (requestedVariantIds: string[], isVariantIdDeclared: (variantId: string) => boolean) => string;
 /**
  * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
  * qualified key) from a plain `Dictionary`. Both carry a `content` field; only
  * the group declares `qualifierTypes`, which is therefore the discriminator.
  */
-declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
+export declare const isQualifiedDictionaryGroup: (value: unknown) => value is QualifiedDictionaryGroup;
 /**
  * Reconstructs a resolvable {@link Dictionary} from a single entry of a
  * qualified group: the content node stored under its composite id, plus the
@@ -77,7 +77,7 @@ declare const isQualifiedDictionaryGroup: (value: unknown) => value is Qualified
  * its serialized (encoded) form, e.g. `'id=abc&userId=123'` — matching happens
  * on the composite id segments, never on this reconstructed field.
  */
-declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
+export declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compositeId: string) => Dictionary;
 /**
  * Resolves a dictionary (or qualified dictionary group) against a selector,
  * across every declared dimension.
@@ -93,12 +93,12 @@ declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compo
  * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
  * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
  */
-declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
+export declare const resolveQualifiedDictionary: (dictionaryOrGroup: Dictionary | QualifiedDictionaryGroup, selector?: DictionarySelector) => Dictionary | Dictionary[] | null;
 /**
  * Splits the second argument of `getIntlayer` / `getDictionary` into the
  * effective locale and the selector object (if any).
  */
-declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
+export declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelector?: L | DictionarySelector) => {
   locale?: L;
   selector?: DictionarySelector;
 };
@@ -117,7 +117,7 @@ declare const parseDictionarySelector: <L extends LocalesValues>(localeOrSelecto
  * @param providerVariant - The `variant` prop of the surrounding provider.
  * @param dictionaryKey - The key being read.
  */
-declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefined, dictionaryKey: string) => DictionaryVariantChain | undefined;
+export declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefined, dictionaryKey: string) => DictionaryVariantChain | undefined;
 /**
  * Builds the effective second argument of a dictionary read by layering the
  * provider defaults under the call-site one — the single place the `locale` and
@@ -132,7 +132,7 @@ declare const resolveProviderVariant: (providerVariant: ProviderVariant | undefi
  * so the existing fast path — and the cache keys built from it — are unchanged
  * for projects that never use variants.
  */
-declare const resolveDictionaryArgument: (params: {
+export declare const resolveDictionaryArgument: (params: {
   localeOrSelector?: LocalesValues | DictionarySelector;
   contextLocale?: LocalesValues;
   contextVariant?: ProviderVariant;
@@ -142,7 +142,6 @@ declare const resolveDictionaryArgument: (params: {
  * Builds a stable string identity of a selector (excluding `locale`), suitable
  * for cache keys and memoization dependencies.
  */
-declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
+export declare const getDictionarySelectorCacheKey: (selector?: DictionarySelector) => string;
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, DEFAULT_VARIANT_ID, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, parseDictionarySelector, reconstructQualifiedEntry, resolveDictionaryArgument, resolveEffectiveVariantId, resolveProviderVariant, resolveQualifiedDictionary, serializeVariant, serializeVariantChain };
 //# sourceMappingURL=qualifiedDictionary.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;cAgBa;;;;;;cAOA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;;;;;;cA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;cA0BE,4BAAyB,+BACP,sBACP;;;;;;cA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;cAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;cA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;cA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;cAqCP,gCAA6B,WAC7B"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;qBAgBa;;;;;;qBAOA;;;;;;;;;;;;;;;;;;;qBAqDA,mBAAgB,SAClB;;;;;;;;;;;;;qBA4BE,wBAAqB,SACvB;;;;;;;;;;;;;;;;qBA0BE,4BAAyB,+BACP,sBACP;;;;;;qBA4CX,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;qBAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;;;qBAkCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;qBAoDH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;;;;;;;;;;;;qBA0Bf,yBAAsB,iBAChB,6BAA2B,0BAE3C;;;;;;;;;;;;;;;qBA0BU,4BAAyB;EACpC,mBAAmB,gBAAgB;EACnC,gBAAgB;EAChB,iBAAiB;EACjB;MACE,gBAAgB;;;;;qBAqCP,gCAA6B,WAC7B"}