optolith-database-schema 0.18.4 → 0.18.6

package/lib/types/equipment/item/Poison.js

@@ -1,5 +1,5 @@
 import { Array, Boolean, BooleanType, Entity, Enum, EnumCase, Float, GenIncludeIdentifier, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../../Locale.js";
+import { NestedTranslationMap } from "../../Locale.js";
 import { AlternativeName } from "../../_AlternativeNames.js";
 import { Dice } from "../../_Dice.js";
 import { Reduceable, Resistance } from "../../_DiseasePoison.js";
@@ -39,7 +39,7 @@ export const Poison = Entity(import.meta.url, {
             type: IncludeIdentifier(PoisonCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "PoisonTranslation", Object({
+        translations: NestedTranslationMap(Required, "Poison", Object({
             name: Required({
                 comment: "The name of the poison.",
                 type: String({ minLength: 1 }),
@@ -102,7 +102,7 @@ const PoisonCost = Enum(import.meta.url, {
 export const NoPoisonCost = TypeAlias(import.meta.url, {
     name: "NoPoisonCost",
     type: () => Object({
-        translations: NestedLocaleMap(Optional, "NoPoisonCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "NoPoisonCost", Object({
             description: Required({
                 comment: "A description of the cost.",
                 type: String({ minLength: 1, isMarkdown: true }),
@@ -113,7 +113,7 @@ export const NoPoisonCost = TypeAlias(import.meta.url, {
 export const IndefinitePoisonCost = TypeAlias(import.meta.url, {
     name: "IndefinitePoisonCost",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "IndefinitePoisonCostTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefinitePoisonCost", Object({
             description: Required({
                 comment: "A description of the cost.",
                 type: String({ minLength: 1, isMarkdown: true }),
@@ -159,7 +159,7 @@ const PoisonTimeUnit = Enum(import.meta.url, {
 export const IndefinitePoisonTime = TypeAlias(import.meta.url, {
     name: "IndefinitePoisonTime",
     type: () => Object({
-        translations: NestedLocaleMap(Optional, "IndefinitePoisonTimeTranslation", Object({
+        translations: NestedTranslationMap(Optional, "IndefinitePoisonTime", Object({
             description: Optional({
                 comment: "A description of the duration.",
                 type: String({ minLength: 1, isMarkdown: true }),
@@ -224,7 +224,7 @@ export const AlchemicalPoison = TypeAlias(import.meta.url, {
             comment: "Additional information if the poison is an intoxicant.",
             type: IncludeIdentifier(Intoxicant),
         }),
-        translations: NestedLocaleMap(Required, "AlchemicalPoisonTranslation", Object({
+        translations: NestedTranslationMap(Required, "AlchemicalPoison", Object({
             typical_ingredients: Required({
                 comment: "A list of typical ingredients.",
                 type: Array(String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
@@ -269,7 +269,7 @@ export const DemonicPoison = TypeAlias(import.meta.url, {
             comment: "The poison’s level.",
             type: IncludeIdentifier(DemonicPoisonLevel),
         }),
-        translations: NestedLocaleMap(Optional, "DemonicPoisonTranslation", Object({
+        translations: NestedTranslationMap(Optional, "DemonicPoison", Object({
             note: Optional({
                 comment: "A note, if any.",
                 type: String({ minLength: 1, isMarkdown: true }),
@@ -318,7 +318,7 @@ export const Intoxicant = TypeAlias(import.meta.url, {
             comment: "The chance of getting addicted after an ingestion in addition to the maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.",
             type: IncludeIdentifier(IntoxicantAddiction),
         }),
-        translations: NestedLocaleMap(Required, "IntoxicantTranslation", Object({
+        translations: NestedTranslationMap(Required, "Intoxicant", Object({
             ingestion: Required({
                 comment: "How to ingest the intoxicant.",
                 type: String({ minLength: 1 }),

package/lib/types/equipment/item/RopeOrChain.d.ts

@@ -125,7 +125,7 @@ export declare const RopeOrChain: import("tsondb/schema/def").EntityDecl<string,
     }, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRef", import("tsondb/schema/def").ObjectType<{
         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<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", import("tsondb/schema/def").ObjectType<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", import("tsondb/schema/def").ObjectType<{
@@ -163,7 +163,7 @@ export declare const RopeOrChain: import("tsondb/schema/def").EntityDecl<string,
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/Stationery.d.ts

@@ -125,7 +125,7 @@ export declare const Stationery: import("tsondb/schema/def").EntityDecl<string,
     }, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRef", import("tsondb/schema/def").ObjectType<{
         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<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", import("tsondb/schema/def").ObjectType<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", import("tsondb/schema/def").ObjectType<{
@@ -163,7 +163,7 @@ export declare const Stationery: import("tsondb/schema/def").EntityDecl<string,
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/ThievesTool.d.ts

@@ -125,7 +125,7 @@ export declare const ThievesTool: import("tsondb/schema/def").EntityDecl<string,
     }, []>>, false>;
     src: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRef", import("tsondb/schema/def").ObjectType<{
         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<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", import("tsondb/schema/def").ObjectType<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", import("tsondb/schema/def").ObjectType<{
@@ -163,7 +163,7 @@ export declare const ThievesTool: import("tsondb/schema/def").EntityDecl<string,
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/ToolOfTheTrade.d.ts

@@ -31,7 +31,7 @@ export declare const ToolOfTheTrade: Entity<"ToolOfTheTrade", {
     }>, []>>>, []>>, 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<{
@@ -69,7 +69,7 @@ export declare const ToolOfTheTrade: Entity<"ToolOfTheTrade", {
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/TravelGearOrTool.d.ts

@@ -126,7 +126,7 @@ export declare const TravelGearOrTool: Entity<"TravelGearOrTool", {
     }, []>>, 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<{
@@ -164,7 +164,7 @@ export declare const TravelGearOrTool: Entity<"TravelGearOrTool", {
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/Vehicle.d.ts

@@ -20,7 +20,7 @@ export declare const Vehicle: Entity<"Vehicle", {
     }, []>>, 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<{
@@ -58,7 +58,7 @@ export declare const Vehicle: Entity<"Vehicle", {
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/Weapon.d.ts

@@ -97,7 +97,7 @@ export declare const Weapon: Entity<"Weapon", {
     restricted_to_traditions: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, 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<NestedEntityMap<"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<import("tsondb/schema/def").IntegerType, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{

package/lib/types/equipment/item/Weapon.js

@@ -1,7 +1,7 @@
 import { Array, Entity, Enum, EnumCase, IncludeIdentifier, NestedEntityMap, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifier, RaceIdentifier, } from "../../_Identifier.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
-import { NestedLocaleMap } from "../../Locale.js";
+import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
 import { Complexity, Cost, StructurePoints, Weight } from "./_Item.js";
@@ -31,6 +31,7 @@ export const Weapon = Entity(import.meta.url, {
             comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
             type: NestedEntityMap({
                 name: "MeleeWeaponUse",
+                namePlural: "MeleeWeaponUses",
                 secondaryEntity: CloseCombatTechnique,
                 type: IncludeIdentifier(MeleeWeapon),
             }),
@@ -39,6 +40,7 @@ export const Weapon = Entity(import.meta.url, {
             comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
             type: NestedEntityMap({
                 name: "RangedWeaponUse",
+                namePlural: "RangedWeaponUses",
                 secondaryEntity: RangedCombatTechnique,
                 type: IncludeIdentifier(RangedWeapon),
             }),
@@ -56,7 +58,7 @@ export const Weapon = Entity(import.meta.url, {
             type: Array(MagicalTraditionIdentifier(), { minItems: 1 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "WeaponTranslation", Object({
+        translations: NestedTranslationMap(Required, "Weapon", Object({
             name: Required({
                 comment: "The item’s name.",
                 type: String({ minLength: 1 }),
@@ -95,6 +97,7 @@ export const ImprovisedWeapon = TypeAlias(import.meta.url, {
             comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
             type: NestedEntityMap({
                 name: "ImprovisedMeleeWeaponUse",
+                namePlural: "ImprovisedMeleeWeaponUses",
                 secondaryEntity: CloseCombatTechnique,
                 type: IncludeIdentifier(MeleeWeapon),
             }),
@@ -103,6 +106,7 @@ export const ImprovisedWeapon = TypeAlias(import.meta.url, {
             comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
             type: NestedEntityMap({
                 name: "ImprovisedRangedWeaponUse",
+                namePlural: "ImprovisedRangedWeaponUses",
                 secondaryEntity: RangedCombatTechnique,
                 type: IncludeIdentifier(RangedWeapon),
             }),
@@ -119,7 +123,7 @@ export const ImprovisedWeapon = TypeAlias(import.meta.url, {
             comment: "Define if during character creation this weapon can only be bought by characters of specific magical or blessed traditions.",
             type: Array(MagicalTraditionIdentifier(), { minItems: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "ImprovisedWeaponTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ImprovisedWeapon", Object({
             advantage: Optional({
                 comment: "The weapon advantage text.",
                 type: String({ minLength: 1, isMarkdown: true }),

package/lib/types/equipment/item/WeaponAccessory.d.ts

@@ -126,7 +126,7 @@ export declare const WeaponAccessory: Entity<"WeaponAccessory", {
     }, []>>, 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<{
@@ -164,7 +164,7 @@ export declare const WeaponAccessory: Entity<"WeaponAccessory", {
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
         note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;

package/lib/types/equipment/item/_Item.d.ts

@@ -126,7 +126,7 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
     }, []>>, 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<{
@@ -164,7 +164,7 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
         name: import("tsondb/schema/def").MemberDecl<String, true>;
         secondary_name: import("tsondb/schema/def").MemberDecl<String, false>;
         note: import("tsondb/schema/def").MemberDecl<String, false>;
@@ -175,7 +175,7 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
         }>, []>>>, []>>, false>;
     }>, true>;
 }, undefined>;
-export declare const DefaultItemTranslations: (singularName: string) => import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
+export declare const DefaultItemTranslations: (singularName: string) => import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}TranslationTranslation`, {
     name: import("tsondb/schema/def").MemberDecl<String, true>;
     secondary_name: import("tsondb/schema/def").MemberDecl<String, false>;
     note: import("tsondb/schema/def").MemberDecl<String, false>;

package/lib/types/equipment/item/_Item.js

@@ -1,5 +1,5 @@
 import { Array, Entity, Enum, EnumCase, Float, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } 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";
 import { SecondaryArmor } from "./Armor.js";
@@ -33,7 +33,7 @@ export const DefaultItem = (sourceUrl, singularName, pluralName) => Entity(sourc
     }),
     displayName: {},
 });
-export const DefaultItemTranslations = (singularName) => NestedLocaleMap(Required, `${singularName}Translation`, Object({
+export const DefaultItemTranslations = (singularName) => NestedTranslationMap(Required, `${singularName}Translation`, Object({
     name: Required({
         comment: "The item’s name.",
         type: String({ minLength: 1 }),
@@ -98,7 +98,7 @@ export const FixedCost = TypeAlias(import.meta.url, {
             comment: "The cost in silverthalers.",
             type: Float({ minimum: { value: 0, isExclusive: true } }),
         }),
-        translations: NestedLocaleMap(Optional, "FixedCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "FixedCost", Object({
             wrap_in_text,
         })),
     }),
@@ -114,7 +114,7 @@ const CostRange = TypeAlias(import.meta.url, {
             comment: "The upper bound of the cost in silverthalers.",
             type: Float({ minimum: { value: 0, isExclusive: true } }),
         }),
-        translations: NestedLocaleMap(Optional, "CostRangeTranslation", Object({
+        translations: NestedTranslationMap(Optional, "CostRange", Object({
             wrap_in_text,
         })),
     }),

package/lib/types/equipment/item/sub/ArmorType.js

@@ -1,5 +1,5 @@
 import { Entity, Integer, Object, Optional, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../../../Locale.js";
+import { NestedTranslationMap } from "../../../Locale.js";
 export const ArmorType = Entity(import.meta.url, {
     name: "ArmorType",
     namePlural: "ArmorTypes",
@@ -8,7 +8,7 @@ export const ArmorType = Entity(import.meta.url, {
             comment: "An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.",
             type: Integer({ minimum: 1, maximum: 20 }),
         }),
-        translations: NestedLocaleMap(Required, "ArmorTypeTranslation", Object({
+        translations: NestedTranslationMap(Required, "ArmorType", Object({
             name: Required({
                 comment: "The armor type’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/equipment/item/sub/Reach.js

@@ -1,10 +1,10 @@
 import { Entity, Object, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../../../Locale.js";
+import { NestedTranslationMap } from "../../../Locale.js";
 export const Reach = Entity(import.meta.url, {
     name: "Reach",
     namePlural: "Reaches",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "ReachTranslation", Object({
+        translations: NestedTranslationMap(Required, "Reach", Object({
             name: Required({
                 comment: "The reach’s name.",
                 type: String({ minLength: 1 }),

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

@@ -182,7 +182,7 @@ export declare const AnimistPower: Entity<"AnimistPower", {
         level: import("tsondb/schema/def").MemberDecl<Integer, 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<{
@@ -226,7 +226,7 @@ export declare const AnimistPower: Entity<"AnimistPower", {
     }>, []>>>, 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/magicalActions/AnimistPower.js

@@ -8,7 +8,7 @@ import { ImprovementCost } from "../_ImprovementCost.js";
 import { AnimistPowerPrerequisites } from "../_Prerequisite.js";
 import { 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 { PublicationRefs, src } from "../source/_PublicationRef.js";
 export const AnimistPower = Entity(import.meta.url, {
@@ -46,7 +46,7 @@ If no tribe tradition is given, the animist power is generally available to all
             type: Array(IncludeIdentifier(AnimistPowerLevel), { minItems: 1 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "AnimistPowerTranslation", Object({
+        translations: NestedTranslationMap(Required, "AnimistPower", Object({
             name: Required({
                 comment: "The animist power’s name.",
                 type: String({ minLength: 1 }),
@@ -86,7 +86,7 @@ const AnimistPowerLevel = TypeAlias(import.meta.url, {
             comment: "The source references, if different than the references for level 1.",
             type: IncludeIdentifier(PublicationRefs),
         }),
-        translations: NestedLocaleMap(Required, "AnimistPowerLevelTranslation", Object({
+        translations: NestedTranslationMap(Required, "AnimistPowerLevel", Object({
             effect: Required({
                 comment: "An additional effect description for this level.",
                 type: String({ minLength: 1, isMarkdown: true }),
@@ -142,7 +142,7 @@ const AnimistPowerCostByPrimaryPatron = TypeAlias(import.meta.url, {
             comment: "If defined, half of the AE cost `value` has to be paid each interval.",
             type: IncludeIdentifier(DurationUnitValue),
         }),
-        translations: NestedLocaleMap(Optional, "AnimistPowerCostByPrimaryPatronTranslation", Object({
+        translations: NestedTranslationMap(Optional, "AnimistPowerCostByPrimaryPatron", Object({
             note: Required({
                 comment: "A note, appended to the generated string in parenthesis.",
                 type: IncludeIdentifier(ResponsiveTextOptional),

package/lib/types/magicalActions/AnimistPower_Tribe.js

@@ -1,10 +1,10 @@
 import { Entity, Object, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "../Locale.js";
+import { NestedTranslationMap } from "../Locale.js";
 export const Tribe = Entity(import.meta.url, {
     name: "Tribe",
     namePlural: "Tribes",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "TribeTranslation", Object({
+        translations: NestedTranslationMap(Required, "Tribe", Object({
             name: Required({
                 comment: "The tribe’s name.",
                 type: String({ minLength: 1 }),

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

@@ -144,7 +144,7 @@ export declare const Curse: Entity<"Curse", {
     property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, 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/Curse.js

@@ -6,7 +6,7 @@ import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
 import { PropertyIdentifier } from "../_Identifier.js";
 import { ResponsiveText, ResponsiveTextOptional } from "../_ResponsiveText.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 Curse = Entity(import.meta.url, {
@@ -30,7 +30,7 @@ export const Curse = Entity(import.meta.url, {
             type: PropertyIdentifier(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "CurseTranslation", Object({
+        translations: NestedTranslationMap(Required, "Curse", Object({
             name: Required({
                 comment: "The curse’s name.",
                 type: String({ minLength: 1 }),
@@ -82,7 +82,7 @@ const FixedCurseCost = TypeAlias(import.meta.url, {
             comment: "The (temporary) AE cost value.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "FixedCurseCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "FixedCurseCost", Object({
             per: Optional({
                 comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -110,7 +110,7 @@ const IndefiniteCurseDuration = TypeAlias(import.meta.url, {
             comment: "Specified if the duration has a maximum time span.",
             type: IncludeIdentifier(MaximumIndefiniteCurseDuration),
         }),
-        translations: NestedLocaleMap(Required, "IndefiniteCurseDurationTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteCurseDuration", Object({
             description: Required({
                 comment: "A description of the duration.",
                 type: IncludeIdentifier(ResponsiveText),

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

@@ -129,7 +129,7 @@ export declare const DominationRitual: Entity<"DominationRitual", {
     property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, 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/DominationRitual.js

@@ -5,7 +5,7 @@ import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
 import { PropertyIdentifier, SkillModificationLevelIdentifier } from "../_Identifier.js";
 import { ResponsiveText } from "../_ResponsiveText.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 DominationRitual = Entity(import.meta.url, {
@@ -29,7 +29,7 @@ export const DominationRitual = Entity(import.meta.url, {
             type: PropertyIdentifier(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "DominationRitualTranslation", Object({
+        translations: NestedTranslationMap(Required, "DominationRitual", Object({
             name: Required({
                 comment: "The domination ritual’s name.",
                 type: String({ minLength: 1 }),
@@ -74,7 +74,7 @@ const DominationRitualCost = TypeAlias(import.meta.url, {
             comment: "The initial skill modification identifier/level.",
             type: SkillModificationLevelIdentifier(),
         }),
-        translations: NestedLocaleMap(Optional, "DominationRitualCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "DominationRitualCost", Object({
             additional: Required({
                 comment: "AE cost in addition to the normal AE cost.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -110,7 +110,7 @@ const IndefiniteDominationRitualDuration = TypeAlias(import.meta.url, {
             comment: "Specified if the duration has a maximum time span.",
             type: IncludeIdentifier(MaximumIndefiniteDominationRitualDuration),
         }),
-        translations: NestedLocaleMap(Required, "IndefiniteDominationRitualDurationTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteDominationRitualDuration", Object({
             description: Required({
                 comment: "A description of the duration.",
                 type: IncludeIdentifier(ResponsiveText),

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

@@ -54,7 +54,7 @@ export declare const ElvenMagicalSong: Entity<"ElvenMagicalSong", {
     }, []>>, 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/ElvenMagicalSong.js

@@ -6,7 +6,7 @@ import { PropertyIdentifier, SkillIdentifier } from "../_Identifier.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
 import { ResponsiveText, ResponsiveTextReplace } from "../_ResponsiveText.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 ElvenMagicalSong = Entity(import.meta.url, {
@@ -42,7 +42,7 @@ export const ElvenMagicalSong = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "ElvenMagicalSongTranslation", Object({
+        translations: NestedTranslationMap(Required, "ElvenMagicalSong", Object({
             name: Required({
                 comment: "The Elven magical song’s name.",
                 type: String({ minLength: 1 }),
@@ -87,7 +87,7 @@ const ElvenMagicalSongCost = TypeAlias(import.meta.url, {
             comment: "A permanent AE cost, independent from a possible interval.",
             type: IncludeIdentifier(ElvenMagicalSongPermanentCost),
         }),
-        translations: NestedLocaleMap(Optional, "ElvenMagicalSongCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ElvenMagicalSongCost", Object({
             per: Required({
                 comment: "The cost have to be per a specific countable entity, e.g. `8 AE per person`.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -102,7 +102,7 @@ const ElvenMagicalSongPermanentCost = TypeAlias(import.meta.url, {
             comment: "The permanent AE cost value.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedLocaleMap(Optional, "ElvenMagicalSongPermanentCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "ElvenMagicalSongPermanentCost", Object({
             replacement: Required({
                 comment: "A replacement string for the permanent cost.",
                 type: IncludeIdentifier(ResponsiveTextReplace),

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

@@ -140,7 +140,7 @@ export declare const GeodeRitual: Entity<"GeodeRitual", {
     }, [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<{