@intlayer/core 9.0.0-canary.2 → 9.0.0-canary.20

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

@@ -1,8 +1,7 @@
 import { DeepTransformContent, NodeProps, Plugins } from "../interpreter/getContent/plugins.js";
+import "../interpreter/index.js";
 import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-import * as _$_intlayer_types0 from "@intlayer/types";
-
 //#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;
@@ -14,14 +13,13 @@ declare const filterTranslationsOnlyPlugin: (locale: LocalesValues, fallback?: L
  */
 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) => {
-  content: any;
   $schema?: "https://intlayer.org/schema.json";
-  id?: _$_intlayer_types0.DictionaryId;
+  id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
-  localId?: _$_intlayer_types0.LocalDictionaryId;
-  localIds?: _$_intlayer_types0.LocalDictionaryId[];
-  format?: _$_intlayer_types0.DictionaryFormat;
-  key: _$_intlayer_types0.DictionaryKey;
+  localId?: import("@intlayer/types").LocalDictionaryId;
+  localIds?: import("@intlayer/types").LocalDictionaryId[];
+  format?: import("@intlayer/types").DictionaryFormat;
+  key: import("@intlayer/types").DictionaryKey;
   title?: string;
   description?: string;
   versions?: string[];
@@ -29,16 +27,16 @@ declare const getFilterTranslationsOnlyDictionary: (dictionary: Dictionary, loca
   filePath?: string;
   tags?: string[];
   item?: number;
-  variant?: string;
-  meta?: _$_intlayer_types0.DictionaryMeta;
+  variant?: import("@intlayer/types").DictionaryVariantValue | import("@intlayer/types").DictionaryVariantValue[];
   locale?: LocalesValues;
-  contentAutoTransformation?: _$_intlayer_types0.ContentAutoTransformation;
-  fill?: _$_intlayer_types0.Fill;
+  contentAutoTransformation?: import("@intlayer/types").ContentAutoTransformation;
+  fill?: import("@intlayer/types").Fill;
   filled?: true;
   priority?: number;
-  importMode?: _$_intlayer_types0.ImportMode;
-  location?: _$_intlayer_types0.DictionaryLocation;
+  importMode?: import("@intlayer/types").ImportMode;
+  location?: import("@intlayer/types").DictionaryLocation;
   schema: undefined;
+  content: any;
 };
 //#endregion
 export { filterTranslationsOnlyPlugin, getFilterTranslationsOnlyContent, getFilterTranslationsOnlyDictionary };

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

@@ -1 +1 @@
-{"version":3,"file":"getFilterTranslationsOnlyContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilterTranslationsOnlyContent.ts"],"mappings":";;;;;;;cAqCa,4BAAA,GACX,MAAA,EAAQ,aAAA,EACR,QAAA,GAAW,aAAA,KACV,OAAA;;;AAHH;;;;cAuFa,gCAAA,aACD,WAAA,YACA,aAAA,GAAgB,eAAA,EAE1B,IAAA,EAAM,CAAA,EACN,MAAA,EAAQ,CAAA,EAER,SAAA,EAAW,SAAA,EACX,QAAA,GAAW,aAAA,KAUL,oBAAA,CAAqB,CAAA;AAAA,cAGhB,mCAAA,GACX,UAAA,EAAY,UAAA,EACZ,MAAA,GAAQ,aAAA,EAER,QAAA,GAAW,aAAA;;;OAAa,kBAAA,CAAA,YAAA"}
+{"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"}

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

@@ -1,19 +1,17 @@
 import { NodeProps } from "../interpreter/getContent/plugins.js";
+import "../interpreter/index.js";
 import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-import * as _$_intlayer_types0 from "@intlayer/types";
-
 //#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[]) => {
-  content: any;
   $schema?: "https://intlayer.org/schema.json";
-  id?: _$_intlayer_types0.DictionaryId;
+  id?: import("@intlayer/types").DictionaryId;
   projectIds?: string[];
