@optolith/database-schema 0.99.0 → 0.101.0

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>;
-            translation: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
-                restriction: DB.MemberDecl<DB.String, true>;
+            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>;
+                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+            }>, []>>, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificApplicableCombatTechniqueTranslation", {
+                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,77 +272,84 @@ 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.",
+        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 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() }),
+        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, {
     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/_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/_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>;