@optolith/database-schema 0.98.0 → 0.100.0

package/lib/main.js

@@ -91,6 +91,7 @@ export const schema = new Schema([
     Types.IlluminationRefillOrSupply,
     Types.InstrumentEnchantment,
     Types.Item,
+    Types.ItemComponent,
     Types.JesterTrick,
     Types.Jewelry,
     Types.KarmaSpecialAbility,

package/lib/types/Locale.d.ts

@@ -1347,6 +1347,9 @@ export declare const Locale: DB.Entity<"Locale", {
         ".input {$count :number} {{{$count} more by primary patron}}": null;
         Patron: null;
         ".input {$count :number} {{Here you can select {$count} fitting special abilities.}}": null;
+        ".input {$count :number} {{{$previousList} as well as {$count} advanced special abilities}}": null;
+        ".input {$count :number} {{{$previousList} as well as {$count} advanced special abilities depending on {$option}}}": null;
+        ".input {$count :number} {{{$count} of the following list}}": null;
         "corresponding combat style special ability": null;
         "corresponding liturgical style special ability": null;
         "corresponding magic style special ability": null;
@@ -1476,16 +1479,22 @@ export declare const Locale: DB.Entity<"Locale", {
         Complex: null;
         Various: null;
         "Parrying weapon (PA bonus +1 for the main weapon)": null;
+        "{$variantArmor} is a type of {$baseArmor}.": null;
+        "{$variantHitZoneArmor} counts as {$baseArmor} for hit zone {$hitZone}.": null;
+        Arms: null;
+        Head: null;
+        Legs: null;
+        Torso: null;
+        "many shamans": null;
         "To buy this item during hero creation, the character must have Tradition ({$traditions}).": null;
         "To buy {$itemName} during hero creation, the character must have Tradition ({$traditions}).": null;
-        "Sanctified ({$traditions}); only {$blessedOnes} may purchase weapons sanctified by {$gods}, respectively.": null;
-        "Sanctified ({$tradition}); only {$blessedOnes} may purchase weapons sanctified by {$god}.": null;
+        "Sanctified ({$traditions})": null;
+        "only {$blessedOnes} may purchase weapons sanctified by {$gods}, respectively.": null;
+        "only {$blessedOnes} may purchase weapons sanctified by {$god}.": null;
         "To buy this item during hero creation, the character must be from {$cultures}.": null;
         "To buy {$itemName} during hero creation, the character must be from {$cultures}.": null;
         "To buy this item during hero creation, the character must have a shamanistic tradition.": null;
         "To buy {$itemName} during hero creation, the character must have a shamanistic tradition.": null;
-        "To buy this item during hero creation, the character must be from {$groupOfCultures}.": null;
-        "To buy {$itemName} during hero creation, the character must be from {$groupOfCultures}.": null;
         ".input {$value :number} {{{$value} inches}}": null;
         unlimited: null;
         "Structure Points": null;

package/lib/types/Locale.js

@@ -1382,6 +1382,9 @@ export const Locale = DB.Entity(import.meta.url, {
                 ".input {$count :number} {{{$count} more by primary patron}}": null,
                 "Patron": null,
                 ".input {$count :number} {{Here you can select {$count} fitting special abilities.}}": null,
+                ".input {$count :number} {{{$previousList} as well as {$count} advanced special abilities}}": null,
+                ".input {$count :number} {{{$previousList} as well as {$count} advanced special abilities depending on {$option}}}": null,
+                ".input {$count :number} {{{$count} of the following list}}": null,
                 "corresponding combat style special ability": null,
                 "corresponding liturgical style special ability": null,
                 "corresponding magic style special ability": null,
@@ -1518,16 +1521,22 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Complex": null,
                 "Various": null,
                 "Parrying weapon (PA bonus +1 for the main weapon)": null,
+                "{$variantArmor} is a type of {$baseArmor}.": null,
+                "{$variantHitZoneArmor} counts as {$baseArmor} for hit zone {$hitZone}.": null,
+                "Arms": null,
+                "Head": null,
+                "Legs": null,
+                "Torso": null,
+                "many shamans": null,
                 "To buy this item during hero creation, the character must have Tradition ({$traditions}).": null,
                 "To buy {$itemName} during hero creation, the character must have Tradition ({$traditions}).": null,
-                "Sanctified ({$traditions}); only {$blessedOnes} may purchase weapons sanctified by {$gods}, respectively.": null,
-                "Sanctified ({$tradition}); only {$blessedOnes} may purchase weapons sanctified by {$god}.": null,
+                "Sanctified ({$traditions})": null,
+                "only {$blessedOnes} may purchase weapons sanctified by {$gods}, respectively.": null,
+                "only {$blessedOnes} may purchase weapons sanctified by {$god}.": null,
                 "To buy this item during hero creation, the character must be from {$cultures}.": null,
                 "To buy {$itemName} during hero creation, the character must be from {$cultures}.": null,
                 "To buy this item during hero creation, the character must have a shamanistic tradition.": null,
                 "To buy {$itemName} during hero creation, the character must have a shamanistic tradition.": null,
-                "To buy this item during hero creation, the character must be from {$groupOfCultures}.": null,
-                "To buy {$itemName} during hero creation, the character must be from {$groupOfCultures}.": null,
                 ".input {$value :number} {{{$value} inches}}": null,
                 "unlimited": null,
                 "Structure Points": null,

package/lib/types/Profession.d.ts

@@ -157,6 +157,13 @@ export declare const Profession: DB.Entity<"Profession", {
                 liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
                     ap_value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
+                lockAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LockAdventurePointsOption", DB.Object<{
+                    apValue: DB.MemberDecl<DB.Integer, true>;
+                    entries: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                    }, []>>>, true>;
+                }>, []>>, false>;
             }>, []>>, false>;
             special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
                 Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleProfessionSpecialAbility", DB.Object<{
@@ -1054,6 +1061,13 @@ export declare const ProfessionVersion: DB.Entity<"ProfessionVersion", {
             liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
                 ap_value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, false>;
+            lockAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LockAdventurePointsOption", DB.Object<{
+                apValue: DB.MemberDecl<DB.Integer, true>;
+                entries: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                    Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>>, true>;
+            }>, []>>, false>;
         }>, []>>, false>;
         special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
             Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleProfessionSpecialAbility", DB.Object<{
@@ -1944,6 +1958,13 @@ export declare const ProfessionPackage: DB.Entity<"ProfessionPackage", {
         liturgies: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgiesOptions", DB.Object<{
             ap_value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, false>;
+        lockAdventurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"LockAdventurePointsOption", DB.Object<{
+            apValue: DB.MemberDecl<DB.Integer, true>;
+            entries: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>>, true>;
+        }>, []>>, false>;
     }>, []>>, false>;
     special_abilities: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ProfessionSpecialAbility", {
         Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleProfessionSpecialAbility", DB.Object<{

package/lib/types/Profession.js

@@ -514,6 +514,9 @@ const ProfessionPackageOptions = DB.TypeAlias(import.meta.url, {
         liturgies: DB.Optional({
             type: DB.IncludeIdentifier(LiturgiesOptions),
         }),
+        lockAdventurePoints: DB.Optional({
+            type: DB.IncludeIdentifier(LockAdventurePointsOption),
+        }),
     }, { minProperties: 1 }),
 });
 const ProfessionVariantPackageOptions = DB.TypeAlias(import.meta.url, {
@@ -768,6 +771,23 @@ const SpecialAbilitiesForAdventurePointsOption = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
+const LockAdventurePointsOption = DB.TypeAlias(import.meta.url, {
+    name: "LockAdventurePointsOption",
+    comment: `Keep AP for use after character creation to buy or improve entries.`,
+    type: () => DB.Object({
+        apValue: DB.Required({
+            comment: "The AP value that is going to be locked for later use.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        entries: DB.Required({
+            comment: "The entries the AP can be used for.",
+            type: DB.Array(DB.IncludeIdentifier(SpellworkIdentifier), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+    }),
+});
 const ProfessionName = DB.TypeAlias(import.meta.url, {
     name: "ProfessionName",
     comment: "The name of the profession that may have sex-specific names. Useful if the term in generell is different (i.e. actor/actress) or if the language uses gendered nouns. The default name is also used in case neither the male nor female name strictly applies.",

package/lib/types/_ActivatableAdvanced.d.ts

@@ -47,5 +47,33 @@ export declare const advanced: (identifier: DB.Type) => DB.MemberDecl<DB.Array<D
             }>, []>>>;
         }, []>>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+    ByOption: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AdvancedSpecialAbilityByOption", DB.Object<{
+        map: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AdvancedSpecialAbilityByOptionMapping", DB.Object<{
+            option: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            associatedAdvanced: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"AdvancedSpecialAbilityByOptionMappingRule", {
+                General: DB.EnumCase<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>>;
+                OneOf: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"OneOfAdvancedSpecialAbilityOptions", DB.Object<{
+                    options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>>, true>;
+                    is_selection_required_on_purchase: 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>;
+                }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+            }, [Identifier: DB.Param<"Identifier", DB.Type>]>>, true>;
+        }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, true>;
+        fallbackOption: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"AdvancedSpecialAbilityByOptionTranslation", {
+            label: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
     Any: DB.EnumCase<null>;
 }, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, true>;

package/lib/types/_ActivatableAdvanced.js

@@ -1,6 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
-import { MagicalTraditionIdentifier, PatronIdentifier } from "./_Identifier.js";
+import { GeneralSelectOptionIdentifier, MagicalTraditionIdentifier, PatronIdentifier, } from "./_Identifier.js";
 import { AdvancedSpecialAbilityRestrictedOptionIdentifier } from "./_IdentifierGroup.js";
+import { NestedTranslationMap } from "./Locale.js";
 import { DisplayOption } from "./prerequisites/DisplayOption.js";
 const AdvancedSpecialAbility = DB.GenEnum(import.meta.url, {
     name: "AdvancedSpecialAbility",
@@ -23,6 +24,9 @@ const AdvancedSpecialAbility = DB.GenEnum(import.meta.url, {
                 DB.TypeArgument(Identifier),
             ]),
         }),
+        ByOption: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(AdvancedSpecialAbilityByOption, [DB.TypeArgument(Identifier)]),
+        }),
         Any: DB.EnumCase({
             comment: "Any advanced special ability is possible.",
             type: null,
@@ -96,6 +100,58 @@ const AdvancedSpecialAbilityDerivedFromExternalOptionMapping = DB.GenTypeAlias(i
         }),
     }),
 });
