@optolith/database-schema 0.77.1 → 0.79.0

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 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.79.0](https://github.com/Optolith/database-schema/compare/v0.78.0...v0.79.0) (2026-10-05)
+
+### ⚠ BREAKING CHANGES
+
+* burning time option for generic items
+
+### Features
+
+* base for select option rules ([5df53d3](https://github.com/Optolith/database-schema/commit/5df53d3448d5c279c9a062b8c68cc4e5ee9cbfdb))
+* burning time option for generic items ([7feb7ff](https://github.com/Optolith/database-schema/commit/7feb7ffb449724433c7f7012369c837d5b8f6688))
+
+## [0.78.0](https://github.com/Optolith/database-schema/compare/v0.77.1...v0.78.0) (2026-10-05)
+
+### ⚠ BREAKING CHANGES
+
+* generalize special ability option selection for professions
+* languages option with optional scripts inclusion
+* missing magical action category translations
+* some plant translations
+* translation for empty profession variants
+
+### Features
+
+* generalize special ability option selection for professions ([ef7d2c9](https://github.com/Optolith/database-schema/commit/ef7d2c9903f987720f173815e5454fdfa06b3a84))
+* languages option with optional scripts inclusion ([31862d3](https://github.com/Optolith/database-schema/commit/31862d38d0027dae845f8b69218395c4307bf59d))
+* optional different race and culture names within prerequisites ([5025e80](https://github.com/Optolith/database-schema/commit/5025e80131e41ad68aca9e51881f5ee08c23dad1))
+* prepare activatable options validation ([d0c7e87](https://github.com/Optolith/database-schema/commit/d0c7e87e3ae9aac67aa4259e63ce8c9c51e1fb3e))
+* some plant translations ([8f3fa6b](https://github.com/Optolith/database-schema/commit/8f3fa6ba1b569b9bcd3b355d01fd86c9fe287478))
+
+### Bug Fixes
+
+* missing magical action category translations ([510d11b](https://github.com/Optolith/database-schema/commit/510d11bd9e98d478ec3e4ab37627496b3c8deec9))
+* translation for empty profession variants ([8f63b30](https://github.com/Optolith/database-schema/commit/8f63b30e14508ee0f900626bdefafed1b2657078))
+
 ## [0.77.1](https://github.com/Optolith/database-schema/compare/v0.77.0...v0.77.1) (2026-10-03)
 
 ### Features

package/gen/types.d.ts

@@ -277,6 +277,7 @@ export type EnumMap = {
   CastingTime: CastingTime<unknown>
   CastingTimeDuringLovemakingUnit: CastingTimeDuringLovemakingUnit
   CheckResultArithmetic: CheckResultArithmetic
+  ChildEntityForSelectOption: ChildEntityForSelectOption
   CollectorsValue: CollectorsValue
   CombatAnimalPowerType: CombatAnimalPowerType
   CombatRelatedSpecialAbilityIdentifier: CombatRelatedSpecialAbilityIdentifier
@@ -413,6 +414,7 @@ export type EnumMap = {
   ProfessionPrerequisiteGroup: ProfessionPrerequisiteGroup
   ProfessionSpecialAbility: ProfessionSpecialAbility
   ProfessionSpecialAbilityIdentifier: ProfessionSpecialAbilityIdentifier
+  ProfessionSpecialAbilityOption: ProfessionSpecialAbilityOption
   PropertyDeclaration: PropertyDeclaration
   PublicationCategory: PublicationCategory
   PublicationPrerequisiteGroup: PublicationPrerequisiteGroup
@@ -437,6 +439,8 @@ export type EnumMap = {
   RulePrerequisiteGroup: RulePrerequisiteGroup
   SelectOptionCategory: SelectOptionCategory
   SelectOptionParentIdentifier: SelectOptionParentIdentifier
+  SelectOptionRuleMultiple: SelectOptionRuleMultiple
+  SelectOptionRuleValue: SelectOptionRuleValue
   SelectOptionsAdventurePointsValue: SelectOptionsAdventurePointsValue<unknown>
   SelectOptionsBindingCostValue: SelectOptionsBindingCostValue<unknown>
   SentenceType: SentenceType
@@ -570,6 +574,7 @@ export type TypeAliasMap = {
   Cause: Cause
   CheckResultBasedModifier: CheckResultBasedModifier
   ChildNode: ChildNode
+  ChildSelectOptionRuleValue: ChildSelectOptionRuleValue
   ChurchBlessedTradition: ChurchBlessedTradition
   CloseCombatTechniqueSpecialRules: CloseCombatTechniqueSpecialRules
   CombatAnimalPower: CombatAnimalPower
@@ -826,6 +831,7 @@ export type TypeAliasMap = {
   PlantPoison: PlantPoison
   PoisonRecipe: PoisonRecipe
   Preconditions: Preconditions
+  PredefinedOrTextInputSelectOptionRuleValue: PredefinedOrTextInputSelectOptionRuleValue
   PrerequisiteForLevel: PrerequisiteForLevel<unknown>
   PrerequisiteGroup: PrerequisiteGroup<unknown>
   PrerequisitesDisjunction: PrerequisitesDisjunction<unknown>
@@ -840,6 +846,7 @@ export type TypeAliasMap = {
   ProfessionPrerequisite: ProfessionPrerequisite
   ProfessionPrerequisites: ProfessionPrerequisites
   ProfessionSpecialAbilitySelection: ProfessionSpecialAbilitySelection
+  ProfessionSpecialAbilitySelectionItem: ProfessionSpecialAbilitySelectionItem
   ProfessionSpellworkIdentifier: ProfessionSpellworkIdentifier
   ProfessionVariantPackageOptions: ProfessionVariantPackageOptions
   ProfessionVariantPrerequisites: ProfessionVariantPrerequisites
@@ -892,6 +899,8 @@ export type TypeAliasMap = {
   RulePrerequisites: RulePrerequisites
   SecondaryArmor: SecondaryArmor
   SelectableAttributeAdjustment: SelectableAttributeAdjustment
+  SelectOptionRule: SelectOptionRule
+  SelectOptionRules: SelectOptionRules
   SelectOptions: SelectOptions
   SelectOptionsDeriveAdventurePointsValueFromImprovementCost: SelectOptionsDeriveAdventurePointsValueFromImprovementCost
   SelectOptionsFixedAdventurePointsValue: SelectOptionsFixedAdventurePointsValue<unknown>
@@ -958,6 +967,7 @@ export type TypeAliasMap = {
   TalismanMeleeWeapon: TalismanMeleeWeapon
   TalismanRangedWeapon: TalismanRangedWeapon
   TargetCategoriesSelectOptionCategory: TargetCategoriesSelectOptionCategory
+  TextInputSelectOptionRuleValue: TextInputSelectOptionRuleValue
   TextNode: TextNode
   TextPrerequisite: TextPrerequisite
   TinyActivatablePrerequisite: TinyActivatablePrerequisite
@@ -1153,6 +1163,11 @@ export interface SelectOptions {
    * An entry category with optional further configuration. All available entries from the specified categories will be included as separate select options. You can also specify a set of groups that should only be included. Groups not mentioned will be excluded then.
    */
   derived?: SelectOptionCategory
+
+  /**
+   * Rules for how options can be selected and relate to each other. Defaults to a single predefined option if the entry has select options defined, otherwise undefined.
+   */
+  rules?: SelectOptionRules
 }
 
 export type SelectOptionCategory =
@@ -2026,6 +2041,9 @@ export interface Locale {
     "Animist Powers": string
     "Geode Rituals": string
     "Zibilja Rituals": string
+    "Bannzeichen": string
+    "Goblin Rituals": string
+    "Magical Runes": string
     "Mod": string
     "Check Modifier": string
     "spells.traditions.general": string
@@ -2697,6 +2715,10 @@ export interface Locale {
     ".input {$count :number} {{check required every {$count}. application in the same month}}": string & { __params: { "count": number } }
     "see {$link}": string & { __params: { "link": string } }
     "CoD": string
+    "Search Difficulty": string
+    "Identification Difficulty": string
+    "Plant Applications": string
+    "Remedies and Traditions": string
     "Romance Novel": string
     "Poetry": string
     "Political Pamphlet": string
@@ -2789,6 +2811,8 @@ export interface Locale {
     "Variants": string
     "Languages and Literacy totaling {$apValue} AP": string & { __params: { "apValue": string } }
     "no Languages and Literacy totaling {$apValue} AP": string & { __params: { "apValue": string } }
+    "Languages totaling {$apValue} AP": string & { __params: { "apValue": string } }
+    "no Languages totaling {$apValue} AP": string & { __params: { "apValue": string } }
     "Skill Specialization {$possibleSkills}": string & { __params: { "possibleSkills": string } }
     "no Skill Specialization {$possibleSkills}": string & { __params: { "possibleSkills": string } }
     "Skill Specialization for a {$skillOfGroup}": string & { __params: { "skillOfGroup": string } }
@@ -2815,6 +2839,7 @@ export interface Locale {
     "except for {$list :list type=conjunction}": string & { __params: { "list": string[] } }
     "depends on selected tradition": string
     "Additional Prerequisites": string
+    "no changes": string
     "Enhancements": string
     "SR {$value}": string & { __params: { "value": string } }
     ".input {$hiddenCount :number} {{Prerequisites}}": string & { __params: { "hiddenCount": number } }
@@ -4679,6 +4704,11 @@ export interface RaceTranslation {
    */
   name: string
 
+  /**
+   * The race’s name in prerequisites, if different from the normal race’s name.
+   */
+  nameInPrerequisites?: 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.
    */
@@ -9761,10 +9791,15 @@ export type Culture_ID = string
 
 export interface CultureTranslation {
   /**
-   * The race’s name.
+   * The culture’s name.
    */
   name: string
 
+  /**
+   * The culture’s name in prerequisites, if different from the normal culture’s name.
+   */
+  nameInPrerequisites?: string
+
   /**
    * The description of the area knowledge.
    */
@@ -10161,6 +10196,11 @@ export interface SpecificSkillSpecializationOptions {
  * Buy languages and scripts for a specific amount of AP.
  */
 export interface LanguagesScriptsOptions {
+  /**
+   * If scripts are included in the selection.
+   */
+  includeScripts: boolean
+
   /**
    * The AP value you can buy languages and scripts for.
    */
@@ -10517,7 +10557,7 @@ export interface ConstantProfessionSpecialAbility {
   /**
    * Received select options. Order is important. Typically, you only need the first array index, though.
    */
-  options?: RequirableSelectOptionIdentifier[]
+  options?: ProfessionSpecialAbilityOption[]
 }
 
 export type ProfessionSpecialAbilityIdentifier =
@@ -15056,6 +15096,13 @@ export interface Hauerkettenzauber {
    */
   nameBuilderRules?: ActivatableNameBuilderRules
 
+  /**
+   * Definitions for possible options for the activatable entry, derived from entry categories.
+   * 
+   * Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.
+   */
+  select_options?: SelectOptions
+
   /**
    * The number stating how often you can buy the entry. The **default** depends on the entry type:
    * 
@@ -15380,6 +15427,13 @@ export interface Keulenzauber {
    */
   nameBuilderRules?: ActivatableNameBuilderRules
 
+  /**
+   * Definitions for possible options for the activatable entry, derived from entry categories.
+   * 
+   * Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.
+   */
+  select_options?: SelectOptions
+
   /**
    * The number stating how often you can buy the entry. The **default** depends on the entry type:
    * 
@@ -16794,6 +16848,13 @@ export interface Schweinetrommelzauber {
    */
   nameBuilderRules?: ActivatableNameBuilderRules
 
+  /**
+   * Definitions for possible options for the activatable entry, derived from entry categories.
+   * 
+   * Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.
+   */
+  select_options?: SelectOptions
+
   /**
    * The number stating how often you can buy the entry. The **default** depends on the entry type:
    * 
@@ -18280,11 +18341,37 @@ export interface WeaponEnchantmentTranslation {
   errata?: Errata
 }
 
+export type ProfessionSpecialAbilityOption =
+  | {
+    kind: "Identifier"
+    Identifier: RequirableSelectOptionIdentifier
+  }
+  | {
+    kind: "Select"
+  }
+
 export interface ProfessionSpecialAbilitySelection {
   /**
    * The list of special abilities to choose from. Must contain at least two entries.
    */
-  options: ConstantProfessionSpecialAbility[]
+  options: ProfessionSpecialAbilitySelectionItem[]
+}
+
+export interface ProfessionSpecialAbilitySelectionItem {
+  /**
+   * The identifier of the special ability to grant.
+   */
+  id: ProfessionSpecialAbilityIdentifier
+
+  /**
+   * The level of the received special ability. If not specified and the special ability has levels, level 1 is used automatically.
+   */
+  level?: number
+
+  /**
+   * Received select options. Order is important. Typically, you only need the first array index, though.
+   */
+  options?: RequirableSelectOptionIdentifier[]
 }
 
 export interface CombatTechniqueRating {
@@ -22413,6 +22500,123 @@ export type AdvantageDisadvantagePrerequisiteGroup =
     PersonalityTrait: PersonalityTraitPrerequisite
   }
 
+/**
+ * Rules for how options can be selected and relate to each other. Defaults to a single predefined option if the entry has select options defined, otherwise undefined.
+ */
+export type SelectOptionRules = SelectOptionRule[]
+
+/**
+ * A rule for how options can be selected and relate to each other.
+ */
+export interface SelectOptionRule {
+  /**
+   * The value of the rule.
+   */
+  value: SelectOptionRuleValue
+
+  /**
+   * Sometimes, multiple options from a single list have to or can be chosen.
+   */
+  multiple?: SelectOptionRuleMultiple
+}
+
+/**
+ * The possible values for select option rules.
+ */
+export type SelectOptionRuleValue =
+  | {
+    kind: "Predefined"
+  }
+  | {
+    kind: "PredefinedOrTextInput"
+    PredefinedOrTextInput: PredefinedOrTextInputSelectOptionRuleValue
+  }
+  | {
+    kind: "Child"
+    Child: ChildSelectOptionRuleValue
+  }
+  | {
+    kind: "TextInput"
+    TextInput: TextInputSelectOptionRuleValue
+  }
+
+export interface PredefinedOrTextInputSelectOptionRuleValue {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: PredefinedOrTextInputSelectOptionRuleValueTranslation
+  }
+}
+
+export interface PredefinedOrTextInputSelectOptionRuleValueTranslation {
+  /**
+   * The label for the text input field.
+   */
+  inputLabel: string
+
+  /**
+   * The label for the extra option in the list of select options that unlocks the text input field.
+   */
+  optionLabel: string
+}
+
+export interface ChildSelectOptionRuleValue {
+  /**
+   * The index of the parent select option in the list of selected options.
+   */
+  parentIndex: number
+
+  /**
+   * The entity you can choose from.
+   */
+  entity: ChildEntityForSelectOption
+}
+
+/**
+ * The possible child entities for select options.
+ */
+export type ChildEntityForSelectOption =
+  | {
+    kind: "SkillApplication"
+  }
+
+export interface TextInputSelectOptionRuleValue {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: TextInputSelectOptionRuleValueTranslation
+  }
+}
+
+export interface TextInputSelectOptionRuleValueTranslation {
+  /**
+   * The label for the text input field.
+   */
+  inputLabel: string
+}
+
+export type SelectOptionRuleMultiple =
+  | {
+    kind: "Constant"
+    Constant: number
+  }
+  | {
+    kind: "Range"
+    Range: {
+      /**
+       * The minimum number of options that need to be selected. If left empty it defaults to 1.
+       */
+      min?: number
+
+      /**
+       * The maximum number of options that need to be selected.
+       */
+      max: number
+    }
+  }
+
 export interface AlternativeRule {
   /**
    * The player types this alternative rule is suitable for.
@@ -24301,6 +24505,11 @@ export interface DefaultEquipmentCategoryTypeRules {
    * Presence of complexity to certain groups for items in this category.
    */
   complexity: ValueRule
+
+  /**
+   * Presence of burning time to certain groups for items in this category.
+   */
+  burningTime: ValueRule
 }
 
 /**
@@ -26285,6 +26494,11 @@ export interface Item {
    */
   structurePoints: StructurePoints
 
+  /**
+   * The burning time is the time how long the light source can be lit. After that time you have to use a new light source.
+   */
+  burningTime?: BurningTime
+
   /**
    * A list of stat blocks for each close combat technique this weapon can be used with.
    */

package/lib/cache/activatableSelectOptions.d.ts

@@ -1,5 +1,5 @@
 import { Case } from "tsondb/schema/gen";
-import type { ActivatableIdentifier, GeneralSelectOption, RequirableSelectOptionIdentifier, TradeSecretAdventurePointsValue } from "../../gen/types.js";
+import type { ActivatableIdentifier as ActivatableIdentifierType, GeneralSelectOption, RequirableSelectOptionIdentifier, TradeSecretAdventurePointsValue } from "../../gen/types.js";
 import type { CacheBuilder } from "./internal.ts";
 import type { ResolvedNewSkillApplication, ResolvedSkillUse } from "./newApplicationsAndUses.ts";
 export type ResolvedSelectOptionIdentifier = RequirableSelectOptionIdentifier | Case<"Blessing" | "Cantrip" | "Script" | "Culture" | "SexPractice" | "HomunculusType" | "BlessedTradition" | "Disease" | "Poison" | "TargetCategory", string>;
@@ -12,7 +12,7 @@ export type ResolvedSelectOption = {
     newApplications: ResolvedNewSkillApplication[];
     uses: ResolvedSkillUse[];
 };
-export type ActivatableSelectOptionsCache = Record<ActivatableIdentifier["kind"], {
+export type ActivatableSelectOptionsCache = Record<ActivatableIdentifierType["kind"], {
     [id: string]: ResolvedSelectOption[];
 }>;
 export declare const activatableSelectOptionsCacheBuilder: CacheBuilder<ActivatableSelectOptionsCache>;

package/lib/cache/activatableSelectOptions.js

@@ -4,6 +4,7 @@ import { mapObject } from "@elyukai/utils/object";
 import { compareNullish, compareNumber } from "@elyukai/utils/ordering";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { Case, fromUniformCase } from "tsondb/schema/gen";
+import { ActivatableIdentifier } from "../types/_IdentifierGroup.js";
 const wrapPlainApValue = (apValue) => apValue === undefined ? undefined : Case("Fixed", apValue);
 const matchesSpecificSkillishIdList = (config, matches) => {
     const isInList = config.list.some(matches);
@@ -758,64 +759,7 @@ const getSelectOptionsForResults = (database, entity, results) => results.reduce
     }
     return acc;
 }, {});
-const cacheKeyBase = {
-    Advantage: null,
-    Disadvantage: null,
-    AdvancedCombatSpecialAbility: null,
-    AdvancedKarmaSpecialAbility: null,
-    AdvancedMagicalSpecialAbility: null,
-    AdvancedSkillSpecialAbility: null,
-    AncestorGlyph: null,
-    ArcaneOrbEnchantment: null,
-    AttireEnchantment: null,
-    Beutelzauber: null,
-    BlessedTradition: null,
-    BowlEnchantment: null,
-    BrawlingSpecialAbility: null,
-    CauldronEnchantment: null,
-    CeremonialItemSpecialAbility: null,
-    ChronicleEnchantment: null,
-    CombatSpecialAbility: null,
-    CombatStyleSpecialAbility: null,
-    CommandSpecialAbility: null,
-    DaggerRitual: null,
-    FamiliarSpecialAbility: null,
-    FatePointSexSpecialAbility: null,
-    FatePointSpecialAbility: null,
-    FoolsHatEnchantment: null,
-    GeneralSpecialAbility: null,
-    Haubenzauber: null,
-    Hauerkettenzauber: null,
-    InstrumentEnchantment: null,
-    KarmaSpecialAbility: null,
-    Keulenzauber: null,
-    Krallenkettenzauber: null,
-    Kristallkugelzauber: null,
-    LiturgicalStyleSpecialAbility: null,
-    LycantropicGift: null,
-    MagicalSign: null,
-    MagicalSpecialAbility: null,
-    MagicalTradition: null,
-    MagicStyleSpecialAbility: null,
-    OrbEnchantment: null,
-    PactGift: null,
-    ProtectiveWardingCircleSpecialAbility: null,
-    RingEnchantment: null,
-    Schweinetrommelzauber: null,
-    Sermon: null,
-    SexSpecialAbility: null,
-    SickleRitual: null,
-    SikaryanDrainSpecialAbility: null,
-    SkillStyleSpecialAbility: null,
-    SpellSwordEnchantment: null,
-    StaffEnchantment: null,
-    ToyEnchantment: null,
-    Trinkhornzauber: null,
-    VampiricGift: null,
-    Vision: null,
-    WandEnchantment: null,
-    WeaponEnchantment: null,
-};
+const cacheKeyBase = mapObject(ActivatableIdentifier.type.value.values, () => null);
 export const activatableSelectOptionsCacheBuilder = database => Object.fromEntries(Object.keys(cacheKeyBase).map((entity) => [
     entity,
     getSelectOptionsForResults(database, entity, database.getAllInstanceContainersOfEntity(entity)),

package/lib/types/Advantage.d.ts

@@ -851,6 +851,35 @@ export declare const Advantage: DB.Entity<"Advantage", {
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/Advantage.js

@@ -4,7 +4,7 @@ import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventur
 import { automatic_entries } from "./_ActivatableAutomatic.js";
 import { subtype } from "./_ActivatableMagical.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "./_ActivatableNames.js";
-import { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "./_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -58,4 +58,5 @@ export const Advantage = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("Advantage", deps),
 });

package/lib/types/Culture.d.ts

@@ -242,6 +242,7 @@ export declare const Culture: DB.Entity<"Culture", {
     }>, []>>>, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"CultureTranslation", {
         name: DB.MemberDecl<DB.String, true>;
+        nameInPrerequisites: DB.MemberDecl<DB.String, false>;
         area_knowledge: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AreaKnowledgeTranslation", DB.Object<{
             description: DB.MemberDecl<DB.String, true>;
             abbreviated: DB.MemberDecl<DB.String, true>;

package/lib/types/Culture.js

@@ -60,7 +60,11 @@ export const Culture = DB.Entity(import.meta.url, {
         src,
         translations: NestedTranslationMap(DB.Required, "Culture", DB.Object({
             name: DB.Required({
-                comment: "The race’s name.",
+                comment: "The culture’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            nameInPrerequisites: DB.Optional({
+                comment: "The culture’s name in prerequisites, if different from the normal culture’s name.",
                 type: DB.String({ minLength: 1 }),
             }),
             area_knowledge: DB.Required({

package/lib/types/Disadvantage.d.ts

@@ -851,6 +851,35 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/Disadvantage.js

@@ -3,7 +3,7 @@ import { input, levels, maximum, name, name_in_library, rules } from "./_Activat
 import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventurePointsValue.js";
 import { subtype } from "./_ActivatableMagical.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "./_ActivatableNames.js";
-import { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "./_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -59,4 +59,5 @@ export const Disadvantage = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("Disadvantage", deps),
 });