optolith-database-schema 0.18.3 → 0.18.5

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.18.5](https://github.com/elyukai/optolith-database-schema/compare/v0.18.4...v0.18.5) (2025-10-09)
+
+
+### Bug Fixes
+
+* duplicate identifier violations and non-existent display name ([0bd47d1](https://github.com/elyukai/optolith-database-schema/commit/0bd47d12b58cf47f804387443927c0d97acc7ce7))
+
+## [0.18.4](https://github.com/elyukai/optolith-database-schema/compare/v0.18.3...v0.18.4) (2025-10-05)
+
 ## [0.18.3](https://github.com/elyukai/optolith-database-schema/compare/v0.18.2...v0.18.3) (2025-10-04)
 
 

package/lib/types/Advantage.d.ts

@@ -695,7 +695,7 @@ export declare const Advantage: Entity<"Advantage", {
                 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<{
@@ -776,7 +776,7 @@ export declare const Advantage: Entity<"Advantage", {
                 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<{
@@ -867,7 +867,7 @@ export declare const Advantage: Entity<"Advantage", {
     is_exclusive_to_arcane_spellworks: 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<{

package/lib/types/Advantage.js

@@ -1,7 +1,7 @@
 import { Boolean, Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { ap_value, ap_value_append, ap_value_l10n, input, levels, maximum, name, name_in_library, range_l10n, rules, select_options, skill_applications, skill_uses, } from "./_Activatable.js";
 import { AdvantageDisadvantagePrerequisites } 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 Advantage = Entity(import.meta.url, {
@@ -26,7 +26,7 @@ export const Advantage = Entity(import.meta.url, {
             type: Boolean(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "AdvantageTranslation", Object({
+        translations: NestedTranslationMap(Required, "Advantage", Object({
             name,
             name_in_library,
             input,

package/lib/types/AnimalDisease.d.ts

@@ -25,7 +25,7 @@ export declare const AnimalDisease: Entity<"AnimalDisease", {
     }>, []>>>, true>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", Array<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<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/AnimalDisease.js

@@ -1,5 +1,5 @@
 import { Array, Entity, IncludeIdentifier, Object, Required } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { cause, Cause, DiseaseTranslation, level, resistance } from "./_DiseasePoison.js";
 import { AnimalTypeIdentifier } from "./_Identifier.js";
 import { src } from "./source/_PublicationRef.js";
@@ -23,7 +23,7 @@ If no causes are given, the disease is not communicable to intelligent creatures
             type: Array(IncludeIdentifier(Cause)),
         }),
         src,
-        translations: NestedLocaleMap(Required, "AnimalDiseaseTranslation", DiseaseTranslation),
+        translations: NestedTranslationMap(Required, "AnimalDisease", DiseaseTranslation),
     }),
     displayName: {},
 });

package/lib/types/AnimalType.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 AnimalType = Entity(import.meta.url, {
     name: "AnimalType",
     namePlural: "AnimalTypes",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "AnimalTypeTranslation", Object({
+        translations: NestedTranslationMap(Required, "AnimalType", Object({
             name: Required({
                 comment: "The animal type’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/ArcaneBardTradition.d.ts

@@ -24,7 +24,7 @@ export declare const ArcaneBardTradition: Entity<"ArcaneBardTradition", {
             }>, 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<"ArcaneBardTraditionTranslation", {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ArcaneBardTraditionTranslationTranslation", {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
     }>, true>;
 }, undefined>;

package/lib/types/ArcaneDancerTradition.d.ts

@@ -24,7 +24,7 @@ export declare const ArcaneDancerTradition: Entity<"ArcaneDancerTradition", {
             }>, 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<"ArcaneDancerTraditionTranslation", {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ArcaneDancerTraditionTranslationTranslation", {
         name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
     }>, true>;
 }, undefined>;

package/lib/types/Aspect.js

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

package/lib/types/Attribute.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 Attribute = Entity(import.meta.url, {
     name: "Attribute",
     namePlural: "Attributes",
     comment: "A base attribute of a character.",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "AttributeTranslation", Object({
+        translations: NestedTranslationMap(Required, "Attribute", Object({
             name: Required({
                 comment: "The attribute’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Blessing.d.ts

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

@@ -1,7 +1,7 @@
 import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { DurationUnit } from "./_ActivatableSkillDuration.js";
 import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.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 Blessing = Entity(import.meta.url, {
@@ -17,7 +17,7 @@ export const Blessing = Entity(import.meta.url, {
             type: IncludeIdentifier(AffectedTargetCategories),
         }),
         src,
-        translations: NestedLocaleMap(Required, "BlessingTranslation", Object({
+        translations: NestedTranslationMap(Required, "Blessing", Object({
             name: Required({
                 comment: "The blessing’s name.",
                 type: String({ minLength: 1 }),
@@ -85,7 +85,7 @@ const FixedBlessingDuration = TypeAlias(import.meta.url, {
 const IndefiniteBlessingDuration = TypeAlias(import.meta.url, {
     name: "IndefiniteBlessingDuration",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "IndefiniteBlessingDurationTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteBlessingDuration", Object({
             description: Required({
                 comment: "A description of the duration.",
                 type: String({ minLength: 1 }),

package/lib/types/Cantrip.d.ts

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

@@ -5,7 +5,7 @@ import { FixedRange } from "./_ActivatableSkillRange.js";
 import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
 import { CurriculumIdentifier, MagicalTraditionIdentifier, PropertyIdentifier, } from "./_Identifier.js";
 import { ResponsiveText } from "./_ResponsiveText.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 Cantrip = Entity(import.meta.url, {
@@ -29,7 +29,7 @@ export const Cantrip = Entity(import.meta.url, {
             type: IncludeIdentifier(CantripNote),
         }),
         src,
-        translations: NestedLocaleMap(Required, "CantripTranslation", Object({
+        translations: NestedTranslationMap(Required, "Cantrip", Object({
             name: Required({
                 comment: "The cantrip’s name.",
                 type: String({ minLength: 1 }),
@@ -97,7 +97,7 @@ const CommonCantripTraditionNote = TypeAlias(import.meta.url, {
             comment: "The magical tradition’s identifier.",
             type: MagicalTraditionIdentifier(),
         }),
-        translations: NestedLocaleMap(Required, "CommonCantripTraditionNoteTranslation", Object({
+        translations: NestedTranslationMap(Required, "CommonCantripTraditionNote", Object({
             note: Required({
                 comment: "A note, appended to the generated string in parenthesis.",
                 type: String({ minLength: 1 }),
@@ -150,7 +150,7 @@ const FixedCantripDuration = TypeAlias(import.meta.url, {
 const IndefiniteCantripDuration = TypeAlias(import.meta.url, {
     name: "IndefiniteCantripDuration",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "IndefiniteCantripDurationTranslation", Object({
+        translations: NestedTranslationMap(Required, "IndefiniteCantripDuration", Object({
             description: Required({
                 comment: "A description of the duration.",
                 type: IncludeIdentifier(ResponsiveText),

package/lib/types/Ceremony.d.ts

@@ -482,7 +482,7 @@ export declare const Ceremony: Entity<"Ceremony", {
     }, [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", Array<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<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
@@ -520,7 +520,7 @@ export declare const Ceremony: Entity<"Ceremony", {
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"LiturgicalChantTranslation", {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CeremonyTranslation", {
         name: import("tsondb/schema/def").MemberDecl<String, true>;
         name_compressed: import("tsondb/schema/def").MemberDecl<String, false>;
         effect: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ActivatableSkillEffect", {
@@ -595,7 +595,7 @@ export declare const Ceremony: Entity<"Ceremony", {
         }, [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", Array<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<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/Ceremony.js

@@ -7,7 +7,7 @@ import { Enhancement } from "./_Enhancements.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
 import { LiturgyPrerequisites } from "./_Prerequisite.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 Ceremony = Entity(import.meta.url, {
@@ -43,7 +43,7 @@ export const Ceremony = Entity(import.meta.url, {
             type: IncludeIdentifier(LiturgyPrerequisites),
         }),
         src,
-        translations: NestedLocaleMap(Required, "LiturgicalChantTranslation", Object({
+        translations: NestedTranslationMap(Required, "Ceremony", Object({
             name: Required({
                 comment: "The ceremony’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/CombatTechnique.d.ts

@@ -17,7 +17,7 @@ export declare const CloseCombatTechnique: Entity<"CloseCombatTechnique", {
     }, []>>, 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<{
@@ -78,7 +78,7 @@ export declare const RangedCombatTechnique: Entity<"RangedCombatTechnique", {
     }, []>>, 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/CombatTechnique.js

@@ -1,7 +1,7 @@
 import { Array, Boolean, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { AttributeIdentifier } from "./_Identifier.js";
 import { ImprovementCost } from "./_ImprovementCost.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 CloseCombatTechnique = Entity(import.meta.url, {
@@ -25,7 +25,7 @@ export const CloseCombatTechnique = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "CloseCombatTechniqueTranslation", Object({
+        translations: NestedTranslationMap(Required, "CloseCombatTechnique", Object({
             name: Required({
                 comment: "The combat technique’s name.",
                 type: String({ minLength: 1 }),
@@ -76,7 +76,7 @@ export const RangedCombatTechnique = Entity(import.meta.url, {
             type: IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedLocaleMap(Required, "RangedCombatTechniqueTranslation", Object({
+        translations: NestedTranslationMap(Required, "RangedCombatTechnique", Object({
             name: Required({
                 comment: "The combat technique’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Condition.d.ts

@@ -2,7 +2,7 @@ import { Array, Entity, IncludeIdentifier, Object, String } from "tsondb/schema/
 export declare const Condition: Entity<"Condition", {
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", Array<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<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/Condition.js

@@ -1,5 +1,5 @@
 import { Array, 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 Condition = Entity(import.meta.url, {
@@ -7,7 +7,7 @@ export const Condition = Entity(import.meta.url, {
     namePlural: "Conditions",
     type: () => Object({
         src,
-        translations: NestedLocaleMap(Required, "ConditionTranslation", Object({
+        translations: NestedTranslationMap(Required, "Condition", Object({
             name: Required({
                 comment: "The condition’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Continent.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 Continent = Entity(import.meta.url, {
     name: "Continent",
     namePlural: "Continents",
     comment: "Continents are mostly referenced to in languages and scripts that occur on a specific continent.",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "ContinentTranslation", Object({
+        translations: NestedTranslationMap(Required, "Continent", Object({
             name: Required({
                 comment: "The continent name.",
                 type: String({ minLength: 1 }),

package/lib/types/Culture.d.ts

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

@@ -2,7 +2,7 @@ import { Array, Boolean, Entity, Enum, EnumCase, GenIncludeIdentifier, GenTypeAl
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { AdvantageIdentifier, BlessedTraditionIdentifier, DisadvantageIdentifier, LanguageIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionVariantIdentifier, ScriptIdentifier, SkillIdentifier, SocialStatusIdentifier, } from "./_Identifier.js";
 import { BinarySex } from "./_Sex.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { MundaneProfessionGroup } from "./Profession.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
@@ -59,7 +59,7 @@ export const Culture = Entity(import.meta.url, {
             type: Array(IncludeIdentifier(CulturalPackageItem), { minItems: 1 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "CultureTranslation", Object({
+        translations: NestedTranslationMap(Required, "Culture", Object({
             name: Required({
                 comment: "The race’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/DerivedCharacteristic.d.ts

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

package/lib/types/DerivedCharacteristic.js

@@ -1,5 +1,5 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { DerivedCharacteristicPrerequisites } from "./_Prerequisite.js";
 import { src } from "./source/_PublicationRef.js";
 export const DerivedCharacteristic = Entity(import.meta.url, {
@@ -10,7 +10,7 @@ export const DerivedCharacteristic = Entity(import.meta.url, {
             type: IncludeIdentifier(DerivedCharacteristicPrerequisites),
         }),
         src,
-        translations: NestedLocaleMap(Required, "DerivedCharacteristicTranslation", Object({
+        translations: NestedTranslationMap(Required, "DerivedCharacteristic", Object({
             name: Required({
                 comment: "The derived characteristic’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Disadvantage.d.ts

@@ -695,7 +695,7 @@ export declare const Disadvantage: Entity<"Disadvantage", {
                 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<{
@@ -776,7 +776,7 @@ export declare const Disadvantage: Entity<"Disadvantage", {
                 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<{
@@ -867,7 +867,7 @@ export declare const Disadvantage: Entity<"Disadvantage", {
     is_exclusive_to_arcane_spellworks: 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<{

package/lib/types/Disadvantage.js

@@ -1,7 +1,7 @@
 import { Boolean, Entity, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
 import { ap_value, ap_value_append, ap_value_l10n, input, levels, maximum, name, name_in_library, rules, select_options, skill_applications, skill_uses, } from "./_Activatable.js";
 import { AdvantageDisadvantagePrerequisites } 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 Disadvantage = Entity(import.meta.url, {
@@ -26,7 +26,7 @@ export const Disadvantage = Entity(import.meta.url, {
             type: Boolean(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "DisadvantageTranslation", Object({
+        translations: NestedTranslationMap(Required, "Disadvantage", Object({
             name,
             name_in_library,
             input,

package/lib/types/Disease.d.ts

@@ -16,7 +16,7 @@ export declare const Disease: Entity<"Disease", {
     }>, []>>>, true>;
     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", 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<import("tsondb/schema/def").IncludeIdentifierType<[], 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<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{

package/lib/types/Disease.js

@@ -1,5 +1,5 @@
 import { Entity, Object, Required } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { cause, DiseaseTranslation, level, resistance } from "./_DiseasePoison.js";
 import { src } from "./source/_PublicationRef.js";
 export const Disease = Entity(import.meta.url, {
@@ -10,7 +10,7 @@ export const Disease = Entity(import.meta.url, {
         resistance,
         cause,
         src,
-        translations: NestedLocaleMap(Required, "DiseaseTranslation", DiseaseTranslation),
+        translations: NestedTranslationMap(Required, "Disease", DiseaseTranslation),
     }),
     displayName: {},
 });

package/lib/types/Element.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 Element = Entity(import.meta.url, {
     name: "Element",
     namePlural: "Elements",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "ElementTranslation", Object({
+        translations: NestedTranslationMap(Required, "Element", Object({
             name: Required({
                 comment: "The element’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/ExperienceLevel.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 ExperienceLevel = Entity(import.meta.url, {
     name: "ExperienceLevel",
     namePlural: "ExperienceLevels",
@@ -33,7 +33,7 @@ export const ExperienceLevel = Entity(import.meta.url, {
             comment: "The maximum of spells of an unfamiliar tradition you can activate.",
             type: Integer(),
         }),
-        translations: NestedLocaleMap(Required, "ExperienceLevelTranslation", Object({
+        translations: NestedTranslationMap(Required, "ExperienceLevel", Object({
             name: Required({
                 comment: "The experience level’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/EyeColor.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 EyeColor = Entity(import.meta.url, {
     name: "EyeColor",
     namePlural: "EyeColors",
     type: () => Object({
-        translations: NestedLocaleMap(Required, "EyeColorTranslation", Object({
+        translations: NestedTranslationMap(Required, "EyeColor", Object({
             name: Required({
                 comment: "The eye color’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/FamiliarsTrick.d.ts

@@ -132,7 +132,7 @@ export declare const FamiliarsTrick: Entity<"FamiliarsTrick", {
     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<{