+const AdvancedSpecialAbilityByOption = DB.GenTypeAlias(import.meta.url, {
+    name: "AdvancedSpecialAbilityByOption",
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        map: DB.Required({
+            comment: "Map options from the external entry to allowed advanced special abilities.",
+            type: DB.Array(DB.GenIncludeIdentifier(AdvancedSpecialAbilityByOptionMapping, [
+                DB.TypeArgument(Identifier),
+            ]), { minItems: 1 }),
+        }),
+        fallbackOption: DB.Optional({
+            comment: "One of the options counts all fallback options and should be sorted last in the list.",
+            type: GeneralSelectOptionIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "AdvancedSpecialAbilityByOption", DB.Object({
+            label: DB.Required({
+                comment: "How to label all options before listing each option with its advanced special ability/-ies.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+const AdvancedSpecialAbilityByOptionMapping = DB.GenTypeAlias(import.meta.url, {
+    name: "AdvancedSpecialAbilityByOptionMapping",
+    parameters: [DB.Param("Identifier")],
+    comment: "Mapping from an option of this entry to an allowed advanced special ability.",
+    type: Identifier => DB.Object({
+        option: DB.Required({
+            comment: "The select option’s identifier.",
+            type: PatronIdentifier(),
+        }),
+        associatedAdvanced: DB.Required({
+            comment: "The advanced special ability’s identifier.",
+            type: DB.GenIncludeIdentifier(AdvancedSpecialAbilityByOptionMappingRule, [
+                DB.TypeArgument(Identifier),
+            ]),
+        }),
+    }),
+});
+const AdvancedSpecialAbilityByOptionMappingRule = DB.GenEnum(import.meta.url, {
+    name: "AdvancedSpecialAbilityByOptionMappingRule",
+    comment: "A reference to an advanced special ability.",
+    parameters: [DB.Param("Identifier")],
+    values: Identifier => ({
+        General: DB.EnumCase({ type: DB.TypeArgument(Identifier) }),
+        OneOf: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(OneOfAdvancedSpecialAbilityOptions, [
+                DB.TypeArgument(Identifier),
+            ]),
+        }),
+    }),
+});
 export const advanced = (identifier) => DB.Required({
     comment: "The Advanced Special Abilities for the respective Style Special Ability. Sometimes, only a specific select option or a set of select options of an entry is allowed, which can be modelled by the option property. It can also be that you can choose from a set of special abilities, but then you can’t specify an option.",
     type: DB.Array(DB.GenIncludeIdentifier(AdvancedSpecialAbility, [identifier]), {

package/lib/types/_ActivatableCombat.d.ts

@@ -69,41 +69,44 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
     None: DB.EnumCase<null>;
     DependingOnCombatStyle: DB.EnumCase<null>;
     All: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCombatTechniques", DB.Object<{
-        restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
-            Improvised: DB.EnumCase<null>;
-            PointedBlade: DB.EnumCase<null>;
-            Mount: DB.EnumCase<null>;
-            Race: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesRaceRestriction", DB.ReferenceIdentifier, []>>>;
-            ExcludeCombatTechniques: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ApplicableCombatTechniquesNegativeCombatTechniquesRestriction", DB.Object<{
+        restrictions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableAllCombatTechniquesRestrictions", DB.Object<{
+            isImprovised: DB.MemberDecl<DB.Boolean, false>;
+            hasPointedBlade: DB.MemberDecl<DB.Boolean, false>;
+            whileMounted: DB.MemberDecl<DB.Boolean, false>;
+            race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            excludeCombatTechniques: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ApplicableCombatTechniquesNegativeCombatTechniquesRestriction", DB.Object<{
                 list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Ref", DB.Type>>>, true>;
-            }>, [Ref: DB.Param<"Ref", DB.Type>]>>>;
-        }, []>>, false>;
+            }>, [Ref: DB.Param<"Ref", DB.Type>]>>, false>;
+        }>, []>>, false>;
     }>, []>>>;
     AllClose: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCloseCombatTechniques", DB.Object<{
-        restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
-            Improvised: DB.EnumCase<null>;
-            PointedBlade: DB.EnumCase<null>;
-            Mount: DB.EnumCase<null>;
-            HasParry: DB.EnumCase<null>;
-            OneHanded: DB.EnumCase<null>;
-            TwoHanded: DB.EnumCase<null>;
-            ParryingWeapon: DB.EnumCase<null>;
-            Race: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesRaceRestriction", DB.ReferenceIdentifier, []>>>;
-            ExcludeCombatTechniques: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ApplicableCombatTechniquesNegativeCombatTechniquesRestriction", DB.Object<{
+        restrictions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCloseCombatTechniquesRestrictions", DB.Object<{
+            isImprovised: DB.MemberDecl<DB.Boolean, false>;
+            hasPointedBlade: DB.MemberDecl<DB.Boolean, false>;
+            whileMounted: DB.MemberDecl<DB.Boolean, false>;
+            hasParry: DB.MemberDecl<DB.Boolean, false>;
+            isOneHanded: DB.MemberDecl<DB.Boolean, false>;
+            isTwoHanded: DB.MemberDecl<DB.Boolean, false>;
+            isParryingWeapon: DB.MemberDecl<DB.Boolean, false>;
+            race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            weaponClass: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MeleeWeaponClass", {
+                Axe: DB.EnumCase<null>;
+            }, []>>, false>;
+            excludeCombatTechniques: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ApplicableCombatTechniquesNegativeCombatTechniquesRestriction", DB.Object<{
                 list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Ref", DB.Type>>>, true>;
-            }>, [Ref: DB.Param<"Ref", DB.Type>]>>>;
-        }, []>>, false>;
+            }>, [Ref: DB.Param<"Ref", DB.Type>]>>, false>;
+        }>, []>>, false>;
     }>, []>>>;
     AllRanged: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableRangedCombatTechniques", DB.Object<{
