optolith-database-schema 0.18.4 → 0.18.6

package/lib/types/FamiliarsTrick.js

@@ -4,7 +4,7 @@ import { IndefiniteOneTimeCost } from "./_ActivatableSkillCost.js";
 import { DurationUnitValue, FixedDuration, IndefiniteDuration, } from "./_ActivatableSkillDuration.js";
 import { AnimalTypeIdentifier, PropertyIdentifier } from "./_Identifier.js";
 import { ResponsiveText, ResponsiveTextOptional } 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 FamiliarsTrick = Entity(import.meta.url, {
@@ -30,7 +30,7 @@ If no animal types are given, the animal disease applies to all animal types.`,
             type: Integer({ minimum: 1 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "FamiliarsTrickTranslation", Object({
+        translations: NestedTranslationMap(Required, "FamiliarsTrick", Object({
             name: Required({
                 comment: "The familiar’s trick’s name.",
                 type: String({ minLength: 1 }),
@@ -64,7 +64,7 @@ const FamiliarsTrickProperty = Enum(import.meta.url, {
 const IndefiniteFamiliarsTrickProperty = TypeAlias(import.meta.url, {
     name: "IndefiniteFamiliarsTrickProperty",
     type: () => Object({
-        translations: NestedLocaleMap(Optional, "IndefiniteFamiliarsTrickPropertyTranslation", Object({
+        translations: NestedTranslationMap(Optional, "IndefiniteFamiliarsTrickProperty", Object({
             description: Required({
                 comment: "A description of the property.",
                 type: IncludeIdentifier(ResponsiveText),
@@ -117,7 +117,7 @@ const FamiliarsTrickFixedOneTimeCost = TypeAlias(import.meta.url, {
             comment: "The interval in which you have to pay the AE cost again.",
             type: IncludeIdentifier(DurationUnitValue),
         }),
-        translations: NestedLocaleMap(Optional, "FamiliarsTrickFixedOneTimeCostTranslation", Object({
+        translations: NestedTranslationMap(Optional, "FamiliarsTrickFixedOneTimeCost", Object({
             per: Optional({
                 comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
                 type: IncludeIdentifier(ResponsiveTextOptional),

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

package/lib/types/Lessons.d.ts

@@ -86,7 +86,7 @@ export declare const Curriculum: Entity<"Curriculum", {
     }, "curriculum">>, 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/Lessons.js

@@ -1,5 +1,5 @@
 import { Array, ChildEntities, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { CurriculumIdentifier, ElementIdentifier, GuidelineIdentifier, MagicalTraditionIdentifier, PropertyIdentifier, SkillIdentifier, } from "./_Identifier.js";
 import { CombatTechniqueIdentifier, SpellworkIdentifier } from "./_IdentifierGroup.js";
 import { Errata } from "./source/_Erratum.js";
@@ -12,7 +12,7 @@ export const Guideline = Entity(import.meta.url, {
             comment: "Maximum number of spells that can be exchanged.",
             type: Integer({ minimum: 0 }),
         }),
-        translations: NestedLocaleMap(Required, "GuidelineTranslation", Object({
+        translations: NestedTranslationMap(Required, "Guideline", Object({
             name: Required({
                 comment: "The guideline’s name.",
                 type: String({ minLength: 1 }),
@@ -43,7 +43,7 @@ export const Curriculum = Entity(import.meta.url, {
             type: ChildEntities(LessonPackage),
         }),
         src,
-        translations: NestedLocaleMap(Required, "CurriculumTranslation", Object({
+        translations: NestedTranslationMap(Required, "Curriculum", Object({
             name: Required({
                 comment: "The institution’s name.",
                 type: String({ minLength: 1 }),
@@ -137,7 +137,7 @@ export const LessonPackage = Entity(import.meta.url, {
         skills: Optional({
             type: Array(IncludeIdentifier(AbilityAdjustment), { minItems: 1, uniqueItems: true }),
         }),
-        translations: NestedLocaleMap(Required, "LessonPackageTranslation", Object({
+        translations: NestedTranslationMap(Required, "LessonPackage", Object({
             name: Required({
                 comment: "The lesson package’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/LiturgicalChant.d.ts

@@ -482,7 +482,7 @@ export declare const LiturgicalChant: Entity<"LiturgicalChant", {
     }, [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<{
@@ -595,7 +595,7 @@ export declare const LiturgicalChant: Entity<"LiturgicalChant", {
         }, [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/LiturgicalChant.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 LiturgicalChant = Entity(import.meta.url, {
@@ -43,7 +43,7 @@ export const LiturgicalChant = Entity(import.meta.url, {
             type: IncludeIdentifier(LiturgyPrerequisites),
         }),
         src,
-        translations: NestedLocaleMap(Required, "LiturgicalChantTranslation", Object({
+        translations: NestedTranslationMap(Required, "LiturgicalChant", Object({
             name: Required({
                 comment: "The liturgical chant’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Locale.d.ts

@@ -4,8 +4,8 @@ export declare const Locale: Entity<"Locale", {
     region: MemberDecl<String, true>;
     is_missing_implementation: MemberDecl<Boolean, true>;
 }, undefined>;
-export declare const NestedLocaleMap: <Name extends string, T extends Record<string, MemberDecl<Type, boolean>>, R extends boolean>(MemberDeclCreator: <T_1 extends Type>(options: {
+export declare const NestedTranslationMap: <Name extends string, T extends Record<string, MemberDecl<Type, boolean>>, R extends boolean>(MemberDeclCreator: <T_1 extends Type>(options: {
     comment?: string;
     isDeprecated?: boolean;
     type: T_1;
-}) => MemberDecl<T_1, R>, name: Name, type: ObjectType<T>) => MemberDecl<NestedEntityMap<Name, T>, R>;
+}) => MemberDecl<T_1, R>, entityName: Name, type: ObjectType<T>) => MemberDecl<NestedEntityMap<`${Name}Translation`, T>, R>;

package/lib/types/Locale.js

@@ -1307,10 +1307,11 @@ export const Locale = Entity(import.meta.url, {
         // }),
     }),
 });
-export const NestedLocaleMap = (MemberDeclCreator, name, type) => MemberDeclCreator({
+export const NestedTranslationMap = (MemberDeclCreator, entityName, type) => MemberDeclCreator({
     comment: "All translations for the entry, identified by IETF language tag (BCP47).",
     type: NestedEntityMap({
-        name,
+        name: `${entityName}Translation`,
+        namePlural: `${entityName}Translations`,
         secondaryEntity: Locale,
         type,
     }),

package/lib/types/MetaCondition.d.ts

@@ -2,7 +2,7 @@ import { Array, Entity, IncludeIdentifier, Object, String } from "tsondb/schema/
 export declare const MetaCondition: Entity<"MetaCondition", {
     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/MetaCondition.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 MetaCondition = Entity(import.meta.url, {
@@ -8,7 +8,7 @@ export const MetaCondition = Entity(import.meta.url, {
     comment: "Meta Conditions are rule elements that work like conditions in the sense that they have four levels with different effects, but which are not explicitly listed as conditions.",
     type: () => Object({
         src,
-        translations: NestedLocaleMap(Required, "MetaConditionTranslation", Object({
+        translations: NestedTranslationMap(Required, "MetaCondition", Object({
             name: Required({
                 comment: "The meta condition’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/PactCategory.d.ts

@@ -14,7 +14,7 @@ export declare const PactCategory: Entity<"PactCategory", {
     }, "parent">>, 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/PactCategory.js

@@ -1,6 +1,6 @@
 import { ChildEntities, Entity, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
 import { PactCategoryIdentifier } 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 PactCategory = Entity(import.meta.url, {
@@ -16,7 +16,7 @@ export const PactCategory = Entity(import.meta.url, {
             type: ChildEntities(PactDomain),
         }),
         src,
-        translations: NestedLocaleMap(Required, "PactCategoryTranslation", Object({
+        translations: NestedTranslationMap(Required, "PactCategory", Object({
             name: Required({
                 comment: "The pact category’s name.",
                 type: String({ minLength: 1 }),
@@ -36,7 +36,7 @@ export const PactType = Entity(import.meta.url, {
             comment: "The pact category this type belongs to.",
             type: PactCategoryIdentifier(),
         }),
-        translations: NestedLocaleMap(Required, "PactTypeTranslation", Object({
+        translations: NestedTranslationMap(Required, "PactType", Object({
             name: Required({
                 comment: "The type’s name.",
                 type: String({ minLength: 1 }),
@@ -54,7 +54,7 @@ export const PactDomain = Entity(import.meta.url, {
             comment: "The pact category this domain belongs to.",
             type: PactCategoryIdentifier(),
         }),
-        translations: NestedLocaleMap(Required, "PactDomainTranslation", Object({
+        translations: NestedTranslationMap(Required, "PactDomain", Object({
             name: Required({
                 comment: "The domain’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Patron.d.ts

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

@@ -2,7 +2,7 @@ import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Opti
 import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, PatronCategoryIdentifier, SkillIdentifier, } from "./_Identifier.js";
 import { SpellworkIdentifier } from "./_IdentifierGroup.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { src } from "./source/_PublicationRef.js";
 export const Patron = Entity(import.meta.url, {
     name: "Patron",
@@ -51,7 +51,7 @@ export const Patron = Entity(import.meta.url, {
             type: Array(IncludeIdentifier(SpellworkIdentifier), { minItems: 1, uniqueItems: true }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "PatronTranslation", Object({
+        translations: NestedTranslationMap(Required, "Patron", Object({
             name: Required({
                 comment: "The patron’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/PatronCategory.js

@@ -1,5 +1,5 @@
 import { Array, Entity, Object, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { CultureIdentifier } from "./_Identifier.js";
 export const PatronCategory = Entity(import.meta.url, {
     name: "PatronCategory",
@@ -9,7 +9,7 @@ export const PatronCategory = Entity(import.meta.url, {
             comment: "The list of cultures where patrons from this category can be the primary patron of.",
             type: Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
-        translations: NestedLocaleMap(Required, "PatronCategoryTranslation", Object({
+        translations: NestedTranslationMap(Required, "PatronCategory", Object({
             name: Required({
                 comment: "The patron category’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/PersonalityTrait.d.ts

@@ -28,7 +28,7 @@ export declare const PersonalityTrait: Entity<"PersonalityTrait", {
     combination_options: 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<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/PersonalityTrait.js

@@ -1,5 +1,5 @@
 import { Array, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { PersonalityTraitIdentifier } from "./_Identifier.js";
 import { PersonalityTraitPrerequisites } from "./_Prerequisite.js";
 import { Errata } from "./source/_Erratum.js";
@@ -21,7 +21,7 @@ export const PersonalityTrait = Entity(import.meta.url, {
             type: Array(PersonalityTraitIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "PersonalityTraitTranslation", Object({
+        translations: NestedTranslationMap(Required, "PersonalityTrait", Object({
             name: Required({
                 comment: "The personality trait’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Profession.d.ts

@@ -538,7 +538,7 @@ export declare const Profession: Entity<"Profession", {
         }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>, false>;
         src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", 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<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", ObjectType<{
                     printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                     pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", ObjectType<{
@@ -1130,7 +1130,7 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
     }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>, false>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", 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<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", ObjectType<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", ObjectType<{

package/lib/types/Profession.js

@@ -3,7 +3,7 @@ import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantag
 import { AdvantageIdentifier, CantripIdentifier, CurriculumIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier, GeneralSelectOptionIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionPackageIdentifier, ProfessionVersionIdentifier, SkillGroupIdentifier, SkillIdentifier, } from "./_Identifier.js";
 import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, RequirableSelectOptionIdentifier, SpecialAbilityIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
 import { ProfessionPrerequisites } 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 Profession = Entity(import.meta.url, {
@@ -97,7 +97,7 @@ export const ProfessionVersion = Entity(import.meta.url, {
             type: Array(GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "ProfessionVersionTranslation", ObjectType({
+        translations: NestedTranslationMap(Required, "ProfessionVersion", ObjectType({
             name: Required({
                 comment: "The basic profession’s name.",
                 type: IncludeIdentifier(ProfessionName),
@@ -257,7 +257,7 @@ export const ProfessionVariant = Entity(import.meta.url, {
             comment: "Clerical profession variants receive these liturgical chants at the listed skill ratings. These liturgical chants are considered activated.",
             type: Array(IncludeIdentifier(LiturgicalChantRating), { minItems: 1 }),
         }),
-        translations: NestedLocaleMap(Required, "ProfessionVariantTranslation", ObjectType({
+        translations: NestedTranslationMap(Required, "ProfessionVariant", ObjectType({
             name: Required({
                 comment: "The profession variant’s name.",
                 type: IncludeIdentifier(ProfessionName),

package/lib/types/Property.js

@@ -1,6 +1,6 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required, String } from "tsondb/schema/def";
 import { SkillCheck } from "./_SkillCheck.js";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 export const Property = Entity(import.meta.url, {
     name: "Property",
     namePlural: "Properties",
@@ -9,7 +9,7 @@ export const Property = Entity(import.meta.url, {
             comment: "The property check’s attributes. Only the properties from the Core Rules have defined property checks.",
             type: IncludeIdentifier(SkillCheck),
         }),
-        translations: NestedLocaleMap(Required, "PropertyTranslation", Object({
+        translations: NestedTranslationMap(Required, "Property", Object({
             name: Required({
                 comment: "The property’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Race.d.ts

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

package/lib/types/Race.js

@@ -3,7 +3,7 @@ import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantag
 import { Dice, DieType } from "./_Dice.js";
 import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, EyeColorIdentifier, HairColorIdentifier, RaceIdentifier, } from "./_Identifier.js";
 import { ExperienceLevel } from "./ExperienceLevel.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 Race = Entity(import.meta.url, {
@@ -42,6 +42,7 @@ export const Race = Entity(import.meta.url, {
             comment: "Defines the starting ages for the race. It depends on the selected experience level.",
             type: NestedEntityMap({
                 name: "StartingAgeConfigForExperienceLevel",
+                namePlural: "StartingAgeConfigsForExperienceLevel",
                 secondaryEntity: ExperienceLevel,
                 type: Object({
                     base: Required({
@@ -53,6 +54,7 @@ export const Race = Entity(import.meta.url, {
                         type: IncludeIdentifier(Dice),
                     }),
                 }),
+                displayName: null,
             }),
         }),
         variants: Required({
@@ -60,7 +62,7 @@ export const Race = Entity(import.meta.url, {
             type: ChildEntities(RaceVariant),
         }),
         src,
-        translations: NestedLocaleMap(Required, "RaceTranslation", Object({
+        translations: NestedTranslationMap(Required, "Race", Object({
             name: Required({
                 comment: "The race’s name.",
                 type: String({ minLength: 1 }),
@@ -246,7 +248,7 @@ export const RaceVariant = Entity(import.meta.url, {
             comment: "Configuration for random height generation.",
             type: IncludeIdentifier(RandomHeightGeneration),
         }),
-        translations: NestedLocaleMap(Required, "RaceVariantTranslation", Object({
+        translations: NestedTranslationMap(Required, "RaceVariant", Object({
             name: Required({
                 comment: "The race variant’s name. If this is the only variant for a base race and thus just provides the missing information without actually being able to select, fill in the name of the base race.",
                 type: String({ minLength: 1 }),

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

package/lib/types/Ritual.d.ts

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

package/lib/types/Ritual.js

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

package/lib/types/Service.d.ts

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

@@ -1,5 +1,5 @@
 import { Array, Entity, Enum, EnumCase, 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 Service = Entity(import.meta.url, {
@@ -14,7 +14,7 @@ export const Service = Entity(import.meta.url, {
             }),
         }),
         src,
-        translations: NestedLocaleMap(Required, "ServiceTranslation", Object({
+        translations: NestedTranslationMap(Required, "Service", Object({
             name: Required({
                 comment: "The service’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/SexPractice.d.ts

@@ -2,7 +2,7 @@ import { Entity, Object, String } from "tsondb/schema/def";
 export declare const SexPractice: Entity<"SexPractice", {
     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<{
@@ -40,7 +40,7 @@ export declare const SexPractice: Entity<"SexPractice", {
             }, []>>>, false>;
         }>, true>;
     }>, []>>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"StateTranslation", {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SexPracticeTranslation", {
         name: import("tsondb/schema/def").MemberDecl<String, true>;
         rules: import("tsondb/schema/def").MemberDecl<String, true>;
         duration: import("tsondb/schema/def").MemberDecl<String, true>;

package/lib/types/SexPractice.js

@@ -1,12 +1,12 @@
 import { Entity, Object, Optional, Required, String } from "tsondb/schema/def";
-import { NestedLocaleMap } from "./Locale.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { src } from "./source/_PublicationRef.js";
 export const SexPractice = Entity(import.meta.url, {
     name: "SexPractice",
     namePlural: "SexPractices",
     type: () => Object({
         src,
-        translations: NestedLocaleMap(Required, "StateTranslation", Object({
+        translations: NestedTranslationMap(Required, "SexPractice", Object({
             name: Required({
                 comment: "The sex practice’s name.",
                 type: String({ minLength: 1 }),

package/lib/types/Skill.d.ts

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

package/lib/types/Skill.js

@@ -5,7 +5,7 @@ import { ChildEntities, Entity, Enum, EnumCase, IncludeIdentifier, Object, Optio
 import { SkillGroupIdentifier, SkillIdentifier } from "./_Identifier.js";
 import { ImprovementCost } from "./_ImprovementCost.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 Skill = Entity(import.meta.url, {
@@ -33,7 +33,7 @@ export const Skill = Entity(import.meta.url, {
             type: SkillGroupIdentifier(),
         }),
         src,
-        translations: NestedLocaleMap(Required, "SkillTranslation", Object({
+        translations: NestedTranslationMap(Required, "Skill", Object({
             name: Required({
                 comment: "The skill’s name.",
                 type: String({ minLength: 1 }),
@@ -103,7 +103,7 @@ export const SkillApplication = Entity(import.meta.url, {
             comment: "The skill this application belongs to.",
             type: SkillIdentifier(),
         }),
-        translations: NestedLocaleMap(Required, "SkillApplicationTranslation", Object({
+        translations: NestedTranslationMap(Required, "SkillApplication", Object({
             name: Required({
                 comment: "The skill application’s name.",
                 type: String({ minLength: 1 }),