@optolith/database-schema 0.100.0 → 0.102.0

package/lib/types/_ActivatableCombat.d.ts

@@ -121,11 +121,11 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
                 race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
                 level: DB.MemberDecl<DB.Integer, false>;
                 hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>, false>;
-            translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+            translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
                 restrictions: DB.MemberDecl<DB.String, true>;
             }>, false>;
-            weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         }>, []>>>, true>;
     }>, []>>>;
 }, []>>, true>;

package/lib/types/_ActivatableCombat.js

@@ -275,16 +275,12 @@ const SpecificApplicableCombatTechnique = DB.TypeAlias(import.meta.url, {
         restrictions: DB.Optional({
             type: DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestrictions),
         }),
-        translation: NestedTranslationMap(DB.Optional, "SpecificApplicableCombatTechnique", DB.Object({
+        translations: NestedTranslationMap(DB.Optional, "SpecificApplicableCombatTechnique", DB.Object({
             restrictions: DB.Required({
                 comment: "The additional restriction(s) of the combat technique.",
                 type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         })),
-        weapons: DB.Optional({
-            comment: "The specific weapons this combat special ability is only applicable to.",
-            type: DB.Array(WeaponIdentifier(), { minItems: 1 }),
-        }),
     }),
 });
 const ApplicableAllCombatTechniquesRestrictions = DB.TypeAlias(import.meta.url, {
@@ -349,6 +345,10 @@ const ApplicableSpecificCombatTechniquesRestrictions = DB.TypeAlias(import.meta.
             type: DB.Integer({ minimum: 1 }),
         }),
         hasOneBluntSide: DB.Optional({ type: DB.Boolean() }),
+        weapons: DB.Optional({
+            comment: "The specific weapons this combat special ability is only applicable to.",
+            type: DB.Array(WeaponIdentifier(), { minItems: 1 }),
+        }),
     }, { minProperties: 1 }),
 });
 const ApplicableCombatTechniquesNegativeCombatTechniquesRestriction = DB.GenTypeAlias(import.meta.url, {

package/lib/types/_CommonnessRatedAdvantageDisadvantage.d.ts

@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
-export declare const CommonnessRatedAdvantageDisadvantage: DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+export declare const SingleCommonnessRatedAdvantageDisadvantage: DB.TypeAlias<"SingleCommonnessRatedAdvantageDisadvantage", DB.Object<{
     id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
     level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
         Constant: DB.EnumCase<DB.Integer>;
@@ -31,9 +31,87 @@ export declare const CommonnessRatedAdvantageDisadvantage: DB.TypeAlias<"Commonn
         ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
         Element: DB.EnumCase<DB.ReferenceIdentifier>;
     }, []>>>, false>;
-    translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SingleCommonnessRatedAdvantageDisadvantageTranslation", {
         options: DB.MemberDecl<DB.String, false>;
         note: DB.MemberDecl<DB.String, false>;
         full: DB.MemberDecl<DB.String, false>;
     }>, false>;
 }>, [Identifier: DB.Param<"Identifier", DB.Type>]>;
+export declare const CommonnessRatedAdvantageDisadvantage: DB.Enum<"CommonnessRatedAdvantageDisadvantage", {
+    Single: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"SingleCommonnessRatedAdvantageDisadvantage", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
+            Constant: DB.EnumCase<DB.Integer>;
+            Range: DB.EnumCase<DB.Object<{
+                min: DB.MemberDecl<DB.Integer, true>;
+                max: DB.MemberDecl<DB.Integer, true>;
+            }>>;
+        }, []>>, false>;
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+            SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
+            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>;
+            Disease: DB.EnumCase<DB.ReferenceIdentifier>;
+            Poison: 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>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SingleCommonnessRatedAdvantageDisadvantageTranslation", {
+            options: DB.MemberDecl<DB.String, false>;
+            note: DB.MemberDecl<DB.String, false>;
+            full: DB.MemberDecl<DB.String, false>;
+        }>, false>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+    Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantageGroup", DB.Object<{
+        list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"SingleCommonnessRatedAdvantageDisadvantageInGroup", DB.Object<{
+            id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+            level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, true>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"CommonnessSelectOptionIdentifier", {
+                SkillGroup: DB.EnumCase<DB.ReferenceIdentifier>;
+                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>;
+                Disease: DB.EnumCase<DB.ReferenceIdentifier>;
+                Poison: 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>;
+        }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageGroupTranslation", {
+            text: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+}, [Identifier: DB.Param<"Identifier", DB.Type>]>;

package/lib/types/_CommonnessRatedAdvantageDisadvantage.js