-        restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
-            Improvised: DB.EnumCase<null>;
-            PointedBlade: DB.EnumCase<null>;
-            Mount: DB.EnumCase<null>;
-            Race: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesRaceRestriction", DB.ReferenceIdentifier, []>>>;
-            ExcludeCombatTechniques: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ApplicableCombatTechniquesNegativeCombatTechniquesRestriction", DB.Object<{
+        restrictions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableRangedCombatTechniquesRestrictions", DB.Object<{
+            isImprovised: DB.MemberDecl<DB.Boolean, false>;
+            hasPointedBlade: DB.MemberDecl<DB.Boolean, false>;
+            whileMounted: DB.MemberDecl<DB.Boolean, false>;
+            race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            excludeCombatTechniques: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"ApplicableCombatTechniquesNegativeCombatTechniquesRestriction", DB.Object<{
                 list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Ref", DB.Type>>>, true>;
-            }>, [Ref: DB.Param<"Ref", DB.Type>]>>>;
-        }, []>>, false>;
+            }>, [Ref: DB.Param<"Ref", DB.Type>]>>, false>;
+        }>, []>>, false>;
     }>, []>>>;
     Specific: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechniques", DB.Object<{
         list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechnique", DB.Object<{
@@ -111,20 +114,21 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
                 CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>, true>;
