@optolith/database-schema 0.49.0 → 0.50.1

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.50.1](https://github.com/Optolith/database-schema/compare/v0.50.0...v0.50.1) (2026-06-14)
+
+
+### Features
+
+* primary blessing for tradition ([9d97dd4](https://github.com/Optolith/database-schema/commit/9d97dd4ec95c8dd42cb6e31873a4702684a941de))
+* trade secrets for herbal aids ([27236a7](https://github.com/Optolith/database-schema/commit/27236a75884fdb891a60a0105ebb5ff82147cbc1)), closes [#159](https://github.com/Optolith/database-schema/issues/159) [#158](https://github.com/Optolith/database-schema/issues/158)
+
+## [0.50.0](https://github.com/Optolith/database-schema/compare/v0.49.0...v0.50.0) (2026-06-14)
+
+
+### ⚠ BREAKING CHANGES
+
+* allow arbitrary AP values for enhancements
+
+### Features
+
+* allow arbitrary AP values for enhancements ([1d06407](https://github.com/Optolith/database-schema/commit/1d06407eb4dee8fec24bc9f8d0d6e31833e4f995))
+* allow arbitrary text input for enhancements ([3a3af6e](https://github.com/Optolith/database-schema/commit/3a3af6e574c1a7d05113ebc75d5d6fa1b92c8dce))
+
 ## [0.49.0](https://github.com/Optolith/database-schema/compare/v0.48.0...v0.49.0) (2026-06-13)
 
 

package/gen/types.d.ts

@@ -298,6 +298,7 @@ export type EnumMap = {
   ElixirEffect: ElixirEffect
   EnchantmentCost: EnchantmentCost
   EncumbranceInfluence: EncumbranceInfluence
+  EnhancementAdventurePoints: EnhancementAdventurePoints
   EnhancementPrerequisiteGroup: EnhancementPrerequisiteGroup
   EquipmentIdentifier: EquipmentIdentifier
   ExpressionBasedParameterExpressionValue: ExpressionBasedParameterExpressionValue
@@ -571,6 +572,7 @@ export type TypeAliasMap = {
   DerivedCharacteristicPermanentLoss: DerivedCharacteristicPermanentLoss
   DerivedCharacteristicPrerequisites: DerivedCharacteristicPrerequisites
   DerivedCharacteristicPurchase: DerivedCharacteristicPurchase
+  DerivedEnhancementAdventurePoints: DerivedEnhancementAdventurePoints
   Dice: Dice
   DiceBasedIntoxicantAddictionInterval: DiceBasedIntoxicantAddictionInterval
   DieType: DieType
@@ -7401,6 +7403,11 @@ export interface BlessedTradition {
    */
   aspects?: [Aspect_ID, Aspect_ID]
 
+  /**
+   * The tradition’s primary blessing. Leave empty if the tradition does not have one.
+   */
+  primaryBlessing?: Blessing_ID
+
   /**
    * If a tradition restricts the possible blessings, the blessings that are **not** allowed.
    */
@@ -7497,19 +7504,6 @@ export interface BlessedTraditionTranslation {
   errata?: Errata
 }
 
-/**
- * If a tradition restricts the possible blessings, the blessings that are **not** allowed.
- */
-export type RestrictedBlessings =
-  | {
-    kind: "Three"
-    Three: [Blessing_ID, Blessing_ID, Blessing_ID]
-  }
-  | {
-    kind: "Six"
-    Six: [Blessing_ID, Blessing_ID, Blessing_ID, Blessing_ID, Blessing_ID, Blessing_ID]
-  }
-
 export interface Blessing {
   /**
    * Measurable parameters of a blessing.
@@ -7642,6 +7636,19 @@ export interface IndefiniteBlessingDurationTranslation {
   description: string
 }
 
+/**
+ * If a tradition restricts the possible blessings, the blessings that are **not** allowed.
+ */
+export type RestrictedBlessings =
+  | {
+    kind: "Three"
+    Three: [Blessing_ID, Blessing_ID, Blessing_ID]
+  }
+  | {
+    kind: "Six"
+    Six: [Blessing_ID, Blessing_ID, Blessing_ID, Blessing_ID, Blessing_ID, Blessing_ID]
+  }
+
 export type FavoredCombatTechniques =
   | {
     kind: "All"
@@ -7955,9 +7962,9 @@ export interface Enhancement {
   skill_rating: number
 
   /**
-   * The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.
+   * Defines how to determine the AP cost of an enhancement.
    */
-  adventure_points_modifier: number
+  adventurePoints: EnhancementAdventurePoints
 
   prerequisites?: EnhancementPrerequisites
 
@@ -7990,6 +7997,11 @@ export interface EnhancementTranslation {
    */
   effect: string
 
+  /**
+   * A string that is used as a label for an input field.
+   */
+  input?: string
+
   errata?: Errata
 }
 
@@ -19930,6 +19942,26 @@ export interface InfluenceEffect {
   text: string
 }
 
+/**
+ * Defines how to determine the AP cost of an enhancement.
+ */
+export type EnhancementAdventurePoints =
+  | {
+    kind: "DerivedFromImprovementCost"
+    DerivedFromImprovementCost: DerivedEnhancementAdventurePoints
+  }
+  | {
+    kind: "Constant"
+    Constant: number
+  }
+
+export interface DerivedEnhancementAdventurePoints {
+  /**
+   * The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.
+   */
+  multiplier: number
+}
+
 export type EnhancementPrerequisites = PlainPrerequisites<EnhancementPrerequisiteGroup>
 
 export type EnhancementPrerequisiteGroup =
@@ -24731,6 +24763,11 @@ export interface HerbalAid {
    */
   crafting_difficulty: number
 
+  /**
+   * AP value and prerequisites of the herbal aid�s trade secret.
+   */
+  trade_secret?: RecipeTradeSecret
+
   /**
    * The armor or weapon this herbal aid represents.
    */

package/lib/types/Ceremony.d.ts

@@ -549,7 +549,12 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -618,6 +623,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/LiturgicalChant.d.ts

@@ -549,7 +549,12 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -618,6 +623,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/Ritual.d.ts

@@ -552,7 +552,12 @@ export declare const Ritual: DB.Entity<"Ritual", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -621,6 +626,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/Spell.d.ts

@@ -552,7 +552,12 @@ export declare const Spell: DB.Entity<"Spell", {
             Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         skill_rating: DB.MemberDecl<DB.Integer, true>;
-        adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+        adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+            DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+                multiplier: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Constant: DB.EnumCase<DB.Integer>;
+        }, []>>, true>;
         prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
             Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
             Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -621,6 +626,7 @@ export declare const Spell: DB.Entity<"Spell", {
         translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
             name: DB.MemberDecl<DB.String, true>;
             effect: DB.MemberDecl<DB.String, true>;
+            input: DB.MemberDecl<DB.String, false>;
             errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
                 date: DB.MemberDecl<DB.Date, true>;
                 description: DB.MemberDecl<DB.String, true>;

package/lib/types/_ActivatableSkillCheckResultBased.d.ts

@@ -1,9 +1,4 @@
 import * as DB from "tsondb/schema/dsl";
-export declare const CheckResultValue: DB.Enum<"CheckResultValue", {
-    QualityLevels: DB.EnumCase<null>;
-    SkillPoints: DB.EnumCase<null>;
-    SkillRating: DB.EnumCase<null>;
-}, []>;
 export declare const CheckResultBasedModifier: DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
         Multiply: DB.EnumCase<null>;
@@ -11,17 +6,3 @@ export declare const CheckResultBasedModifier: DB.TypeAlias<"CheckResultBasedMod
     }, []>>, true>;
     value: DB.MemberDecl<DB.Integer, true>;
 }>, []>;
-export declare const CheckResultBased: DB.TypeAlias<"CheckResultBased", DB.Object<{
-    base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
-        QualityLevels: DB.EnumCase<null>;
-        SkillPoints: DB.EnumCase<null>;
-        SkillRating: DB.EnumCase<null>;
-    }, []>>, true>;
-    modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
-        arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
-            Multiply: DB.EnumCase<null>;
-            Divide: DB.EnumCase<null>;
-        }, []>>, true>;
-        value: DB.MemberDecl<DB.Integer, true>;
-    }>, []>>, false>;
-}>, []>;

package/lib/types/_ActivatableSkillCheckResultBased.js

@@ -1,13 +1,4 @@
 import * as DB from "tsondb/schema/dsl";
-export const CheckResultValue = DB.Enum(import.meta.url, {
-    name: "CheckResultValue",
-    comment: "Defines the derived (unitless) value.",
-    values: () => ({
-        QualityLevels: DB.EnumCase({ type: null }),
-        SkillPoints: DB.EnumCase({ type: null }),
-        SkillRating: DB.EnumCase({ type: null }),
-    }),
-});
 const CheckResultArithmetic = DB.Enum(import.meta.url, {
     name: "CheckResultArithmetic",
     comment: "Defines how the the `value` is set off against the check result.",
@@ -29,17 +20,3 @@ export const CheckResultBasedModifier = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
-export const CheckResultBased = DB.TypeAlias(import.meta.url, {
-    name: "CheckResultBased",
-    comment: "Defines a parameter being based on a check result.",
-    type: () => DB.Object({
-        base: DB.Required({
-            comment: "The base value that is derived from the check result.",
-            type: DB.IncludeIdentifier(CheckResultValue),
-        }),
-        modifier: DB.Optional({
-            comment: "If defined, it modifies the base value.",
-            type: DB.IncludeIdentifier(CheckResultBasedModifier),
-        }),
-    }),
-});

package/lib/types/_Enhancements.d.ts

@@ -10,7 +10,12 @@ export declare const Enhancements: DB.TypeAlias<"Enhancements", DB.ChildEntities
         Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
     }, []>>, true>;
     skill_rating: DB.MemberDecl<DB.Integer, true>;
-    adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+    adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+        DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+            multiplier: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Constant: DB.EnumCase<DB.Integer>;
+    }, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
         Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -79,6 +84,7 @@ export declare const Enhancements: DB.TypeAlias<"Enhancements", DB.ChildEntities
     translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         effect: DB.MemberDecl<DB.String, true>;
+        input: DB.MemberDecl<DB.String, false>;
         errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
             date: DB.MemberDecl<DB.Date, true>;
             description: DB.MemberDecl<DB.String, true>;
@@ -93,7 +99,12 @@ export declare const Enhancement: DB.Entity<"Enhancement", {
         Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
     }, []>>, true>;
     skill_rating: DB.MemberDecl<DB.Integer, true>;
-    adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+    adventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnhancementAdventurePoints", {
+        DerivedFromImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedEnhancementAdventurePoints", DB.Object<{
+            multiplier: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Constant: DB.EnumCase<DB.Integer>;
+    }, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
         Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
         Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
@@ -162,6 +173,7 @@ export declare const Enhancement: DB.Entity<"Enhancement", {
     translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         effect: DB.MemberDecl<DB.String, true>;
+        input: DB.MemberDecl<DB.String, false>;
         errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
             date: DB.MemberDecl<DB.Date, true>;
             description: DB.MemberDecl<DB.String, true>;

package/lib/types/_Enhancements.js

@@ -2,6 +2,7 @@
  * @title Enhancements
  */
 import * as DB from "tsondb/schema/dsl";
+import { input } from "./_Activatable.js";
 import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js";
 import { EnhancementPrerequisites } from "./_Prerequisite.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -28,11 +29,9 @@ export const Enhancement = DB.Entity(import.meta.url, {
                 multipleOf: 2,
             }),
         }),
-        adventure_points_modifier: DB.Required({
-            comment: "The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
-            type: DB.Integer({
-                minimum: 1,
-            }),
+        adventurePoints: DB.Required({
+            comment: "Defines how to determine the AP cost of an enhancement.",
+            type: DB.IncludeIdentifier(EnhancementAdventurePoints),
         }),
         prerequisites: DB.Optional({
             type: DB.IncludeIdentifier(EnhancementPrerequisites),
@@ -55,6 +54,7 @@ export const Enhancement = DB.Entity(import.meta.url, {
                     markdown: "block",
                 }),
             }),
+            input,
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
             }),
@@ -78,3 +78,31 @@ export const Enhancement = DB.Entity(import.meta.url, {
         ],
     ],
 });
+const EnhancementAdventurePoints = DB.Enum(import.meta.url, {
+    name: "EnhancementAdventurePoints",
+    comment: "Defines how to determine the AP cost of an enhancement.",
+    values: () => ({
+        DerivedFromImprovementCost: DB.EnumCase({
+            comment: "Use the numeric representation of the associated skill's improvement cost as the AP cost of this enhancement.",
+            type: DB.IncludeIdentifier(DerivedEnhancementAdventurePoints),
+        }),
+        Constant: DB.EnumCase({
+            comment: "Use the specified constant value as the AP cost of this enhancement.",
+            type: DB.Integer({
+                minimum: 1,
+            }),
+        }),
+    }),
+});
+const DerivedEnhancementAdventurePoints = DB.TypeAlias(import.meta.url, {
+    name: "DerivedEnhancementAdventurePoints",
+    type: () => DB.Object({
+        multiplier: DB.Required({
+            comment: "The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
+            type: DB.Integer({
+                minimum: 1,
+                maximum: 3,
+            }),
+        }),
+    }),
+});

package/lib/types/equipment/item/HerbalAid.d.ts

@@ -10,6 +10,33 @@ export declare const HerbalAid: DB.Entity<"HerbalAid", {
         Supernatural: DB.EnumCase<null>;
     }, []>>>, true>;
     crafting_difficulty: DB.MemberDecl<DB.Integer, true>;
+    trade_secret: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RecipeTradeSecret", DB.Object<{
+        ap_value: DB.MemberDecl<DB.Integer, true>;
+        prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+            Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+            Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                    Hide: DB.EnumCase<null>;
+                    ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                        sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                            Standalone: DB.EnumCase<null>;
+                            Connected: DB.EnumCase<null>;
+                        }, []>>, false>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                            replacement: DB.MemberDecl<DB.String, true>;
+                        }>, true>;
+                    }>, []>>>;
+                }, []>>, false>;
+            }>, [T: DB.Param<"T", DB.Type>]>>>;
+            Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                    text: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, [T: DB.Param<"T", DB.Type>]>>>;
+        }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+    }>, []>>, false>;
     combatUse: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HerbalAidCombatUse", {
         Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
         Armor: DB.EnumCase<DB.ReferenceIdentifier>;

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

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { src } from "../../source/_PublicationRef.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { WeaponIdentifier, ArmorIdentifier } from "../../_Identifier.js";
-import { EffectType } from "./_Herbary.js";
+import { EffectType, RecipeTradeSecret } from "./_Herbary.js";
 export const HerbalAid = DB.Entity(import.meta.url, {
     name: "HerbalAid",
     namePlural: "HerbalAids",
@@ -15,6 +15,10 @@ export const HerbalAid = DB.Entity(import.meta.url, {
             comment: "The difficulty for this aid to craft.",
             type: DB.Integer(),
         }),
+        trade_secret: DB.Optional({
+            comment: "AP value and prerequisites of the herbal aid�s trade secret.",
+            type: DB.IncludeIdentifier(RecipeTradeSecret),
+        }),
         combatUse: DB.Optional({
             comment: "The armor or weapon this herbal aid represents.",
             type: DB.IncludeIdentifier(HerbalAidCombatUse),

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

@@ -940,6 +940,7 @@ export declare const BlessedTradition: DB.Entity<"BlessedTradition", {
     }, "parent">>, true>;
     primary: DB.MemberDecl<DB.ReferenceIdentifier, false>;
     aspects: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    primaryBlessing: DB.MemberDecl<DB.ReferenceIdentifier, false>;
     restricted_blessings: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedBlessings", {
         Three: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
         Six: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;

package/lib/types/specialAbility/BlessedTradition.js

@@ -27,6 +27,10 @@ export const BlessedTradition = DB.Entity(import.meta.url, {
             comment: "The tradition’s aspects, if any.",
             type: DB.Array(AspectIdentifier(), { minItems: 2, maxItems: 2 }),
         }),
+        primaryBlessing: DB.Optional({
+            comment: "The tradition’s primary blessing. Leave empty if the tradition does not have one.",
+            type: BlessingIdentifier(),
+        }),
         restricted_blessings: DB.Optional({
             comment: "If a tradition restricts the possible blessings, the blessings that are **not** allowed.",
             type: DB.IncludeIdentifier(RestrictedBlessings),

package/package.json

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