optolith-database-schema 0.40.0 → 0.42.0

package/lib/types/Race.d.ts

@@ -1,21 +1,8 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const Race: DB.Entity<"Race", {
     ap_value: DB.MemberDecl<DB.Integer, true>;
-    base_values: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BaseValues", DB.Object<{
-        life_points: DB.MemberDecl<DB.Integer, true>;
-        spirit: DB.MemberDecl<DB.Integer, true>;
-        toughness: DB.MemberDecl<DB.Integer, true>;
-        movement: DB.MemberDecl<DB.Integer, true>;
-    }>, []>>, true>;
-    attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{
-        fixed: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAttributeAdjustment", DB.Object<{
-            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
-            value: DB.MemberDecl<DB.Integer, true>;
-        }>, []>>>, false>;
-        selectable: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectableAttributeAdjustment", DB.Object<{
-            list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
-            value: DB.MemberDecl<DB.Integer, true>;
-        }>, []>>>, false>;
+    base_values: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BaseValues", DB.NestedEntityMap<string, {
+        value: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
     automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
@@ -35,6 +22,7 @@ export declare const Race: DB.Entity<"Race", {
             options: DB.MemberDecl<DB.String, true>;
         }>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
+    hairColorCount: DB.MemberDecl<DB.Integer, false>;
     weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RandomWeightGeneration", DB.Object<{
         base: DB.MemberDecl<DB.Integer, true>;
         random: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"WeightDice", DB.Object<{
@@ -56,6 +44,16 @@ export declare const Race: DB.Entity<"Race", {
     }>, true>;
     variants: DB.MemberDecl<DB.ChildEntities<DB.Entity<"RaceVariant", {
         race: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{
+            fixed: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAttributeAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>, false>;
+            selectable: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectableAttributeAdjustment", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>, false>;
+        }>, []>>, true>;
         common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
@@ -81,8 +79,8 @@ export declare const Race: DB.Entity<"Race", {
                 options: DB.MemberDecl<DB.String, true>;
             }>, false>;
         }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-        hair_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
-        eye_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+        hair_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        eye_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         height: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RandomHeightGeneration", DB.Object<{
             base: DB.MemberDecl<DB.Integer, true>;
             random: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
@@ -146,6 +144,7 @@ export declare const Race: DB.Entity<"Race", {
         automatic_disadvantages: DB.MemberDecl<DB.String, false>;
         strongly_recommended_advantages: DB.MemberDecl<DB.String, false>;
         strongly_recommended_disadvantages: DB.MemberDecl<DB.String, false>;
+        hairColorLabel: 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>;
@@ -154,6 +153,16 @@ export declare const Race: DB.Entity<"Race", {
 }, undefined>;
 export declare const RaceVariant: DB.Entity<"RaceVariant", {
     race: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    attribute_adjustments: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAdjustments", DB.Object<{
+        fixed: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAttributeAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, false>;
+        selectable: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectableAttributeAdjustment", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, false>;
+    }>, []>>, true>;
     common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
@@ -179,8 +188,8 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
             options: DB.MemberDecl<DB.String, true>;
         }>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-    hair_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
-    eye_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    hair_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    eye_color: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
     height: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RandomHeightGeneration", DB.Object<{
         base: DB.MemberDecl<DB.Integer, true>;
         random: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{

package/lib/types/Race.js

@@ -1,7 +1,9 @@
+import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { Dice, DieType } from "./_Dice.js";
 import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, EyeColorIdentifier, HairColorIdentifier, RaceIdentifier, } from "./_Identifier.js";
+import { calculationContainsRaceBase, DerivedCharacteristic } from "./DerivedCharacteristic.js";
 import { ExperienceLevel } from "./ExperienceLevel.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
@@ -18,10 +20,6 @@ export const Race = DB.Entity(import.meta.url, {
             comment: "The race’s base values.",
             type: DB.IncludeIdentifier(BaseValues),
         }),
-        attribute_adjustments: DB.Required({
-            comment: "Describes how to raise or lower maximum attribute values during character creation.",
-            type: DB.IncludeIdentifier(AttributeAdjustments),
-        }),
         automatic_advantages: DB.Optional({
             comment: "A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.",
             type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]), {
@@ -40,6 +38,10 @@ export const Race = DB.Entity(import.meta.url, {
             comment: "A list of strongly recommended disadvantages.",
             type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
         }),
+        hairColorCount: DB.Optional({
+            comment: "How many different hair colors a race may have. By default, they have a single one that is for their whole body, but a race may have multiple if their hair color is different for different body parts. Additionally, if the hair color is labelled differently (e.g. scale color), there might be multiple colors for different body parts as well. This should only be set if the hair color count is higher than 1.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
         weight: DB.Required({
             comment: "Configuration for random weight generation.",
             type: DB.IncludeIdentifier(RandomWeightGeneration),
@@ -93,6 +95,10 @@ export const Race = DB.Entity(import.meta.url, {
                 comment: "The respective strongly recommended disadvantages text from the source book.",
                 type: DB.String({ minLength: 1 }),
             }),
+            hairColorLabel: DB.Optional({
+                comment: "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.",
+                type: DB.String({ minLength: 1 }),
+            }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
             }),
@@ -105,25 +111,29 @@ export const Race = DB.Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, getAllInstanceContainers, getDisplayNameAndId }) => {
+        const expectedBaseValues = getAllInstanceContainers("DerivedCharacteristic").filter(dc => calculationContainsRaceBase(dc.content.calculation.base));
+        const actualBaseValues = Object.keys(instanceContent.base_values);
+        return [
+            expectedBaseValues.length !== actualBaseValues.length ||
+                actualBaseValues.some(actual => !expectedBaseValues.some(expected => actual === expected.id))
+                ? `The race needs to define base values for ${expectedBaseValues.map(dc => getDisplayNameAndId("DerivedCharacteristic", dc.id)).join(", ")}, but defines ${actualBaseValues.map(dcId => getDisplayNameAndId("DerivedCharacteristic", dcId)).join(", ")}.`
+                : null,
+        ].filter(isNotNullish);
+    },
 });
 const BaseValues = DB.TypeAlias(import.meta.url, {
     name: "BaseValues",
-    type: () => DB.Object({
-        life_points: DB.Required({
-            comment: "The race’s life point base value.",
-            type: DB.Integer(),
-        }),
-        spirit: DB.Required({
-            comment: "The race’s Spirit base value.",
-            type: DB.Integer(),
-        }),
-        toughness: DB.Required({
-            comment: "The race’s Toughness base value.",
-            type: DB.Integer(),
-        }),
-        movement: DB.Required({
-            comment: "The race’s tactical movement rate.",
-            type: DB.Integer(),
+    type: () => DB.NestedEntityMap({
+        name: "RaceBaseValue",
+        namePlural: "RaceBaseValues",
+        comment: "The base value for a derived characteristic that is granted by the race.",
+        secondaryEntity: DerivedCharacteristic,
+        type: DB.Object({
+            value: DB.Required({
+                comment: "The base value for the derived characteristic that is granted by the race.",
+                type: DB.Integer(),
+            }),
         }),
     }),
 });
@@ -233,6 +243,10 @@ export const RaceVariant = DB.Entity(import.meta.url, {
             comment: "The associated race.",
             type: RaceIdentifier(),
         }),
+        attribute_adjustments: DB.Required({
+            comment: "Describes how to raise or lower maximum attribute values during character creation.",
+            type: DB.IncludeIdentifier(AttributeAdjustments),
+        }),
         common_cultures: DB.Optional({
             comment: "The list of common cultures.",
             type: DB.Array(CultureIdentifier(), { minItems: 1 }),
@@ -253,11 +267,11 @@ export const RaceVariant = DB.Entity(import.meta.url, {
             comment: "A list of uncommon disadvantages.",
             type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
         }),
-        hair_color: DB.Optional({
+        hair_color: DB.Required({
             comment: "An array containing 20 (numeric) hair color identifiers. The array also represents the 20-sided die for a random hair color.",
             type: DB.Array(HairColorIdentifier(), { minItems: 20, maxItems: 20 }),
         }),
-        eye_color: DB.Optional({
+        eye_color: DB.Required({
             comment: "An array containing 20 (numeric) eye color identifiers. The array also represents the 20-sided die for a random eye color.",
             type: DB.Array(EyeColorIdentifier(), { minItems: 20, maxItems: 20 }),
         }),

package/lib/types/Ritual.d.ts

@@ -194,6 +194,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
                         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", {
@@ -279,6 +280,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
                     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", {
@@ -420,6 +422,7 @@ export declare const Ritual: DB.Entity<"Ritual", {
                         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", {

package/lib/types/Spell.d.ts

@@ -194,6 +194,7 @@ export declare const Spell: DB.Entity<"Spell", {
                         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", {
@@ -279,6 +280,7 @@ export declare const Spell: DB.Entity<"Spell", {
                     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", {
@@ -420,6 +422,7 @@ export declare const Spell: DB.Entity<"Spell", {
                         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", {

package/lib/types/Talisman.d.ts

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { MathOperation } from "./_MathExpression.js";
 export declare const Talisman: DB.Entity<"Talisman", {
     tradition: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
     type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"TalismanType", {
@@ -8,6 +9,27 @@ export declare const Talisman: DB.Entity<"Talisman", {
         Regalia: DB.EnumCase<null>;
         PowerfulTalisman: DB.EnumCase<null>;
     }, []>>, false>;
+    activation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivation", DB.Object<{
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationCost", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>, true>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationDuration", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationDurationExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                Seconds: DB.EnumCase<null>;
+                Minutes: DB.EnumCase<null>;
+                Hours: DB.EnumCase<null>;
+                Days: DB.EnumCase<null>;
+                Weeks: DB.EnumCase<null>;
+                Months: DB.EnumCase<null>;
+                Years: DB.EnumCase<null>;
+                Centuries: DB.EnumCase<null>;
+                Actions: DB.EnumCase<null>;
+                CombatRounds: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>, true>;
+    }>, []>>, false>;
     ap_value: DB.MemberDecl<DB.Integer, false>;
     combatUse: DB.MemberDecl<DB.Object<{
         melee_uses: DB.MemberDecl<DB.NestedEntityMap<string, {
@@ -25,7 +47,7 @@ export declare const Talisman: DB.Entity<"Talisman", {
             }, []>>, false>;
             attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
             parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-            reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
             size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
                 Small: DB.EnumCase<null>;
@@ -48,7 +70,10 @@ export declare const Talisman: DB.Entity<"Talisman", {
                 medium: DB.MemberDecl<DB.Integer, true>;
                 far: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, true>;
-            ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, false>;
             length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
             is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
         }>, false>;
@@ -97,13 +122,14 @@ export declare const Talisman: DB.Entity<"Talisman", {
     translations: DB.MemberDecl<DB.NestedEntityMap<"TalismanTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         effect: DB.MemberDecl<DB.String, true>;
-        activation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"TalismanActivationTranslation", DB.Object<{
-            cost: DB.MemberDecl<DB.Integer, true>;
-            duration: DB.MemberDecl<DB.String, true>;
-        }>, []>>, 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>;
         }>, []>>>, []>>, false>;
     }>, true>;
 }, undefined>;
+export declare const TalismanActivationDurationExpression: DB.TypeAlias<"TalismanActivationDurationExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>;
+export declare const TalismanActivationDurationExpressionValue: DB.Enum<"TalismanActivationDurationExpressionValue", {
+    Constant: DB.EnumCase<DB.Integer>;
+    QualityLevels: DB.EnumCase<null>;
+}, []>;

package/lib/types/Talisman.js

@@ -1,6 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
+import { DurationUnit } from "./_ActivatableSkillDuration.js";
 import { Dice } from "./_Dice.js";
-import { BlessedTraditionIdentifier } from "./_Identifier.js";
+import { BlessedTraditionIdentifier, DerivedCharacteristicIdentifier } from "./_Identifier.js";
 import { MathOperation } from "./_MathExpression.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "./CombatTechnique.js";
 import { GenMeleeWeapon } from "./equipment/item/_MeleeWeapon.js";
@@ -21,6 +22,10 @@ export const Talisman = DB.Entity(import.meta.url, {
             comment: "The talisman type, if any.",
             type: DB.IncludeIdentifier(TalismanType),
         }),
+        activation: DB.Optional({
+            comment: "The activation parameters.",
+            type: DB.IncludeIdentifier(TalismanActivation),
+        }),
         ap_value: DB.Optional({
             comment: "The AP value for the required trade secret, if possible.",
             type: DB.Integer({ minimum: 5, multipleOf: 5 }),
@@ -59,10 +64,6 @@ export const Talisman = DB.Entity(import.meta.url, {
                 comment: "The effect description.",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
-            activation: DB.Optional({
-                comment: "The activation parameters.",
-                type: DB.IncludeIdentifier(TalismanActivationTranslation),
-            }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
             }),
@@ -113,16 +114,55 @@ const TalismanType = DB.Enum(import.meta.url, {
         PowerfulTalisman: DB.EnumCase({ type: null }),
     }),
 });
-const TalismanActivationTranslation = DB.TypeAlias(import.meta.url, {
-    name: "TalismanActivationTranslation",
+const TalismanActivation = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivation",
     type: () => DB.Object({
         cost: DB.Required({
-            comment: "The KP cost.",
-            type: DB.Integer({ minimum: 0 }),
+            comment: "The cost to activate the talisman.",
+            type: DB.IncludeIdentifier(TalismanActivationCost),
         }),
         duration: DB.Required({
-            comment: "The duration.",
-            type: DB.String({ minLength: 1 }),
+            comment: "The duration of how long the talisman will be active.",
+            type: DB.IncludeIdentifier(TalismanActivationDuration),
+        }),
+    }),
+});
+const TalismanActivationCost = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivationCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (numeric) cost value.",
+            type: DB.Integer({ minimum: 0 }),
         }),
+        unit: DB.Required({
+            comment: "The unit in which to pay the cost.",
+            type: DerivedCharacteristicIdentifier(),
+        }),
+    }),
+});
+const TalismanActivationDuration = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivationDuration",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (numeric) duration value.",
+            type: DB.IncludeIdentifier(TalismanActivationDurationExpression),
+        }),
+        unit: DB.Required({
+            comment: "The unit of the duration.",
+            type: DB.IncludeIdentifier(DurationUnit),
+        }),
+    }),
+});
+export const TalismanActivationDurationExpression = DB.TypeAlias(import.meta.url, {
+    name: "TalismanActivationDurationExpression",
+    type: () => DB.GenIncludeIdentifier(MathOperation, [
+        DB.IncludeIdentifier(TalismanActivationDurationExpressionValue),
+    ]),
+});
+export const TalismanActivationDurationExpressionValue = DB.Enum(import.meta.url, {
+    name: "TalismanActivationDurationExpressionValue",
+    values: () => ({
+        Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
+        QualityLevels: DB.EnumCase({ type: null }),
     }),
 });

package/lib/types/_ActivatableSkill.d.ts

@@ -185,6 +185,7 @@ export declare const OneTimePerformanceParameters: DB.TypeAlias<"OneTimePerforma
                 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", {
@@ -270,6 +271,7 @@ export declare const OneTimePerformanceParameters: DB.TypeAlias<"OneTimePerforma
             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", {
@@ -491,6 +493,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                     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", {
@@ -576,6 +579,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                 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", {
@@ -717,6 +721,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                     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", {
@@ -946,6 +951,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                     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", {
@@ -1031,6 +1037,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                 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", {
@@ -1172,6 +1179,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                     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", {

package/lib/types/_ActivatableSkillCheckResultBased.d.ts

@@ -2,6 +2,7 @@ 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", {
@@ -14,6 +15,7 @@ export declare const CheckResultBased: DB.TypeAlias<"CheckResultBased", DB.Objec
     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", {

package/lib/types/_ActivatableSkillCheckResultBased.js

@@ -5,6 +5,7 @@ export const CheckResultValue = DB.Enum(import.meta.url, {
     values: () => ({
         QualityLevels: DB.EnumCase({ type: null }),
         SkillPoints: DB.EnumCase({ type: null }),
+        SkillRating: DB.EnumCase({ type: null }),
     }),
 });
 const CheckResultArithmetic = DB.Enum(import.meta.url, {

package/lib/types/_ActivatableSkillDuration.d.ts

@@ -58,6 +58,7 @@ export declare const DurationForOneTime: DB.Enum<"DurationForOneTime", {
         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", {
@@ -121,6 +122,7 @@ export declare const CheckResultBasedDuration: DB.TypeAlias<"CheckResultBasedDur
     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", {

package/lib/types/_ActivatableSkillRange.d.ts

@@ -24,6 +24,7 @@ export declare const Range: DB.TypeAlias<"Range", 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", {

package/lib/types/_Identifier.d.ts

@@ -50,6 +50,7 @@ export declare const CultureIdentifier: () => R;
 export declare const CurriculumIdentifier: () => R;
 export declare const CurseIdentifier: () => R;
 export declare const DaggerRitualIdentifier: () => R;
+export declare const DerivedCharacteristicIdentifier: () => R;
 export declare const DisadvantageIdentifier: () => R;
 export declare const DiseaseIdentifier: () => R;
 export declare const DominationRitualIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -15,6 +15,7 @@ import { CloseCombatTechnique, RangedCombatTechnique } from "./CombatTechnique.j
 import { Condition } from "./Condition.js";
 import { Continent } from "./Continent.js";
 import { Culture } from "./Culture.js";
+import { DerivedCharacteristic } from "./DerivedCharacteristic.js";
 import { Disadvantage } from "./Disadvantage.js";
 import { Disease } from "./Disease.js";
 import { Element } from "./Element.js";
@@ -202,6 +203,7 @@ export const CultureIdentifier = () => R(Culture);
 export const CurriculumIdentifier = () => R(Curriculum);
 export const CurseIdentifier = () => R(Curse);
 export const DaggerRitualIdentifier = () => R(DaggerRitual);
+export const DerivedCharacteristicIdentifier = () => R(DerivedCharacteristic);
 export const DisadvantageIdentifier = () => R(Disadvantage);
 export const DiseaseIdentifier = () => R(Disease);
 export const DominationRitualIdentifier = () => R(DominationRitual);

package/lib/types/_IdentifierGroup.d.ts

@@ -133,6 +133,60 @@ export declare const CombatRelatedSpecialAbilityIdentifier: DB.Enum<"CombatRelat
     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
     CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
 }, []>;
+export declare const ProfessionSpecialAbilityIdentifier: DB.Enum<"ProfessionSpecialAbilityIdentifier", {
+    Enhancement: DB.EnumCase<DB.ReferenceIdentifier>;
+    AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+    ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+    BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+    BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+    FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+    InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+    Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+    LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+    MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+    MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+    MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+    ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+    SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+    SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+    VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+    Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+    WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+    WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+}, []>;
 export declare const TraditionIdentifier: DB.Enum<"TraditionIdentifier", {
     MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
     BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -347,6 +401,10 @@ export declare const EquipmentIdentifier: DB.Enum<"EquipmentIdentifier", {
     WeaponAccessory: DB.EnumCase<DB.ReferenceIdentifier>;
     WorkingSupernaturalCreature: DB.EnumCase<DB.ReferenceIdentifier>;
 }, []>;
+export declare const AmmunitionishIdentifier: DB.Enum<"AmmunitionishIdentifier", {
+    Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+    Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+}, []>;
 export declare const AdvancedSkillStyleSpecialAbilityIdentifier: DB.Enum<"AdvancedSkillStyleSpecialAbilityIdentifier", {
     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
     AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;