-            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
-                Improvised: DB.EnumCase<null>;
-                PointedBlade: DB.EnumCase<null>;
-                Mount: DB.EnumCase<null>;
-                Race: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesRaceRestriction", DB.ReferenceIdentifier, []>>>;
-                Level: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesLevelRestriction", DB.Object<{
-                    level: DB.MemberDecl<DB.Integer, true>;
-                }>, []>>>;
-                OneBluntSide: DB.EnumCase<null>;
-            }, []>>, false>;
+            restrictions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableSpecificCombatTechniquesRestrictions", DB.Object<{
+                isImprovised: DB.MemberDecl<DB.Boolean, false>;
+                hasPointedBlade: DB.MemberDecl<DB.Boolean, false>;
+                whileMounted: DB.MemberDecl<DB.Boolean, false>;
+                race: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                level: DB.MemberDecl<DB.Integer, false>;
+                hasOneBluntSide: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, false>;
             translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
-                restriction: DB.MemberDecl<DB.String, true>;
+                restrictions: DB.MemberDecl<DB.String, true>;
             }>, false>;
             weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         }>, []>>>, true>;
     }>, []>>>;
 }, []>>, true>;
+export declare const MeleeWeaponClass: DB.Enum<"MeleeWeaponClass", {
+    Axe: DB.EnumCase<null>;
+}, []>;

