optolith-database-schema 0.18.4 → 0.18.6

package/lib/types/magicalActions/GeodeRitual.js

@@ -8,7 +8,7 @@ import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
 import { PropertyIdentifier } from "../_Identifier.js";
 import { GeodeRitualPrerequisites } from "../_Prerequisite.js";
 import { SkillCheck } from "../_SkillCheck.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 GeodeRitual = Entity(import.meta.url, {
@@ -36,7 +36,7 @@ export const GeodeRitual = Entity(import.meta.url, {
             type: IncludeIdentifier(GeodeRitualPrerequisites),
         }),
         src,
-        translations: NestedLocaleMap(Required, "GeodeRitualTranslation", Object({
+        translations: NestedTranslationMap(Required, "GeodeRitual", Object({
             name: Required({
                 comment: "The geode ritual’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/magicalActions/JesterTrick.d.ts

@@ -95,7 +95,7 @@ export declare const JesterTrick: Entity<"JesterTrick", {
     }, []>>, true>;
     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/magicalActions/JesterTrick.js

@@ -6,7 +6,7 @@ import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
 import { PropertyIdentifier } from "../_Identifier.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
 import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.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 JesterTrick = Entity(import.meta.url, {
@@ -38,7 +38,7 @@ export const JesterTrick = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "JesterTrickTranslation", Object({
+        translations: NestedTranslationMap(Required, "JesterTrick", Object({
             name: Required({
                 comment: "The jester trick’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/magicalActions/MagicalDance.d.ts

@@ -42,7 +42,7 @@ export declare const MagicalDance: Entity<"MagicalDance", {
     property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
     music_tradition: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<string, Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
             name: import("tsondb/schema/def").MemberDecl<String, true>;
         }>, true>;
     }>, []>>>, true>;
@@ -54,7 +54,7 @@ export declare const MagicalDance: Entity<"MagicalDance", {
     }, []>>, true>;
     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/magicalActions/MagicalDance.js

@@ -6,7 +6,7 @@ import { ArcaneDancerTraditionIdentifier, PropertyIdentifier } from "../_Identif
 import { ImprovementCost } from "../_ImprovementCost.js";
 import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js";
 import { SkillCheck } from "../_SkillCheck.js";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
 import { MusicDuration, MusicTraditionReference } from "./_MusicTradition.js";
@@ -37,7 +37,7 @@ export const MagicalDance = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "MagicalDanceTranslation", Object({
+        translations: NestedTranslationMap(Required, "MagicalDance", Object({
             name: Required({
                 comment: "The magical dance’s name.",
                 type: String({ minLength: 1 }),
@@ -89,7 +89,7 @@ const FixedMagicalDanceCost = TypeAlias(import.meta.url, {
             comment: "The (temporary) AE cost value.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "FixedMagicalDanceCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "FixedMagicalDanceCost", Object({
             per: Optional({
                 comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -104,7 +104,7 @@ const IndefiniteMagicalDanceCost = TypeAlias(import.meta.url, {
             comment: "Specified if the indefinite description's result value is to be modified by a certain number.",
             type: IncludeIdentifier(CheckResultBasedModifier),
         }),
-        translations: NestedLocaleMap(Required, "IndefiniteMagicalDanceCostTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteMagicalDanceCost", Object({
             description: Required({
                 comment: "A description of where the cost come from.",
                 type: IncludeIdentifier(ResponsiveText),

package/lib/types/magicalActions/MagicalMelody.d.ts

@@ -33,7 +33,7 @@ export declare const MagicalMelody: Entity<"MagicalMelody", {
     property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
     music_tradition: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<string, Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
             name: import("tsondb/schema/def").MemberDecl<String, true>;
         }>, true>;
     }>, []>>>, true>;
@@ -45,7 +45,7 @@ export declare const MagicalMelody: Entity<"MagicalMelody", {
     }, []>>, true>;
     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/magicalActions/MagicalMelody.js

@@ -4,7 +4,7 @@ import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
 import { ArcaneBardTraditionIdentifier, PropertyIdentifier, SkillIdentifier, } from "../_Identifier.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
 import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
 import { MusicDuration, MusicTraditionReference } from "./_MusicTradition.js";
@@ -47,7 +47,7 @@ export const MagicalMelody = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "MagicalMelodyTranslation", Object({
+        translations: NestedTranslationMap(Required, "MagicalMelody", Object({
             name: Required({
                 comment: "The magical melody’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/magicalActions/MagicalRune.d.ts

@@ -169,7 +169,7 @@ export declare const MagicalRune: Entity<"MagicalRune", {
     }, []>>, true>;
     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/magicalActions/MagicalRune.js

@@ -8,7 +8,7 @@ import { CombatTechniqueIdentifier } from "../_IdentifierGroup.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
 import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.js";
 import { SkillCheck } from "../_SkillCheck.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 MagicalRune = Entity(import.meta.url, {
@@ -42,7 +42,7 @@ If there are multiple options, the magical rune may be activated for each option
             type: IncludeIdentifier(MagicalRuneImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "MagicalRuneTranslation", Object({
+        translations: NestedTranslationMap(Required, "MagicalRune", Object({
             name: Required({
                 comment: `The magical rune’s name.
 
@@ -170,7 +170,7 @@ const SingleMagicalRuneCost = TypeAlias(import.meta.url, {
             comment: "The AE cost value.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "SingleMagicalRuneCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "SingleMagicalRuneCost", Object({
             note: Required({
                 comment: "A note, appended to the generated string in parenthesis.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -194,7 +194,7 @@ const MagicalRuneCraftingTime = TypeAlias(import.meta.url, {
             comment: "The crafting time in actions.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "MagicalRuneCraftingTimeTranslation", Object({
+        translations: NestedTranslationMap(Optional, "MagicalRuneCraftingTime", Object({
             per: Required({
                 comment: "The crafting time has to be per a specific countable entity, e.g. `8 actions per person`.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -241,7 +241,7 @@ export const MagicalRuneOption = Entity(import.meta.url, {
         suboption: Optional({
             type: IncludeIdentifier(MagicalRuneSuboption),
         }),
-        translations: NestedLocaleMap(Required, "MagicalRuneOptionTranslation", Object({
+        translations: NestedTranslationMap(Required, "MagicalRuneOption", Object({
             name: Required({
                 comment: `The magical rune option’s name.
 
@@ -269,7 +269,7 @@ const MagicalRuneSuboption = Enum(import.meta.url, {
 const CustomMagicalRuneSuboption = TypeAlias(import.meta.url, {
     name: "CustomMagicalRuneSuboption",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "CustomMagicalRuneSuboptionTranslation", Object({
+        translations: NestedTranslationMap(Required, "CustomMagicalRuneSuboption", Object({
             examples: Optional({
                 comment: "One or more examples for the suboption.",
                 type: Array(String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),

package/lib/types/magicalActions/ZibiljaRitual.d.ts

@@ -331,7 +331,7 @@ export declare const ZibiljaRitual: Entity<"ZibiljaRitual", {
     }, []>>, true>;
     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<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{

package/lib/types/magicalActions/ZibiljaRitual.js

@@ -6,7 +6,7 @@ import { AffectedTargetCategories } from "../_ActivatableSkillTargetCategory.js"
 import { PropertyIdentifier } from "../_Identifier.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
 import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.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 ZibiljaRitual = Entity(import.meta.url, {
@@ -38,7 +38,7 @@ export const ZibiljaRitual = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "ZibiljaRitualTranslation", Object({
+        translations: NestedTranslationMap(Required, "ZibiljaRitual", Object({
             name: Required({
                 comment: "The zibilja ritual’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/magicalActions/_MusicTradition.d.ts

@@ -1,7 +1,7 @@
 import { Enum, EnumCase, IncludeIdentifier, Object, ReferenceIdentifier, String, TypeAlias } from "tsondb/schema/def";
 export declare const MusicTraditionReference: (traditionIdentifier: ReferenceIdentifier) => TypeAlias<string, Object<{
     id: import("tsondb/schema/def").MemberDecl<ReferenceIdentifier, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<string, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
         name: import("tsondb/schema/def").MemberDecl<String, true>;
     }>, true>;
 }>, []>;

package/lib/types/magicalActions/_MusicTradition.js

@@ -1,5 +1,5 @@
 import { Enum, EnumCase, IncludeIdentifier, Object, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 export const MusicTraditionReference = (traditionIdentifier) => TypeAlias(import.meta.url, {
     name: traditionIdentifier.entity.name + "Reference",
     comment: "A reference to a music tradition with the music-tradition-specific name of the entry.",
@@ -8,7 +8,7 @@ export const MusicTraditionReference = (traditionIdentifier) => TypeAlias(import
             comment: "The music tradition’s identifier.",
             type: traditionIdentifier,
         }),
-        translations: NestedLocaleMap(Required, traditionIdentifier.entity.name + "ReferenceTranslation", Object({
+        translations: NestedTranslationMap(Required, traditionIdentifier.entity.name + "ReferenceTranslation", Object({
             name: Required({
                 comment: "The music-tradition-specific name of the entry.",
                 type: String({ minLength: 1 }),

package/lib/types/prerequisites/DisplayOption.js

@@ -1,5 +1,5 @@
 import { Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 import { SentenceType } from "./single/TextPrerequisite.js";
 export const DisplayOption = Enum(import.meta.url, {
     name: "DisplayOption",
@@ -17,7 +17,7 @@ const ReplacementDisplayOption = TypeAlias(import.meta.url, {
 A standalone sentence is connected to the previous prerequisite string with a period and a period is also added at the end of the sentence automatically, if it is not present. A connected sentence is connected to the previous prerequisite string with a semicolon and a period is not added to the end of the sentence. In this case, if there are prerequisites after this one, they will be connected using a semicolon again, unless a different punctuation mark is present at the end of the given text.`,
             type: IncludeIdentifier(SentenceType),
         }),
-        translations: NestedLocaleMap(Required, "ReplacementDisplayOptionTranslation", Object({
+        translations: NestedTranslationMap(Required, "ReplacementDisplayOption", Object({
             replacement: Required({
                 comment: "The replacement text.",
                 type: String({ minLength: 1 }),

package/lib/types/prerequisites/single/TextPrerequisite.js

@@ -1,5 +1,5 @@
 import { Boolean, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../../Locale.js";
+import { NestedTranslationMap } from "../../Locale.js";
 export const TextPrerequisite = TypeAlias(import.meta.url, {
     name: "TextPrerequisite",
     comment: "A prerequisite that is either not verifyable in general – e.g. roleplay or background information – or the referenced entities were not made available for use yet – e.g. races –, but which should be displayed, because it is part of the prerequisite string from the sources.",
@@ -22,7 +22,7 @@ If all prerequisites of an entry are marked as meta, the entry is considered to
 This is the only use case for this property.`,
             type: Boolean(),
         }),
-        translations: NestedLocaleMap(Required, "TextPrerequisiteTranslation", Object({
+        translations: NestedTranslationMap(Required, "TextPrerequisite", Object({
             text: Required({
                 comment: "The displayed text.",
                 type: String({ minLength: 1, isMarkdown: true }),

package/lib/types/rule/CoreRule.d.ts

@@ -94,7 +94,7 @@ export declare const CoreRule: Entity<"CoreRule", {
     }, []>>>, true>;
     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/rule/CoreRule.js

@@ -1,7 +1,7 @@
 import { Array, Boolean, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { CoreRuleIdentifier } from "../_Identifier.js";
 import { CoreRuleDerivableContentIdentifier } from "../_IdentifierGroup.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 CoreRule = Entity(import.meta.url, {
@@ -12,7 +12,7 @@ export const CoreRule = Entity(import.meta.url, {
             type: Array(IncludeIdentifier(ContentNode), { minItems: 1 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "CoreRuleTranslation", Object({
+        translations: NestedTranslationMap(Required, "CoreRule", Object({
             name: Required({
                 comment: "The core rule’s name.",
                 type: String({ minLength: 1 }),
@@ -51,7 +51,7 @@ const TextNode = TypeAlias(import.meta.url, {
     name: "TextNode",
     comment: "A simple text block, containing one or multiple paragraphs. Headings are not allowed, they should be handled as nested core rules instead.",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "TextNodeTranslation", Object({
+        translations: NestedTranslationMap(Required, "TextNode", Object({
             text: Required({
                 comment: "Markdown-formatted text.",
                 type: String({ minLength: 1, isMarkdown: true }),
@@ -66,7 +66,7 @@ const ReferenceListNode = TypeAlias(import.meta.url, {
         source: Required({
             type: IncludeIdentifier(ReferenceListNodeSource),
         }),
-        translations: NestedLocaleMap(Required, "ReferenceListNodeTranslation", Object({
+        translations: NestedTranslationMap(Required, "ReferenceListNode", Object({
             text: Required({
                 comment: "Markdown-formatted text.",
                 type: String({ minLength: 1, isMarkdown: true }),

package/lib/types/rule/FocusRule.d.ts

@@ -5,7 +5,7 @@ export declare const FocusRule: Entity<"FocusRule", {
     isMissingImplementation: import("tsondb/schema/def").MemberDecl<Boolean, true>;
     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<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/rule/FocusRule.js

@@ -1,6 +1,6 @@
 import { Boolean, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, } from "tsondb/schema/def";
 import { SubjectIdentifier } 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 FocusRule = Entity(import.meta.url, {
@@ -20,7 +20,7 @@ export const FocusRule = Entity(import.meta.url, {
             type: Boolean(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "FocusRuleTranslation", Object({
+        translations: NestedTranslationMap(Required, "FocusRule", Object({
             name: Required({
                 comment: "The focus rule’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/rule/FocusRule_Subject.js

@@ -1,11 +1,11 @@
 import { Entity, Object, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 export const Subject = Entity(import.meta.url, {
     name: "Subject",
     namePlural: "Subjects",
     comment: "Subjects or Subject Areas are the categories of Focus Rules.",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "SubjectTranslation", Object({
+        translations: NestedTranslationMap(Required, "Subject", Object({
             name: Required({
                 comment: "The subject.",
                 type: String({ minLength: 1 }),

package/lib/types/rule/OptionalRule.d.ts

@@ -3,7 +3,7 @@ export declare const OptionalRule: Entity<"OptionalRule", {
     isMissingImplementation: import("tsondb/schema/def").MemberDecl<Boolean, true>;
     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<{
@@ -44,6 +44,7 @@ export declare const OptionalRule: Entity<"OptionalRule", {
     translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"OptionalRuleTranslation", {
         name: import("tsondb/schema/def").MemberDecl<String, true>;
         description: import("tsondb/schema/def").MemberDecl<String, true>;
+        additionalRules: import("tsondb/schema/def").MemberDecl<String, true>;
         errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Errata", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Erratum", Object<{
             date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
             description: import("tsondb/schema/def").MemberDecl<String, true>;

package/lib/types/rule/OptionalRule.js

@@ -1,5 +1,5 @@
 import { Boolean, 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 OptionalRule = Entity(import.meta.url, {
@@ -11,13 +11,17 @@ export const OptionalRule = Entity(import.meta.url, {
             type: Boolean(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "OptionalRuleTranslation", Object({
+        translations: NestedTranslationMap(Required, "OptionalRule", Object({
             name: Required({
                 comment: "The optional rule’s name.",
                 type: String({ minLength: 1 }),
             }),
             description: Required({
-                comment: "The description of the optional rule.",
+                comment: "The description of the optional rule, as stated in the optional rule box.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            additionalRules: Required({
+                comment: "Sometimes, an optional rule does not only contain all the rules belonging to it in its rule box, but also in the main text.",
                 type: String({ minLength: 1, isMarkdown: true }),
             }),
             errata: Optional({

package/lib/types/source/Publication.js

@@ -1,5 +1,5 @@
 import { Boolean, Date, Entity, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 import { PublicationPrerequisites } from "../_Prerequisite.js";
 export const Publication = Entity(import.meta.url, {
     name: "Publication",
@@ -21,7 +21,7 @@ export const Publication = Entity(import.meta.url, {
         prerequisites: Optional({
             type: IncludeIdentifier(PublicationPrerequisites),
         }),
-        translations: NestedLocaleMap(Required, "PublicationTranslation", Object({
+        translations: NestedTranslationMap(Required, "Publication", Object({
             publisherId: Optional({
                 comment: "The publisher’s publication identifier.",
                 type: String({ minLength: 1 }),

package/lib/types/source/_PublicationRef.d.ts

@@ -1,10 +1,10 @@
 /**
  * @main PublicationRefs
  */
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+import { Array, Enum, EnumCase, IncludeIdentifier, Integer, NestedEntityMap, Object, TypeAlias } from "tsondb/schema/def";
 export declare const PublicationRefs: 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<NestedEntityMap<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<{
@@ -44,7 +44,7 @@ export declare const PublicationRefs: TypeAlias<"PublicationRefs", Array<Include
 }>, []>>>, []>;
 export declare const 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<NestedEntityMap<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<{
@@ -84,7 +84,7 @@ export declare const src: import("tsondb/schema/def").MemberDecl<IncludeIdentifi
 }>, []>>>, []>>, true>;
 export declare const optionalSrc: 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<NestedEntityMap<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<{
@@ -124,7 +124,7 @@ export declare const optionalSrc: import("tsondb/schema/def").MemberDecl<Include
 }>, []>>>, []>>, false>;
 export declare const PublicationRef: 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<NestedEntityMap<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/source/_PublicationRef.js

@@ -1,9 +1,9 @@
 /**
  * @main PublicationRefs
  */
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { Array, Enum, EnumCase, IncludeIdentifier, Integer, NestedEntityMap, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
 import { PublicationIdentifier } from "../_Identifier.js";
-import { NestedLocaleMap } from "../Locale.js";
+import { Locale } from "../Locale.js";
 export const PublicationRefs = TypeAlias(import.meta.url, {
     name: "PublicationRefs",
     comment: "The publications where you can find the entry.",
@@ -23,16 +23,24 @@ export const PublicationRef = TypeAlias(import.meta.url, {
             comment: "The publication’s identifier.",
             type: PublicationIdentifier(),
         }),
-        occurrences: NestedLocaleMap(Required, "Occurrence", Object({
-            initial: Required({
-                comment: "The initial occurrence of the entry.",
-                type: IncludeIdentifier(InitialOccurrence),
+        occurrences: Required({
+            comment: "All translations for the entry, identified by IETF language tag (BCP47).",
+            type: NestedEntityMap({
+                name: "Occurrence",
+                namePlural: "Occurrences",
+                secondaryEntity: Locale,
+                type: Object({
+                    initial: Required({
+                        comment: "The initial occurrence of the entry.",
+                        type: IncludeIdentifier(InitialOccurrence),
+                    }),
+                    revisions: Optional({
+                        comment: "Revisions of the entry, resulting in either changed page references or re-addition or removal of an entry.",
+                        type: Array(IncludeIdentifier(Revision), { minItems: 1 }),
+                    }),
+                }),
             }),
-            revisions: Optional({
-                comment: "Revisions of the entry, resulting in either changed page references or re-addition or removal of an entry.",
-                type: Array(IncludeIdentifier(Revision), { minItems: 1 }),
-            }),
-        })),
+        }),
     }),
 });
 const InitialOccurrence = TypeAlias(import.meta.url, {

package/lib/types/specialAbility/AdvancedCombatSpecialAbility.d.ts

@@ -700,7 +700,7 @@ export declare const AdvancedCombatSpecialAbility: Entity<"AdvancedCombatSpecial
                 ap_value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, 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<{
@@ -781,7 +781,7 @@ export declare const AdvancedCombatSpecialAbility: Entity<"AdvancedCombatSpecial
                 ap_value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, 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<{
@@ -982,7 +982,7 @@ export declare const AdvancedCombatSpecialAbility: Entity<"AdvancedCombatSpecial
     }, []>>, true>;
     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/specialAbility/AdvancedCombatSpecialAbility.js

@@ -1,7 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { ap_value, ap_value_append, ap_value_l10n, combat_techniques, levels, maximum, name, name_in_library, penalty, rules, select_options, skill_applications, skill_uses, usage_type, } from "../_Activatable.js";
 import { GeneralPrerequisites } from "../_Prerequisite.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 AdvancedCombatSpecialAbility = Entity(import.meta.url, {
@@ -22,7 +22,7 @@ export const AdvancedCombatSpecialAbility = Entity(import.meta.url, {
         combat_techniques,
         ap_value,
         src,
-        translations: NestedLocaleMap(Required, "AdvancedCombatSpecialAbilityTranslation", Object({
+        translations: NestedTranslationMap(Required, "AdvancedCombatSpecialAbility", Object({
             name,
             name_in_library,
             rules,