@intlayer/core 8.4.9 → 8.4.10

package/dist/cjs/transpiler/condition/condition.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"condition.cjs","names":["CONDITION"],"sources":["../../../../src/transpiler/condition/condition.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { CONDITION, formatNodeType } from '@intlayer/types/nodeType';\n\nexport type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {\n  fallback?: Content;\n};\n\nexport type ConditionContent<Content = unknown> = TypedNodeModel<\n  typeof CONDITION,\n  ConditionContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a condition.\n *\n * Usage:\n *\n * ```ts\n * cond({\n *  'true': 'The condition is validated',\n *  'false': 'The condition is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst condition = <Content>(content?: ConditionContentStates<Content>) =>\n  formatNodeType(CONDITION, content);\n\nexport { condition as cond };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,aAAsB,yDACXA,oCAAW,QAAQ"}
+{"version":3,"file":"condition.cjs","names":["CONDITION"],"sources":["../../../../src/transpiler/condition/condition.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { CONDITION, formatNodeType } from '@intlayer/types/nodeType';\n\nexport type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {\n  fallback?: Content;\n};\n\nexport type ConditionContent<Content = unknown> = TypedNodeModel<\n  typeof CONDITION,\n  ConditionContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a condition.\n *\n * Usage:\n *\n * ```ts\n * cond({\n *  'true': 'The condition is validated',\n *  'false': 'The condition is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst condition = <Content>(\n  content?: ConditionContentStates<Content>\n): ConditionContent<Content> => formatNodeType(CONDITION, content);\n\nexport { condition as cond };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,aACJ,yDAC6CA,oCAAW,QAAQ"}

package/dist/cjs/transpiler/enumeration/enumeration.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"enumeration.cjs","names":["ENUMERATION"],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { ENUMERATION, formatNodeType } from '@intlayer/types/nodeType';\n\ntype Positive = number | `${number}`;\ntype Negative = `-${number}`;\ntype Numbers = Positive | Negative;\n\ntype Equal = Numbers;\ntype EqualString = `=${Numbers}`;\ntype Superior = `>${Numbers}`;\ntype SuperiorOrEqual = `>=${Numbers}`;\ntype Inferior = `<${Numbers}`;\ntype InferiorOrEqual = `<=${Numbers}`;\n\nexport type EnterFormat =\n  | Equal\n  | EqualString\n  | Superior\n  | SuperiorOrEqual\n  | Inferior\n  | InferiorOrEqual;\n\nexport type EnumerationContentState<Content> = Partial<\n  Record<EnterFormat, Content>\n> & {\n  fallback?: Content;\n};\n\nexport type EnumerationContent<Content = unknown> = TypedNodeModel<\n  typeof ENUMERATION,\n  EnumerationContentState<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a quantity.\n *\n * Usage:\n *\n * ```ts\n * enu({\n *  '<=-2.3': 'You have less than -2.3',\n *  '<1': 'You have less than one',\n *  '2': 'You have two',\n *  '>=3': 'You have three or more',\n * });\n * ```\n *\n * > The order of the keys will define the priority of the content.\n *\n */\nconst enumeration = <Content = unknown>(\n  content?: EnumerationContentState<Content>\n) => formatNodeType(ENUMERATION, content);\n\nexport { enumeration as enu };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAM,eACJ,yDACkBA,sCAAa,QAAQ"}
+{"version":3,"file":"enumeration.cjs","names":["ENUMERATION"],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { ENUMERATION, formatNodeType } from '@intlayer/types/nodeType';\n\ntype Positive = number | `${number}`;\ntype Negative = `-${number}`;\ntype Numbers = Positive | Negative;\n\ntype Equal = Numbers;\ntype EqualString = `=${Numbers}`;\ntype Superior = `>${Numbers}`;\ntype SuperiorOrEqual = `>=${Numbers}`;\ntype Inferior = `<${Numbers}`;\ntype InferiorOrEqual = `<=${Numbers}`;\n\nexport type EnterFormat =\n  | Equal\n  | EqualString\n  | Superior\n  | SuperiorOrEqual\n  | Inferior\n  | InferiorOrEqual;\n\nexport type EnumerationContentState<Content> = Partial<\n  Record<EnterFormat, Content>\n> & {\n  fallback?: Content;\n};\n\nexport type EnumerationContent<Content = unknown> = TypedNodeModel<\n  typeof ENUMERATION,\n  EnumerationContentState<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a quantity.\n *\n * Usage:\n *\n * ```ts\n * enu({\n *  '<=-2.3': 'You have less than -2.3',\n *  '<1': 'You have less than one',\n *  '2': 'You have two',\n *  '>=3': 'You have three or more',\n * });\n * ```\n *\n * > The order of the keys will define the priority of the content.\n *\n */\nconst enumeration = <Content = unknown>(\n  content?: EnumerationContentState<Content>\n): EnumerationContent<Content> => formatNodeType(ENUMERATION, content);\n\nexport { enumeration as enu };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAM,eACJ,yDAC+CA,sCAAa,QAAQ"}

package/dist/cjs/transpiler/gender/gender.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"gender.cjs","names":["GENDER"],"sources":["../../../../src/transpiler/gender/gender.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, GENDER } from '@intlayer/types/nodeType';\n\nexport type Gender = 'male' | 'female' | 'fallback';\n\nexport type GenderContentStates<Content> = Record<`${Gender}`, Content> & {\n  fallback?: Content;\n};\n\nexport type GenderContent<Content = unknown> = TypedNodeModel<\n  typeof GENDER,\n  GenderContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a gender.\n *\n * Usage:\n *\n * ```ts\n * gender({\n *  'true': 'The gender is validated',\n *  'false': 'The gender is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst gender = <Content>(content?: GenderContentStates<Content>) =>\n  formatNodeType(GENDER, content);\n\nexport { gender };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,UAAmB,yDACRA,iCAAQ,QAAQ"}
+{"version":3,"file":"gender.cjs","names":["GENDER"],"sources":["../../../../src/transpiler/gender/gender.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, GENDER } from '@intlayer/types/nodeType';\n\nexport type Gender = 'male' | 'female' | 'fallback';\n\nexport type GenderContentStates<Content> = Record<`${Gender}`, Content> & {\n  fallback?: Content;\n};\n\nexport type GenderContent<Content = unknown> = TypedNodeModel<\n  typeof GENDER,\n  GenderContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a gender.\n *\n * Usage:\n *\n * ```ts\n * gender({\n *  'true': 'The gender is validated',\n *  'false': 'The gender is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst gender = <Content>(\n  content?: GenderContentStates<Content>\n): GenderContent<Content> => formatNodeType(GENDER, content);\n\nexport { gender };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,UACJ,yDAC0CA,iCAAQ,QAAQ"}

package/dist/cjs/transpiler/translation/translation.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"translation.cjs","names":["TRANSLATION"],"sources":["../../../../src/transpiler/translation/translation.ts"],"sourcesContent":["import type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, TRANSLATION } from '@intlayer/types/nodeType';\n\nexport type TranslationContent<\n  Content = unknown,\n  RecordContent extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n> = TypedNodeModel<typeof TRANSLATION, RecordContent>;\n\n/**\n *\n * Function intended to be used to build intlayer dictionaries.\n *\n * Get the content of a translation based on the locale.\n *\n * Usage:\n *\n * ```ts\n * translation<string>({\n *   \"en\": \"Hello\",\n *   \"fr\": \"Bonjour\",\n *   // ... any other available locale\n * })\n * ```\n *\n * Using TypeScript:\n * - this function require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nconst translation = <\n  Content = unknown,\n  ContentRecord extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n>(\n  content: ContentRecord\n) =>\n  formatNodeType(TRANSLATION, content) satisfies TranslationContent<\n    Content,\n    ContentRecord\n  >;\n\nexport { translation as t };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,eAKJ,yDAEeA,sCAAa,QAAQ"}
+{"version":3,"file":"translation.cjs","names":["TRANSLATION"],"sources":["../../../../src/transpiler/translation/translation.ts"],"sourcesContent":["import type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, TRANSLATION } from '@intlayer/types/nodeType';\n\nexport type TranslationContent<\n  Content = unknown,\n  RecordContent extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n> = TypedNodeModel<typeof TRANSLATION, RecordContent>;\n\n/**\n *\n * Function intended to be used to build intlayer dictionaries.\n *\n * Get the content of a translation based on the locale.\n *\n * Usage:\n *\n * ```ts\n * translation<string>({\n *   \"en\": \"Hello\",\n *   \"fr\": \"Bonjour\",\n *   // ... any other available locale\n * })\n * ```\n *\n * Using TypeScript:\n * - this function require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nconst translation = <\n  Content = unknown,\n  ContentRecord extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n>(\n  content: ContentRecord\n): TranslationContent<Content, ContentRecord> =>\n  formatNodeType(TRANSLATION, content) satisfies TranslationContent<\n    Content,\n    ContentRecord\n  >;\n\nexport { translation as t };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,eAKJ,yDAEeA,sCAAa,QAAQ"}

package/dist/esm/transpiler/condition/condition.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"condition.mjs","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { CONDITION, formatNodeType } from '@intlayer/types/nodeType';\n\nexport type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {\n  fallback?: Content;\n};\n\nexport type ConditionContent<Content = unknown> = TypedNodeModel<\n  typeof CONDITION,\n  ConditionContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a condition.\n *\n * Usage:\n *\n * ```ts\n * cond({\n *  'true': 'The condition is validated',\n *  'false': 'The condition is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst condition = <Content>(content?: ConditionContentStates<Content>) =>\n  formatNodeType(CONDITION, content);\n\nexport { condition as cond };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,aAAsB,YAC1B,eAAe,WAAW,QAAQ"}
+{"version":3,"file":"condition.mjs","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { CONDITION, formatNodeType } from '@intlayer/types/nodeType';\n\nexport type ConditionContentStates<Content> = Record<`${boolean}`, Content> & {\n  fallback?: Content;\n};\n\nexport type ConditionContent<Content = unknown> = TypedNodeModel<\n  typeof CONDITION,\n  ConditionContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a condition.\n *\n * Usage:\n *\n * ```ts\n * cond({\n *  'true': 'The condition is validated',\n *  'false': 'The condition is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst condition = <Content>(\n  content?: ConditionContentStates<Content>\n): ConditionContent<Content> => formatNodeType(CONDITION, content);\n\nexport { condition as cond };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA6BA,MAAM,aACJ,YAC8B,eAAe,WAAW,QAAQ"}

package/dist/esm/transpiler/enumeration/enumeration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"enumeration.mjs","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { ENUMERATION, formatNodeType } from '@intlayer/types/nodeType';\n\ntype Positive = number | `${number}`;\ntype Negative = `-${number}`;\ntype Numbers = Positive | Negative;\n\ntype Equal = Numbers;\ntype EqualString = `=${Numbers}`;\ntype Superior = `>${Numbers}`;\ntype SuperiorOrEqual = `>=${Numbers}`;\ntype Inferior = `<${Numbers}`;\ntype InferiorOrEqual = `<=${Numbers}`;\n\nexport type EnterFormat =\n  | Equal\n  | EqualString\n  | Superior\n  | SuperiorOrEqual\n  | Inferior\n  | InferiorOrEqual;\n\nexport type EnumerationContentState<Content> = Partial<\n  Record<EnterFormat, Content>\n> & {\n  fallback?: Content;\n};\n\nexport type EnumerationContent<Content = unknown> = TypedNodeModel<\n  typeof ENUMERATION,\n  EnumerationContentState<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a quantity.\n *\n * Usage:\n *\n * ```ts\n * enu({\n *  '<=-2.3': 'You have less than -2.3',\n *  '<1': 'You have less than one',\n *  '2': 'You have two',\n *  '>=3': 'You have three or more',\n * });\n * ```\n *\n * > The order of the keys will define the priority of the content.\n *\n */\nconst enumeration = <Content = unknown>(\n  content?: EnumerationContentState<Content>\n) => formatNodeType(ENUMERATION, content);\n\nexport { enumeration as enu };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAM,eACJ,YACG,eAAe,aAAa,QAAQ"}
+{"version":3,"file":"enumeration.mjs","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { ENUMERATION, formatNodeType } from '@intlayer/types/nodeType';\n\ntype Positive = number | `${number}`;\ntype Negative = `-${number}`;\ntype Numbers = Positive | Negative;\n\ntype Equal = Numbers;\ntype EqualString = `=${Numbers}`;\ntype Superior = `>${Numbers}`;\ntype SuperiorOrEqual = `>=${Numbers}`;\ntype Inferior = `<${Numbers}`;\ntype InferiorOrEqual = `<=${Numbers}`;\n\nexport type EnterFormat =\n  | Equal\n  | EqualString\n  | Superior\n  | SuperiorOrEqual\n  | Inferior\n  | InferiorOrEqual;\n\nexport type EnumerationContentState<Content> = Partial<\n  Record<EnterFormat, Content>\n> & {\n  fallback?: Content;\n};\n\nexport type EnumerationContent<Content = unknown> = TypedNodeModel<\n  typeof ENUMERATION,\n  EnumerationContentState<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a quantity.\n *\n * Usage:\n *\n * ```ts\n * enu({\n *  '<=-2.3': 'You have less than -2.3',\n *  '<1': 'You have less than one',\n *  '2': 'You have two',\n *  '>=3': 'You have three or more',\n * });\n * ```\n *\n * > The order of the keys will define the priority of the content.\n *\n */\nconst enumeration = <Content = unknown>(\n  content?: EnumerationContentState<Content>\n): EnumerationContent<Content> => formatNodeType(ENUMERATION, content);\n\nexport { enumeration as enu };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAoDA,MAAM,eACJ,YACgC,eAAe,aAAa,QAAQ"}

package/dist/esm/transpiler/gender/gender.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"gender.mjs","names":[],"sources":["../../../../src/transpiler/gender/gender.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, GENDER } from '@intlayer/types/nodeType';\n\nexport type Gender = 'male' | 'female' | 'fallback';\n\nexport type GenderContentStates<Content> = Record<`${Gender}`, Content> & {\n  fallback?: Content;\n};\n\nexport type GenderContent<Content = unknown> = TypedNodeModel<\n  typeof GENDER,\n  GenderContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a gender.\n *\n * Usage:\n *\n * ```ts\n * gender({\n *  'true': 'The gender is validated',\n *  'false': 'The gender is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst gender = <Content>(content?: GenderContentStates<Content>) =>\n  formatNodeType(GENDER, content);\n\nexport { gender };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,UAAmB,YACvB,eAAe,QAAQ,QAAQ"}
+{"version":3,"file":"gender.mjs","names":[],"sources":["../../../../src/transpiler/gender/gender.ts"],"sourcesContent":["import type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, GENDER } from '@intlayer/types/nodeType';\n\nexport type Gender = 'male' | 'female' | 'fallback';\n\nexport type GenderContentStates<Content> = Record<`${Gender}`, Content> & {\n  fallback?: Content;\n};\n\nexport type GenderContent<Content = unknown> = TypedNodeModel<\n  typeof GENDER,\n  GenderContentStates<Content>\n>;\n\n/**\n * Function intended to be used to build intlayer dictionaries.\n *\n * Allow to pick a content based on a gender.\n *\n * Usage:\n *\n * ```ts\n * gender({\n *  'true': 'The gender is validated',\n *  'false': 'The gender is not validated',\n * });\n * ```\n *\n * The last key provided will be used as the fallback value.\n *\n */\nconst gender = <Content>(\n  content?: GenderContentStates<Content>\n): GenderContent<Content> => formatNodeType(GENDER, content);\n\nexport { gender };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AA+BA,MAAM,UACJ,YAC2B,eAAe,QAAQ,QAAQ"}

package/dist/esm/transpiler/translation/translation.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"translation.mjs","names":[],"sources":["../../../../src/transpiler/translation/translation.ts"],"sourcesContent":["import type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, TRANSLATION } from '@intlayer/types/nodeType';\n\nexport type TranslationContent<\n  Content = unknown,\n  RecordContent extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n> = TypedNodeModel<typeof TRANSLATION, RecordContent>;\n\n/**\n *\n * Function intended to be used to build intlayer dictionaries.\n *\n * Get the content of a translation based on the locale.\n *\n * Usage:\n *\n * ```ts\n * translation<string>({\n *   \"en\": \"Hello\",\n *   \"fr\": \"Bonjour\",\n *   // ... any other available locale\n * })\n * ```\n *\n * Using TypeScript:\n * - this function require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nconst translation = <\n  Content = unknown,\n  ContentRecord extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n>(\n  content: ContentRecord\n) =>\n  formatNodeType(TRANSLATION, content) satisfies TranslationContent<\n    Content,\n    ContentRecord\n  >;\n\nexport { translation as t };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,eAKJ,YAEA,eAAe,aAAa,QAAQ"}
+{"version":3,"file":"translation.mjs","names":[],"sources":["../../../../src/transpiler/translation/translation.ts"],"sourcesContent":["import type { StrictModeLocaleMap } from '@intlayer/types/module_augmentation';\nimport type { TypedNodeModel } from '@intlayer/types/nodeType';\nimport { formatNodeType, TRANSLATION } from '@intlayer/types/nodeType';\n\nexport type TranslationContent<\n  Content = unknown,\n  RecordContent extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n> = TypedNodeModel<typeof TRANSLATION, RecordContent>;\n\n/**\n *\n * Function intended to be used to build intlayer dictionaries.\n *\n * Get the content of a translation based on the locale.\n *\n * Usage:\n *\n * ```ts\n * translation<string>({\n *   \"en\": \"Hello\",\n *   \"fr\": \"Bonjour\",\n *   // ... any other available locale\n * })\n * ```\n *\n * Using TypeScript:\n * - this function require each locale to be defined if defined in the project configuration.\n * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.\n */\nconst translation = <\n  Content = unknown,\n  ContentRecord extends\n    StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>,\n>(\n  content: ContentRecord\n): TranslationContent<Content, ContentRecord> =>\n  formatNodeType(TRANSLATION, content) satisfies TranslationContent<\n    Content,\n    ContentRecord\n  >;\n\nexport { translation as t };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,eAKJ,YAEA,eAAe,aAAa,QAAQ"}

package/dist/types/transpiler/condition/condition.d.ts

@@ -22,7 +22,7 @@ type ConditionContent<Content = unknown> = TypedNodeModel<typeof CONDITION, Cond
  * The last key provided will be used as the fallback value.
  *
  */
-declare const condition: <Content>(content?: ConditionContentStates<Content>) => TypedNodeModel<"condition", ConditionContentStates<Content>, {}>;
+declare const condition: <Content>(content?: ConditionContentStates<Content>) => ConditionContent<Content>;
 //#endregion
 export { ConditionContent, ConditionContentStates, condition as cond };
 //# sourceMappingURL=condition.d.ts.map

package/dist/types/transpiler/condition/condition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"condition.d.ts","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"mappings":";;;KAGY,sBAAA,YAAkC,MAAA,eAAqB,OAAA;EACjE,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,gBAAA,sBAAsC,cAAA,QACzC,SAAA,EACP,sBAAA,CAAuB,OAAA;;;;;;;;;;;;;AAFzB;;;;;cAsBM,SAAA,YAAsB,OAAA,GAAU,sBAAA,CAAuB,OAAA,MAAQ,cAAA,cAAA,sBAAA,CAAA,OAAA"}
+{"version":3,"file":"condition.d.ts","names":[],"sources":["../../../../src/transpiler/condition/condition.ts"],"mappings":";;;KAGY,sBAAA,YAAkC,MAAA,eAAqB,OAAA;EACjE,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,gBAAA,sBAAsC,cAAA,QACzC,SAAA,EACP,sBAAA,CAAuB,OAAA;;;;;;;;;;;;;AAFzB;;;;;cAsBM,SAAA,YACJ,OAAA,GAAU,sBAAA,CAAuB,OAAA,MAChC,gBAAA,CAAiB,OAAA"}

package/dist/types/transpiler/enumeration/enumeration.d.ts

@@ -34,7 +34,7 @@ type EnumerationContent<Content = unknown> = TypedNodeModel<typeof ENUMERATION,
  * > The order of the keys will define the priority of the content.
  *
  */
-declare const enumeration: <Content = unknown>(content?: EnumerationContentState<Content>) => TypedNodeModel<"enumeration", EnumerationContentState<Content>, {}>;
+declare const enumeration: <Content = unknown>(content?: EnumerationContentState<Content>) => EnumerationContent<Content>;
 //#endregion
 export { EnterFormat, EnumerationContent, EnumerationContentState, enumeration as enu };
 //# sourceMappingURL=enumeration.d.ts.map

package/dist/types/transpiler/enumeration/enumeration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enumeration.d.ts","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"mappings":";;;KAGK,QAAA;AAAA,KACA,QAAA;AAAA,KACA,OAAA,GAAU,QAAA,GAAW,QAAA;AAAA,KAErB,KAAA,GAAQ,OAAA;AAAA,KACR,WAAA,OAAkB,OAAA;AAAA,KAClB,QAAA,OAAe,OAAA;AAAA,KACf,eAAA,QAAuB,OAAA;AAAA,KACvB,QAAA,OAAe,OAAA;AAAA,KACf,eAAA,QAAuB,OAAA;AAAA,KAEhB,WAAA,GACR,KAAA,GACA,WAAA,GACA,QAAA,GACA,eAAA,GACA,QAAA,GACA,eAAA;AAAA,KAEQ,uBAAA,YAAmC,OAAA,CAC7C,MAAA,CAAO,WAAA,EAAa,OAAA;EAEpB,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,kBAAA,sBAAwC,cAAA,QAC3C,WAAA,EACP,uBAAA,CAAwB,OAAA;;;AAzBQ;;;;;AAEd;;;;;AACU;;;;;AACH;;cA2CrB,WAAA,sBACJ,OAAA,GAAU,uBAAA,CAAwB,OAAA,MAAQ,cAAA,gBAAA,uBAAA,CAAA,OAAA"}
+{"version":3,"file":"enumeration.d.ts","names":[],"sources":["../../../../src/transpiler/enumeration/enumeration.ts"],"mappings":";;;KAGK,QAAA;AAAA,KACA,QAAA;AAAA,KACA,OAAA,GAAU,QAAA,GAAW,QAAA;AAAA,KAErB,KAAA,GAAQ,OAAA;AAAA,KACR,WAAA,OAAkB,OAAA;AAAA,KAClB,QAAA,OAAe,OAAA;AAAA,KACf,eAAA,QAAuB,OAAA;AAAA,KACvB,QAAA,OAAe,OAAA;AAAA,KACf,eAAA,QAAuB,OAAA;AAAA,KAEhB,WAAA,GACR,KAAA,GACA,WAAA,GACA,QAAA,GACA,eAAA,GACA,QAAA,GACA,eAAA;AAAA,KAEQ,uBAAA,YAAmC,OAAA,CAC7C,MAAA,CAAO,WAAA,EAAa,OAAA;EAEpB,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,kBAAA,sBAAwC,cAAA,QAC3C,WAAA,EACP,uBAAA,CAAwB,OAAA;;;AAzBQ;;;;;AAEd;;;;;AACU;;;;;AACH;;cA2CrB,WAAA,sBACJ,OAAA,GAAU,uBAAA,CAAwB,OAAA,MACjC,kBAAA,CAAmB,OAAA"}

package/dist/types/transpiler/gender/gender.d.ts

@@ -23,7 +23,7 @@ type GenderContent<Content = unknown> = TypedNodeModel<typeof GENDER, GenderCont
  * The last key provided will be used as the fallback value.
  *
  */
-declare const gender: <Content>(content?: GenderContentStates<Content>) => TypedNodeModel<"gender", GenderContentStates<Content>, {}>;
+declare const gender: <Content>(content?: GenderContentStates<Content>) => GenderContent<Content>;
 //#endregion
 export { Gender, GenderContent, GenderContentStates, gender };
 //# sourceMappingURL=gender.d.ts.map

package/dist/types/transpiler/gender/gender.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gender.d.ts","names":[],"sources":["../../../../src/transpiler/gender/gender.ts"],"mappings":";;;KAGY,MAAA;AAAA,KAEA,mBAAA,YAA+B,MAAA,IAAU,MAAA,IAAU,OAAA;EAC7D,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,aAAA,sBAAmC,cAAA,QACtC,MAAA,EACP,mBAAA,CAAoB,OAAA;;AANtB;;;;;;;;;;;;;;;;cA0BM,MAAA,YAAmB,OAAA,GAAU,mBAAA,CAAoB,OAAA,MAAQ,cAAA,WAAA,mBAAA,CAAA,OAAA"}
+{"version":3,"file":"gender.d.ts","names":[],"sources":["../../../../src/transpiler/gender/gender.ts"],"mappings":";;;KAGY,MAAA;AAAA,KAEA,mBAAA,YAA+B,MAAA,IAAU,MAAA,IAAU,OAAA;EAC7D,QAAA,GAAW,OAAA;AAAA;AAAA,KAGD,aAAA,sBAAmC,cAAA,QACtC,MAAA,EACP,mBAAA,CAAoB,OAAA;;AANtB;;;;;;;;;;;;;;;;cA0BM,MAAA,YACJ,OAAA,GAAU,mBAAA,CAAoB,OAAA,MAC7B,aAAA,CAAc,OAAA"}

package/dist/types/transpiler/translation/translation.d.ts

@@ -23,11 +23,7 @@ type TranslationContent<Content = unknown, RecordContent extends StrictModeLocal
  * - this function require each locale to be defined if defined in the project configuration.
  * - If a locale is missing, it will make each existing locale optional and raise an error if the locale is not found.
  */
-declare const translation: <Content = unknown, ContentRecord extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>>(content: ContentRecord) => TypedNodeModel<"translation", ContentRecord, {
-  nodeType: "translation";
-} & {
-  translation: ContentRecord;
-}>;
+declare const translation: <Content = unknown, ContentRecord extends StrictModeLocaleMap<Content> = StrictModeLocaleMap<Content>>(content: ContentRecord) => TranslationContent<Content, ContentRecord>;
 //#endregion
 export { TranslationContent, translation as t };
 //# sourceMappingURL=translation.d.ts.map

package/dist/types/transpiler/translation/translation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"translation.d.ts","names":[],"sources":["../../../../src/transpiler/translation/translation.ts"],"mappings":";;;;KAIY,kBAAA,0CAGR,mBAAA,CAAoB,OAAA,IAAW,mBAAA,CAAoB,OAAA,KACnD,cAAA,QAAsB,WAAA,EAAa,aAAA;AAJvC;;;;;;;;;;;;;;;;;;;;AAAA,cA0BM,WAAA,4CAGF,mBAAA,CAAoB,OAAA,IAAW,mBAAA,CAAoB,OAAA,GAErD,OAAA,EAAS,aAAA,KAAa,cAAA,gBAAA,aAAA"}
+{"version":3,"file":"translation.d.ts","names":[],"sources":["../../../../src/transpiler/translation/translation.ts"],"mappings":";;;;KAIY,kBAAA,0CAGR,mBAAA,CAAoB,OAAA,IAAW,mBAAA,CAAoB,OAAA,KACnD,cAAA,QAAsB,WAAA,EAAa,aAAA;AAJvC;;;;;;;;;;;;;;;;;;;;AAAA,cA0BM,WAAA,4CAGF,mBAAA,CAAoB,OAAA,IAAW,mBAAA,CAAoB,OAAA,GAErD,OAAA,EAAS,aAAA,KACR,kBAAA,CAAmB,OAAA,EAAS,aAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intlayer/core",
-  "version": "8.4.9",
+  "version": "8.4.10",
   "private": false,
   "description": "Includes core Intlayer functions like translation, dictionary, and utility functions shared across multiple packages.",
   "keywords": [
@@ -168,11 +168,11 @@
     "typecheck": "tsc --noEmit --project tsconfig.types.json"
   },
   "dependencies": {
-    "@intlayer/api": "8.4.9",
-    "@intlayer/config": "8.4.9",
-    "@intlayer/dictionaries-entry": "8.4.9",
-    "@intlayer/types": "8.4.9",
-    "@intlayer/unmerged-dictionaries-entry": "8.4.9",
+    "@intlayer/api": "8.4.10",
+    "@intlayer/config": "8.4.10",
+    "@intlayer/dictionaries-entry": "8.4.10",
+    "@intlayer/types": "8.4.10",
+    "@intlayer/unmerged-dictionaries-entry": "8.4.10",
     "defu": "6.1.4"
   },
   "devDependencies": {
@@ -182,8 +182,8 @@
     "@utils/tsdown-config": "1.0.4",
     "rimraf": "6.1.3",
     "tsdown": "0.21.4",
-    "typescript": "5.9.3",
-    "vitest": "4.1.0"
+    "typescript": "6.0.2",
+    "vitest": "4.1.1"
   },
   "engines": {
     "node": ">=14.18"