package/lib/types/_ActivatableCombat.js

@@ -237,24 +237,24 @@ export const combat_techniques = DB.Required({
 const AllApplicableCombatTechniques = DB.TypeAlias(import.meta.url, {
     name: "AllApplicableCombatTechniques",
     type: () => DB.Object({
-        restriction: DB.Optional({
-            type: DB.IncludeIdentifier(ApplicableAllCombatTechniquesRestriction),
+        restrictions: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableAllCombatTechniquesRestrictions),
         }),
     }),
 });
 const AllApplicableCloseCombatTechniques = DB.TypeAlias(import.meta.url, {
     name: "AllApplicableCloseCombatTechniques",
     type: () => DB.Object({
-        restriction: DB.Optional({
-            type: DB.IncludeIdentifier(ApplicableCloseCombatTechniquesRestriction),
+        restrictions: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableCloseCombatTechniquesRestrictions),
         }),
     }),
 });
 const AllApplicableRangedCombatTechniques = DB.TypeAlias(import.meta.url, {
     name: "AllApplicableRangedCombatTechniques",
     type: () => DB.Object({
-        restriction: DB.Optional({
-            type: DB.IncludeIdentifier(ApplicableRangedCombatTechniquesRestriction),
+        restrictions: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableRangedCombatTechniquesRestrictions),
         }),
     }),
 });
