@optolith/database-schema 0.42.4 → 0.43.0

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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.43.0](https://github.com/Optolith/database-schema/compare/v0.42.4...v0.43.0) (2026-05-29)
+
+
+### ⚠ BREAKING CHANGES
+
+* auto/strong dis/advantages in race variantFeature/race advantage variant
+* add translation for name of spellcasters
+* add translations for favored skills
+
+### Features
+
+* add translation for name of spellcasters ([21780be](https://github.com/Optolith/database-schema/commit/21780be505cf21d08bb2ef7691e613047cb0447f))
+* add translations for favored skills ([57b1916](https://github.com/Optolith/database-schema/commit/57b1916f21edbd1acb57c8e0aa3b06f9be6da724))
+* auto/strong dis/advantages in race variantFeature/race advantage variant ([7afc6b0](https://github.com/Optolith/database-schema/commit/7afc6b032614b1fae26f54e648eceee3aa49559c)), closes [elyukai/optolith-data#1291](https://github.com/elyukai/optolith-data/issues/1291) [#139](https://github.com/Optolith/database-schema/issues/139) [#138](https://github.com/Optolith/database-schema/issues/138)
+* printed values for lesson packages ([c268659](https://github.com/Optolith/database-schema/commit/c2686593cb874e4f18ba86ea51d6c7d59f0cce85))
+
 ## [0.42.4](https://github.com/Optolith/database-schema/compare/v0.42.3...v0.42.4) (2026-04-10)
 
 

package/gen/types.d.ts

@@ -856,6 +856,7 @@ export type TypeAliasMap = {
   SpecificSkillSpecializationOptions: SpecificSkillSpecializationOptions
   SpecificTargetCategory: SpecificTargetCategory
   SpellworkAdjustment: SpellworkAdjustment
+  SpellworkAdjustmentWithBase: SpellworkAdjustmentWithBase
   SpellworkChange: SpellworkChange
   SpellworkPrerequisites: SpellworkPrerequisites
   StatePrerequisite: StatePrerequisite
@@ -2337,7 +2338,14 @@ export interface Locale {
     "corresponding liturgical style special ability": string
     "corresponding magic style special ability": string
     "corresponding skill style special ability": string
+    "Favored Skills": string
+    "The primary attribute of this Tradition is {$attr}.": string & { __params: { "attr": StringableTranslationParameter } }
+    "This primary attribute of this Tradition is {$attr}; however, {$casters} use only half of this stat (rounded up) to calculate their base AE pool or purchase AE.": string & { __params: { "attr": StringableTranslationParameter; "casters": StringableTranslationParameter } }
+    "Tradition ({$name}) has no associated primary attribute, meaning {$casters} receive no bonus to the AE pool and cannot purchase additional AE.": string & { __params: { "name": StringableTranslationParameter; "casters": StringableTranslationParameter } }
+    ".input {$count :number} {{{$baseList}, and {$count} of your choice from the following list: {$selection}}}": string & { __params: { "count": number; "baseList": StringableTranslationParameter; "selection": StringableTranslationParameter } }
     "All": string
+    "All Combat Techniques": string
+    "All Combat Techniques used in hunting": string
     "All Close Combat Techniques": string
     "All Ranged Combat Techniques": string
     "Depends on combat style; both combat styles can be used only for their corresponding combat techniques": string
@@ -4403,26 +4411,6 @@ export interface Race {
    */
   base_values: BaseValues
 
-  /**
-   * A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.
-   */
-  automatic_advantages?: AutomaticAdvantageDisadvantage<Advantage_ID>[]
-
-  /**
-   * A list of automatically applied disadvantages. This does only work for disadvantages with no further configuration such as level or special selection.
-   */
-  automatic_disadvantages?: AutomaticAdvantageDisadvantage<Disadvantage_ID>[]
-
-  /**
-   * A list of strongly recommended advantages.
-   */
-  strongly_recommended_advantages?: CommonnessRatedAdvantageDisadvantage<Advantage_ID>[]
-
-  /**
-   * A list of strongly recommended disadvantages.
-   */
-  strongly_recommended_disadvantages?: CommonnessRatedAdvantageDisadvantage<Disadvantage_ID>[]
-
   /**
    * How many different hair colors a race may have. By default, they have a single one that is for their whole body, but a race may have multiple if their hair color is different for different body parts. Additionally, if the hair color is labelled differently (e.g. scale color), there might be multiple colors for different body parts as well. This should only be set if the hair color count is higher than 1.
    */
@@ -4476,31 +4464,6 @@ export interface RaceTranslation {
    */
   name: string
 
-  /**
-   * The respective attribute adjustments text from the source book.
-   */
-  attribute_adjustments: string
-
-  /**
-   * The respective automatic advantages text from the source book.
-   */
-  automatic_advantages?: string
-
-  /**
-   * The respective automatic disadvantages text from the source book.
-   */
-  automatic_disadvantages?: string
-
-  /**
-   * The respective strongly recommended advantages text from the source book.
-   */
-  strongly_recommended_advantages?: string
-
-  /**
-   * The respective strongly recommended disadvantages text from the source book.
-   */
-  strongly_recommended_disadvantages?: string
-
   /**
    * The label for hair colors if it is not a hair color in that sense: Some races may have different labels for hair color such as scale color.
    */
@@ -7466,6 +7429,11 @@ export interface MagicalTraditionTranslation {
    */
   name_in_library?: string
 
+  /**
+   * The name of spellcasters of this tradition. This is used to derive special rules from the data set already for this tradition.
+   */
+  nameOfSpellcasters: string
+
   /**
    * The special rules of the tradition. They should be sorted like they are in the book.
    */
@@ -7495,7 +7463,7 @@ export interface PrimaryAttribute {
   /**
    * The attribute’s identifier.
    */
-  id?: Attribute_ID
+  id: Attribute_ID
 
   /**
    * Typically, the value of the primary attribute (if one exists) is added onto the base of 20 AE to get the actual AE. But sometimes, only half the value is added.
@@ -8087,6 +8055,11 @@ export interface LessonPackage {
    */
   curriculum: Curriculum_ID
 
+  /**
+   * The AP value of the lesson package. This is only used to compare the generated AP value with the one in the book for error checking.
+   */
+  apValue?: number
+
   /**
    * The spell values difference of the lesson package. This field reflects the changes (difference) to the field of the same name in the profession package. If a spell gets to SR 0 because of this, it will be removed completely.
    */
@@ -8149,7 +8122,7 @@ export type AbilityAdjustment =
   }
   | {
     kind: "Spellwork"
-    Spellwork: SpellworkAdjustment
+    Spellwork: SpellworkAdjustmentWithBase
   }
 
 export interface CombatTechniqueAdjustment {
@@ -8159,6 +8132,11 @@ export interface CombatTechniqueAdjustment {
    * The combat technique points that will be added to the current combat technique rating.
    */
   points: number
+
+  /**
+   * The combat technique rating of the base profession package. This is only used to compare the derived rating from the profession package with the one in the book for error checking. Note that 6 is always added to that number, so to get a base rating of 10, this field should be 4.
+   */
+  basePoints?: number
 }
 
 export interface SkillAdjustment {
@@ -8168,6 +8146,30 @@ export interface SkillAdjustment {
    * The skill points that will be added to the current skill rating.
    */
   points: number
+
+  /**
+   * The skill rating of the base profession package. This is only used to compare the derived rating from the profession package with the one in the book for error checking.
+   */
+  basePoints?: number
+}
+
+export interface SpellworkAdjustmentWithBase {
+  id: SpellworkIdentifier
+
+  /**
+   * The skill points that will be added to the current skill rating. If a spell gets to a skill rating of 0 because of this, it will be removed completely.
+   */
+  points: number
+
+  /**
+   * The spell rating of the base profession package. This is only used to compare the derived rating from the profession package with the one in the book for error checking.
+   */
+  basePoints?: number
+
+  /**
+   * The target tradition. If the target spell is not from the Guild Mage tradition, specify the tradition identifier here.
+   */
+  tradition?: MagicalTradition_ID
 }
 
 export interface ProfessionVersion {
@@ -19600,16 +19602,6 @@ export interface CalculationTranslation {
   no_primary?: string
 }
 
-/**
- * An advantage or disadvantage that is automatically applied to the character after selecting the race. This does only work for advantages or disadvantages with no further configuration such as level or special selection.
- */
-export interface AutomaticAdvantageDisadvantage<Identifier> {
-  /**
-   * The automatic advantage or disadvantage.
-   */
-  id: Identifier
-}
-
 /**
  * Configuration for random weight generation.
  */
@@ -19672,6 +19664,26 @@ export interface RaceVariant {
    */
   common_cultures?: Culture_ID[]
 
+  /**
+   * A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.
+   */
+  automatic_advantages?: AutomaticAdvantageDisadvantage<Advantage_ID>[]
+
+  /**
+   * A list of automatically applied disadvantages. This does only work for disadvantages with no further configuration such as level or special selection.
+   */
+  automatic_disadvantages?: AutomaticAdvantageDisadvantage<Disadvantage_ID>[]
+
+  /**
+   * A list of strongly recommended advantages.
+   */
+  strongly_recommended_advantages?: CommonnessRatedAdvantageDisadvantage<Advantage_ID>[]
+
+  /**
+   * A list of strongly recommended disadvantages.
+   */
+  strongly_recommended_disadvantages?: CommonnessRatedAdvantageDisadvantage<Disadvantage_ID>[]
+
   /**
    * A list of common advantages.
    */
@@ -19726,6 +19738,31 @@ export interface RaceVariantTranslation {
    */
   name: string
 
+  /**
+   * The respective attribute adjustments text from the source book.
+   */
+  attribute_adjustments?: string
+
+  /**
+   * The respective automatic advantages text from the source book.
+   */
+  automatic_advantages?: string
+
+  /**
+   * The respective automatic disadvantages text from the source book.
+   */
+  automatic_disadvantages?: string
+
+  /**
+   * The respective strongly recommended advantages text from the source book.
+   */
+  strongly_recommended_advantages?: string
+
+  /**
+   * The respective strongly recommended disadvantages text from the source book.
+   */
+  strongly_recommended_disadvantages?: string
+
   /**
    * The respective common advantages text from the source book.
    */
@@ -19794,6 +19831,16 @@ export interface SelectableAttributeAdjustment {
   value: number
 }
 
+/**
+ * An advantage or disadvantage that is automatically applied to the character after selecting the race. This does only work for advantages or disadvantages with no further configuration such as level or special selection.
+ */
+export interface AutomaticAdvantageDisadvantage<Identifier> {
+  /**
+   * The automatic advantage or disadvantage.
+   */
+  id: Identifier
+}
+
 export interface HairColor {
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).

package/lib/types/Lessons.d.ts

@@ -40,6 +40,7 @@ export declare const Curriculum: DB.Entity<"Curriculum", {
     }, []>>>, []>>, false>;
     lesson_packages: DB.MemberDecl<DB.ChildEntities<DB.Entity<"LessonPackage", {
         curriculum: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        apValue: DB.MemberDecl<DB.Integer, false>;
         spellwork_changes: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkChange", DB.Object<{
             base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
@@ -65,17 +66,20 @@ export declare const Curriculum: DB.Entity<"Curriculum", {
                     RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>, true>;
                 points: DB.MemberDecl<DB.Integer, true>;
+                basePoints: DB.MemberDecl<DB.Integer, false>;
             }>, []>>>;
             Skill: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillAdjustment", DB.Object<{
                 id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
                 points: DB.MemberDecl<DB.Integer, true>;
+                basePoints: DB.MemberDecl<DB.Integer, false>;
             }>, []>>>;
-            Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+            Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustmentWithBase", DB.Object<{
                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
                     Spell: DB.EnumCase<DB.ReferenceIdentifier>;
                     Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>, true>;
                 points: DB.MemberDecl<DB.Integer, true>;
+                basePoints: DB.MemberDecl<DB.Integer, false>;
                 tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
             }>, []>>>;
         }, []>>>, false>;
@@ -135,6 +139,7 @@ export declare const Curriculum: DB.Entity<"Curriculum", {
 }, undefined>;
 export declare const LessonPackage: DB.Entity<"LessonPackage", {
     curriculum: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    apValue: DB.MemberDecl<DB.Integer, false>;
     spellwork_changes: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkChange", DB.Object<{
         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
             id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
@@ -160,17 +165,20 @@ export declare const LessonPackage: DB.Entity<"LessonPackage", {
                 RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>, true>;
             points: DB.MemberDecl<DB.Integer, true>;
+            basePoints: DB.MemberDecl<DB.Integer, false>;
         }>, []>>>;
         Skill: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillAdjustment", DB.Object<{
             id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
             points: DB.MemberDecl<DB.Integer, true>;
+            basePoints: DB.MemberDecl<DB.Integer, false>;
         }>, []>>>;
-        Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+        Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustmentWithBase", DB.Object<{
             id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
                 Spell: DB.EnumCase<DB.ReferenceIdentifier>;
                 Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>, true>;
             points: DB.MemberDecl<DB.Integer, true>;
+            basePoints: DB.MemberDecl<DB.Integer, false>;
             tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
         }>, []>>>;
     }, []>>>, false>;

package/lib/types/Lessons.js

@@ -145,6 +145,10 @@ export const LessonPackage = DB.Entity(import.meta.url, {
             comment: "The associated curriculum.",
             type: CurriculumIdentifier(),
         }),
+        apValue: DB.Optional({
+            comment: "The AP value of the lesson package. This is only used to compare the generated AP value with the one in the book for error checking.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
         spellwork_changes: DB.Optional({
             comment: "The spell values difference of the lesson package. This field reflects the changes (difference) to the field of the same name in the profession package. If a spell gets to SR 0 because of this, it will be removed completely.",
             type: DB.Array(DB.IncludeIdentifier(SpellworkChange), { minItems: 1, uniqueItems: true }),
@@ -185,7 +189,7 @@ const AbilityAdjustment = DB.Enum(import.meta.url, {
     values: () => ({
         CombatTechnique: DB.EnumCase({ type: DB.IncludeIdentifier(CombatTechniqueAdjustment) }),
         Skill: DB.EnumCase({ type: DB.IncludeIdentifier(SkillAdjustment) }),
-        Spellwork: DB.EnumCase({ type: DB.IncludeIdentifier(SpellworkAdjustment) }),
+        Spellwork: DB.EnumCase({ type: DB.IncludeIdentifier(SpellworkAdjustmentWithBase) }),
     }),
 });
 const CombatTechniqueAdjustment = DB.TypeAlias(import.meta.url, {
@@ -198,6 +202,10 @@ const CombatTechniqueAdjustment = DB.TypeAlias(import.meta.url, {
             comment: "The combat technique points that will be added to the current combat technique rating.",
             type: DB.Integer({ minimum: -6, maximum: 6 }),
         }),
+        basePoints: DB.Optional({
+            comment: "The combat technique rating of the base profession package. This is only used to compare the derived rating from the profession package with the one in the book for error checking. Note that 6 is always added to that number, so to get a base rating of 10, this field should be 4.",
+            type: DB.Integer({ minimum: 0, maximum: 6 }),
+        }),
     }),
 });
 const SkillAdjustment = DB.TypeAlias(import.meta.url, {
@@ -210,6 +218,10 @@ const SkillAdjustment = DB.TypeAlias(import.meta.url, {
             comment: "The skill points that will be added to the current skill rating.",
             type: DB.Integer({ minimum: -8, maximum: 8 }),
         }),
+        basePoints: DB.Optional({
+            comment: "The skill rating of the base profession package. This is only used to compare the derived rating from the profession package with the one in the book for error checking.",
+            type: DB.Integer({ minimum: 0, maximum: 8 }),
+        }),
     }),
 });
 const SpellworkAdjustment = DB.TypeAlias(import.meta.url, {
@@ -228,3 +240,23 @@ const SpellworkAdjustment = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const SpellworkAdjustmentWithBase = DB.TypeAlias(import.meta.url, {
+    name: "SpellworkAdjustmentWithBase",
+    type: () => DB.Object({
+        id: DB.Required({
+            type: DB.IncludeIdentifier(SpellworkIdentifier),
+        }),
+        points: DB.Required({
+            comment: "The skill points that will be added to the current skill rating. If a spell gets to a skill rating of 0 because of this, it will be removed completely.",
+            type: DB.Integer({ minimum: -10, maximum: 10 }),
+        }),
+        basePoints: DB.Optional({
+            comment: "The spell rating of the base profession package. This is only used to compare the derived rating from the profession package with the one in the book for error checking.",
+            type: DB.Integer({ minimum: 0, maximum: 10 }),
+        }),
+        tradition: DB.Optional({
+            comment: "The target tradition. If the target spell is not from the Guild Mage tradition, specify the tradition identifier here.",
+            type: MagicalTraditionIdentifier(),
+        }),
+    }),
+});

package/lib/types/Locale.d.ts

@@ -1335,7 +1335,14 @@ export declare const Locale: DB.Entity<"Locale", {
         "corresponding liturgical style special ability": null;
         "corresponding magic style special ability": null;
         "corresponding skill style special ability": null;
+        "Favored Skills": null;
+        "The primary attribute of this Tradition is {$attr}.": null;
+        "This primary attribute of this Tradition is {$attr}; however, {$casters} use only half of this stat (rounded up) to calculate their base AE pool or purchase AE.": null;
+        "Tradition ({$name}) has no associated primary attribute, meaning {$casters} receive no bonus to the AE pool and cannot purchase additional AE.": null;
+        ".input {$count :number} {{{$baseList}, and {$count} of your choice from the following list: {$selection}}}": null;
         All: null;
+        "All Combat Techniques": null;
+        "All Combat Techniques used in hunting": null;
         "All Close Combat Techniques": null;
         "All Ranged Combat Techniques": null;
         "Depends on combat style; both combat styles can be used only for their corresponding combat techniques": null;

package/lib/types/Locale.js

@@ -1369,8 +1369,15 @@ export const Locale = DB.Entity(import.meta.url, {
                 "corresponding liturgical style special ability": null,
                 "corresponding magic style special ability": null,
                 "corresponding skill style special ability": null,
+                "Favored Skills": null,
+                "The primary attribute of this Tradition is {$attr}.": null,
+                "This primary attribute of this Tradition is {$attr}; however, {$casters} use only half of this stat (rounded up) to calculate their base AE pool or purchase AE.": null,
+                "Tradition ({$name}) has no associated primary attribute, meaning {$casters} receive no bonus to the AE pool and cannot purchase additional AE.": null,
+                ".input {$count :number} {{{$baseList}, and {$count} of your choice from the following list: {$selection}}}": null,
                 // combat special ability -- applicable combat techniques
                 "All": null,
+                "All Combat Techniques": null, // for favored combat techniques
+                "All Combat Techniques used in hunting": null,
                 "All Close Combat Techniques": null,
                 "All Ranged Combat Techniques": null,
                 "Depends on combat style; both combat styles can be used only for their corresponding combat techniques": null,

package/lib/types/Race.d.ts

@@ -4,24 +4,6 @@ export declare const Race: DB.Entity<"Race", {
     base_values: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BaseValues", DB.NestedEntityMap<string, {
         value: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
-    automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
-        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-    automatic_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
-        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-    strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
-        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
-            options: DB.MemberDecl<DB.String, true>;
-        }>, false>;
-    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-    strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
-        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
-            options: DB.MemberDecl<DB.String, true>;
-        }>, false>;
-    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
     hairColorCount: DB.MemberDecl<DB.Integer, false>;
     weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RandomWeightGeneration", DB.Object<{
         base: DB.MemberDecl<DB.Integer, true>;
@@ -55,6 +37,24 @@ export declare const Race: DB.Entity<"Race", {
             }>, []>>>, false>;
         }>, []>>, true>;
         common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+        automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
+            id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+        automatic_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
+            id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+        strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+            id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+                options: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+        strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+            id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+                options: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
         common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
@@ -90,6 +90,11 @@ export declare const Race: DB.Entity<"Race", {
         }>, []>>, true>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"RaceVariantTranslation", {
             name: DB.MemberDecl<DB.String, true>;
+            attribute_adjustments: DB.MemberDecl<DB.String, false>;
+            automatic_advantages: DB.MemberDecl<DB.String, false>;
+            automatic_disadvantages: DB.MemberDecl<DB.String, false>;
+            strongly_recommended_advantages: DB.MemberDecl<DB.String, false>;
+            strongly_recommended_disadvantages: DB.MemberDecl<DB.String, false>;
             common_advantages: DB.MemberDecl<DB.String, false>;
             common_disadvantages: DB.MemberDecl<DB.String, false>;
             uncommon_advantages: DB.MemberDecl<DB.String, false>;
@@ -139,11 +144,6 @@ export declare const Race: DB.Entity<"Race", {
     }>, []>>>, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"RaceTranslation", {
         name: DB.MemberDecl<DB.String, true>;
-        attribute_adjustments: DB.MemberDecl<DB.String, true>;
-        automatic_advantages: DB.MemberDecl<DB.String, false>;
-        automatic_disadvantages: DB.MemberDecl<DB.String, false>;
-        strongly_recommended_advantages: DB.MemberDecl<DB.String, false>;
-        strongly_recommended_disadvantages: DB.MemberDecl<DB.String, false>;
         hairColorLabel: DB.MemberDecl<DB.String, false>;
         errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
             date: DB.MemberDecl<DB.Date, true>;
@@ -164,6 +164,24 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
         }>, []>>>, false>;
     }>, []>>, true>;
     common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+    automatic_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+    strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+            options: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+    strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+            options: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
     common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
@@ -199,6 +217,11 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
     }>, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"RaceVariantTranslation", {
         name: DB.MemberDecl<DB.String, true>;
+        attribute_adjustments: DB.MemberDecl<DB.String, false>;
+        automatic_advantages: DB.MemberDecl<DB.String, false>;
+        automatic_disadvantages: DB.MemberDecl<DB.String, false>;
+        strongly_recommended_advantages: DB.MemberDecl<DB.String, false>;
+        strongly_recommended_disadvantages: DB.MemberDecl<DB.String, false>;
         common_advantages: DB.MemberDecl<DB.String, false>;
         common_disadvantages: DB.MemberDecl<DB.String, false>;
         uncommon_advantages: DB.MemberDecl<DB.String, false>;

package/lib/types/Race.js

@@ -20,24 +20,6 @@ export const Race = DB.Entity(import.meta.url, {
             comment: "The race’s base values.",
             type: DB.IncludeIdentifier(BaseValues),
         }),
-        automatic_advantages: DB.Optional({
-            comment: "A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.",
-            type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]), {
-                minItems: 1,
-            }),
-        }),
-        automatic_disadvantages: DB.Optional({
-            comment: "A list of automatically applied disadvantages. This does only work for disadvantages with no further configuration such as level or special selection.",
-            type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
-        }),
-        strongly_recommended_advantages: DB.Optional({
-            comment: "A list of strongly recommended advantages.",
-            type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [AdvantageIdentifier()]), { minItems: 1 }),
-        }),
-        strongly_recommended_disadvantages: DB.Optional({
-            comment: "A list of strongly recommended disadvantages.",
-            type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
-        }),
         hairColorCount: DB.Optional({
             comment: "How many different hair colors a race may have. By default, they have a single one that is for their whole body, but a race may have multiple if their hair color is different for different body parts. Additionally, if the hair color is labelled differently (e.g. scale color), there might be multiple colors for different body parts as well. This should only be set if the hair color count is higher than 1.",
             type: DB.Integer({ minimum: 2 }),
@@ -75,26 +57,6 @@ export const Race = DB.Entity(import.meta.url, {
                 comment: "The race’s name.",
                 type: DB.String({ minLength: 1 }),
             }),
-            attribute_adjustments: DB.Required({
-                comment: "The respective attribute adjustments text from the source book.",
-                type: DB.String({ minLength: 1 }),
-            }),
-            automatic_advantages: DB.Optional({
-                comment: "The respective automatic advantages text from the source book.",
-                type: DB.String({ minLength: 1 }),
-            }),
-            automatic_disadvantages: DB.Optional({
-                comment: "The respective automatic disadvantages text from the source book.",
-                type: DB.String({ minLength: 1 }),
-            }),
-            strongly_recommended_advantages: DB.Optional({
-                comment: "The respective strongly recommended advantages text from the source book.",
-                type: DB.String({ minLength: 1 }),
-            }),
-            strongly_recommended_disadvantages: DB.Optional({
-                comment: "The respective strongly recommended disadvantages text from the source book.",
-                type: DB.String({ minLength: 1 }),
-            }),
             hairColorLabel: DB.Optional({
                 comment: "The label for hair colors if it is not a hair color in that sense: Some races may have different labels for hair color such as scale color.",
                 type: DB.String({ minLength: 1 }),
@@ -251,6 +213,24 @@ export const RaceVariant = DB.Entity(import.meta.url, {
             comment: "The list of common cultures.",
             type: DB.Array(CultureIdentifier(), { minItems: 1 }),
         }),
+        automatic_advantages: DB.Optional({
+            comment: "A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.",
+            type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]), {
+                minItems: 1,
+            }),
+        }),
+        automatic_disadvantages: DB.Optional({
+            comment: "A list of automatically applied disadvantages. This does only work for disadvantages with no further configuration such as level or special selection.",
+            type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
+        }),
+        strongly_recommended_advantages: DB.Optional({
+            comment: "A list of strongly recommended advantages.",
+            type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [AdvantageIdentifier()]), { minItems: 1 }),
+        }),
+        strongly_recommended_disadvantages: DB.Optional({
+            comment: "A list of strongly recommended disadvantages.",
+            type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
+        }),
         common_advantages: DB.Optional({
             comment: "A list of common advantages.",
             type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [AdvantageIdentifier()]), { minItems: 1 }),
@@ -284,6 +264,26 @@ export const RaceVariant = DB.Entity(import.meta.url, {
                 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: DB.String({ minLength: 1 }),
             }),
+            attribute_adjustments: DB.Optional({
+                comment: "The respective attribute adjustments text from the source book.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            automatic_advantages: DB.Optional({
+                comment: "The respective automatic advantages text from the source book.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            automatic_disadvantages: DB.Optional({
+                comment: "The respective automatic disadvantages text from the source book.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            strongly_recommended_advantages: DB.Optional({
+                comment: "The respective strongly recommended advantages text from the source book.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            strongly_recommended_disadvantages: DB.Optional({
+                comment: "The respective strongly recommended disadvantages text from the source book.",
+                type: DB.String({ minLength: 1 }),
+            }),
             common_advantages: DB.Optional({
                 comment: "The respective common advantages text from the source book.",
                 type: DB.String({ minLength: 1 }),

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

@@ -947,7 +947,7 @@ export declare const MagicalTradition: DB.Entity<"MagicalTradition", {
         }>, false>;
     }, "parent">>, true>;
     primary: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PrimaryAttribute", DB.Object<{
-        id: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         use_half_for_arcane_energy: DB.MemberDecl<DB.Boolean, true>;
     }>, []>>, false>;
     can_learn_cantrips: DB.MemberDecl<DB.Boolean, true>;
@@ -1119,6 +1119,7 @@ export declare const MagicalTradition: DB.Entity<"MagicalTradition", {
         name: DB.MemberDecl<DB.String, true>;
         name_for_arcane_spellworks: DB.MemberDecl<DB.String, false>;
         name_in_library: DB.MemberDecl<DB.String, false>;
+        nameOfSpellcasters: DB.MemberDecl<DB.String, true>;
         special_rules: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecialRule", DB.Object<{
             label: DB.MemberDecl<DB.String, false>;
             text: DB.MemberDecl<DB.String, true>;
@@ -1132,7 +1133,3 @@ export declare const MagicalTradition: DB.Entity<"MagicalTradition", {
         }>, []>>>, []>>, false>;
     }>, true>;
 }, undefined>;
-export declare const PrimaryAttribute: DB.TypeAlias<"PrimaryAttribute", DB.Object<{
-    id: DB.MemberDecl<DB.ReferenceIdentifier, false>;
-    use_half_for_arcane_energy: DB.MemberDecl<DB.Boolean, true>;
-}>, []>;

package/lib/types/specialAbility/MagicalTradition.js

@@ -76,6 +76,10 @@ export const MagicalTradition = DB.Entity(import.meta.url, {
                 type: DB.String({ minLength: 1 }),
             }),
             name_in_library,
+            nameOfSpellcasters: DB.Required({
+                comment: "The name of spellcasters of this tradition. This is used to derive special rules from the data set already for this tradition.",
+                type: DB.String({ minLength: 1 }),
+            }),
             special_rules: DB.Required({
                 comment: "The special rules of the tradition. They should be sorted like they are in the book.",
                 type: DB.Array(DB.IncludeIdentifier(SpecialRule), { minItems: 1 }),
@@ -100,10 +104,10 @@ export const MagicalTradition = DB.Entity(import.meta.url, {
         },
     ],
 });
-export const PrimaryAttribute = DB.TypeAlias(import.meta.url, {
+const PrimaryAttribute = DB.TypeAlias(import.meta.url, {
     name: "PrimaryAttribute",
     type: () => DB.Object({
-        id: DB.Optional({
+        id: DB.Required({
             comment: "The attribute’s identifier.",
             type: AttributeIdentifier(),
         }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.42.4",
+  "version": "0.43.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",