@optolith/database-schema 0.60.0 → 0.62.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 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.62.0](https://github.com/Optolith/database-schema/compare/v0.61.0...v0.62.0) (2026-09-15)
+
+### ⚠ BREAKING CHANGES
+
+* removable prerequisites in profession variants
+
+### Features
+
+* removable prerequisites in profession variants ([da532f7](https://github.com/Optolith/database-schema/commit/da532f7fd939602dd042ecd4599bda74cca4fc8c))
+## [0.61.0](https://github.com/Optolith/database-schema/compare/v0.60.0...v0.61.0) (2026-09-13)
+
+### ⚠ BREAKING CHANGES
+
+* **content:** add STD translation
+
+### Bug Fixes
+
+* **content:** add STD translation ([3ff3417](https://github.com/Optolith/database-schema/commit/3ff34175d031be21801f7b9449919897523256e4))
 ## [0.60.0](https://github.com/Optolith/database-schema/compare/v0.59.0...v0.60.0) (2026-09-12)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -395,6 +395,7 @@ export type EnumMap = {
   PoisonStart: PoisonStart
   PoisonTimeUnit: PoisonTimeUnit
   PreconditionGroup: PreconditionGroup
+  PrerequisiteDiff: PrerequisiteDiff<unknown>
   PrerequisitesElement: PrerequisitesElement<unknown>
   PrimaryAttributeCategory: PrimaryAttributeCategory
   PrimaryAttributeDamageThreshold: PrimaryAttributeDamageThreshold
@@ -792,6 +793,7 @@ export type TypeAliasMap = {
   PersonalityTraitPrerequisites: PersonalityTraitPrerequisites
   PlainBookRules: PlainBookRules
   PlainCommonProfessions: PlainCommonProfessions
+  PlainDiffPrerequisites: PlainDiffPrerequisites<unknown>
   PlainGeneralPrerequisites: PlainGeneralPrerequisites
   PlainPrerequisites: PlainPrerequisites<unknown>
   PlantEffect: PlantEffect
@@ -817,6 +819,7 @@ export type TypeAliasMap = {
   ProfessionSpecialAbilitySelection: ProfessionSpecialAbilitySelection
   ProfessionSpellworkIdentifier: ProfessionSpellworkIdentifier
   ProfessionVariantPackageOptions: ProfessionVariantPackageOptions
+  ProfessionVariantPrerequisites: ProfessionVariantPrerequisites
   ProfessionVariantSpecialAbility: ProfessionVariantSpecialAbility
   PropertiesSelectOptionCategory: PropertiesSelectOptionCategory
   Protection: Protection
@@ -2171,6 +2174,7 @@ export interface Locale {
     "no advantage": string
     "disadvantage": string
     "no disadvantage": string
+    "no prerequisite {$prerequisite}": string & { __params: { "prerequisite": StringableTranslationParameter } }
     "domain {$domain}": string & { __params: { "domain": StringableTranslationParameter } }
     "{$pact} level {$pactLevel}": string & { __params: { "pact": StringableTranslationParameter; "pactLevel": StringableTranslationParameter } }
     "Level {$level}": string & { __params: { "level": StringableTranslationParameter } }
@@ -2616,6 +2620,7 @@ export interface Locale {
     "Communicability to Intelligent Creatures": string
     "childhood disease": string
     "magical disease": string
+    "sexually transmittable disease": string
     "Can be combined with": string
     "Skill": string
     "{$defaultDuration}, but no more than {$maximumDuration}": string & { __params: { "defaultDuration": StringableTranslationParameter; "maximumDuration": StringableTranslationParameter } }
@@ -9850,7 +9855,7 @@ export interface ProfessionVariant {
   /**
    * Which prerequisites must be met to buy the stat block? For example, a character might need the advantage Spellcaster or Blessed. Note: the AP cost for a profession package does not include these prerequisites.
    */
-  prerequisites?: ProfessionPrerequisites
+  prerequisites?: ProfessionVariantPrerequisites
 
   /**
    * In some areas, the profession package grants a loose set of stats where the player must choose between different options for the profession package. The variant may override or remove those options.
@@ -9912,6 +9917,20 @@ export interface ProfessionVariantTranslation {
   concluding_text?: string
 }
 
+export type ProfessionVariantPrerequisites = PlainDiffPrerequisites<ProfessionPrerequisiteGroup>
+
+export type PlainDiffPrerequisites<T> = PrerequisiteDiff<PrerequisitesElement<T>>[]
+
+export type PrerequisiteDiff<T> =
+  | {
+    kind: "Add"
+    Add: T
+  }
+  | {
+    kind: "Remove"
+    Remove: T
+  }
+
 /**
  * In some areas, the profession package grants a loose set of stats where the player must choose between different options for the profession package. The variant may override or remove those options.
  */

package/lib/types/Locale.d.ts

@@ -1085,6 +1085,7 @@ export declare const Locale: DB.Entity<"Locale", {
         "no advantage": null;
         disadvantage: null;
         "no disadvantage": null;
+        "no prerequisite {$prerequisite}": null;
         "domain {$domain}": null;
         "{$pact} level {$pactLevel}": null;
         "Level {$level}": null;
@@ -1545,6 +1546,7 @@ export declare const Locale: DB.Entity<"Locale", {
         "Communicability to Intelligent Creatures": null;
         "childhood disease": null;
         "magical disease": null;
+        "sexually transmittable disease": null;
         "Can be combined with": null;
         Skill: null;
         "{$defaultDuration}, but no more than {$maximumDuration}": null;

package/lib/types/Locale.js

@@ -1110,6 +1110,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "no advantage": null,
                 "disadvantage": null,
                 "no disadvantage": null,
+                "no prerequisite {$prerequisite}": null,
                 "domain {$domain}": null,
                 "{$pact} level {$pactLevel}": null,
                 // Personality Trait prerequisite
@@ -1590,6 +1591,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Communicability to Intelligent Creatures": null,
                 "childhood disease": null,
                 "magical disease": null,
+                "sexually transmittable disease": null,
                 // personality traits
                 "Can be combined with": null,
                 // magical actions

package/lib/types/Profession.d.ts

@@ -297,29 +297,9 @@ export declare const Profession: DB.Entity<"Profession", {
             variants: DB.MemberDecl<DB.ChildEntities<DB.Entity<"ProfessionVariant", {
                 profession_package: DB.MemberDecl<DB.ReferenceIdentifier, true>;
                 ap_value: DB.MemberDecl<DB.Integer, false>;
-                prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
-                    Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
-                    Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
-                        list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-                        display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
-                            Hide: DB.EnumCase<null>;
-                            ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
-                                sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
-                                    Standalone: DB.EnumCase<null>;
-                                    Connected: DB.EnumCase<null>;
-                                }, []>>, false>;
-                                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
-                                    replacement: DB.MemberDecl<DB.String, true>;
-                                }>, true>;
-                            }>, []>>>;
-                        }, []>>, false>;
-                    }>, [T: DB.Param<"T", DB.Type>]>>>;
-                    Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
-                        list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-                        translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
-                            text: DB.MemberDecl<DB.String, true>;
-                        }>, true>;
-                    }>, [T: DB.Param<"T", DB.Type>]>>>;
+                prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainDiffPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisiteDiff", {
+                    Add: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                    Remove: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
                 }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
                 options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPackageOptions", DB.Object<{
                     skill_specialization: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
@@ -1084,29 +1064,9 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
         variants: DB.MemberDecl<DB.ChildEntities<DB.Entity<"ProfessionVariant", {
             profession_package: DB.MemberDecl<DB.ReferenceIdentifier, true>;
             ap_value: DB.MemberDecl<DB.Integer, false>;
-            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
-                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
-                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
-                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
-                        Hide: DB.EnumCase<null>;
-                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
-                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
-                                Standalone: DB.EnumCase<null>;
-                                Connected: DB.EnumCase<null>;
-                            }, []>>, false>;
-                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
-                                replacement: DB.MemberDecl<DB.String, true>;
-                            }>, true>;
-                        }>, []>>>;
-                    }, []>>, false>;
-                }>, [T: DB.Param<"T", DB.Type>]>>>;
-                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
-                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
-                        text: DB.MemberDecl<DB.String, true>;
-                    }>, true>;
-                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainDiffPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisiteDiff", {
+                Add: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Remove: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
             options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPackageOptions", DB.Object<{
                 skill_specialization: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
@@ -1863,29 +1823,9 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
     variants: DB.MemberDecl<DB.ChildEntities<DB.Entity<"ProfessionVariant", {
         profession_package: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         ap_value: DB.MemberDecl<DB.Integer, false>;
-        prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
-            Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
-            Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
-                list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-                display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
-                    Hide: DB.EnumCase<null>;
-                    ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
-                        sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
-                            Standalone: DB.EnumCase<null>;
-                            Connected: DB.EnumCase<null>;
-                        }, []>>, false>;
-                        translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
-                            replacement: DB.MemberDecl<DB.String, true>;
-                        }>, true>;
-                    }>, []>>>;
-                }, []>>, false>;
-            }>, [T: DB.Param<"T", DB.Type>]>>>;
-            Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
-                list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-                translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
-                    text: DB.MemberDecl<DB.String, true>;
-                }>, true>;
-            }>, [T: DB.Param<"T", DB.Type>]>>>;
+        prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainDiffPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisiteDiff", {
+            Add: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+            Remove: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
         options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPackageOptions", DB.Object<{
             skill_specialization: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {
@@ -2151,29 +2091,9 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
 export declare const ProfessionVariant: DB.Entity<"ProfessionVariant", {
     profession_package: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     ap_value: DB.MemberDecl<DB.Integer, false>;
-    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
-        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
-        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
-            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
-                Hide: DB.EnumCase<null>;
-                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
-                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
-                        Standalone: DB.EnumCase<null>;
-                        Connected: DB.EnumCase<null>;
-                    }, []>>, false>;
-                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
-                        replacement: DB.MemberDecl<DB.String, true>;
-                    }>, true>;
-                }>, []>>>;
-            }, []>>, false>;
-        }>, [T: DB.Param<"T", DB.Type>]>>>;
-        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
-            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
-                text: DB.MemberDecl<DB.String, true>;
-            }>, true>;
-        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainDiffPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisiteDiff", {
+        Add: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Remove: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
     }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ProfessionVariantPackageOptions", DB.Object<{
         skill_specialization: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"VariantOptionAction", {

package/lib/types/Profession.js

@@ -3,7 +3,7 @@ import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { AdvantageIdentifier, CantripIdentifier, CurriculumIdentifier, DisadvantageIdentifier, ExperienceLevelIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, ProfessionPackageIdentifier, ProfessionVersionIdentifier, SkillGroupIdentifier, SkillIdentifier, } from "./_Identifier.js";
 import { CombatTechniqueIdentifier, LiturgyIdentifier, MagicalActionIdentifier, ProfessionSpecialAbilityIdentifier, RequirableSelectOptionIdentifier, SpellworkIdentifier, } from "./_IdentifierGroup.js";
-import { ProfessionPrerequisites } from "./_Prerequisite.js";
+import { ProfessionPrerequisites, ProfessionVariantPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
@@ -244,7 +244,7 @@ export const ProfessionVariant = DB.Entity(import.meta.url, {
         }),
         prerequisites: DB.Optional({
             comment: "Which prerequisites must be met to buy the stat block? For example, a character might need the advantage Spellcaster or Blessed. Note: the AP cost for a profession package does not include these prerequisites.",
-            type: DB.IncludeIdentifier(ProfessionPrerequisites),
+            type: DB.IncludeIdentifier(ProfessionVariantPrerequisites),
         }),
         options: DB.Optional({
             comment: "In some areas, the profession package grants a loose set of stats where the player must choose between different options for the profession package. The variant may override or remove those options.",

package/lib/types/_Prerequisite.d.ts

@@ -149,6 +149,10 @@ export declare const ProfessionPrerequisites: DB.TypeAlias<"ProfessionPrerequisi
         }>, true>;
     }>, [T: DB.Param<"T", DB.Type>]>>>;
 }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>;
+export declare const ProfessionVariantPrerequisites: DB.TypeAlias<"ProfessionVariantPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainDiffPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisiteDiff", {
+    Add: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+    Remove: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+}, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>;
 export declare const AdvantageDisadvantagePrerequisites: DB.TypeAlias<"AdvantageDisadvantagePrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesForLevels", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteForLevel", DB.Object<{
     level: DB.MemberDecl<DB.Integer, true>;
     prerequisite: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {

package/lib/types/_Prerequisite.js

@@ -50,6 +50,27 @@ const PlainPrerequisites = DB.GenTypeAlias(import.meta.url, {
     parameters: [DB.Param("T")],
     type: T => DB.Array(DB.GenIncludeIdentifier(PrerequisitesElement, [DB.TypeArgument(T)]), { minItems: 1 }),
 });
+const PrerequisiteDiff = DB.GenEnum(import.meta.url, {
+    name: "PrerequisiteDiff",
+    parameters: [DB.Param("T")],
+    values: T => ({
+        Add: DB.EnumCase({
+            comment: "This prerequisite is added to the list of existing prerequisites.",
+            type: DB.TypeArgument(T),
+        }),
+        Remove: DB.EnumCase({
+            comment: "This prerequisite is removed from the list of existing prerequisites.",
+            type: DB.TypeArgument(T),
+        }),
+    }),
+});
+const PlainDiffPrerequisites = DB.GenTypeAlias(import.meta.url, {
+    name: "PlainDiffPrerequisites",
+    parameters: [DB.Param("T")],
+    type: T => DB.Array(DB.GenIncludeIdentifier(PrerequisiteDiff, [
+        DB.GenIncludeIdentifier(PrerequisitesElement, [DB.TypeArgument(T)]),
+    ]), { minItems: 1 }),
+});
 const PrerequisiteForLevel = DB.GenTypeAlias(import.meta.url, {
     name: "PrerequisiteForLevel",
     parameters: [DB.Param("T")],
@@ -103,6 +124,12 @@ export const ProfessionPrerequisites = DB.TypeAlias(import.meta.url, {
         DB.IncludeIdentifier(ProfessionPrerequisiteGroup),
     ]),
 });
+export const ProfessionVariantPrerequisites = DB.TypeAlias(import.meta.url, {
+    name: "ProfessionVariantPrerequisites",
+    type: () => DB.GenIncludeIdentifier(PlainDiffPrerequisites, [
+        DB.IncludeIdentifier(ProfessionPrerequisiteGroup),
+    ]),
+});
 export const AdvantageDisadvantagePrerequisites = DB.TypeAlias(import.meta.url, {
     name: "AdvantageDisadvantagePrerequisites",
     type: () => DB.GenIncludeIdentifier(PrerequisitesForLevels, [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.60.0",
+  "version": "0.62.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",