optolith-database-schema 0.18.4 → 0.18.5

package/lib/types/SkillGroup.js

@@ -1,6 +1,6 @@
 import { Entity, IncludeIdentifier, Object, Required, String } from "tsondb/schema/def";
 import { SkillCheck } from "./_SkillCheck.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const SkillGroup = Entity(import.meta.url, {
     name: "SkillGroup",
     namePlural: "SkillGroups",
@@ -9,7 +9,7 @@ export const SkillGroup = Entity(import.meta.url, {
             comment: "The skill group’s skill check attributes",
             type: IncludeIdentifier(SkillCheck),
         }),
-        translations: NestedLocaleMap(Required, "SkillGroupTranslation", Object({
+        translations: NestedTranslationMap(Required, "SkillGroup", Object({
             name: Required({
                 comment: "The skill group’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/SkillModificationLevel.js

@@ -2,7 +2,7 @@
  * @main SkillModificationLevel
  */
 import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const SkillModificationLevel = Entity(import.meta.url, {
     name: "SkillModificationLevel",
     namePlural: "SkillModificationLevels",
@@ -15,7 +15,7 @@ export const SkillModificationLevel = Entity(import.meta.url, {
             comment: "Configuration for this level for slow skills (rituals, ceremonies).",
             type: IncludeIdentifier(SlowSkillModificationLevelConfig),
         }),
-        translations: NestedLocaleMap(Optional, "SkillModificationLevelTranslation", Object({
+        translations: NestedTranslationMap(Optional, "SkillModificationLevel", Object({
             fast: Optional({
                 comment: "Configuration for this level for fast skills (spells, liturgical chants). Values set here override the default generated text.",
                 type: IncludeIdentifier(LevelTypeConfigTranslation),

package/lib/types/SocialStatus.js

@@ -1,5 +1,5 @@
 import { Entity, Integer, Object, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const SocialStatus = Entity(import.meta.url, {
     name: "SocialStatus",
     namePlural: "SocialStatuses",
@@ -8,7 +8,7 @@ export const SocialStatus = Entity(import.meta.url, {
             comment: "The social status’ order. The higher the order, the more powerful the social status. This has to be a unique value.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Required, "SocialStatusTranslation", Object({
+        translations: NestedTranslationMap(Required, "SocialStatus", Object({
             name: Required({
                 comment: "The social status’ name.",
                 type: String({ minLength: 1 }),

package/lib/types/Spell.d.ts

@@ -480,7 +480,7 @@ export declare const Spell: Entity<"Spell", {
     }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
@@ -592,7 +592,7 @@ export declare const Spell: Entity<"Spell", {
         }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
         src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRef", Object<{
             id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-            occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+            occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
                 initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", Object<{
                     printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                     pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/Spell.js

@@ -8,7 +8,7 @@ import { ImprovementCost } from "./_ImprovementCost.js";
 import { SpellworkPrerequisites } from "./_Prerequisite.js";
 import { SkillCheck, SkillCheckPenalty } from "./_SkillCheck.js";
 import { SpellworkTraditions } from "./_Spellwork.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
 export const Spell = Entity(import.meta.url, {
@@ -48,7 +48,7 @@ export const Spell = Entity(import.meta.url, {
             type: IncludeIdentifier(SpellworkPrerequisites),
         }),
         src,
-        translations: NestedLocaleMap(Required, "SpellTranslation", Object({
+        translations: NestedTranslationMap(Required, "Spell", Object({
             name: Required({
                 comment: "The spell’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/State.d.ts

@@ -2,7 +2,7 @@ import { Entity, IncludeIdentifier, Object, String } from "tsondb/schema/def";
 export declare const State: Entity<"State", {
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/State.js

@@ -1,5 +1,5 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
 export const State = Entity(import.meta.url, {
@@ -7,7 +7,7 @@ export const State = Entity(import.meta.url, {
     namePlural: "States",
     type: () => Object({
         src,
-        translations: NestedLocaleMap(Required, "StateTranslation", Object({
+        translations: NestedTranslationMap(Required, "State", Object({
             name: Required({
                 comment: "The state’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Talisman.d.ts

@@ -11,7 +11,7 @@ export declare const Talisman: Entity<"Talisman", {
     ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{

package/lib/types/Talisman.js

@@ -1,6 +1,6 @@
 import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { BlessedTraditionIdentifier } from "./_Identifier.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
 export const Talisman = Entity(import.meta.url, {
@@ -20,7 +20,7 @@ export const Talisman = Entity(import.meta.url, {
             type: Integer({ minimum: 5, multipleOf: 5 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "TalismanTranslation", Object({
+        translations: NestedTranslationMap(Required, "Talisman", Object({
             name: Required({
                 comment: "The talisman’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/TargetCategory.js

@@ -1,5 +1,5 @@
 import { Entity, ObjectType, Optional, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { TargetCategoryIdentifier } from "./_Identifier.js";
 export const TargetCategory = Entity(import.meta.url, {
     name: "TargetCategory",
@@ -9,7 +9,7 @@ export const TargetCategory = Entity(import.meta.url, {
             comment: "A superordinate target category, if present.",
             type: TargetCategoryIdentifier(),
         }),
-        translations: NestedLocaleMap(Required, "TargetCategoryTranslation", ObjectType({
+        translations: NestedTranslationMap(Required, "TargetCategory", ObjectType({
             name: Required({
                 comment: "The target category’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/_Activatable.d.ts

@@ -700,7 +700,7 @@ export declare const select_options: import("tsondb/schema/def").MemberDecl<Incl
             ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
             src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
                 id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-                occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+                occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
                     initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                         printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                         pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
@@ -781,7 +781,7 @@ export declare const select_options: import("tsondb/schema/def").MemberDecl<Incl
             ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
             src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
                 id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-                occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+                occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
                     initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                         printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                         pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
@@ -915,7 +915,7 @@ export declare const GeneralSelectOption: Entity<"GeneralSelectOption", {
     ap_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{

package/lib/types/_Activatable.js

@@ -2,7 +2,7 @@
  * General type specifications used by multiple activatable entries.
  */
 import { Array, Boolean, Entity, Enum, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { SelectOptionCategory } from "./_ActivatableSelectOptionCategory.js";
 import { DurationUnitValue } from "./_ActivatableSkillDuration.js";
 import { AspectIdentifier, CloseCombatTechniqueIdentifier, GeneralIdentifier, MagicalTraditionIdentifier, NewSkillApplicationIdentifier, PatronIdentifier, PropertyIdentifier, RaceIdentifier, RangedCombatTechniqueIdentifier, SkillIdentifier, SkillUseIdentifier, WeaponIdentifier, } from "./_Identifier.js";
@@ -97,7 +97,7 @@ export const GeneralSelectOption = Entity(import.meta.url, {
             type: Integer({ minimum: 1 }),
         }),
         src: optionalSrc,
-        translations: NestedLocaleMap(Required, "GeneralSelectOptionTranslation", Object({
+        translations: NestedTranslationMap(Required, "GeneralSelectOption", Object({
             name: Required({
                 comment: "The name of the select option.",
                 type: String({ minLength: 1 }),
@@ -150,7 +150,7 @@ const ExplicitSkillSelectOption = TypeAlias(import.meta.url, {
             type: Integer({ minimum: 1 }),
         }),
         src: optionalSrc,
-        translations: NestedLocaleMap(Optional, "ExplicitSkillSelectOptionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ExplicitSkillSelectOption", Object({
             errata: Optional({
                 type: IncludeIdentifier(Errata),
             }),
@@ -177,7 +177,7 @@ const ExplicitCombatTechniqueSelectOption = TypeAlias(import.meta.url, {
             type: Integer({ minimum: 1 }),
         }),
         src: optionalSrc,
-        translations: NestedLocaleMap(Optional, "ExplicitCombatTechniqueSelectOptionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ExplicitCombatTechniqueSelectOption", Object({
             errata: Optional({
                 type: IncludeIdentifier(Errata),
             }),
@@ -360,7 +360,7 @@ export const NewSkillApplication = Entity(import.meta.url, {
             comment: "If an application applies to multiple skills, it may need to ensure the respective skill is on a certain skill rating if the activatable entry cannot ensure this prerequisite.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "NewSkillApplicationTranslation", Object({
+        translations: NestedTranslationMap(Optional, "NewSkillApplication", Object({
             name: Required({
                 comment: "The name of the application if different from the activatable entry’s name.",
                 type: String({ minLength: 1 }),
@@ -392,7 +392,7 @@ export const SkillUse = Entity(import.meta.url, {
             comment: "If a use applies to multiple skills, it may need to ensure the respective skill is on a certain skill rating if the activatable entry cannot ensure this prerequisite.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "SkillUseTranslation", Object({
+        translations: NestedTranslationMap(Optional, "SkillUse", Object({
             name: Required({
                 comment: "The name of the use if different from the activatable entry’s name.",
                 type: String({ minLength: 1 }),
@@ -651,7 +651,7 @@ const FixedArcaneEnergyCost = TypeAlias(import.meta.url, {
             comment: "The AE cost are per level of the enchantment. It may either be displayed in a compressed way (e.g. `1 AE per level`) or in a verbose way (e.g. `1 AE for level I; 2 AE for level II`).",
             type: IncludeIdentifier(FixedArcaneEnergyCostPerLevel),
         }),
-        translations: NestedLocaleMap(Optional, "FixedArcaneEnergyCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "FixedArcaneEnergyCost", Object({
             note: Optional({
                 comment: "A note, appended to the generated option string in parenthesis.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -678,7 +678,7 @@ const ArcaneEnergyCostPerCountable = TypeAlias(import.meta.url, {
             comment: "If defined, in addition to the cost per entity you have to pay a flat amount, regardless of the entity count.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Required, "ArcaneEnergyCostPerCountableTranslation", Object({
+        translations: NestedTranslationMap(Required, "ArcaneEnergyCostPerCountable", Object({
             per: Required({
                 comment: "The cost have to be per a specific countable entity, e.g. `8 AE per person`.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -723,7 +723,7 @@ const IndefiniteArcaneEnergyCost = TypeAlias(import.meta.url, {
             comment: "Specified if the indefinite AP cost description needs to be modified by a certain value.",
             type: IncludeIdentifier(IndefiniteArcaneEnergyCostModifier),
         }),
-        translations: NestedLocaleMap(Required, "IndefiniteArcaneEnergyCostTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteArcaneEnergyCost", Object({
             description: Required({
                 comment: "A description of where the cost come from.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -789,7 +789,7 @@ const ArcaneEnergyCostDisjunctionOption = TypeAlias(import.meta.url, {
             comment: "A possible AE cost value.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "ArcaneEnergyCostDisjunctionOptionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ArcaneEnergyCostDisjunctionOption", Object({
             note: Optional({
                 comment: "A note, appended to the generated option string in parenthesis.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -800,7 +800,7 @@ const ArcaneEnergyCostDisjunctionOption = TypeAlias(import.meta.url, {
 const NoArcaneEnergyCost = TypeAlias(import.meta.url, {
     name: "NoArcaneEnergyCost",
     type: () => Object({
-        translations: NestedLocaleMap(Optional, "NoArcaneEnergyCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "NoArcaneEnergyCost", Object({
             note: Optional({
                 comment: "A note, appended to the generated string in parenthesis.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -908,7 +908,7 @@ This will generate the exact same string as seen above. The associated options a
             comment: "The possible costs and associated labels.",
             type: Array(IncludeIdentifier(VolumeMapOption), { minItems: 2 }),
         }),
-        translations: NestedLocaleMap(Optional, "VolumeMapTranslation", Object({
+        translations: NestedTranslationMap(Optional, "VolumeMap", Object({
             list_prepend: Optional({
                 comment: "Place a string between the `for` and the grouped map option labels.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -935,7 +935,7 @@ const VolumeMapOption = TypeAlias(import.meta.url, {
             comment: "Links to the options this volume specification is meant for.",
             type: Array(IncludeIdentifier(VolumeMapOptionAssociatedOption), { minItems: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "VolumeMapOptionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "VolumeMapOption", Object({
             label: Required({
                 comment: "The description of the option for cost string generation.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -1030,7 +1030,7 @@ This will generate the exact same string as seen above.`,
             comment: "The possible costs and associated labels.",
             type: Array(IncludeIdentifier(BindingCostMapOption), { minItems: 2 }),
         }),
-        translations: NestedLocaleMap(Optional, "BindingCostMapTranslation", Object({
+        translations: NestedTranslationMap(Optional, "BindingCostMap", Object({
             list_prepend: Optional({
                 comment: "Place a string between the `for` and the grouped map option labels.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -1053,7 +1053,7 @@ const BindingCostMapOption = TypeAlias(import.meta.url, {
             comment: "The full permanent AE cost value for this option.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "BindingCostMapOptionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "BindingCostMapOption", Object({
             label: Required({
                 comment: "The description of the option for cost string generation.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -1376,7 +1376,7 @@ const AdventurePointsDerivedFromSelection = TypeAlias(import.meta.url, {
     name: "AdventurePointsDerivedFromSelection",
     comment: "The adventure points value is derived from the selection of the special ability. Its display value may be able to be derived from the given information for the select options. If that is not the case or the generated text would not match the original one, a replacement text can be provided.",
     type: () => Object({
-        translations: NestedLocaleMap(Optional, "AdventurePointsDerivedFromSelectionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "AdventurePointsDerivedFromSelection", Object({
             replacement: Optional({
                 comment: "A replacement for the generated text if it would not match the original one.",
                 type: String({ minLength: 1, isMarkdown: true }),

package/lib/types/_ActivatableSelectOptionCategory.js

@@ -1,5 +1,5 @@
 import { Array, Boolean, Enum, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { CeremonyIdentifier, CloseCombatTechniqueIdentifier, ElementIdentifier, LiturgicalChantIdentifier, RangedCombatTechniqueIdentifier, RitualIdentifier, SkillGroupIdentifier, SkillIdentifier, SpellIdentifier, TargetCategoryIdentifier, } from "./_Identifier.js";
 import { ActivatableIdentifier, CombatTechniqueIdentifier, SkillishIdentifier, } from "./_IdentifierGroup.js";
 export const SelectOptionCategory = Enum(import.meta.url, {
@@ -219,7 +219,7 @@ const SkillApplicationOrUse = TypeAlias(import.meta.url, {
             comment: "The application’s or use’s identifier. An entry-unique, increasing integer.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "SkillApplicationOrUseTranslation", Object({
+        translations: NestedTranslationMap(Optional, "SkillApplicationOrUse", Object({
             name: Required({
                 comment: "The name of the application or use if different from the activatable entry’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/_ActivatableSkillCost.js

@@ -2,7 +2,7 @@ import { Array, Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Opt
 import { DurationUnitValue } from "./_ActivatableSkillDuration.js";
 import { SkillModificationLevelIdentifier } from "./_Identifier.js";
 import { ResponsiveText, ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const OneTimeCost = Enum(import.meta.url, {
     name: "OneTimeCost",
     values: () => ({
@@ -37,7 +37,7 @@ const ModifiableOneTimeCost = TypeAlias(import.meta.url, {
             comment: "The part of the cost value that has to be spent permanently.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "ModifiableOneTimeCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ModifiableOneTimeCost", Object({
             replacement: Required({
                 comment: "A replacement string.",
                 type: IncludeIdentifier(ResponsiveTextReplace),
@@ -64,7 +64,7 @@ const NonModifiableOneTimeCost = TypeAlias(import.meta.url, {
             comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
             type: IncludeIdentifier(NonModifiableOneTimeCostPerCountable),
         }),
-        translations: NestedLocaleMap(Optional, "NonModifiableOneTimeCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "NonModifiableOneTimeCost", Object({
             note: Required({
                 comment: "A note, appended to the generated string in parenthesis.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -79,7 +79,7 @@ const NonModifiableOneTimeCostPerCountable = TypeAlias(import.meta.url, {
             comment: "If defined, the minimum total AE that have to be spent casting the skill.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "NonModifiableOneTimeCostPerCountableTranslation", Object({
+        translations: NestedTranslationMap(Optional, "NonModifiableOneTimeCostPerCountable", Object({
             countable: Required({
                 comment: "The countable entity name.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -90,7 +90,7 @@ const NonModifiableOneTimeCostPerCountable = TypeAlias(import.meta.url, {
 export const IndefiniteOneTimeCost = TypeAlias(import.meta.url, {
     name: "IndefiniteOneTimeCost",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "IndefiniteOneTimeCostTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteOneTimeCost", Object({
             description: Required({
                 comment: "A description of where the cost come from.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -123,7 +123,7 @@ This will generate the exact same string as seen above – given it is set for a
                 minItems: 2,
             }),
         }),
-        translations: NestedLocaleMap(Optional, "CostMapTranslation", Object({
+        translations: NestedTranslationMap(Optional, "CostMap", Object({
             list_prepend: Optional({
                 comment: "Place a string between the `for` and the grouped map option labels.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -150,7 +150,7 @@ const CostMapOption = TypeAlias(import.meta.url, {
             comment: "The part of the `value` that has to be paid permanently.",
             type: Integer({ minimum: 0 }),
         }),
-        translations: NestedLocaleMap(Optional, "CostMapOptionTranslation", Object({
+        translations: NestedTranslationMap(Optional, "CostMapOption", Object({
             label: Required({
                 comment: "The description of the option for cost string generation.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -214,7 +214,7 @@ const NonModifiableSustainedCostPerCountable = TypeAlias(import.meta.url, {
             comment: "If defined, the minimum total AE that have to be spent casting the skill.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Required, "NonModifiableSustainedCostPerCountableTranslation", Object({
+        translations: NestedTranslationMap(Required, "NonModifiableSustainedCostPerCountable", Object({
             countable: Required({
                 comment: "The countable entity name.",
                 type: IncludeIdentifier(ResponsiveText),

package/lib/types/_ActivatableSkillDuration.js

@@ -1,7 +1,7 @@
 import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
 import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
 import { ResponsiveText, ResponsiveTextReplace } from "./_ResponsiveText.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const DurationForOneTime = Enum(import.meta.url, {
     name: "DurationForOneTime",
     values: () => ({
@@ -19,7 +19,7 @@ const Immediate = TypeAlias(import.meta.url, {
             comment: "Specified if the duration has a maximum time span.",
             type: IncludeIdentifier(DurationUnitValue),
         }),
-        translations: NestedLocaleMap(Optional, "ImmediateTranslation", Object({
+        translations: NestedTranslationMap(Optional, "Immediate", Object({
             replacement: Optional({
                 comment: "A replacement string.",
                 type: IncludeIdentifier(ResponsiveTextReplace),
@@ -30,7 +30,7 @@ const Immediate = TypeAlias(import.meta.url, {
 const PermanentDuration = TypeAlias(import.meta.url, {
     name: "PermanentDuration",
     type: () => Object({
-        translations: NestedLocaleMap(Optional, "PermanentDurationTranslation", Object({
+        translations: NestedTranslationMap(Optional, "PermanentDuration", Object({
             replacement: Optional({
                 comment: "A replacement string.",
                 type: IncludeIdentifier(ResponsiveTextReplace),
@@ -53,7 +53,7 @@ export const FixedDuration = TypeAlias(import.meta.url, {
             comment: "The duration unit.",
             type: IncludeIdentifier(DurationUnit),
         }),
-        translations: NestedLocaleMap(Optional, "FixedDurationTranslation", Object({
+        translations: NestedTranslationMap(Optional, "FixedDuration", Object({
             replacement: Optional({
                 comment: "A replacement string.",
                 type: IncludeIdentifier(ResponsiveTextReplace),
@@ -80,7 +80,7 @@ export const CheckResultBasedDuration = TypeAlias(import.meta.url, {
             comment: "The duration unit.",
             type: IncludeIdentifier(DurationUnit),
         }),
-        translations: NestedLocaleMap(Optional, "CheckResultBasedDurationTranslation", Object({
+        translations: NestedTranslationMap(Optional, "CheckResultBasedDuration", Object({
             replacement: Optional({
                 comment: "A replacement string.",
                 type: IncludeIdentifier(ResponsiveTextReplace),
@@ -91,7 +91,7 @@ export const CheckResultBasedDuration = TypeAlias(import.meta.url, {
 export const IndefiniteDuration = TypeAlias(import.meta.url, {
     name: "IndefiniteDuration",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "IndefiniteDurationTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteDuration", Object({
             description: Required({
                 comment: "A description of the duration.",
                 type: IncludeIdentifier(ResponsiveText),

package/lib/types/_ActivatableSkillRange.js

@@ -2,7 +2,7 @@ import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional,
 import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
 import { SkillModificationLevelIdentifier } from "./_Identifier.js";
 import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const Range = TypeAlias(import.meta.url, {
     name: "Range",
     type: () => Object({
@@ -10,7 +10,7 @@ export const Range = TypeAlias(import.meta.url, {
             comment: "The range value.",
             type: IncludeIdentifier(RangeValue),
         }),
-        translations: NestedLocaleMap(Optional, "RangeTranslation", Object({
+        translations: NestedTranslationMap(Optional, "Range", Object({
             note: Optional({
                 comment: "A note, appended to the generated string in parenthesis. If the generated is modified using `replacement`, the note is appended to the modifier string.",
                 type: IncludeIdentifier(ResponsiveTextOptional),

package/lib/types/_ActivatableSkillTargetCategory.js

@@ -1,5 +1,5 @@
 import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { TargetCategoryIdentifier } from "./_Identifier.js";
 export const AffectedTargetCategories = TypeAlias(import.meta.url, {
     name: "AffectedTargetCategories",
@@ -12,7 +12,7 @@ const SpecificAffectedTargetCategory = TypeAlias(import.meta.url, {
     name: "SpecificAffectedTargetCategory",
     type: () => Object({
         id: Required({ type: IncludeIdentifier(SpecificAffectedTargetCategoryIdentifier) }),
-        translations: NestedLocaleMap(Optional, "SpecificAffectedTargetCategoryTranslation", Object({
+        translations: NestedTranslationMap(Optional, "SpecificAffectedTargetCategory", Object({
             note: Required({ type: String({ minLength: 1 }) }),
         })),
     }),

package/lib/types/_ArcaneTradition.d.ts

@@ -24,7 +24,7 @@ export declare const ArcaneTraditionType: <TN extends string>(translationName: T
             }>, true>;
         }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
     }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<TN, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${TN}Translation`, {
         name: import("tsondb/schema/def").MemberDecl<String, true>;
     }>, true>;
 }>;

package/lib/types/_ArcaneTradition.js

@@ -1,11 +1,11 @@
 import { IncludeIdentifier, Object, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { ArcaneTraditionPrerequisites } from "./_Prerequisite.js";
 export const ArcaneTraditionType = (translationName) => () => Object({
     prerequisites: Required({
         type: IncludeIdentifier(ArcaneTraditionPrerequisites),
     }),
-    translations: NestedLocaleMap(Required, translationName, Object({
+    translations: NestedTranslationMap(Required, translationName, Object({
         name: Required({
             comment: "The arcane tradition’s name.",
             type: String({ minLength: 1 }),

package/lib/types/_DiseasePoison.js

@@ -2,7 +2,7 @@
  * This file defines some shared types for different diseases and poisons.
  */
 import { Array, Enum, EnumCase, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { AlternativeName } from "./_AlternativeNames.js";
 import { Errata } from "./source/_Erratum.js";
 export const level = Required({
@@ -30,7 +30,7 @@ export const Cause = TypeAlias(import.meta.url, {
             comment: "The chance to get infected by this cause, in percent. Some causes do not have a specific chance.",
             type: Integer({ minimum: 5, multipleOf: 5, maximum: 100 }),
         }),
-        translations: NestedLocaleMap(Required, "CauseTranslation", Object({
+        translations: NestedTranslationMap(Required, "Cause", Object({
             name: Required({
                 comment: "The cause’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/_Enhancements.d.ts

@@ -37,7 +37,7 @@ export declare const Enhancements: TypeAlias<"Enhancements", ChildEntities<Entit
     }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
@@ -119,7 +119,7 @@ export declare const Enhancement: Entity<"Enhancement", {
     }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{

package/lib/types/_Enhancements.js

@@ -4,7 +4,7 @@
 import { ChildEntities, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js";
 import { EnhancementPrerequisites } from "./_Prerequisite.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { PublicationRefs } from "./source/_PublicationRef.js";
 export const Enhancements = TypeAlias(import.meta.url, {
@@ -41,7 +41,7 @@ export const Enhancement = Entity(import.meta.url, {
             comment: "Only defined if different than the associated skill.",
             type: IncludeIdentifier(PublicationRefs),
         }),
-        translations: NestedLocaleMap(Required, "EnhancementTranslation", Object({
+        translations: NestedTranslationMap(Required, "Enhancement", Object({
             name: Required({
                 comment: "The name of the enhancement.",
                 type: String({

package/lib/types/_Influence.d.ts

@@ -26,7 +26,7 @@ export declare const Influence: Entity<"Influence", {
     }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{