@@ -272,12 +272,12 @@ const SpecificApplicableCombatTechnique = DB.TypeAlias(import.meta.url, {
         id: DB.Required({
             type: DB.IncludeIdentifier(CombatTechniqueIdentifier),
         }),
-        restriction: DB.Optional({
-            type: DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestriction),
+        restrictions: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestrictions),
         }),
         translation: NestedTranslationMap(DB.Optional, "SpecificApplicableCombatTechnique", DB.Object({
-            restriction: DB.Required({
-                comment: "The additional restriction of the combat technique.",
+            restrictions: DB.Required({
+                comment: "The additional restriction(s) of the combat technique.",
                 type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
         })),
@@ -287,62 +287,69 @@ const SpecificApplicableCombatTechnique = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
-const ApplicableAllCombatTechniquesRestriction = DB.Enum(import.meta.url, {
-    name: "ApplicableAllCombatTechniquesRestriction",
-    values: () => ({
-        Improvised: DB.EnumCase({ type: null }),
-        PointedBlade: DB.EnumCase({ type: null }),
-        Mount: DB.EnumCase({ type: null }),
-        Race: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesRaceRestriction) }),
-        ExcludeCombatTechniques: DB.EnumCase({
-            type: DB.GenIncludeIdentifier(ApplicableCombatTechniquesNegativeCombatTechniquesRestriction, [
-                DB.IncludeIdentifier(CombatTechniqueIdentifier),
-            ]),
+const ApplicableAllCombatTechniquesRestrictions = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableAllCombatTechniquesRestrictions",
+    type: () => DB.Object({
+        isImprovised: DB.Optional({ type: DB.Boolean() }),
+        hasPointedBlade: DB.Optional({ type: DB.Boolean() }),
+        whileMounted: DB.Optional({ type: DB.Boolean() }),
+        race: DB.Optional({ type: RaceIdentifier() }),
+        excludeCombatTechniques: DB.Optional({
+            type: DB.GenIncludeIdentifier(ApplicableCombatTechniquesNegativeCombatTechniquesRestriction, [DB.IncludeIdentifier(CombatTechniqueIdentifier)]),
         }),
-    }),
+    }, { minProperties: 1 }),
 });
-const ApplicableCloseCombatTechniquesRestriction = DB.Enum(import.meta.url, {
-    name: "ApplicableCloseCombatTechniquesRestriction",
+const ApplicableCloseCombatTechniquesRestrictions = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableCloseCombatTechniquesRestrictions",
+    type: () => DB.Object({
+        isImprovised: DB.Optional({ type: DB.Boolean() }),
+        hasPointedBlade: DB.Optional({ type: DB.Boolean() }),
+        whileMounted: DB.Optional({ type: DB.Boolean() }),
+        hasParry: DB.Optional({ type: DB.Boolean() }),
+        isOneHanded: DB.Optional({ type: DB.Boolean() }),
+        isTwoHanded: DB.Optional({ type: DB.Boolean() }),
+        isParryingWeapon: DB.Optional({ type: DB.Boolean() }),
+        race: DB.Optional({ type: RaceIdentifier() }),
+        weaponClass: DB.Optional({
+            comment: "Only a class of melee weapon is allowed",
+            type: DB.IncludeIdentifier(MeleeWeaponClass),
+        }),
+        excludeCombatTechniques: DB.Optional({
+            type: DB.GenIncludeIdentifier(ApplicableCombatTechniquesNegativeCombatTechniquesRestriction, [CloseCombatTechniqueIdentifier()]),
+        }),
+    }, { minProperties: 1 }),
+});
+export const MeleeWeaponClass = DB.Enum(import.meta.url, {
+    name: "MeleeWeaponClass",
     values: () => ({
-        Improvised: DB.EnumCase({ type: null }),
-        PointedBlade: DB.EnumCase({ type: null }),
-        Mount: DB.EnumCase({ type: null }),
-        HasParry: DB.EnumCase({ type: null }),
-        OneHanded: DB.EnumCase({ type: null }),
-        TwoHanded: DB.EnumCase({ type: null }),
-        ParryingWeapon: DB.EnumCase({ type: null }),
-        Race: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesRaceRestriction) }),
-        ExcludeCombatTechniques: DB.EnumCase({
-            type: DB.GenIncludeIdentifier(ApplicableCombatTechniquesNegativeCombatTechniquesRestriction, [
-                CloseCombatTechniqueIdentifier(),
-            ]),
-        }),
+        Axe: DB.EnumCase({ type: null }),
     }),
 });
