optolith-database-schema 0.29.1 → 0.30.1

package/lib/types/_ActivatableCombat.d.ts

@@ -65,7 +65,7 @@ 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<{
-        restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
+        restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
             Improvised: DB.EnumCase<null>;
             PointedBlade: DB.EnumCase<null>;
             Mount: DB.EnumCase<null>;
@@ -73,10 +73,10 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
             ExcludeCombatTechniques: DB.EnumCase<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>;
+        }, []>>, false>;
     }>, []>>>;
     AllClose: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCloseCombatTechniques", DB.Object<{
-        restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
+        restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
             Improvised: DB.EnumCase<null>;
             PointedBlade: DB.EnumCase<null>;
             Mount: DB.EnumCase<null>;
@@ -88,10 +88,10 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
             ExcludeCombatTechniques: DB.EnumCase<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>;
+        }, []>>, false>;
     }>, []>>>;
     AllRanged: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableRangedCombatTechniques", DB.Object<{
-        restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
+        restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
             Improvised: DB.EnumCase<null>;
             PointedBlade: DB.EnumCase<null>;
             Mount: DB.EnumCase<null>;
@@ -99,7 +99,7 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
             ExcludeCombatTechniques: DB.EnumCase<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>;
+        }, []>>, false>;
     }>, []>>>;
     Specific: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechniques", DB.Object<{
         list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechnique", DB.Object<{
@@ -107,7 +107,7 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
                 CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>, true>;
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -115,11 +115,9 @@ export declare const combat_techniques: DB.MemberDecl<DB.IncludeIdentifier<[], D
                 Level: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesLevelRestriction", DB.Object<{
                     level: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>>;
-                Weapons: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesWeaponRestriction", DB.Object<{
-                    list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
-                }>, []>>>;
                 OneBluntSide: DB.EnumCase<null>;
-            }, []>>>, false>;
+            }, []>>, false>;
+            weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         }>, []>>>, true>;
     }>, []>>>;
 }, []>>, true>;

package/lib/types/_ActivatableCombat.js

@@ -224,30 +224,24 @@ export const combat_techniques = DB.Required({
 const AllApplicableCombatTechniques = DB.TypeAlias(import.meta.url, {
     name: "AllApplicableCombatTechniques",
     type: () => DB.Object({
-        restrictions: DB.Optional({
-            type: DB.Array(DB.IncludeIdentifier(ApplicableAllCombatTechniquesRestriction), {
-                minItems: 1,
-            }),
+        restriction: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableAllCombatTechniquesRestriction),
         }),
     }),
 });
 const AllApplicableCloseCombatTechniques = DB.TypeAlias(import.meta.url, {
     name: "AllApplicableCloseCombatTechniques",
     type: () => DB.Object({
-        restrictions: DB.Optional({
-            type: DB.Array(DB.IncludeIdentifier(ApplicableCloseCombatTechniquesRestriction), {
-                minItems: 1,
-            }),
+        restriction: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableCloseCombatTechniquesRestriction),
         }),
     }),
 });
 const AllApplicableRangedCombatTechniques = DB.TypeAlias(import.meta.url, {
     name: "AllApplicableRangedCombatTechniques",
     type: () => DB.Object({
-        restrictions: DB.Optional({
-            type: DB.Array(DB.IncludeIdentifier(ApplicableRangedCombatTechniquesRestriction), {
-                minItems: 1,
-            }),
+        restriction: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableRangedCombatTechniquesRestriction),
         }),
     }),
 });
@@ -265,10 +259,12 @@ const SpecificApplicableCombatTechnique = DB.TypeAlias(import.meta.url, {
         id: DB.Required({
             type: DB.IncludeIdentifier(CombatTechniqueIdentifier),
         }),
-        restrictions: DB.Optional({
-            type: DB.Array(DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestriction), {
-                minItems: 1,
-            }),
+        restriction: DB.Optional({
+            type: DB.IncludeIdentifier(ApplicableSpecificCombatTechniquesRestriction),
+        }),
+        weapons: DB.Optional({
+            comment: "The specific weapons this combat special ability is only applicable to.",
+            type: DB.Array(WeaponIdentifier(), { minItems: 1 }),
         }),
     }),
 });
