optolith-database-schema 0.28.3 → 0.29.1

package/lib/types/DerivedCharacteristic.d.ts

@@ -1,6 +1,167 @@
 import * as DB from "tsondb/schema/dsl";
+import { MathOperation } from "./_MathExpression.ts";
 export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
     position: DB.MemberDecl<DB.Integer, true>;
+    calculation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicCalculation", DB.Object<{
+        base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+        modifiers: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicModifier", DB.Object<{
+            source: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicModifierPrerequisiteGroup", {
+                Rule: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisite", DB.Object<{
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ExtensionRuleIdentifier", {
+                        FocusRule: DB.EnumCase<DB.ReferenceIdentifier>;
+                        OptionalRule: 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>;
+                }>, []>>>;
+                Activatable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatablePrerequisite", DB.Object<{
+                    id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+                        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>;
+                        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>, true>;
+                    active: DB.MemberDecl<DB.Boolean, true>;
+                    level: DB.MemberDecl<DB.Integer, false>;
+                    options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+                        General: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Race: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+                        SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+                        CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                        RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Property: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Language: DB.EnumCase<DB.ReferenceIdentifier>;
+                        AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+                        LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                        TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                        ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Element: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>>, false>;
+                    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>;
+                    when: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Preconditions", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"PreconditionGroup", {
+                        Publication: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationPrerequisite", DB.Object<{
+                            id: DB.MemberDecl<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>;
+                        }>, []>>>;
+                        SexualCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SexualCharacteristicPrerequisite", DB.Object<{
+                            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SexualCharacteristic", {
+                                Penis: DB.EnumCase<null>;
+                                Vagina: DB.EnumCase<null>;
+                            }, []>>, true>;
+                        }>, []>>>;
+                    }, []>>>, []>>, false>;
+                }>, []>>>;
+            }, []>>, true>;
+            operation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicModifierOperation", {
+                Addition: DB.EnumCase<null>;
+                Subtraction: DB.EnumCase<null>;
+                Multiplication: DB.EnumCase<null>;
+                Division: DB.EnumCase<null>;
+            }, []>>, true>;
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, false>;
+        purchasable: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPurchase", DB.Object<{
+            improvementCost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+                A: DB.EnumCase<null>;
+                B: DB.EnumCase<null>;
+                C: DB.EnumCase<null>;
+                D: DB.EnumCase<null>;
+            }, []>>, true>;
+            maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBase", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
+        }>, []>>, false>;
+        permanentLoss: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPermanentLoss", DB.Object<{
+            canBeBoughtBack: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicBuyBack", DB.Object<{
+                cost: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>, false>;
+        }>, []>>, false>;
+    }>, []>>, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DerivedCharacteristicPrerequisites", 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<{
@@ -43,7 +204,7 @@ export declare const DerivedCharacteristic: DB.Entity<"DerivedCharacteristic", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/DerivedCharacteristic.js

@@ -1,6 +1,10 @@
 import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
+import { AttributeIdentifier } from "./_Identifier.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { MathOperation } from "./_MathExpression.js";
 import { DerivedCharacteristicPrerequisites } from "./_Prerequisite.js";
+import { DerivedCharacteristicModifierPrerequisiteGroup } from "./prerequisites/PrerequisiteGroups.js";
 import { src } from "./source/_PublicationRef.js";
 export const DerivedCharacteristic = DB.Entity(import.meta.url, {
     name: "DerivedCharacteristic",
@@ -10,6 +14,10 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
             comment: "The position of the derived characteristic in lists. This has to be a unique value.",
             type: DB.Integer({ minimum: 0 }),
         }),
+        calculation: DB.Required({
+            comment: "Instructions for calculating the derived characteristic’s value.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicCalculation),
+        }),
         prerequisites: DB.Optional({
             type: DB.IncludeIdentifier(DerivedCharacteristicPrerequisites),
         }),
@@ -47,6 +55,118 @@ export const DerivedCharacteristic = DB.Entity(import.meta.url, {
         },
     ],
 });