@@ -1,8 +1,8 @@
 import * as DB from "tsondb/schema/dsl";
 import { CommonnessSelectOptionIdentifier } from "./_IdentifierGroup.js";
 import { NestedTranslationMap } from "./Locale.js";
-export const CommonnessRatedAdvantageDisadvantage = DB.GenTypeAlias(import.meta.url, {
-    name: "CommonnessRatedAdvantageDisadvantage",
+export const SingleCommonnessRatedAdvantageDisadvantage = DB.GenTypeAlias(import.meta.url, {
+    name: "SingleCommonnessRatedAdvantageDisadvantage",
     comment: "Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.",
     parameters: [DB.Param("Identifier")],
     type: Identifier => DB.Object({
@@ -18,7 +18,7 @@ export const CommonnessRatedAdvantageDisadvantage = DB.GenTypeAlias(import.meta.
             comment: "The options the commonness rating applies to.",
             type: DB.Array(DB.IncludeIdentifier(CommonnessSelectOptionIdentifier), { minItems: 1 }),
         }),
-        translations: NestedTranslationMap(DB.Optional, "CommonnessRatedAdvantageDisadvantage", DB.Object({
+        translations: NestedTranslationMap(DB.Optional, "SingleCommonnessRatedAdvantageDisadvantage", DB.Object({
             options: DB.Optional({
                 comment: "The options the commonness rating applies to. This can be specified if plain options cannot exactly describe the options as written in the publication.",
                 type: DB.String({ minLength: 1 }),
@@ -47,3 +47,58 @@ const CommonnessRatedAdvantageDisadvantageLevel = DB.Enum(import.meta.url, {
         }),
     }),
 });
+const SingleCommonnessRatedAdvantageDisadvantageInGroup = DB.GenTypeAlias(import.meta.url, {
+    name: "SingleCommonnessRatedAdvantageDisadvantageInGroup",
+    comment: "Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.",
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        id: DB.Required({
+            comment: "The advantage’s or disadvantage’s identifier.",
+            type: DB.TypeArgument(Identifier),
+        }),
+        level: DB.Optional({
+            comment: "The level of a commonness-rated advantage or disadvantage.",
+            type: DB.IncludeIdentifier(CommonnessRatedAdvantageDisadvantageLevel),
+        }),
+        options: DB.Optional({
+            comment: "The options the commonness rating applies to.",
+            type: DB.Array(DB.IncludeIdentifier(CommonnessSelectOptionIdentifier), { minItems: 1 }),
+        }),
+    }),
+});
+const CommonnessRatedAdvantageDisadvantageGroup = DB.GenTypeAlias(import.meta.url, {
+    name: "CommonnessRatedAdvantageDisadvantageGroup",
+    comment: "Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.",
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        list: DB.Required({
+            type: DB.Array(DB.GenIncludeIdentifier(SingleCommonnessRatedAdvantageDisadvantageInGroup, [
+                DB.TypeArgument(Identifier),
+            ]), {
+                minItems: 2,
+            }),
+        }),
+        translations: NestedTranslationMap(DB.Required, "CommonnessRatedAdvantageDisadvantageGroup", DB.Object({
+            text: DB.Required({
+                comment: "The text replacing all entries in the group.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+        })),
+    }),
+});
+export const CommonnessRatedAdvantageDisadvantage = DB.GenEnum(import.meta.url, {
+    name: "CommonnessRatedAdvantageDisadvantage",
+    parameters: [DB.Param("Identifier")],
+    values: Identifier => ({
+        Single: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(SingleCommonnessRatedAdvantageDisadvantage, [
+                DB.TypeArgument(Identifier),
+            ]),
+        }),
+        Group: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantageGroup, [
+                DB.TypeArgument(Identifier),
+            ]),
+        }),
+    }),
+});

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

@@ -31,18 +31,30 @@ export declare const ItemComponent: DB.Entity<"ItemComponent", {
         Factor: DB.EnumCase<DB.Float>;
         DerivedFromOption: DB.EnumCase<null>;
     }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, false>;
     applicableItems: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableItems", {
         MeleeWeapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableMeleeWeapons", DB.Object<{
             weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
-            combatTechniques: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            combatTechniques: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableMeleeCombatTechnique", DB.Object<{
+                combatTechnique: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ApplicableMeleeCombatTechniqueTranslation", {
+                    text: DB.MemberDecl<DB.String, true>;
+                }>, false>;
+            }>, []>>>, false>;
             category: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableMeleeWeaponCategory", {
                 HasMetalSurface: DB.EnumCase<null>;
                 HasMetalBladeOrTip: DB.EnumCase<null>;
+                HasWrappableHandle: DB.EnumCase<null>;
             }, []>>, false>;
         }>, []>>>;
         RangedWeapon: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableRangedWeapons", DB.Object<{
             weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
-            combatTechniques: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            combatTechniques: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableRangedCombatTechnique", DB.Object<{
+                combatTechnique: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ApplicableRangedCombatTechniqueTranslation", {
+                    text: DB.MemberDecl<DB.String, true>;
+                }>, false>;
+            }>, []>>>, false>;
             minimumReloadTime: DB.MemberDecl<DB.Integer, false>;
             usesBullets: DB.MemberDecl<DB.Boolean, false>;
         }>, []>>>;

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

