@optolith/database-schema 0.58.0 → 0.60.0

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 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.60.0](https://github.com/Optolith/database-schema/compare/v0.59.0...v0.60.0) (2026-09-12)
+
+### ⚠ BREAKING CHANGES
+
+* add sexual transmittable disease flag
+* any special ability of group prerequisite
+
+### Features
+
+* add prerequisite for cantrips and blessings ([a06284c](https://github.com/Optolith/database-schema/commit/a06284cb508b65749f9e2c0beabf5310aeeebb0b)), closes [Optolith/database-schema#172](https://github.com/Optolith/database-schema/issues/172), references [#173](https://github.com/Optolith/database-schema/issues/173)
+* add sexual transmittable disease flag ([998c55b](https://github.com/Optolith/database-schema/commit/998c55bdfc132ca94067bc8cbeed7a70268cb4fc)), closes [Optolith/database-schema#184](https://github.com/Optolith/database-schema/issues/184), references [#185](https://github.com/Optolith/database-schema/issues/185)
+* any special ability of group prerequisite ([376c8f9](https://github.com/Optolith/database-schema/commit/376c8f951af16d3883e800a940a62b47f3248ed6)), closes [#176](https://github.com/Optolith/database-schema/issues/176), references [#177](https://github.com/Optolith/database-schema/issues/177)
+## [0.59.0](https://github.com/Optolith/database-schema/compare/v0.58.0...v0.59.0) (2026-09-12)
+
+### ⚠ BREAKING CHANGES
+
+* magical dis-/advantage subtypes
+
+### Features
+
+* magical dis-/advantage subtypes ([986a5a9](https://github.com/Optolith/database-schema/commit/986a5a958f4d2f056ae47bdc6fe3f8627359ced1)), closes [#147](https://github.com/Optolith/database-schema/issues/147)
 ## [0.58.0](https://github.com/Optolith/database-schema/compare/v0.57.0...v0.58.0) (2026-09-11)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -219,6 +219,7 @@ export type EnumMap = {
   AdvancedSpecialAbility: AdvancedSpecialAbility<unknown>
   AdvancedSpecialAbilityRestrictedOptionIdentifier: AdvancedSpecialAbilityRestrictedOptionIdentifier
   AdvantageDisadvantagePrerequisiteGroup: AdvantageDisadvantagePrerequisiteGroup
+  AdvantageDisadvantageSubtype: AdvantageDisadvantageSubtype
   AdventurePointsDependingOnActiveInstances: AdventurePointsDependingOnActiveInstances
   AdventurePointsDependingOnActiveInstancesExpressionValue: AdventurePointsDependingOnActiveInstancesExpressionValue
   AdventurePointsValue: AdventurePointsValue
@@ -442,6 +443,7 @@ export type EnumMap = {
   SkillWithEnhancementsIdentifier: SkillWithEnhancementsIdentifier
   SlowPerformanceParameters: SlowPerformanceParameters
   SlowSkillCastingTimeUnit: SlowSkillCastingTimeUnit
+  SpecialAbilityGroup: SpecialAbilityGroup
   SpecificAffectedTargetCategoryIdentifier: SpecificAffectedTargetCategoryIdentifier
   SpecificFromSkillSelectOptionCategoryCategoryOperation: SpecificFromSkillSelectOptionCategoryCategoryOperation
   SpellFilter: SpellFilter
@@ -455,6 +457,7 @@ export type EnumMap = {
   TalismanDamageOption: TalismanDamageOption
   TalismanType: TalismanType
   TextVerificationRule: TextVerificationRule
+  TinyActivatableIdentifier: TinyActivatableIdentifier
   TradeSecretAdventurePointsValue: TradeSecretAdventurePointsValue
   TradeSecretSelectOptionCategory: TradeSecretSelectOptionCategory
   TribePrerequisiteGroup: TribePrerequisiteGroup
@@ -500,6 +503,7 @@ export type TypeAliasMap = {
   AnimistPowerLevel: AnimistPowerLevel
   AnimistPowerPrerequisite: AnimistPowerPrerequisite
   AnimistPowerPrerequisites: AnimistPowerPrerequisites
+  AnySpecialAbilityOfGroupPrerequisite: AnySpecialAbilityOfGroupPrerequisite
   ApplicableCombatTechniquesLevelRestriction: ApplicableCombatTechniquesLevelRestriction
   ApplicableCombatTechniquesNegativeCombatTechniquesRestriction: ApplicableCombatTechniquesNegativeCombatTechniquesRestriction<unknown>
   ApplicableCombatTechniquesRaceRestriction: ApplicableCombatTechniquesRaceRestriction
@@ -923,6 +927,7 @@ export type TypeAliasMap = {
   TargetCategoriesSelectOptionCategory: TargetCategoriesSelectOptionCategory
   TextNode: TextNode
   TextPrerequisite: TextPrerequisite
+  TinyActivatablePrerequisite: TinyActivatablePrerequisite
   TradeSecretSelectOptions: TradeSecretSelectOptions
   TribePrerequisites: TribePrerequisites
   VolumeByLevel: VolumeByLevel
@@ -2150,6 +2155,7 @@ export interface Locale {
     ".input {$count :number} {{{$count} ranged combat techniques}}": string & { __params: { "count": number } }
     "special ability": string
     "no special ability": string
+    ".input {$entity :string} {{a special ability}}": string & { __params: { "entity": string } }
     "Tradition": string
     "Tradition ({$tradition})": string & { __params: { "tradition": StringableTranslationParameter } }
     "Church": string
@@ -2440,6 +2446,10 @@ export interface Locale {
     "only those with at least one blunt side": string
     "only {$nameWithLevel}": string & { __params: { "nameWithLevel": StringableTranslationParameter } }
     "only {$weapons}": string & { __params: { "weapons": StringableTranslationParameter } }
+    "Magical Rank": string
+    "Magical Title": string
+    "Magical Honor": string
+    "Magical Punishment": string
     ".input {$ord :number} {{{$ord}. attack}}": string & { __params: { "ord": number } }
     ".input {$ord :number} {{{$ord}. throw}}": string & { __params: { "ord": number } }
     "depending on the level of the special ability {$name}": string & { __params: { "name": StringableTranslationParameter } }
@@ -3037,6 +3047,8 @@ export interface Advantage {
    */
   levels?: number
 
+  subtype?: AdvantageDisadvantageSubtype
+
   /**
    * Rules for building the name of an activatable. These rules are used when the activatable doesn't have a custom name specified.
    */
@@ -3142,6 +3154,20 @@ export interface AdvantageTranslation {
   errata?: Errata
 }
 
+export type AdvantageDisadvantageSubtype =
+  | {
+    kind: "MagicalRank"
+  }
+  | {
+    kind: "MagicalTitle"
+  }
+  | {
+    kind: "MagicalHonor"
+  }
+  | {
+    kind: "MagicalPunishment"
+  }
+
 export interface GeneralSelectOption {
   /**
    * The entry that contains select option.
@@ -3441,6 +3467,8 @@ export interface Disadvantage {
    */
   levels?: number
 
+  subtype?: AdvantageDisadvantageSubtype
+
   /**
    * Rules for building the name of an activatable. These rules are used when the activatable doesn't have a custom name specified.
    */
@@ -4454,6 +4482,14 @@ export type GeneralPrerequisiteGroup =
     kind: "MagicalTradition"
     MagicalTradition: MagicalTraditionPrerequisite
   }
+  | {
+    kind: "TinyActivatable"
+    TinyActivatable: TinyActivatablePrerequisite
+  }
+  | {
+    kind: "AnySpecialAbilityOfGroup"
+    AnySpecialAbilityOfGroup: AnySpecialAbilityOfGroupPrerequisite
+  }
   | {
     kind: "Rated"
     Rated: RatedPrerequisite
@@ -5307,6 +5343,11 @@ export interface Disease {
    */
   isMagicalDisease: boolean
 
+  /**
+   * Whether the disease is sexually transmittable.
+   */
+  isSexuallyTransmittableDisease: boolean
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -21557,6 +21598,197 @@ export type PrimaryAttributeCategory =
     kind: "Magical"
   }
 
+/**
+ * Requires a specific cantrip or blessing.
+ */
+export interface TinyActivatablePrerequisite {
+  /**
+   * The required item.
+   */
+  id: TinyActivatableIdentifier
+
+  display_option?: DisplayOption
+}
+
+export type TinyActivatableIdentifier =
+  | {
+    kind: "Blessing"
+    Blessing: Blessing_ID
+  }
+  | {
+    kind: "Cantrip"
+    Cantrip: Cantrip_ID
+  }
+
+export interface AnySpecialAbilityOfGroupPrerequisite {
+  group: SpecialAbilityGroup
+  display_option?: DisplayOption
+}
+
+export type SpecialAbilityGroup =
+  | {
+    kind: "AdvancedCombatSpecialAbility"
+  }
+  | {
+    kind: "AdvancedKarmaSpecialAbility"
+  }
+  | {
+    kind: "AdvancedMagicalSpecialAbility"
+  }
+  | {
+    kind: "AdvancedSkillSpecialAbility"
+  }
+  | {
+    kind: "AncestorGlyph"
+  }
+  | {
+    kind: "ArcaneOrbEnchantment"
+  }
+  | {
+    kind: "AttireEnchantment"
+  }
+  | {
+    kind: "Beutelzauber"
+  }
+  | {
+    kind: "BlessedTradition"
+  }
+  | {
+    kind: "BowlEnchantment"
+  }
+  | {
+    kind: "BrawlingSpecialAbility"
+  }
+  | {
+    kind: "CauldronEnchantment"
+  }
+  | {
+    kind: "CeremonialItemSpecialAbility"
+  }
+  | {
+    kind: "ChronicleEnchantment"
+  }
+  | {
+    kind: "CombatSpecialAbility"
+  }
+  | {
+    kind: "CombatStyleSpecialAbility"
+  }
+  | {
+    kind: "CommandSpecialAbility"
+  }
+  | {
+    kind: "DaggerRitual"
+  }
+  | {
+    kind: "FamiliarSpecialAbility"
+  }
+  | {
+    kind: "FatePointSexSpecialAbility"
+  }
+  | {
+    kind: "FatePointSpecialAbility"
+  }
+  | {
+    kind: "FoolsHatEnchantment"
+  }
+  | {
+    kind: "GeneralSpecialAbility"
+  }
+  | {
+    kind: "Haubenzauber"
+  }
+  | {
+    kind: "Hauerkettenzauber"
+  }
+  | {
+    kind: "InstrumentEnchantment"
+  }
+  | {
+    kind: "KarmaSpecialAbility"
+  }
+  | {
+    kind: "Keulenzauber"
+  }
+  | {
+    kind: "Krallenkettenzauber"
+  }
+  | {
+    kind: "Kristallkugelzauber"
+  }
+  | {
+    kind: "LiturgicalStyleSpecialAbility"
+  }
+  | {
+    kind: "LycantropicGift"
+  }
+  | {
+    kind: "MagicalSign"
+  }
+  | {
+    kind: "MagicalSpecialAbility"
+  }
+  | {
+    kind: "MagicalTradition"
+  }
+  | {
+    kind: "MagicStyleSpecialAbility"
+  }
+  | {
+    kind: "OrbEnchantment"
+  }
+  | {
+    kind: "PactGift"
+  }
+  | {
+    kind: "ProtectiveWardingCircleSpecialAbility"
+  }
+  | {
+    kind: "RingEnchantment"
+  }
+  | {
+    kind: "Schweinetrommelzauber"
+  }
+  | {
+    kind: "Sermon"
+  }
+  | {
+    kind: "SexSpecialAbility"
+  }
+  | {
+    kind: "SickleRitual"
+  }
+  | {
+    kind: "SikaryanDrainSpecialAbility"
+  }
+  | {
+    kind: "SkillStyleSpecialAbility"
+  }
+  | {
+    kind: "SpellSwordEnchantment"
+  }
+  | {
+    kind: "StaffEnchantment"
+  }
+  | {
+    kind: "ToyEnchantment"
+  }
+  | {
+    kind: "Trinkhornzauber"
+  }
+  | {
+    kind: "VampiricGift"
+  }
+  | {
+    kind: "Vision"
+  }
+  | {
+    kind: "WandEnchantment"
+  }
+  | {
+    kind: "WeaponEnchantment"
+  }
+
 export interface RatedMinimumNumberPrerequisite {
   /**
    * The minimum number of skills that need to be on the defined minimum skill rating.
@@ -21794,6 +22026,14 @@ export type AdvantageDisadvantagePrerequisiteGroup =
     kind: "MagicalTradition"
     MagicalTradition: MagicalTraditionPrerequisite
   }
+  | {
+    kind: "TinyActivatable"
+    TinyActivatable: TinyActivatablePrerequisite
+  }
+  | {
+    kind: "AnySpecialAbilityOfGroup"
+    AnySpecialAbilityOfGroup: AnySpecialAbilityOfGroupPrerequisite
+  }
   | {
     kind: "Rated"
     Rated: RatedPrerequisite

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -50,6 +50,8 @@ const isPrerequisiteFor = (idMap, type, prerequisite, getById, traversedIds) =>
         case "PrimaryAttribute":
         case "BlessedTradition":
         case "MagicalTradition":
+        case "TinyActivatable":
+        case "AnySpecialAbilityOfGroup":
         case "RatedMinimumNumber":
         case "RatedSum":
         case "Enhancement":

package/lib/types/Advantage.d.ts

@@ -1,6 +1,12 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const Advantage: DB.Entity<"Advantage", {
     levels: DB.MemberDecl<DB.Integer, false>;
+    subtype: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AdvantageDisadvantageSubtype", {
+        MagicalRank: DB.EnumCase<null>;
+        MagicalTitle: DB.EnumCase<null>;
+        MagicalHonor: DB.EnumCase<null>;
+        MagicalPunishment: DB.EnumCase<null>;
+    }, []>>, false>;
     nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableNameBuilderRules", DB.Object<{
         levelPlacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableNameLevelPlacement", {
             BeforeOptions: DB.EnumCase<null>;

package/lib/types/Advantage.js

@@ -2,6 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { input, levels, maximum, name, name_in_library, range_l10n, rules } from "./_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventurePointsValue.js";
 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 { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
@@ -14,6 +15,7 @@ export const Advantage = DB.Entity(import.meta.url, {
     namePlural: "Advantages",
     type: () => DB.Object({
         levels,
+        subtype,
         nameBuilderRules,
         select_options,
         explicit_select_options,

package/lib/types/Disadvantage.d.ts

@@ -1,6 +1,12 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const Disadvantage: DB.Entity<"Disadvantage", {
     levels: DB.MemberDecl<DB.Integer, false>;
+    subtype: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AdvantageDisadvantageSubtype", {
+        MagicalRank: DB.EnumCase<null>;
+        MagicalTitle: DB.EnumCase<null>;
+        MagicalHonor: DB.EnumCase<null>;
+        MagicalPunishment: DB.EnumCase<null>;
+    }, []>>, false>;
     nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableNameBuilderRules", DB.Object<{
         levelPlacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableNameLevelPlacement", {
             BeforeOptions: DB.EnumCase<null>;

package/lib/types/Disadvantage.js

@@ -1,6 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { input, levels, maximum, name, name_in_library, rules } from "./_Activatable.js";
 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 { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
@@ -13,6 +14,7 @@ export const Disadvantage = DB.Entity(import.meta.url, {
     namePlural: "Disadvantages",
     type: () => DB.Object({
         levels,
+        subtype,
         nameBuilderRules,
         select_options,
         explicit_select_options,

package/lib/types/Disease.d.ts

@@ -43,6 +43,7 @@ export declare const Disease: DB.Entity<"Disease", {
     }>, []>>, false>;
     isChildhoodDisease: DB.MemberDecl<DB.Boolean, true>;
     isMagicalDisease: DB.MemberDecl<DB.Boolean, true>;
+    isSexuallyTransmittableDisease: DB.MemberDecl<DB.Boolean, true>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {

package/lib/types/Disease.js

@@ -22,6 +22,10 @@ export const Disease = DB.Entity(import.meta.url, {
             comment: "Whether the disease is a magical disease.",
             type: DB.Boolean(),
         }),
+        isSexuallyTransmittableDisease: DB.Required({
+            comment: "Whether the disease is sexually transmittable.",
+            type: DB.Boolean(),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Disease", DiseaseTranslation),
     }),

package/lib/types/Locale.d.ts

@@ -1069,6 +1069,7 @@ export declare const Locale: DB.Entity<"Locale", {
         ".input {$count :number} {{{$count} ranged combat techniques}}": null;
         "special ability": null;
         "no special ability": null;
+        ".input {$entity :string} {{a special ability}}": null;
         Tradition: null;
         "Tradition ({$tradition})": null;
         Church: null;
@@ -1374,6 +1375,10 @@ export declare const Locale: DB.Entity<"Locale", {
         "only those with at least one blunt side": null;
         "only {$nameWithLevel}": null;
         "only {$weapons}": null;
+        "Magical Rank": null;
+        "Magical Title": null;
+        "Magical Honor": null;
+        "Magical Punishment": null;
         ".input {$ord :number} {{{$ord}. attack}}": null;
         ".input {$ord :number} {{{$ord}. throw}}": null;
         "depending on the level of the special ability {$name}": null;

package/lib/types/Locale.js

@@ -1094,6 +1094,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 ".input {$count :number} {{{$count} ranged combat techniques}}": null,
                 "special ability": null,
                 "no special ability": null,
+                ".input {$entity :string} {{a special ability}}": null,
                 "Tradition": null,
                 "Tradition ({$tradition})": null,
                 "Church": null,
@@ -1409,6 +1410,11 @@ export const Locale = DB.Entity(import.meta.url, {
                 "only those with at least one blunt side": null,
                 "only {$nameWithLevel}": null,
                 "only {$weapons}": null,
+                // advantages/disadvantages
+                "Magical Rank": null,
+                "Magical Title": null,
+                "Magical Honor": null,
+                "Magical Punishment": null,
                 // combat special ability -- penalty
                 ".input {$ord :number} {{{$ord}. attack}}": null,
                 ".input {$ord :number} {{{$ord}. throw}}": null,

package/lib/types/_ActivatableMagical.d.ts

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const subtype: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AdvantageDisadvantageSubtype", {
+    MagicalRank: DB.EnumCase<null>;
+    MagicalTitle: DB.EnumCase<null>;
+    MagicalHonor: DB.EnumCase<null>;
+    MagicalPunishment: DB.EnumCase<null>;
+}, []>>, false>;

package/lib/types/_ActivatableMagical.js

@@ -0,0 +1,11 @@
+import * as DB from "tsondb/schema/dsl";
+const AdvantageDisadvantageSubtype = DB.Enum(import.meta.url, {
+    name: "AdvantageDisadvantageSubtype",
+    values: () => ({
+        MagicalRank: DB.EnumCase({ type: null }),
+        MagicalTitle: DB.EnumCase({ type: null }),
+        MagicalHonor: DB.EnumCase({ type: null }),
+        MagicalPunishment: DB.EnumCase({ type: null }),
+    }),
+});
+export const subtype = DB.Optional({ type: DB.IncludeIdentifier(AdvantageDisadvantageSubtype) });

package/lib/types/_IdentifierGroup.d.ts

@@ -451,3 +451,7 @@ export declare const AdvancedSkillStyleSpecialAbilityIdentifier: DB.Enum<"Advanc
     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
     AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
 }, []>;
+export declare const TinyActivatableIdentifier: DB.Enum<"TinyActivatableIdentifier", {
+    Blessing: DB.EnumCase<DB.ReferenceIdentifier>;
+    Cantrip: DB.EnumCase<DB.ReferenceIdentifier>;
+}, []>;

package/lib/types/_IdentifierGroup.js

@@ -347,3 +347,10 @@ export const AdvancedSkillStyleSpecialAbilityIdentifier = DB.Enum(import.meta.ur
         AdvancedSkillSpecialAbility: DB.EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
     }),
 });
+export const TinyActivatableIdentifier = DB.Enum(import.meta.url, {
+    name: "TinyActivatableIdentifier",
+    values: () => ({
+        Blessing: DB.EnumCase({ type: BlessingIdentifier() }),
+        Cantrip: DB.EnumCase({ type: CantripIdentifier() }),
+    }),
+});

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

@@ -556,6 +556,41 @@ export declare const GeneralPrerequisiteGroup: DB.Enum<"GeneralPrerequisiteGroup
             }>, []>>>;
         }, []>>, false>;
     }>, []>>>;
+    TinyActivatable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TinyActivatablePrerequisite", DB.Object<{
+        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"TinyActivatableIdentifier", {
+            Blessing: DB.EnumCase<DB.ReferenceIdentifier>;
+            Cantrip: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, 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>;
+    }>, []>>>;
+    AnySpecialAbilityOfGroup: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AnySpecialAbilityOfGroupPrerequisite", DB.Object<{
+        group: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityGroup", {
+            [k: string]: DB.EnumCase<null>;
+        }, []>>, 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>;
+    }>, []>>>;
     Rated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RatedPrerequisite", DB.Object<{
         id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RatedIdentifier", {
             Attribute: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1191,6 +1226,41 @@ export declare const AdvantageDisadvantagePrerequisiteGroup: DB.Enum<"AdvantageD
             }>, []>>>;
         }, []>>, false>;
     }>, []>>>;
+    TinyActivatable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TinyActivatablePrerequisite", DB.Object<{
+        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"TinyActivatableIdentifier", {
+            Blessing: DB.EnumCase<DB.ReferenceIdentifier>;
+            Cantrip: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, 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>;
+    }>, []>>>;
+    AnySpecialAbilityOfGroup: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AnySpecialAbilityOfGroupPrerequisite", DB.Object<{
+        group: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityGroup", {
+            [k: string]: DB.EnumCase<null>;
+        }, []>>, 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>;
+    }>, []>>>;
     Rated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RatedPrerequisite", DB.Object<{
         id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RatedIdentifier", {
             Attribute: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -2,6 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { ActivatablePrerequisite } from "./single/ActivatablePrerequisite.js";
 import { AncestorBloodPrerequisite } from "./single/AncestorBloodPrerequisite.js";
 import { AnimistPowerPrerequisite } from "./single/AnimistPowerPrerequisite.js";
+import { AnySpecialAbilityOfGroupPrerequisite } from "./single/AnySpecialAbilityOfGroupPrerequisite.js";
 import { CulturePrerequisite } from "./single/CulturePrerequisite.js";
 import { EnhancementPrerequisite } from "./single/EnhancementPrerequisite.js";
 import { InfluencePrerequisite } from "./single/InfluencePrerequisite.js";
@@ -20,6 +21,7 @@ import { SexualCharacteristicPrerequisite } from "./single/SexualCharacteristicP
 import { SocialStatusPrerequisite } from "./single/SocialStatusPrerequisite.js";
 import { StatePrerequisite } from "./single/StatePrerequisite.js";
 import { TextPrerequisite } from "./single/TextPrerequisite.js";
+import { TinyActivatablePrerequisite } from "./single/TinyActivatablePrerequisite.js";
 import { BlessedTraditionPrerequisite, MagicalTraditionPrerequisite, } from "./single/TraditionPrerequisite.js";
 export const RulePrerequisiteGroup = DB.Enum(import.meta.url, {
     name: "RulePrerequisiteGroup",
@@ -62,6 +64,10 @@ export const GeneralPrerequisiteGroup = DB.Enum(import.meta.url, {
         Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
         BlessedTradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionPrerequisite) }),
         MagicalTradition: DB.EnumCase({ type: DB.IncludeIdentifier(MagicalTraditionPrerequisite) }),
+        TinyActivatable: DB.EnumCase({ type: DB.IncludeIdentifier(TinyActivatablePrerequisite) }),
+        AnySpecialAbilityOfGroup: DB.EnumCase({
+            type: DB.IncludeIdentifier(AnySpecialAbilityOfGroupPrerequisite),
+        }),
         Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
         RatedMinimumNumber: DB.EnumCase({ type: DB.IncludeIdentifier(RatedMinimumNumberPrerequisite) }),
         RatedSum: DB.EnumCase({ type: DB.IncludeIdentifier(RatedSumPrerequisite) }),

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

@@ -0,0 +1,18 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AnySpecialAbilityOfGroupPrerequisite: DB.TypeAlias<"AnySpecialAbilityOfGroupPrerequisite", DB.Object<{
+    group: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecialAbilityGroup", {
+        [k: string]: DB.EnumCase<null>;
+    }, []>>, 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>;
+}>, []>;

package/lib/types/prerequisites/single/AnySpecialAbilityOfGroupPrerequisite.js

@@ -0,0 +1,23 @@
+import * as DB from "tsondb/schema/dsl";
+import { SpecialAbilityIdentifier } from "../../_IdentifierGroup.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const AnySpecialAbilityOfGroupPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "AnySpecialAbilityOfGroupPrerequisite",
+    type: () => DB.Object({
+        group: DB.Required({
+            type: DB.IncludeIdentifier(SpecialAbilityGroup),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});
+const SpecialAbilityGroup = DB.Enum(import.meta.url, {
+    name: "SpecialAbilityGroup",
+    values: () => ({
+        ...Object.fromEntries(Object.keys(SpecialAbilityIdentifier.type.value.values).map(entity => [
+            entity,
+            DB.EnumCase({ type: null }),
+        ])),
+    }),
+});

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

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const TinyActivatablePrerequisite: DB.TypeAlias<"TinyActivatablePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"TinyActivatableIdentifier", {
+        Blessing: DB.EnumCase<DB.ReferenceIdentifier>;
+        Cantrip: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, 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>;
+}>, []>;

package/lib/types/prerequisites/single/TinyActivatablePrerequisite.js

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+import { TinyActivatableIdentifier } from "../../_IdentifierGroup.js";
+import { DisplayOption } from "../DisplayOption.js";
+export const TinyActivatablePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "TinyActivatablePrerequisite",
+    comment: "Requires a specific cantrip or blessing.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The required item.",
+            type: DB.IncludeIdentifierType(TinyActivatableIdentifier),
+        }),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
+        }),
+    }),
+});

package/package.json

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