optolith-database-schema 0.23.1 → 0.24.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 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.24.0](https://github.com/elyukai/optolith-database-schema/compare/v0.23.2...v0.24.0) (2025-12-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* The prerequisites field is moved from profession
+versions to profession packages.
+
+### Bug Fixes
+
+* arcane traditions and elements can be requirable select options ([d1c9795](https://github.com/elyukai/optolith-database-schema/commit/d1c9795e8378b8f7da69e47491c48df6514661a8))
+* profession prerequisites can differ per profession version ([08a7d8d](https://github.com/elyukai/optolith-database-schema/commit/08a7d8d2c88beff69ea7b4d68995b1eb6d2528a6))
+
+## [0.23.2](https://github.com/elyukai/optolith-database-schema/compare/v0.23.1...v0.23.2) (2025-12-04)
+
+
+### Bug Fixes
+
+* use correct identifiers in restrictions ([9392990](https://github.com/elyukai/optolith-database-schema/commit/9392990109296bc4cfbc5116c8fa5360efd4a02d))
+
 ## [0.23.1](https://github.com/elyukai/optolith-database-schema/compare/v0.23.0...v0.23.1) (2025-12-04)
 
 

package/gen/types.d.ts

@@ -3991,6 +3991,18 @@ export type RequirableSelectOptionIdentifier =
     kind: "TradeSecret"
     TradeSecret: TradeSecret_ID
   }
+  | {
+    kind: "ArcaneBardTradition"
+    ArcaneBardTradition: ArcaneBardTradition_ID
+  }
+  | {
+    kind: "ArcaneDancerTradition"
+    ArcaneDancerTradition: ArcaneDancerTradition_ID
+  }
+  | {
+    kind: "Element"
+    Element: Element_ID
+  }
 
 export interface CloseCombatTechnique {
   /**
@@ -6927,6 +6939,76 @@ export type TradeSecretAdventurePointsValue =
 
 export type PlainGeneralPrerequisites = PlainPrerequisites<GeneralPrerequisiteGroup>
 
+export interface ArcaneBardTradition {
+  prerequisites: ArcaneTraditionPrerequisites
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: ArcaneBardTraditionTranslationTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type ArcaneBardTradition_ID = string
+
+export interface ArcaneBardTraditionTranslationTranslation {
+  /**
+   * The arcane tradition’s name.
+   */
+  name: string
+}
+
+export type ArcaneTraditionPrerequisites = PlainPrerequisites<ArcaneTraditionPrerequisiteGroup>
+
+export type ArcaneTraditionPrerequisiteGroup =
+  | {
+    kind: "Sex"
+    Sex: SexPrerequisite
+  }
+  | {
+    kind: "Culture"
+    Culture: CulturePrerequisite
+  }
+
+/**
+ * Requires a specific culture or one of a specific set of cultures.
+ */
+export interface CulturePrerequisite {
+  /**
+   * The culture’s identifier.
+   */
+  id: Culture_ID
+
+  display_option?: DisplayOption
+}
+
+export interface ArcaneDancerTradition {
+  prerequisites: ArcaneTraditionPrerequisites
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: ArcaneDancerTraditionTranslationTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type ArcaneDancerTradition_ID = string
+
+export interface ArcaneDancerTraditionTranslationTranslation {
+  /**
+   * The arcane tradition’s name.
+   */
+  name: string
+}
+
 /**
  * A list of preconditions for the prerequisite it is defined on, so that it only takes effect if the prerequisites in this list are matched.
  * 
@@ -7408,11 +7490,6 @@ export interface ProfessionVersion {
    */
   profession: Profession_ID
 
-  /**
-   * 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
-
   /**
    * A list of available race variants where one has to be selected. If no variants are to be selected, a single variant with no name has to be provided which will be used as the missing values for the base race.
    */
@@ -7490,42 +7567,6 @@ export interface ProfessionVersionTranslation {
   errata?: Errata
 }
 
-export type ProfessionPrerequisites = PlainPrerequisites<ProfessionPrerequisiteGroup>
-
-export type ProfessionPrerequisiteGroup =
-  | {
-    kind: "Sex"
-    Sex: SexPrerequisite
-  }
-  | {
-    kind: "Race"
-    Race: RacePrerequisite
-  }
-  | {
-    kind: "Culture"
-    Culture: CulturePrerequisite
-  }
-  | {
-    kind: "Activatable"
-    Activatable: ActivatablePrerequisite
-  }
-  | {
-    kind: "Rated"
-    Rated: RatedPrerequisite
-  }
-
-/**
- * Requires a specific culture or one of a specific set of cultures.
- */
-export interface CulturePrerequisite {
-  /**
-   * The culture’s identifier.
-   */
-  id: Culture_ID
-
-  display_option?: DisplayOption
-}
-
 export interface ProfessionPackage {
   /**
    * The associated profession version.
@@ -7542,6 +7583,11 @@ export interface ProfessionPackage {
    */
   ap_value: number
 
+  /**
+   * 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
+
   /**
    * In some areas, the profession package grants a loose set of stats where the player must choose between different options for the profession package.
    */
@@ -7588,6 +7634,30 @@ export interface ProfessionPackage {
  */
 export type ProfessionPackage_ID = string
 
+export type ProfessionPrerequisites = PlainPrerequisites<ProfessionPrerequisiteGroup>
+
+export type ProfessionPrerequisiteGroup =
+  | {
+    kind: "Sex"
+    Sex: SexPrerequisite
+  }
+  | {
+    kind: "Race"
+    Race: RacePrerequisite
+  }
+  | {
+    kind: "Culture"
+    Culture: CulturePrerequisite
+  }
+  | {
+    kind: "Activatable"
+    Activatable: ActivatablePrerequisite
+  }
+  | {
+    kind: "Rated"
+    Rated: RatedPrerequisite
+  }
+
 /**
  * In some areas, the profession package grants a loose set of stats where the player must choose between different options for the profession package.
  */
@@ -10130,7 +10200,7 @@ export interface RestrictedToRaces {
   /**
    * The item is restricted to one of a list of races. If only one race is allowed, the list may only have a single element.
    */
-  scope: MagicalTradition_ID[]
+  scope: Race_ID[]
 }
 
 /**
@@ -10140,7 +10210,7 @@ export interface RestrictedToCultures {
   /**
    * The item is restricted to one of a list of cultures. If only one culture is allowed, the list may only have a single element.
    */
-  scope: MagicalTradition_ID[]
+  scope: Culture_ID[]
 }
 
 /**
@@ -10150,7 +10220,7 @@ export interface RestrictedToProfessions {
   /**
    * The item is restricted to one of a list of professions. If only one profession is allowed, the list may only have a single element.
    */
-  scope: MagicalTradition_ID[]
+  scope: Profession_ID[]
 }
 
 /**
@@ -15525,41 +15595,6 @@ export interface ArcaneBardTraditionReferenceTranslationTranslation {
   name: string
 }
 
-export interface ArcaneBardTradition {
-  prerequisites: ArcaneTraditionPrerequisites
-
-  /**
-   * All translations for the entry, identified by IETF language tag (BCP47).
-   */
-  translations: {
-    [localeId: string]: ArcaneBardTraditionTranslationTranslation
-  }
-}
-
-/**
- * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
- */
-export type ArcaneBardTradition_ID = string
-
-export interface ArcaneBardTraditionTranslationTranslation {
-  /**
-   * The arcane tradition’s name.
-   */
-  name: string
-}
-
-export type ArcaneTraditionPrerequisites = PlainPrerequisites<ArcaneTraditionPrerequisiteGroup>
-
-export type ArcaneTraditionPrerequisiteGroup =
-  | {
-    kind: "Sex"
-    Sex: SexPrerequisite
-  }
-  | {
-    kind: "Culture"
-    Culture: CulturePrerequisite
-  }
-
 export interface MagicalDance {
   /**
    * Lists the linked three attributes used to make a skill check.
@@ -15713,29 +15748,6 @@ export interface ArcaneDancerTraditionReferenceTranslationTranslation {
   name: string
 }
 
-export interface ArcaneDancerTradition {
-  prerequisites: ArcaneTraditionPrerequisites
-
-  /**
-   * All translations for the entry, identified by IETF language tag (BCP47).
-   */
-  translations: {
-    [localeId: string]: ArcaneDancerTraditionTranslationTranslation
-  }
-}
-
-/**
- * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
- */
-export type ArcaneDancerTradition_ID = string
-
-export interface ArcaneDancerTraditionTranslationTranslation {
-  /**
-   * The arcane tradition’s name.
-   */
-  name: string
-}
-
 export interface JesterTrick {
   /**
    * Lists the linked three attributes used to make a skill check.

package/lib/types/Profession.d.ts

@@ -13,34 +13,34 @@ export declare const Profession: Entity<"Profession", {
     }, []>>, true>;
     versions: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"ProfessionVersion", {
         profession: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"PrerequisitesElement", {
-            Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
-            Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", ObjectType<{
-                list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
-                display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
-                    Hide: EnumCase<null>;
-                    ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", ObjectType<{
-                        sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
-                            Standalone: EnumCase<null>;
-                            Connected: EnumCase<null>;
-                        }, []>>, false>;
-                        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
-                            replacement: import("tsondb/schema/def").MemberDecl<String, true>;
-                        }>, true>;
-                    }>, []>>>;
-                }, []>>, false>;
-            }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
-            Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", ObjectType<{
-                list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
-                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
-                    text: import("tsondb/schema/def").MemberDecl<String, true>;
-                }>, true>;
-            }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
-        }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
         package: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"ProfessionPackage", {
             profession_version: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
             experience_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
             ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"PrerequisitesElement", {
+                Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+                Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", ObjectType<{
+                    list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+                    display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
+                        Hide: EnumCase<null>;
+                        ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", ObjectType<{
+                            sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
+                                Standalone: EnumCase<null>;
+                                Connected: EnumCase<null>;
+                            }, []>>, false>;
+                            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                                replacement: import("tsondb/schema/def").MemberDecl<String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+                Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", ObjectType<{
+                    list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+                        text: import("tsondb/schema/def").MemberDecl<String, true>;
+                    }>, true>;
+                }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+            }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
             options: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPackageOptions", ObjectType<{
                 skill_specialization: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SkillSpecializationOptions", {
                     Specific: EnumCase<IncludeIdentifier<[], TypeAlias<"SpecificSkillSpecializationOptions", ObjectType<{
@@ -145,6 +145,9 @@ export declare const Profession: Entity<"Profession", {
                         Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     }, []>>>, false>;
                 }>, []>>>;
                 Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -215,6 +218,9 @@ export declare const Profession: Entity<"Profession", {
                             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         }, []>>>, false>;
                     }>, []>>>, true>;
                 }>, []>>>;
@@ -394,6 +400,9 @@ export declare const Profession: Entity<"Profession", {
                                 Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                 Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                 TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             }, []>>>, false>;
                         }>, []>>>;
                         Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -464,6 +473,9 @@ export declare const Profession: Entity<"Profession", {
                                     Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                     Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                     TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                    ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                    ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                    Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                 }, []>>>, false>;
                             }>, []>>>, true>;
                         }>, []>>>;
@@ -605,34 +617,34 @@ export declare const MundaneProfessionGroup: Enum<"MundaneProfessionGroup", {
 }, []>;
 export declare const ProfessionVersion: Entity<"ProfessionVersion", {
     profession: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"PrerequisitesElement", {
-        Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
-        Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", ObjectType<{
-            list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
-            display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
-                Hide: EnumCase<null>;
-                ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", ObjectType<{
-                    sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
-                        Standalone: EnumCase<null>;
-                        Connected: EnumCase<null>;
-                    }, []>>, false>;
-                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
-                        replacement: import("tsondb/schema/def").MemberDecl<String, true>;
-                    }>, true>;
-                }>, []>>>;
-            }, []>>, false>;
-        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
-        Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", ObjectType<{
-            list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
-            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
-                text: import("tsondb/schema/def").MemberDecl<String, true>;
-            }>, true>;
-        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
-    }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
     package: import("tsondb/schema/def").MemberDecl<ChildEntities<Entity<"ProfessionPackage", {
         profession_version: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
         experience_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
         ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"PrerequisitesElement", {
+            Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+            Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", ObjectType<{
+                list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+                display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
+                    Hide: EnumCase<null>;
+                    ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", ObjectType<{
+                        sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
+                            Standalone: EnumCase<null>;
+                            Connected: EnumCase<null>;
+                        }, []>>, false>;
+                        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                            replacement: import("tsondb/schema/def").MemberDecl<String, true>;
+                        }>, true>;
+                    }>, []>>>;
+                }, []>>, false>;
+            }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+            Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", ObjectType<{
+                list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+                    text: import("tsondb/schema/def").MemberDecl<String, true>;
+                }>, true>;
+            }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+        }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
         options: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPackageOptions", ObjectType<{
             skill_specialization: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SkillSpecializationOptions", {
                 Specific: EnumCase<IncludeIdentifier<[], TypeAlias<"SpecificSkillSpecializationOptions", ObjectType<{
@@ -737,6 +749,9 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
                     Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                 }, []>>>, false>;
             }>, []>>>;
             Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -807,6 +822,9 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
                         Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     }, []>>>, false>;
                 }>, []>>>, true>;
             }>, []>>>;
@@ -986,6 +1004,9 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
                             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         }, []>>>, false>;
                     }>, []>>>;
                     Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -1056,6 +1077,9 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
                                 Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                 Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                                 TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                                Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             }, []>>>, false>;
                         }>, []>>>, true>;
                     }>, []>>>;
@@ -1193,6 +1217,30 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
     profession_version: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
     experience_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
     ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"PrerequisitesElement", {
+        Single: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+        Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", ObjectType<{
+            list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+            display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
+                Hide: EnumCase<null>;
+                ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", ObjectType<{
+                    sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
+                        Standalone: EnumCase<null>;
+                        Connected: EnumCase<null>;
+                    }, []>>, false>;
+                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                        replacement: import("tsondb/schema/def").MemberDecl<String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+        Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", ObjectType<{
+            list: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+                text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, true>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+    }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
     options: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ProfessionPackageOptions", ObjectType<{
         skill_specialization: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SkillSpecializationOptions", {
             Specific: EnumCase<IncludeIdentifier<[], TypeAlias<"SpecificSkillSpecializationOptions", ObjectType<{
@@ -1297,6 +1345,9 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
                 Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                 Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                 TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             }, []>>>, false>;
         }>, []>>>;
         Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -1367,6 +1418,9 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
                     Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                 }, []>>>, false>;
             }>, []>>>, true>;
         }>, []>>>;
@@ -1546,6 +1600,9 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
                         Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     }, []>>>, false>;
                 }>, []>>>;
                 Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -1616,6 +1673,9 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
                             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         }, []>>>, false>;
                     }>, []>>>, true>;
                 }>, []>>>;
@@ -1806,6 +1866,9 @@ export declare const ProfessionVariant: Entity<"ProfessionVariant", {
                     Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                    Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                 }, []>>>, false>;
             }>, []>>>;
             Selection: EnumCase<IncludeIdentifier<[], TypeAlias<"ProfessionSpecialAbilitySelection", ObjectType<{
@@ -1876,6 +1939,9 @@ export declare const ProfessionVariant: Entity<"ProfessionVariant", {
                         Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                         TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                        Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
                     }, []>>>, false>;
                 }>, []>>>, true>;
             }>, []>>>;

package/lib/types/Profession.js

@@ -72,10 +72,6 @@ export const ProfessionVersion = Entity(import.meta.url, {
             comment: "The associated profession.",
             type: ProfessionIdentifier(),
         }),
-        prerequisites: 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: IncludeIdentifier(ProfessionPrerequisites),
-        }),
         package: Required({
             comment: "A list of available race variants where one has to be selected. If no variants are to be selected, a single variant with no name has to be provided which will be used as the missing values for the base race.",
             type: ChildEntities(ProfessionPackage),
@@ -165,6 +161,10 @@ export const ProfessionPackage = Entity(import.meta.url, {
             comment: "What does the professional package cost in adventure points?",
             type: Integer({ minimum: 0 }),
         }),
+        prerequisites: 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: IncludeIdentifier(ProfessionPrerequisites),
+        }),
         options: 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.",
             type: IncludeIdentifier(ProfessionPackageOptions),

package/lib/types/_IdentifierGroup.d.ts

@@ -292,6 +292,9 @@ export declare const RequirableSelectOptionIdentifier: Enum<"RequirableSelectOpt
     Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
     Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
     TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
 }, []>;
 export declare const CoreRuleDerivableContentIdentifier: Enum<"CoreRuleDerivableContentIdentifier", {
     MagicalTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;

package/lib/types/_IdentifierGroup.js

@@ -352,6 +352,9 @@ export const RequirableSelectOptionIdentifier = Enum(import.meta.url, {
         Spell: EnumCase({ type: SpellIdentifier() }),
         Ritual: EnumCase({ type: RitualIdentifier() }),
         TradeSecret: EnumCase({ type: TradeSecretIdentifier() }),
+        ArcaneBardTradition: EnumCase({ type: ArcaneBardTraditionIdentifier() }),
+        ArcaneDancerTradition: EnumCase({ type: ArcaneDancerTraditionIdentifier() }),
+        Element: EnumCase({ type: ElementIdentifier() }),
     }),
 });
 export const CoreRuleDerivableContentIdentifier = Enum(import.meta.url, {

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

@@ -1,5 +1,5 @@
 import { Array, Boolean, Entity, Enum, EnumCase, Float, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-import { BlessedTraditionIdentifier, MagicalTraditionIdentifier } from "../../_Identifier.js";
+import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, RaceIdentifier, } from "../../_Identifier.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -175,7 +175,7 @@ export const RestrictedToRaces = TypeAlias(import.meta.url, {
     type: () => Object({
         scope: Required({
             comment: "The item is restricted to one of a list of races. If only one race is allowed, the list may only have a single element.",
-            type: Array(MagicalTraditionIdentifier(), { minItems: 1, uniqueItems: true }),
+            type: Array(RaceIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
     }),
 });
@@ -185,7 +185,7 @@ export const RestrictedToCultures = TypeAlias(import.meta.url, {
     type: () => Object({
         scope: Required({
             comment: "The item is restricted to one of a list of cultures. If only one culture is allowed, the list may only have a single element.",
-            type: Array(MagicalTraditionIdentifier(), { minItems: 1, uniqueItems: true }),
+            type: Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
     }),
 });
@@ -195,7 +195,7 @@ export const RestrictedToProfessions = TypeAlias(import.meta.url, {
     type: () => Object({
         scope: Required({
             comment: "The item is restricted to one of a list of professions. If only one profession is allowed, the list may only have a single element.",
-            type: Array(MagicalTraditionIdentifier(), { minItems: 1, uniqueItems: true }),
+            type: Array(ProfessionIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
     }),
 });

package/lib/types/prerequisites/PrerequisiteGroups.d.ts

@@ -260,6 +260,9 @@ export declare const GeneralPrerequisiteGroup: Enum<"GeneralPrerequisiteGroup",
             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
         }, []>>>, false>;
         display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
             Hide: EnumCase<null>;
@@ -552,6 +555,9 @@ export declare const ProfessionPrerequisiteGroup: Enum<"ProfessionPrerequisiteGr
             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
         }, []>>>, false>;
         display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
             Hide: EnumCase<null>;
@@ -820,6 +826,9 @@ export declare const AdvantageDisadvantagePrerequisiteGroup: Enum<"AdvantageDisa
             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
         }, []>>>, false>;
         display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
             Hide: EnumCase<null>;
@@ -1259,6 +1268,9 @@ export declare const LanguagePrerequisiteGroup: Enum<"LanguagePrerequisiteGroup"
             Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
             TradeSecret: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneBardTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            ArcaneDancerTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
         }, []>>>, false>;
         display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
             Hide: EnumCase<null>;

package/lib/types/prerequisites/single/ActivatablePrerequisite.d.ts

@@ -69,6 +69,9 @@ export declare const ActivatablePrerequisite: TypeAlias<"ActivatablePrerequisite
         Spell: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
         Ritual: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
         TradeSecret: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ArcaneBardTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        ArcaneDancerTradition: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Element: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ReferenceIdentifierType>;
     }, []>>>, false>;
     display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
         Hide: import("tsondb/schema/def").EnumCaseDecl<null>;

package/package.json

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