-  localId?: _$_intlayer_types0.LocalDictionaryId;
-  localIds?: _$_intlayer_types0.LocalDictionaryId[];
-  format?: _$_intlayer_types0.DictionaryFormat;
-  key: _$_intlayer_types0.DictionaryKey;
+  localId?: import("@intlayer/types").LocalDictionaryId;
+  localIds?: import("@intlayer/types").LocalDictionaryId[];
+  format?: import("@intlayer/types").DictionaryFormat;
+  key: import("@intlayer/types").DictionaryKey;
   title?: string;
   description?: string;
   versions?: string[];
@@ -21,16 +19,16 @@ declare const getFilteredLocalesDictionary: (dictionary: Dictionary, locale: Loc
   filePath?: string;
   tags?: string[];
   item?: number;
-  variant?: string;
-  meta?: _$_intlayer_types0.DictionaryMeta;
+  variant?: import("@intlayer/types").DictionaryVariantValue | import("@intlayer/types").DictionaryVariantValue[];
   locale?: LocalesValues;
-  contentAutoTransformation?: _$_intlayer_types0.ContentAutoTransformation;
-  fill?: _$_intlayer_types0.Fill;
+  contentAutoTransformation?: import("@intlayer/types").ContentAutoTransformation;
+  fill?: import("@intlayer/types").Fill;
   filled?: true;
   priority?: number;
-  importMode?: _$_intlayer_types0.ImportMode;
-  location?: _$_intlayer_types0.DictionaryLocation;
+  importMode?: import("@intlayer/types").ImportMode;
+  location?: import("@intlayer/types").DictionaryLocation;
   schema: undefined;
+  content: any;
 };
 //#endregion
 export { getFilteredLocalesContent, getFilteredLocalesDictionary };

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

@@ -1 +1 @@
-{"version":3,"file":"getFilteredLocalesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getFilteredLocalesContent.ts"],"mappings":";;;;;;cAuCa,yBAAA,GACX,IAAA,EAAM,WAAA,EACN,OAAA,EAAS,aAAA,GAAgB,aAAA,IACzB,SAAA,EAAW,SAAA;AAAA,cAwBA,4BAAA,GACX,UAAA,EAAY,UAAA,EACZ,MAAA,EAAQ,aAAA,GAAgB,aAAA;;;OAAa,kBAAA,CAAA,YAAA"}
+{"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"}

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

@@ -1,7 +1,7 @@
 import { DeepTransformContent, NodeProps } from "../interpreter/getContent/plugins.js";