@@ -326,9 +322,6 @@ const ApplicableSpecificCombatTechniquesRestriction = DB.Enum(import.meta.url, {
         Mount: DB.EnumCase({ type: null }),
         Race: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesRaceRestriction) }),
         Level: DB.EnumCase({ type: DB.IncludeIdentifier(ApplicableCombatTechniquesLevelRestriction) }),
-        Weapons: DB.EnumCase({
-            type: DB.IncludeIdentifier(ApplicableCombatTechniquesWeaponRestriction),
-        }),
         OneBluntSide: DB.EnumCase({ type: null }),
     }),
 });
@@ -355,12 +348,3 @@ const ApplicableCombatTechniquesLevelRestriction = DB.TypeAlias(import.meta.url,
         }),
     }),
 });
-const ApplicableCombatTechniquesWeaponRestriction = DB.TypeAlias(import.meta.url, {
-    name: "ApplicableCombatTechniquesWeaponRestriction",
-    type: () => DB.Object({
-        list: DB.Required({
-            comment: "The specific weapons this combat special ability is only applicable to.",
-            type: DB.Array(WeaponIdentifier(), { minItems: 1 }),
-        }),
-    }),
-});

package/lib/types/_ActivatableNonMundane.d.ts

@@ -95,25 +95,6 @@ export declare const cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Encha
             }>, true>;
         }>, []>>>;
         Disjunction: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostDisjunction", DB.Object<{
-            interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostDisjunctionInterval", DB.Object<{
-                value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
-                    value: DB.MemberDecl<DB.Integer, true>;
-                    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
-                        Seconds: DB.EnumCase<null>;
-                        Minutes: DB.EnumCase<null>;
-                        Hours: DB.EnumCase<null>;
-                        Days: DB.EnumCase<null>;
-                        Weeks: DB.EnumCase<null>;
-                        Months: DB.EnumCase<null>;
-                        Years: DB.EnumCase<null>;
-                        Centuries: DB.EnumCase<null>;
-                        Actions: DB.EnumCase<null>;
-                        CombatRounds: DB.EnumCase<null>;
-                    }, []>>, true>;
-                }>, []>>, true>;
-                activation_value: DB.MemberDecl<DB.Integer, true>;
-                after_activation: DB.MemberDecl<DB.Boolean, true>;
-            }>, []>>, false>;
             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostDisjunctionOption", DB.Object<{
                 value: DB.MemberDecl<DB.Integer, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"ArcaneEnergyCostDisjunctionOptionTranslation", {
@@ -125,6 +106,15 @@ export declare const cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Encha
             }>, []>>>, true>;
         }>, []>>>;
         Variable: DB.EnumCase<null>;
+        ByLevel: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostByLevel", DB.Object<{
+            levels: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostByLevelLevel", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>, true>;
+            style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArcaneEnergyCostByLevelStyle", {
+                Compressed: DB.EnumCase<null>;
+                Verbose: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
     }, []>>>;
     BindingCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"BindingCost", {
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedBindingCost", DB.Object<{
@@ -266,25 +256,6 @@ export declare const ArcaneEnergyCost: DB.Enum<"ArcaneEnergyCost", {
         }>, true>;
     }>, []>>>;
     Disjunction: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostDisjunction", DB.Object<{
-        interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostDisjunctionInterval", DB.Object<{
-            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
-                value: DB.MemberDecl<DB.Integer, true>;
-                unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
-                    Seconds: DB.EnumCase<null>;
-                    Minutes: DB.EnumCase<null>;
-                    Hours: DB.EnumCase<null>;
-                    Days: DB.EnumCase<null>;
-                    Weeks: DB.EnumCase<null>;
-                    Months: DB.EnumCase<null>;
-                    Years: DB.EnumCase<null>;
-                    Centuries: DB.EnumCase<null>;
-                    Actions: DB.EnumCase<null>;
-                    CombatRounds: DB.EnumCase<null>;
-                }, []>>, true>;
-            }>, []>>, true>;
-            activation_value: DB.MemberDecl<DB.Integer, true>;
-            after_activation: DB.MemberDecl<DB.Boolean, true>;
-        }>, []>>, false>;
         options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostDisjunctionOption", DB.Object<{
             value: DB.MemberDecl<DB.Integer, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"ArcaneEnergyCostDisjunctionOptionTranslation", {
@@ -296,6 +267,15 @@ export declare const ArcaneEnergyCost: DB.Enum<"ArcaneEnergyCost", {
         }>, []>>>, true>;
     }>, []>>>;
     Variable: DB.EnumCase<null>;