-const ApplicableRangedCombatTechniquesRestriction = DB.Enum(import.meta.url, {
-    name: "ApplicableRangedCombatTechniquesRestriction",
-    values: () => ({
-        Improvised: DB.EnumCase({ type: null }),
-        PointedBlade: DB.EnumCase({ type: null }),
-        Mount: DB.EnumCase({ type: null }),
-        Race: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesRaceRestriction) }),
-        ExcludeCombatTechniques: DB.EnumCase({
-            type: DB.GenIncludeIdentifier(ApplicableCombatTechniquesNegativeCombatTechniquesRestriction, [
-                RangedCombatTechniqueIdentifier(),
-            ]),
+const ApplicableRangedCombatTechniquesRestrictions = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableRangedCombatTechniquesRestrictions",
+    type: () => DB.Object({
+        isImprovised: DB.Optional({ type: DB.Boolean() }),
+        hasPointedBlade: DB.Optional({ type: DB.Boolean() }),
+        whileMounted: DB.Optional({ type: DB.Boolean() }),
+        race: DB.Optional({ type: RaceIdentifier() }),
+        excludeCombatTechniques: DB.Optional({
+            type: DB.GenIncludeIdentifier(ApplicableCombatTechniquesNegativeCombatTechniquesRestriction, [RangedCombatTechniqueIdentifier()]),
         }),
-    }),
+    }, { minProperties: 1 }),
 });