@@ -4,7 +4,7 @@ import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechniq
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
-import { FixedCost } from "./_Item.js";
+import { FixedCost, Weight } from "./_Item.js";
 export const ItemComponent = DB.Entity(import.meta.url, {
     name: "ItemComponent",
     namePlural: "ItemComponents",
@@ -16,6 +16,10 @@ export const ItemComponent = DB.Entity(import.meta.url, {
             comment: ItemComponentCost.comment,
             type: DB.IncludeIdentifier(ItemComponentCost),
         }),
+        weight: DB.Optional({
+            comment: "The weight in kg.",
+            type: DB.IncludeIdentifier(Weight),
+        }),
         applicableItems: DB.Required({
             comment: "The items the component can be applied to.",
             type: DB.IncludeIdentifier(ApplicableItems),
@@ -116,12 +120,7 @@ const ItemComponentCostByCombatTechnique = DB.TypeAlias(import.meta.url, {
                         comment: "The cost in silverthalers for the close combat technique.",
                         type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
                     }),
-                    translations: NestedTranslationMap(DB.Optional, "ItemComponentCostByCloseCombatTechnique", DB.Object({
-                        label: DB.Required({
-                            comment: "The label for cost, if different from the name of the combat technique.",
-                            type: DB.String({ minLength: 1 }),
-                        }),
-                    })),
+                    translations: NestedTranslationMap(DB.Optional, "ItemComponentCostByCloseCombatTechnique", DB.IncludeIdentifier(ItemComponentCostByCombatTechniqueTranslation)),
                 }),
             }),
         }),
@@ -136,17 +135,21 @@ const ItemComponentCostByCombatTechnique = DB.TypeAlias(import.meta.url, {
                         comment: "The cost in silverthalers for the ranged combat technique.",
                         type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
                     }),
-                    translations: NestedTranslationMap(DB.Optional, "ItemComponentCostByRangedCombatTechnique", DB.Object({
-                        label: DB.Required({
-                            comment: "The label for cost, if different from the name of the combat technique.",
-                            type: DB.String({ minLength: 1 }),
-                        }),
-                    })),
+                    translations: NestedTranslationMap(DB.Optional, "ItemComponentCostByRangedCombatTechnique", DB.IncludeIdentifier(ItemComponentCostByCombatTechniqueTranslation)),
                 }),
             }),
         }),
     }, { minProperties: 1 }),
 });