+const DerivedCharacteristicCalculation = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicCalculation",
+    type: () => DB.Object({
+        base: DB.Required({
+            comment: "The base value for the calculation.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicBase),
+        }),
+        modifiers: DB.Optional({
+            comment: "A list of modifiers that are applied to the base value. The modifiers are applied in the order they appear in the list.",
+            type: DB.Array(DB.IncludeIdentifier(DerivedCharacteristicModifier), { minItems: 1 }),
+        }),
+        purchasable: DB.Optional({
+            comment: "If set, the derived characteristic can be improved by spending AP.\n\nIf the derived characteristic’s permanent losses can be bought back, points will not be able to be purchased unless all permanent losses have been bought back.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPurchase),
+        }),
+        permanentLoss: DB.Optional({
+            comment: "If set, the derived characteristic can suffer permanent losses that reduce its maximum value. It may also be possible to buy back these permanent losses.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicPermanentLoss),
+        }),
+    }),
+});
+const DerivedCharacteristicRaceBaseValue = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicRaceBaseValue",
+    values: () => ({
+        LifePoints: DB.EnumCase({ type: null }),
+        Spirit: DB.EnumCase({ type: null }),
+        Toughness: DB.EnumCase({ type: null }),
+        Movement: DB.EnumCase({ type: null }),
+    }),
+});
+const DerivedCharacteristicPrimaryAttributeValue = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicPrimaryAttributeValue",
+    values: () => ({
+        Magical: DB.EnumCase({ type: null }),
+        Blessed: DB.EnumCase({ type: null }),
+    }),
+});
+const DerivedCharacteristicBaseValue = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicBaseValue",
+    values: () => ({
+        Constant: DB.EnumCase({ type: DB.Integer() }),
+        Attribute: DB.EnumCase({ type: AttributeIdentifier() }),
+        RaceBaseValue: DB.EnumCase({
+            displayName: "Base Value from Race",
+            type: DB.IncludeIdentifier(DerivedCharacteristicRaceBaseValue),
+        }),
+        PrimaryAttribute: DB.EnumCase({
+            type: DB.IncludeIdentifier(DerivedCharacteristicPrimaryAttributeValue),
+        }),
+    }),
+});
+const DerivedCharacteristicBase = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicBase",
+    type: () => DB.GenIncludeIdentifier(MathOperation, [DB.IncludeIdentifier(DerivedCharacteristicBaseValue)]),
+});
+const DerivedCharacteristicModifierOperation = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicModifierOperation",
+    values: () => ({
+        Addition: DB.EnumCase({ type: null }),
+        Subtraction: DB.EnumCase({ type: null }),
+        Multiplication: DB.EnumCase({ type: null }),
+        Division: DB.EnumCase({ type: null }),
+    }),
+});
+const DerivedCharacteristicModifier = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicModifier",
+    type: () => DB.Object({
+        source: DB.Required({
+            comment: "The entry that, when active, causes the modifier.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicModifierPrerequisiteGroup),
+        }),
+        operation: DB.Required({
+            comment: "The mathematical operation that modifies the base value. The previous result is on the left side.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicModifierOperation),
+        }),
+        value: DB.Required({
+            comment: "The value that is used in the modifier operation. If the source entry has levels, the value is multiplied by the source entry’s level.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const DerivedCharacteristicPurchase = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicPurchase",
+    type: () => DB.Object({
+        improvementCost: DB.Required({
+            comment: "The cost for improving the derived characteristic by one.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        maximum: DB.Required({
+            comment: "The maximum value that can be achieved for the derived characteristic through improvements.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicBase),
+        }),
+    }),
+});
+const DerivedCharacteristicPermanentLoss = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicPermanentLoss",
+    type: () => DB.Object({
+        canBeBoughtBack: DB.Optional({
+            comment: "If set, permanent losses to the derived characteristic can be bought back for the specified cost.",
+            type: DB.IncludeIdentifier(DerivedCharacteristicBuyBack),
+        }),
+    }),
+});
+const DerivedCharacteristicBuyBack = DB.TypeAlias(import.meta.url, {
+    name: "DerivedCharacteristicBuyBack",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The AP cost for buying back one point.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
 const CalculationTranslation = DB.TypeAlias(import.meta.url, {
     name: "CalculationTranslation",
     type: () => DB.Object({

package/lib/types/Disadvantage.d.ts

@@ -46,8 +46,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                 prerequisites: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"LanguagesSelectOptionCategoryPrerequisite", {
                     SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                         id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -99,6 +97,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                             WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                             WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                         }, []>>, true>;
                         active: DB.MemberDecl<DB.Boolean, true>;
                         level: DB.MemberDecl<DB.Integer, false>;
@@ -134,8 +134,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -187,6 +185,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -220,8 +220,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -273,6 +271,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -293,8 +293,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -346,6 +344,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -366,8 +366,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -419,6 +417,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -439,8 +439,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -492,6 +490,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -529,8 +529,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -582,6 +580,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -602,8 +602,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -655,6 +653,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -695,8 +695,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {
-            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+            TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -748,7 +747,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
             Vision: DB.EnumCase<DB.ReferenceIdentifier>;
             WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
             WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
-            TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         profession_only: DB.MemberDecl<DB.Boolean, false>;
         skill_applications: DB.MemberDecl<DB.ChildEntities<DB.Entity<"NewSkillApplication", {
@@ -852,7 +852,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;
@@ -987,8 +987,6 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
         }>, []>>>;
         DependingOnActive: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActive", DB.Object<{
             id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1040,6 +1038,8 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                 Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                 WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                 WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>, true>;
             active: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsSingleValue", DB.Integer, []>>, true>;
             inactive: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsSingleValue", DB.Integer, []>>, true>;
@@ -1050,7 +1050,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.js").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.ts").MathOperation>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;
@@ -1074,7 +1074,7 @@ export declare const Disadvantage: DB.Entity<"Disadvantage", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Disease.d.ts

@@ -59,7 +59,7 @@ export declare const Disease: DB.Entity<"Disease", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/FamiliarsTrick.d.ts

@@ -148,7 +148,7 @@ export declare const FamiliarsTrick: DB.Entity<"FamiliarsTrick", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Lessons.d.ts

@@ -102,7 +102,7 @@ export declare const Curriculum: DB.Entity<"Curriculum", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/LiturgicalChant.d.ts

@@ -529,7 +529,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, false>;
+            }>, []>>, true>;
             revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                 Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                     printing: DB.MemberDecl<DB.Integer, true>;
@@ -643,7 +643,7 @@ export declare const LiturgicalChant: DB.Entity<"LiturgicalChant", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, false>;
+                }>, []>>, true>;
                 revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
                     Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
                         printing: DB.MemberDecl<DB.Integer, true>;

package/lib/types/Locale.d.ts

@@ -892,6 +892,7 @@ export declare const Locale: DB.Entity<"Locale", {
         ID: null;
         "Creation Difficulty": null;
         CD: null;
+        Object: null;
         Effect: null;
         "Casting Time": null;
         "Ritual Time": null;
@@ -1022,6 +1023,7 @@ export declare const Locale: DB.Entity<"Locale", {
         " (casting)": null;
         Zone: null;
         "Liturgical Chants and Ceremonies": null;
+        Spellworks: null;
         General: null;
         Note: null;
         all: null;
@@ -1057,6 +1059,9 @@ export declare const Locale: DB.Entity<"Locale", {
         "domain {$domain}": null;
         "{$pact} level {$pactLevel}": null;
         "Level {$level}:": null;
+        ".input {$level :number} {{Level {$level}}}": null;
+        "cannot be chosen at the same time as {$trait}": null;
+        "must have {$trait}": null;
         "inlinewiki.castingtime": null;
         "inlinewiki.ritualtime": null;
         "inlinewiki.aecost": null;
@@ -1258,6 +1263,11 @@ export declare const Locale: DB.Entity<"Locale", {
         "Back Cover Inside": null;
         ".input {$printing :number} {{since the {$printing}. printing}}": null;
         ".input {$printing :number} {{removed in {$printing}. printing}}": null;
+        "Base Value": null;
+        "Base {$name} from Race": null;
+        "Race Base {$abbreviation}": null;
+        "Primary attribute for the magic user\u2019s Tradition": null;
+        "Primary attribute for the Blessed One\u2019s Tradition": null;
     }>, false>;
 }, undefined>;
 export declare const NestedTranslationMap: <Name extends string, T extends Record<string, DB.MemberDecl>, R extends boolean>(MemberDeclCreator: <T_1 extends DB.Type>(options: {