-const ApplicableSpecificCombatTechniquesRestriction = DB.Enum(import.meta.url, {
-    name: "ApplicableSpecificCombatTechniquesRestriction",
-    values: () => ({
-        Improvised: DB.EnumCase({ type: null }),
-        PointedBlade: DB.EnumCase({ type: null }),
-        Mount: DB.EnumCase({ type: null }),
-        Race: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesRaceRestriction) }),
-        Level: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesLevelRestriction) }),
-        OneBluntSide: DB.EnumCase({ type: null }),
-    }),
+const ApplicableSpecificCombatTechniquesRestrictions = DB.TypeAlias(import.meta.url, {
+    name: "ApplicableSpecificCombatTechniquesRestrictions",
+    type: () => DB.Object({
+        isImprovised: DB.Optional({ type: DB.Boolean() }),
+        hasPointedBlade: DB.Optional({ type: DB.Boolean() }),
+        whileMounted: DB.Optional({ type: DB.Boolean() }),
+        race: DB.Optional({ type: RaceIdentifier() }),
+        level: DB.Optional({
+            comment: "The combat special ability is only applicable on a certain level.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        hasOneBluntSide: DB.Optional({ type: DB.Boolean() }),
+    }, { minProperties: 1 }),
 });
 const ApplicableCombatTechniquesNegativeCombatTechniquesRestriction = DB.GenTypeAlias(import.meta.url, {
     name: "ApplicableCombatTechniquesNegativeCombatTechniquesRestriction",
@@ -354,16 +361,3 @@ const ApplicableCombatTechniquesNegativeCombatTechniquesRestriction = DB.GenType
         }),
     }),
 });
-const ApplicableCombatTechniquesRaceRestriction = DB.TypeAlias(import.meta.url, {
-    name: "ApplicableCombatTechniquesRaceRestriction",
-    type: () => RaceIdentifier(),
-});
-const ApplicableCombatTechniquesLevelRestriction = DB.TypeAlias(import.meta.url, {
-    name: "ApplicableCombatTechniquesLevelRestriction",
-    type: () => DB.Object({
-        level: DB.Required({
-            comment: "The combat special ability is only applicable on a certain level.",
-            type: DB.Integer({ minimum: 1 }),
-        }),
-    }),
-});

package/lib/types/_Identifier.d.ts

@@ -89,6 +89,7 @@ export declare const IlluminationRefillOrSupplyIdentifier: () => R;
 export declare const InfluenceIdentifier: () => R;
 export declare const InstrumentEnchantmentIdentifier: () => R;
 export declare const ItemIdentifier: () => R;
+export declare const ItemComponentIdentifier: () => R;
 export declare const JesterTrickIdentifier: () => R;
 export declare const JewelryIdentifier: () => R;
 export declare const KarmaSpecialAbilityIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -39,6 +39,7 @@ import { HerbalPreservation } from "./equipment/item/HerbalPreservation.js";
 import { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js";
 import { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js";
 import { Item } from "./equipment/item/Item.js";
+import { ItemComponent } from "./equipment/item/ItemComponent.js";
 import { Jewelry } from "./equipment/item/Jewelry.js";
 import { Laboratory } from "./equipment/item/Laboratory.js";
 import { Liebesspielzeug } from "./equipment/item/Liebesspielzeug.js";
@@ -258,6 +259,7 @@ export const IlluminationRefillOrSupplyIdentifier = () => R(IlluminationRefillOr
 export const InfluenceIdentifier = () => R(Influence);
 export const InstrumentEnchantmentIdentifier = () => R(InstrumentEnchantment);
 export const ItemIdentifier = () => R(Item);
+export const ItemComponentIdentifier = () => R(ItemComponent);
 export const JesterTrickIdentifier = () => R(JesterTrick);
 export const JewelryIdentifier = () => R(Jewelry);
 export const KarmaSpecialAbilityIdentifier = () => R(KarmaSpecialAbility);

package/lib/types/_IdentifierGroup.d.ts

@@ -448,6 +448,7 @@ export declare const EquipmentIdentifier: DB.Enum<"EquipmentIdentifier", {
     GemOrPreciousStone: DB.EnumCase<DB.ReferenceIdentifier>;
     IlluminationLightSource: DB.EnumCase<DB.ReferenceIdentifier>;
     IlluminationRefillOrSupply: DB.EnumCase<DB.ReferenceIdentifier>;
+    ItemComponent: DB.EnumCase<DB.ReferenceIdentifier>;
     Jewelry: DB.EnumCase<DB.ReferenceIdentifier>;
     Laboratory: DB.EnumCase<DB.ReferenceIdentifier>;
     Liebesspielzeug: DB.EnumCase<DB.ReferenceIdentifier>;