+const ItemComponentCostByCombatTechniqueTranslation = DB.TypeAlias(import.meta.url, {
+    name: "ItemComponentCostByCombatTechniqueTranslation",
+    type: () => DB.Object({
+        label: DB.Required({
+            comment: "The label for cost, if different from the name of the combat technique.",
+            type: DB.String({ minLength: 1 }),
+        }),
+    }),
+});
 const ApplicableItems = DB.Enum(import.meta.url, {
     name: "ApplicableItems",
     comment: "The items the component can be applied to.",
@@ -169,7 +172,7 @@ const ApplicableMeleeWeapons = DB.TypeAlias(import.meta.url, {
         }),
         combatTechniques: DB.Optional({
             comment: "Weapons of combat techniques this component can be applied to.",
-            type: DB.Array(CloseCombatTechniqueIdentifier(), {
+            type: DB.Array(DB.IncludeIdentifier(ApplicableMeleeCombatTechnique), {
                 minItems: 1,
                 uniqueItems: true,
             }),
@@ -180,11 +183,27 @@ const ApplicableMeleeWeapons = DB.TypeAlias(import.meta.url, {
         }),
     }, { minProperties: 1 }),
 });
+const ApplicableMeleeCombatTechnique = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableMeleeCombatTechnique",
+    type: () => DB.Object({
+        combatTechnique: DB.Required({
+            comment: "The combat technique this component can be applied to.",
+            type: CloseCombatTechniqueIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "ApplicableMeleeCombatTechnique", DB.Object({
+            text: DB.Required({
+                comment: "The name that should be displayed if the name of combat technique should not be used.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
 const ApplicableMeleeWeaponCategory = DB.Enum(import.meta.url, {
     name: "ApplicableMeleeWeaponCategory",
     values: () => ({
         HasMetalSurface: DB.EnumCase({ type: null }),
         HasMetalBladeOrTip: DB.EnumCase({ type: null }),
+        HasWrappableHandle: DB.EnumCase({ type: null }),
     }),
 });
 const ApplicableRangedWeapons = DB.TypeAlias(import.meta.url, {
@@ -199,7 +218,7 @@ const ApplicableRangedWeapons = DB.TypeAlias(import.meta.url, {
         }),
         combatTechniques: DB.Optional({
             comment: "Weapons of combat techniques this component can be applied to.",
-            type: DB.Array(RangedCombatTechniqueIdentifier(), {
+            type: DB.Array(DB.IncludeIdentifier(ApplicableRangedCombatTechnique), {
                 minItems: 1,
                 uniqueItems: true,
             }),
@@ -214,6 +233,21 @@ const ApplicableRangedWeapons = DB.TypeAlias(import.meta.url, {
         }),
     }, { minProperties: 1 }),
 });
+const ApplicableRangedCombatTechnique = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableRangedCombatTechnique",
+    type: () => DB.Object({
+        combatTechnique: DB.Required({
+            comment: "The combat technique this component can be applied to.",
+            type: RangedCombatTechniqueIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "ApplicableRangedCombatTechnique", DB.Object({
+            text: DB.Required({
+                comment: "The name that should be displayed if the name of combat technique should not be used.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
 const ApplicableAmmunition = DB.TypeAlias(import.meta.url, {
     name: "ApplicableAmmunition",
     type: () => DB.Object({

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

@@ -762,6 +762,25 @@ export declare const ProfessionPrerequisiteGroup: DB.Enum<"ProfessionPrerequisit
             }>, []>>>;
         }, []>>, false>;
     }>, []>>>;
+    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>;
+        active: DB.MemberDecl<DB.Boolean, 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", {
             ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -89,6 +89,7 @@ export const ProfessionPrerequisiteGroup = DB.Enum(import.meta.url, {
         Sex: DB.EnumCase({ type: DB.IncludeIdentifier(SexPrerequisite) }),
         Race: DB.EnumCase({ type: DB.IncludeIdentifier(RacePrerequisite) }),
         Culture: DB.EnumCase({ type: DB.IncludeIdentifier(CulturePrerequisite) }),
+        Rule: DB.EnumCase({ type: DB.IncludeIdentifier(RulePrerequisite) }),
         Activatable: DB.EnumCase({ type: DB.IncludeIdentifier(ActivatablePrerequisite) }),
         Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
         RatedMinimumNumber: DB.EnumCase({

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

@@ -1268,11 +1268,11 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                     race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
                     level: DB.MemberDecl<DB.Integer, false>;
                     hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+                    weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 }>, []>>, false>;
-                translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
                     restrictions: DB.MemberDecl<DB.String, true>;
                 }>, false>;
-                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

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

@@ -1158,11 +1158,11 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
                     race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
                     level: DB.MemberDecl<DB.Integer, false>;
                     hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+                    weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 }>, []>>, false>;
-                translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
                     restrictions: DB.MemberDecl<DB.String, true>;
                 }>, false>;
-                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

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

@@ -1264,11 +1264,11 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
                     race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
                     level: DB.MemberDecl<DB.Integer, false>;
                     hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+                    weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 }>, []>>, false>;
-                translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
                     restrictions: DB.MemberDecl<DB.String, true>;
                 }>, false>;
-                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

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

@@ -1345,11 +1345,11 @@ export declare const CombatStyleSpecialAbility: DB.Entity<"CombatStyleSpecialAbi
                     race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
                     level: DB.MemberDecl<DB.Integer, false>;
                     hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+                    weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 }>, []>>, false>;
-                translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
                     restrictions: DB.MemberDecl<DB.String, true>;
                 }>, false>;
-                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

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

@@ -1158,11 +1158,11 @@ export declare const CommandSpecialAbility: DB.Entity<"CommandSpecialAbility", {
                     race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
                     level: DB.MemberDecl<DB.Integer, false>;
                     hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+                    weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 }>, []>>, false>;
-                translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+                translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
                     restrictions: DB.MemberDecl<DB.String, true>;
                 }>, false>;
-                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.100.0",
+  "version": "0.102.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",
@@ -39,7 +39,7 @@
   "license": "MPL-2.0",
   "dependencies": {
     "@elyukai/utils": "^0.3.6",
-    "tsondb": "^0.21.5"
+    "tsondb": "^0.21.10"
   },
   "devDependencies": {
     "@elyukai/oxc-config": "^0.1.0",