+import "../interpreter/index.js";
 import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { DeclaredLocales, LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/deepTransformPlugins/getLocalizedContent.d.ts
 /**
  * Transforms a node in a single pass, applying each plugin as needed.

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

@@ -1 +1 @@
-{"version":3,"file":"getLocalizedContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getLocalizedContent.ts"],"mappings":";;;;;;;;AAqBA;;;;;cAAa,mBAAA,aACD,WAAA,YACA,aAAA,GAAgB,eAAA,EAE1B,IAAA,EAAM,CAAA,EACN,MAAA,EAAQ,CAAA,EACR,SAAA,EAAW,SAAA,EACX,QAAA,GAAW,aAAA,KAUL,oBAAA,CAAqB,CAAA;AAAA,cAGhB,sBAAA,aACD,UAAA,YACA,aAAA,EAEV,UAAA,EAAY,CAAA,EACZ,MAAA,EAAQ,CAAA,EACR,QAAA,GAAW,aAAA,KACV,UAAA"}
+{"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"}

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

@@ -1,6 +1,6 @@
 import { Plugins } from "../interpreter/getContent/plugins.js";
+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;

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

@@ -1 +1 @@
-{"version":3,"file":"getMaskContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMaskContent.ts"],"mappings":";;;;;cAYa,eAAA,EAAiB,OAAA;AAAA,cAMjB,cAAA,GAAkB,MAAA,EAAQ,UAAA"}
+{"version":3,"file":"getMaskContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMaskContent.ts"],"mappings":";;;;;cAYa,iBAAiB;cAMjB,iBAAc,QAAY"}

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

@@ -1,8 +1,8 @@
 import { NodeProps, Plugins } from "../interpreter/getContent/plugins.js";
+import "../interpreter/index.js";
 import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 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;

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

@@ -1 +1 @@
-{"version":3,"file":"getMissingLocalesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMissingLocalesContent.ts"],"mappings":";;;;;;;cAiGa,yBAAA,GACX,OAAA,EAAS,MAAA,IACT,eAAA,GAAkB,MAAA,EAAQ,MAAA,cACzB,OAAA;;AAHH;;;;;cA0Ga,wBAAA,aAAsC,WAAA,EACjD,IAAA,EAAM,CAAA,EACN,OAAA,EAAS,aAAA,IAET,SAAA,EAAW,SAAA,KACV,MAAA;AAAA,cAuBU,sCAAA,GACX,UAAA,EAAY,UAAA,EACZ,OAAA,GAAS,aAAA,OAA+C,MAAA"}
+{"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"}

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

@@ -1,5 +1,4 @@
 import { Dictionary } from "@intlayer/types/dictionary";
-
 //#region src/deepTransformPlugins/getMultilingualDictionary.d.ts
 /**
  * Transform a per-locale dictionary into a multilingual dictionary.

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

@@ -1 +1 @@
-{"version":3,"file":"getMultilingualDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMultilingualDictionary.ts"],"mappings":";;;;;AAmCA;;;;;;;;;;;;;;;;;;;;;;;cAAa,yBAAA,GACX,UAAA,EAAY,UAAA,KACX,UAAA"}
+{"version":3,"file":"getMultilingualDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getMultilingualDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCa,4BAAyB,YACxB,eACX"}

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

@@ -1,6 +1,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;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"getReplacedValuesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getReplacedValuesContent.ts"],"mappings":";;;;cA8Da,wBAAA,GACX,IAAA,EAAM,WAAA,EACN,KAAA,6BACA,SAAA,EAAW,SAAA"}
+{"version":3,"file":"getReplacedValuesContent.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/getReplacedValuesContent.ts"],"mappings":";;;;cA8Da,2BAAwB,MAC7B,aAAW,kCACe,WACrB"}

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

@@ -1,6 +1,5 @@
 import { ContentNode, Dictionary } from "@intlayer/types/dictionary";
 import { DeclaredLocales } from "@intlayer/types/module_augmentation";
-
 //#region src/deepTransformPlugins/getSplittedContent.d.ts
 type SplittedContentOutput<T = ContentNode> = Record<DeclaredLocales, T> & {
   common: T;
@@ -37,7 +36,7 @@ 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"]>;
+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,qBAAA,KAA0B,WAAA,IAAe,MAAA,CAAO,eAAA,EAAiB,CAAA;EACpE,MAAA,EAAQ,CAAA;AAAA;AAAA,cAsKG,kBAAA,GACX,OAAA,EAAS,WAAA,KACR,qBAAA;;;;;;;;;;;;;;;;;;AAFH;;;;;;;;;AAoDA;;;;;cAAa,4BAAA,GACX,UAAA,EAAY,UAAA,KACX,qBAAA,CAAsB,UAAA"}
+{"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"}

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

@@ -1,6 +1,5 @@
 import { Dictionary } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/deepTransformPlugins/insertContentInDictionary.d.ts
 /**
  * Insert content into a dictionary with deep merge support
@@ -19,7 +18,7 @@ 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;
+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":";;;;;;AAkQA;;;;;;;;;;;;;;;cAAa,yBAAA,GACX,UAAA,EAAY,UAAA,EACZ,OAAA,EAAS,UAAA,aACT,MAAA,GAAS,aAAA,KACR,UAAA"}
+{"version":3,"file":"insertContentInDictionary.d.ts","names":[],"sources":["../../../src/deepTransformPlugins/insertContentInDictionary.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;cAkQa,4BAAyB,YACxB,YAAU,SACb,uBAAqB,SACrB,kBACR"}

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

@@ -1,6 +1,5 @@
 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;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"editDictionaryByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"mappings":";;;;cAMa,uBAAA,GACX,iBAAA,EAAmB,WAAA,EACnB,OAAA,EAAS,OAAA,IACT,QAAA,EAAU,WAAA,KACT,WAAA"}
+{"version":3,"file":"editDictionaryByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/editDictionaryByKeyPath.ts"],"mappings":";;;cAMa,0BAAuB,mBACf,aAAW,SACrB,WAAS,UACR,gBACT"}

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

@@ -1,7 +1,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;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"getContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"mappings":";;;;;cAKa,uBAAA,GACX,iBAAA,EAAmB,WAAA,EACnB,OAAA,EAAS,OAAA,IACT,cAAA,GAAiB,aAAA,KAChB,WAAA"}
+{"version":3,"file":"getContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getContentNodeByKeyPath.ts"],"mappings":";;;;cAKa,0BAAuB,mBACf,aAAW,SACrB,WAAS,iBACD,kBAChB"}

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

@@ -1,7 +1,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;
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;;cAMa,cAAA,GACX,QAAA,EAAU,QAAA,EACV,OAAA,EAAS,aAAA,IACT,OAAA,GAAU,WAAA,KACT,WAAA"}
+{"version":3,"file":"getDefaultNode.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getDefaultNode.ts"],"mappings":";;;;cAMa,iBAAc,UACf,UAAQ,SACT,iBAAe,UACd,gBACT"}

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

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

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

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

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

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

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

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;;cA4Ca,WAAA,GAAe,OAAA,EAAS,WAAA,KAAc,QAAA"}
+{"version":3,"file":"getNodeType.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/getNodeType.ts"],"mappings":";;;cA4Ca,cAAW,SAAa,gBAAc"}

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

@@ -8,8 +8,8 @@ import { mergeDictionaries } from "./mergeDictionaries.js";
 import { mergeQualifiedDictionaries } from "./mergeQualifiedDictionaries.js";
 import { normalizeDictionaries, normalizeDictionary } from "./normalizeDictionary.js";
 import { orderDictionaries } from "./orderDictionaries.js";
-import { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync } from "./qualifiedDictionary.js";
+import { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant } from "./qualifiedDictionary.js";
 import { removeContentNodeByKeyPath } from "./removeContentNodeByKeyPath.js";
 import { renameContentNodeByKeyPath } from "./renameContentNodeByKeyPath.js";
 import { updateNodeChildren } from "./updateNodeChildren.js";
-export { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, editDictionaryByKeyPath, getContentNodeByKeyPath, getDefaultNode, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEmptyNode, getNodeChildren, getNodeType, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, mergeDictionaries, mergeQualifiedDictionaries, normalizeDictionaries, normalizeDictionary, orderDictionaries, parseDictionarySelector, reconstructQualifiedEntry, removeContentNodeByKeyPath, renameContentNodeByKeyPath, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, updateNodeChildren };
+export { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, editDictionaryByKeyPath, getContentNodeByKeyPath, getDefaultNode, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getEmptyNode, getNodeChildren, getNodeType, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, mergeDictionaries, mergeQualifiedDictionaries, normalizeDictionaries, normalizeDictionary, orderDictionaries, parseDictionarySelector, reconstructQualifiedEntry, removeContentNodeByKeyPath, renameContentNodeByKeyPath, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant, updateNodeChildren };

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

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

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

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

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

@@ -1,5 +1,4 @@
 import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
-
 //#region src/dictionaryManipulator/mergeQualifiedDictionaries.d.ts
 /**
  * Merges sibling dictionaries sharing the same key, honouring qualifiers.
@@ -8,7 +7,7 @@ import { Dictionary, QualifiedDictionaryGroup } from "@intlayer/types/dictionary
  *   `mergeDictionaries` (single merged dictionary).
  * - At least one dictionary declares a qualifier → the group's dimension set is
  *   the union of every declared dimension (in canonical order
- *   `variant → meta → item`). Dictionaries are grouped by their composite id
+ *   `variant → item`). Dictionaries are grouped by their composite id
  *   (one segment per dimension), merged within each group (locale completion /
  *   priority overrides preserved), and a `QualifiedDictionaryGroup` is returned.
  *   Unqualified siblings act as shared base content merged into every entry.

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

@@ -1 +1 @@
-{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;AA8BA;;;;;;;;;;;;;cAAa,0BAAA,GACX,YAAA,EAAc,UAAA,OACb,UAAA,GAAa,wBAAA"}
+{"version":3,"file":"mergeQualifiedDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/mergeQualifiedDictionaries.ts"],"mappings":";;;;;;;;;;;;;;;;;cA6Ba,6BAA0B,cACvB,iBACb,aAAa"}

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

@@ -1,6 +1,5 @@
 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[];

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

@@ -1 +1 @@
-{"version":3,"file":"normalizeDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/normalizeDictionary.ts"],"mappings":";;;;cAOa,mBAAA,GACX,UAAA,EAAY,UAAA,EACZ,aAAA,EAAe,cAAA,KACd,UAAA;AAAA,cAmCU,qBAAA,GACX,YAAA,EAAc,UAAA,IACd,aAAA,EAAe,cAAA,KACd,UAAA"}
+{"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"}

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

@@ -1,5 +1,4 @@
 import { Dictionary } from "@intlayer/types/dictionary";
-
 //#region src/dictionaryManipulator/orderDictionaries.d.ts
 /**
  * Orders dictionaries based on the dictionary priority strategy.
@@ -10,7 +9,7 @@ import { Dictionary } from "@intlayer/types/dictionary";
  */
 declare const orderDictionaries: (dictionaries: Dictionary[], config?: {
   editor: {
-    dictionaryPriorityStrategy: "local_first" | "distant_first";
+    dictionaryPriorityStrategy: 'local_first' | 'distant_first';
   };
 }) => Dictionary[];
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;AAUA;;;;;cAAa,iBAAA,GACX,YAAA,EAAc,UAAA,IACd,MAAA;EACE,MAAA;IACE,0BAAA;EAAA;AAAA,MAGH,UAAA"}
+{"version":3,"file":"orderDictionaries.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/orderDictionaries.ts"],"mappings":";;;;;;;;;cAUa,oBAAiB,cACd,cAAY;EAExB;IACE;;MAGH"}

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