+    ByLevel: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostByLevel", DB.Object<{
+        levels: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneEnergyCostByLevelLevel", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, true>;
+        style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArcaneEnergyCostByLevelStyle", {
+            Compressed: DB.EnumCase<null>;
+            Verbose: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>>;
 }, []>;
 export declare const aeCost: DB.MemberDecl<DB.String, false>;
 export declare const volume: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Volume", {

package/lib/types/_ActivatableNonMundane.js

@@ -28,6 +28,7 @@ export const ArcaneEnergyCost = DB.Enum(import.meta.url, {
         Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteArcaneEnergyCost) }),
         Disjunction: DB.EnumCase({ type: DB.IncludeIdentifier(ArcaneEnergyCostDisjunction) }),
         Variable: DB.EnumCase({ type: null }),
+        ByLevel: DB.EnumCase({ type: DB.IncludeIdentifier(ArcaneEnergyCostByLevel) }),
     }),
 });
 export const aeCost = DB.Optional({
@@ -156,35 +157,36 @@ const IndefiniteArcaneEnergyCostModifierArithmetic = DB.Enum(import.meta.url, {
 const ArcaneEnergyCostDisjunction = DB.TypeAlias(import.meta.url, {
     name: "ArcaneEnergyCostDisjunction",
     type: () => DB.Object({
-        interval: DB.Optional({
-            comment: "Specified if the selected AE cost option has to be paid for each time interval.",
-            type: DB.IncludeIdentifier(ArcaneEnergyCostDisjunctionInterval),
-        }),
+        // interval: DB.Optional({
+        //   comment: "Specified if the selected AE cost option has to be paid for each time interval.",
+        //   type: DB.IncludeIdentifier(ArcaneEnergyCostDisjunctionInterval),
+        // }),
         options: DB.Required({
             comment: "The possible AE cost values.",
             type: DB.Array(DB.IncludeIdentifier(ArcaneEnergyCostDisjunctionOption), { minItems: 1 }),
         }),
     }),
 });
-const ArcaneEnergyCostDisjunctionInterval = DB.TypeAlias(import.meta.url, {
-    name: "ArcaneEnergyCostDisjunctionInterval",
-    type: () => DB.Object({
-        value: DB.Required({
-            comment: "The interval itself.",
-            type: DB.IncludeIdentifier(DurationUnitValue),
-        }),
-        activation_value: DB.Required({
-            comment: "The AE cost value for activation.",
-            type: DB.Integer({ minimum: 1 }),
-        }),
-        after_activation: DB.Required({
-            comment: `Set to \`true\` if the action where the enchantment is casted does not as a part of the first interval that has to be payed, so that the first interval payment needs to be done after the activation.
-
-This works different than other sustained spells, since for them the end of the cast usually already counts as part of the first interval.`,
-            type: DB.Boolean(),
-        }),
-    }),
-});
+// Unclear what the following was for, but I will keep it in here for now just in case I forgot about something
+// const ArcaneEnergyCostDisjunctionInterval = DB.TypeAlias(import.meta.url, {
+//   name: "ArcaneEnergyCostDisjunctionInterval",
+//   type: () =>
+//     DB.Object({
+//       value: DB.Required({
+//         comment: "The interval itself.",
+//         type: DB.IncludeIdentifier(DurationUnitValue),
+//       }),
+//       activation_value: DB.Required({
+//         comment: "The AE cost value for activation.",
+//         type: DB.Integer({ minimum: 1 }),
+//       }),
+//       after_activation: DB.Required({
+//         comment: `Set to \`true\` if the action where the enchantment is casted does not as a part of the first interval that has to be payed, so that the first interval payment needs to be done after the activation.
+// This works different than other sustained spells, since for them the end of the cast usually already counts as part of the first interval.`,
+//         type: DB.Boolean(),
+//       }),
+//     }),
+// })
 const ArcaneEnergyCostDisjunctionOption = DB.TypeAlias(import.meta.url, {
     name: "ArcaneEnergyCostDisjunctionOption",
     type: () => DB.Object({
@@ -200,6 +202,36 @@ const ArcaneEnergyCostDisjunctionOption = DB.TypeAlias(import.meta.url, {
         }, { minProperties: 1 })),
     }),
 });
+const ArcaneEnergyCostByLevel = DB.TypeAlias(import.meta.url, {
+    name: "ArcaneEnergyCostByLevel",
+    type: () => DB.Object({
+        levels: DB.Required({
+            comment: "A continuous range of arcane energy cost for each level. The first element is the AE cost for the first level, the second element is the AE cost for the second level, and so on.",
+            type: DB.Array(DB.IncludeIdentifier(ArcaneEnergyCostByLevelLevel), { minItems: 2 }),
+        }),
+        style: DB.Required({
+            comment: "How to display the AE cost by level.",
+            type: DB.IncludeIdentifier(ArcaneEnergyCostByLevelStyle),
+        }),
+    }),
+});
+const ArcaneEnergyCostByLevelLevel = DB.TypeAlias(import.meta.url, {
+    name: "ArcaneEnergyCostByLevelLevel",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The arcane energy cost for this level.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+    }),
+});
+const ArcaneEnergyCostByLevelStyle = DB.Enum(import.meta.url, {
+    name: "ArcaneEnergyCostByLevelStyle",
+    comment: "The AE cost are defined by level of the enchantment. It may either be displayed in a compressed way (e.g. `1/2 AE for level I/II`) or in a verbose way (e.g. `1 AE for level I; 2 AE for level II`).",
+    values: () => ({
+        Compressed: DB.EnumCase({ type: null }),
+        Verbose: DB.EnumCase({ type: null }),
+    }),
+});
 const Volume = DB.Enum(import.meta.url, {
     name: "Volume",
     comment: "The volume points the enchantment needs.",

package/lib/types/_IdentifierGroup.d.ts

@@ -346,3 +346,7 @@ export declare const EquipmentIdentifier: DB.Enum<"EquipmentIdentifier", {
     Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
     WeaponAccessory: DB.EnumCase<DB.ReferenceIdentifier>;
 }, []>;
+export declare const AdvancedSkillStyleSpecialAbilityIdentifier: DB.Enum<"AdvancedSkillStyleSpecialAbilityIdentifier", {
+    AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+    AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+}, []>;

package/lib/types/_IdentifierGroup.js

@@ -307,3 +307,10 @@ export const EquipmentIdentifier = DB.Enum(import.meta.url, {
         WeaponAccessory: DB.EnumCase({ type: WeaponAccessoryIdentifier() }),
     }),
 });
+export const AdvancedSkillStyleSpecialAbilityIdentifier = DB.Enum(import.meta.url, {
+    name: "AdvancedSkillStyleSpecialAbilityIdentifier",
+    values: () => ({
+        AdvancedCombatSpecialAbility: DB.EnumCase({ type: AdvancedCombatSpecialAbilityIdentifier() }),
+        AdvancedSkillSpecialAbility: DB.EnumCase({ type: AdvancedSkillSpecialAbilityIdentifier() }),
+    }),
+});

package/lib/types/rule/FocusRule.d.ts

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const FocusRule: DB.Entity<"FocusRule", {
-    subject: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    subject: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     level: DB.MemberDecl<DB.Integer, true>;
     isMissingImplementation: DB.MemberDecl<DB.Boolean, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {

package/lib/types/rule/FocusRule.js

@@ -8,7 +8,7 @@ export const FocusRule = DB.Entity(import.meta.url, {
     name: "FocusRule",
     namePlural: "FocusRules",
     type: () => DB.Object({
-        subject: DB.Optional({
+        subject: DB.Required({
             comment: "The associated subject.",
             type: SubjectIdentifier(),
         }),

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

@@ -1028,7 +1028,7 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
         None: DB.EnumCase<null>;
         DependingOnCombatStyle: DB.EnumCase<null>;
         All: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -1036,10 +1036,10 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         AllClose: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCloseCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -1051,10 +1051,10 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         AllRanged: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableRangedCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -1062,7 +1062,7 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         Specific: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechniques", DB.Object<{
             list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechnique", DB.Object<{
@@ -1070,7 +1070,7 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                     CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                     RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>, true>;
-                restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
+                restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
                     Improvised: DB.EnumCase<null>;
                     PointedBlade: DB.EnumCase<null>;
                     Mount: DB.EnumCase<null>;
@@ -1078,11 +1078,9 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                     Level: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesLevelRestriction", DB.Object<{
                         level: DB.MemberDecl<DB.Integer, true>;
                     }>, []>>>;
-                    Weapons: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesWeaponRestriction", DB.Object<{
-                        list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
-                    }>, []>>>;
                     OneBluntSide: DB.EnumCase<null>;
-                }, []>>>, false>;
+                }, []>>, false>;
+                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

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

@@ -922,7 +922,7 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
         None: DB.EnumCase<null>;
         DependingOnCombatStyle: DB.EnumCase<null>;
         All: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -930,10 +930,10 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         AllClose: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCloseCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -945,10 +945,10 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         AllRanged: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableRangedCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -956,7 +956,7 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         Specific: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechniques", DB.Object<{
             list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechnique", DB.Object<{
@@ -964,7 +964,7 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
                     CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                     RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>, true>;
-                restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
+                restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
                     Improvised: DB.EnumCase<null>;
                     PointedBlade: DB.EnumCase<null>;
                     Mount: DB.EnumCase<null>;
@@ -972,11 +972,9 @@ export declare const BrawlingSpecialAbility: DB.Entity<"BrawlingSpecialAbility",
                     Level: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesLevelRestriction", DB.Object<{
                         level: DB.MemberDecl<DB.Integer, true>;
                     }>, []>>>;
-                    Weapons: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesWeaponRestriction", DB.Object<{
-                        list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
-                    }>, []>>>;
                     OneBluntSide: DB.EnumCase<null>;
-                }, []>>>, false>;
+                }, []>>, false>;
+                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;

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

@@ -1028,7 +1028,7 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
         None: DB.EnumCase<null>;
         DependingOnCombatStyle: DB.EnumCase<null>;
         All: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableAllCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -1036,10 +1036,10 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         AllClose: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableCloseCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableCloseCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -1051,10 +1051,10 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         AllRanged: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AllApplicableRangedCombatTechniques", DB.Object<{
-            restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
+            restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableRangedCombatTechniquesRestriction", {
                 Improvised: DB.EnumCase<null>;
                 PointedBlade: DB.EnumCase<null>;
                 Mount: DB.EnumCase<null>;
@@ -1062,7 +1062,7 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
                 ExcludeCombatTechniques: DB.EnumCase<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>;
+            }, []>>, false>;
         }>, []>>>;
         Specific: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechniques", DB.Object<{
             list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificApplicableCombatTechnique", DB.Object<{
@@ -1070,7 +1070,7 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
                     CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                     RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>, true>;
-                restrictions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
+                restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ApplicableSpecificCombatTechniquesRestriction", {
                     Improvised: DB.EnumCase<null>;
                     PointedBlade: DB.EnumCase<null>;
                     Mount: DB.EnumCase<null>;
@@ -1078,11 +1078,9 @@ export declare const CombatSpecialAbility: DB.Entity<"CombatSpecialAbility", {
                     Level: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesLevelRestriction", DB.Object<{
                         level: DB.MemberDecl<DB.Integer, true>;
                     }>, []>>>;
-                    Weapons: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ApplicableCombatTechniquesWeaponRestriction", DB.Object<{
-                        list: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
-                    }>, []>>>;
                     OneBluntSide: DB.EnumCase<null>;
-                }, []>>>, false>;
+                }, []>>, false>;
+                weapons: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>, true>;
         }>, []>>>;
     }, []>>, true>;