@@ -1,44 +1,66 @@
-import { Dictionary, DictionaryQualifierType, DictionarySelector, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
+import { Dictionary, DictionaryQualifierType, DictionarySelector, DictionaryVariantValue, QualifiedDictionaryGroup } from "@intlayer/types/dictionary";
 import { LocalesValues } from "@intlayer/types/module_augmentation";
-
 //#region src/dictionaryManipulator/qualifiedDictionary.d.ts
 /**
- * Canonical order of qualifier dimensions. A key that declares several
- * dimensions always nests them in this order, with `item` innermost so it can
- * act as the collection (array) axis.
+ * Canonical order of qualifier dimensions. A key that declares both dimensions
+ * always nests them in this order, with `item` innermost so it can act as the
+ * collection (array) axis.
  */
-declare const QUALIFIER_ORDER: readonly ["variant", "meta", "item"];
+declare const QUALIFIER_ORDER: readonly ["variant", "item"];
 /**
  * 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 = "/";
+/**
+ * Canonical serialization of a single variant value into its identity string —
+ * the variant segment of a composite id, the chunk directory name in dynamic
+ * mode, and the runtime matching key.
+ *
+ * - `undefined` → `'default'` (the implicit fallback variant)
+ * - a string → the string itself (a named variant)
+ * - an object → its sorted `key=value` pairs joined by `&`
+ *   (e.g. `{ userId: '123', id: 'abc' }` → `'id=abc&userId=123'`)
+ *
+ * Characters that are unsafe in file paths or generated code are
+ * percent-encoded (fixed-width `%XXXX` runs, injective). Common names —
+ * letters, digits, `-` `_` `.` — are left untouched. Both the declaration and
+ * the selector go through this function, so encoding never affects matching.
+ *
+ * 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;
+/**
+ * Normalizes the `variant` field of a dictionary into the list of variant ids
+ * the declaration registers under. A single value yields one id; an **array**
+ * fans out into one id per element (duplicates collapsed). Returns `undefined`
+ * when the dictionary does not declare the variant dimension (no `variant`
+ * field, or an empty array).
+ */
+declare const getVariantIds: (variant: Dictionary['variant']) => string[] | undefined;
 /**
  * Returns the qualifier dimensions declared on a dictionary, in canonical
- * order (`variant → meta → item`). Empty when the dictionary is unqualified
+ * order (`variant → item`). Empty when the dictionary is unqualified
  * (plain dictionary or shared base content of a qualified group).
  */
 declare const getDictionaryQualifierTypes: (dictionary: Dictionary) => DictionaryQualifierType[];
 /**
- * Returns the qualifier identifier of a dictionary for the given qualifier
- * dimension — one segment of the composite entry id.
+ * Returns the qualifier identifiers of a dictionary for the given qualifier
+ * dimension — the candidate segments of the composite entry ids.
  *
- * - 'variant' → the variant name
- * - 'meta' → the `meta.id` discriminator
- * - 'item' → the item index as string
- */
-declare const getDictionaryQualifierId: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string | undefined;
-/**
- * Returns the per-dimension id segments of a dictionary for the given ordered
- * dimension set, or `undefined` when the dictionary does not declare every
- * dimension of the set.
+ * - 'variant' → the serialized variant id(s); an array variant yields one id
+ *   per element (declaration-side fan-out)
+ * - 'item' → the item index as a single-element list
  */
-declare const getDictionaryQualifierSegments: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
+declare const getDictionaryQualifierIds: (dictionary: Dictionary, qualifierType: DictionaryQualifierType) => string[] | undefined;
 /**
- * Builds the composite entry id of a dictionary — its per-dimension id segments
- * joined in canonical order. `undefined` when a dimension is missing.
+ * Builds every composite entry id of a dictionary — the cartesian product of
+ * its per-dimension id lists, joined in canonical order. A dictionary with a
+ * plain (non-array) variant yields exactly one id; an array variant fans out
+ * into one id per element. `undefined` when a dimension of the set is missing.
  */
-declare const getDictionaryCompositeId: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string | undefined;
+declare const getDictionaryCompositeIds: (dictionary: Dictionary, qualifierTypes: DictionaryQualifierType[]) => string[] | undefined;
 /**
  * Type guard discriminating a `QualifiedDictionaryGroup` (merge output of a
  * qualified key) from a plain `Dictionary`. Both carry a `content` field; only
@@ -48,12 +70,13 @@ declare const isQualifiedDictionaryGroup: (value: unknown) => value is Qualified
 /**
  * Reconstructs a resolvable {@link Dictionary} from a single entry of a
  * qualified group: the content node stored under its composite id, plus the
- * qualifier coordinates decoded from that id (`variant`, `item`) and the
- * preserved `meta` object for the meta dimension.
+ * qualifier coordinates decoded from that id (`variant`, `item`).
  *
- * This keeps the resolver's matching/transform code unchanged: it still sees a
- * `{ key, content, variant?, item?, meta? }` shape, even though the stored
- * format no longer duplicates those fields per entry.
+ * This keeps the resolver's transform code unchanged: it still sees a
+ * `{ key, content, variant?, item? }` shape, even though the stored format no
+ * longer duplicates those fields per entry. The `variant` coordinate stays in
+ * 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;
 /**
@@ -63,8 +86,8 @@ declare const reconstructQualifiedEntry: (group: QualifiedDictionaryGroup, compo
  * - Plain dictionary → returned as-is (selector ignored)
  * - `item` declared but not selected → every matching entry ordered by index
  * - `item` selected → the matching entry or null
- * - `variant` defaults to the `default` entry when not selected
- * - `meta` requires `{ id }` and every declared meta field to match
+ * - `variant` defaults to the `default` entry when not selected; an object
+ *   variant resolves only when the selector provides an equal object
  *
  * Dimensions compose: e.g. a variant × item key with `{ variant: 'promo' }`
  * returns every promo item as an array; adding `{ item: 2 }` narrows to one.
@@ -119,7 +142,7 @@ type QualifiedDynamicLoaderMap = {
 };
 /**
  * Type guard discriminating a qualified dynamic loader map (collections /
- * variants / meta records, possibly combined) from a plain dynamic loader map.
+ * variants, possibly combined) from a plain dynamic loader map.
  */
 declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is QualifiedDynamicLoaderMap;
 /**
@@ -127,11 +150,11 @@ declare const isQualifiedDynamicLoaderMap: (value: unknown) => value is Qualifie
  * loading only the chunk(s) the selector actually targets.
  *
  * Walks the nested loader tree one dimension at a time (canonical order
- * `variant → meta → item`): `variant` defaults to `default`, `meta` descends by
- * `id`, and `item` either narrows to the selected index or — when no item is
- * given — expands into every sibling chunk (the collection axis). Meta-equality
- * is verified on the loaded chunk. Semantics mirror
- * {@link resolveQualifiedDictionary} so dynamic and static modes behave alike.
+ * `variant → item`): `variant` defaults to `default` (or descends by the
+ * serialized object identity), and `item` either narrows to the selected index
+ * or — when no item is given — expands into every sibling chunk (the collection
+ * axis). Semantics mirror {@link resolveQualifiedDictionary} so dynamic and
+ * static modes behave alike.
  *
  * The Suspense mechanism is injected through `loadChunk` so the same logic
  * serves both the client (suspender cache) and the server (`react.use`). Every
@@ -172,5 +195,5 @@ declare const resolveQualifiedDynamicContentAsync: <Content>(params: {
   transform: (dictionary: Dictionary) => Content;
 }) => Promise<Content | Content[] | null>;
 //#endregion
-export { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeId, getDictionaryQualifierId, getDictionaryQualifierSegments, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync };
+export { COMPOSITE_ID_SEPARATOR, DynamicDictionaryLoader, QUALIFIER_DYNAMIC_TYPES_KEY, QUALIFIER_ORDER, QualifiedDynamicLoaderMap, QualifiedDynamicLoaderTree, getDictionaryCompositeIds, getDictionaryQualifierIds, getDictionaryQualifierTypes, getDictionarySelectorCacheKey, getVariantIds, isQualifiedDictionaryGroup, isQualifiedDynamicLoaderMap, parseDictionarySelector, reconstructQualifiedEntry, resolveQualifiedDictionary, resolveQualifiedDynamicContent, resolveQualifiedDynamicContentAsync, serializeVariant };
 //# 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":";;;;;;AAmBA;;;cAAa,eAAA;;AAUb;;;cAAa,sBAAA;;AAOb;;;;cAAa,2BAAA,GACX,UAAA,EAAY,UAAA,KACX,uBAAA;;;;;AAmBH;;;;cAAa,wBAAA,GACX,UAAA,EAAY,UAAA,EACZ,aAAA,EAAe,uBAAA;;;;;;cAeJ,8BAAA,GACX,UAAA,EAAY,UAAA,EACZ,cAAA,EAAgB,uBAAA;;;;;cAiBL,wBAAA,GACX,UAAA,EAAY,UAAA,EACZ,cAAA,EAAgB,uBAAA;;;;;AAFlB;cAgEa,0BAAA,GACX,KAAA,cACC,KAAA,IAAS,wBAAA;;;;;;;;;AAFZ;;cAmBa,yBAAA,GACX,KAAA,EAAO,wBAAA,EACP,WAAA,aACC,UAAA;;;;;;;AAHH;;;;;;;cAwCa,0BAAA,GACX,iBAAA,EAAmB,UAAA,GAAa,wBAAA,EAChC,QAAA,GAAW,kBAAA,KACV,UAAA,GAAa,UAAA;;;AAHhB;;cAqCa,uBAAA,aAAqC,aAAA,EAChD,gBAAA,GAAmB,CAAA,GAAI,kBAAA;EACpB,MAAA,GAAS,CAAA;EAAG,QAAA,GAAW,kBAAA;AAAA;;;;;cAef,6BAAA,GACX,QAAA,GAAW,kBAAA;;;;;;;cAiBA,2BAAA;;AAnCb;;KAwCY,uBAAA,SAAgC,OAAA,CAAQ,UAAA;;;;;KAMxC,0BAAA;EAAA,CACT,OAAA,WAAkB,0BAAA,GAA6B,uBAAA;AAAA;;;;;;;;;;;;AA9BlD;KA6CY,yBAAA;EAAA,CACT,2BAAA,GAA8B,uBAAA;EAAA,CAC9B,MAAA,WAAiB,0BAAA,GAA6B,uBAAA;AAAA;AA7BjD;;;;AAAA,cAoCa,2BAAA,GACX,KAAA,cACC,KAAA,IAAS,yBAAA;AAjCZ;;;;;AAMA;;;;;;;;;AAgBA;;;;;;;;;AAtBA,cAuLa,8BAAA,YAA2C,MAAA;EACtD,SAAA,EAAW,yBAAA;EACX,GAAA;EACA,MAAA;EACA,QAAA,EAAU,kBAAA;EACV,SAAA,GAAY,QAAA,UAAkB,OAAA,EAAS,OAAA,CAAQ,UAAA,MAAgB,UAAA;EAC/D,SAAA,GAAY,UAAA,EAAY,UAAA,KAAe,OAAA;AAAA,MACrC,OAAA,GAAU,OAAA;;;;;;;;;AAPd;;;cAyCa,mCAAA,YAAsD,MAAA;EACjE,SAAA,EAAW,yBAAA;EACX,GAAA;EACA,MAAA;EACA,QAAA,EAAU,kBAAA;EACV,SAAA,GAAY,UAAA,EAAY,UAAA,KAAe,OAAA;AAAA,MACrC,OAAA,CAAQ,OAAA,GAAU,OAAA"}
+{"version":3,"file":"qualifiedDictionary.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/qualifiedDictionary.ts"],"mappings":";;;;;;;;cAca;;;;;cASA;;;;;;;;;;;;;;;;;;;cAqDA,mBAAgB,SAClB;;;;;;;;cAuBE,gBAAa,SACf;;;;;;cAeE,8BAA2B,YAC1B,eACX;;;;;;;;;cAmBU,4BAAyB,YACxB,YAAU,eACP;;;;;;;cAcJ,4BAAyB,YACxB,YAAU,gBACN;;;;;;cAiDL,6BAA0B,mBAEpC,SAAS;;;;;;;;;;;;cAkBC,4BAAyB,OAC7B,0BAAwB,wBAE9B;;;;;;;;;;;;;;cAgCU,6BAA0B,mBAClB,aAAa,0BAAwB,WAC7C,uBACV,aAAa;;;;;cA+BH,0BAA2B,UAAU,eAAa,mBAC1C,IAAI;EACpB,SAAS;EAAG,WAAW;;;;;;cAef,gCAA6B,WAC7B;;;;;;;cAwBA;;;;KAKD,gCAAgC,QAAQ;;;;;KAMxC;GACT,kBAAkB,6BAA6B;;;;;;;;;;;;;;KAetC;GACT,8BAA8B;GAC9B,iBAAiB,6BAA6B;;;;;;cAOpC,8BAA2B,mBAErC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;cA6GC,iCAAkC,SAAO;EACpD,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,kBAAkB,SAAS,QAAQ,gBAAgB;EAC/D,YAAY,YAAY,eAAe;MACrC,UAAU;;;;;;;;;;;;cAkCD,sCAA6C,SAAO;EAC/D,WAAW;EACX;EACA;EACA,UAAU;EACV,YAAY,YAAY,eAAe;MACrC,QAAQ,UAAU"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;;cAKa,0BAAA,GACX,iBAAA,EAAmB,WAAA,EACnB,OAAA,EAAS,OAAA,OACR,WAAA"}
+{"version":3,"file":"removeContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/removeContentNodeByKeyPath.ts"],"mappings":";;;cAKa,6BAA0B,mBAClB,aAAW,SACrB,cACR"}

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;;cAKa,0BAAA,GACX,iBAAA,EAAmB,WAAA,EACnB,MAAA,EAAQ,OAAA,SACR,OAAA,EAAS,OAAA,OACR,WAAA"}
+{"version":3,"file":"renameContentNodeByKeyPath.d.ts","names":[],"sources":["../../../src/dictionaryManipulator/renameContentNodeByKeyPath.ts"],"mappings":";;;cAKa,6BAA0B,mBAClB,aAAW,QACtB,gBAAc,SACb,cACR"}