optolith-database-schema 0.24.3 → 0.26.0

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

@@ -1,16 +1,16 @@
-import { Entity, IncludeIdentifier, NestedEntityMap, Object, String, TypeAlias } from "tsondb/schema/def";
+import { Entity, IncludeIdentifier, NestedEntityMap, ObjectType, String, TypeAlias } from "tsondb/schema/def";
 export declare const Weapon: Entity<"Weapon", {
     cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Cost", {
         Free: import("tsondb/schema/def").EnumCaseDecl<null>;
         Various: import("tsondb/schema/def").EnumCaseDecl<null>;
         Invaluable: import("tsondb/schema/def").EnumCaseDecl<null>;
-        Fixed: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
+        Fixed: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"FixedCost", ObjectType<{
             value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
             translations: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"FixedCostTranslation", {
                 wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
             }>, false>;
         }>, []>>>;
-        Range: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"CostRange", Object<{
+        Range: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"CostRange", ObjectType<{
             from: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
             to: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
             translations: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"CostRangeTranslation", {
@@ -22,27 +22,27 @@ export declare const Weapon: Entity<"Weapon", {
     complexity: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Complexity", {
         Primitive: import("tsondb/schema/def").EnumCaseDecl<null>;
         Simple: import("tsondb/schema/def").EnumCaseDecl<null>;
-        Complex: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"ComplexComplexity", Object<{
+        Complex: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"ComplexComplexity", ObjectType<{
             ap_value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
         }>, []>>>;
     }, []>>, false>;
-    structure_points: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"StructurePoints", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"StructurePointsComponent", Object<{
+    structure_points: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"StructurePoints", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"StructurePointsComponent", ObjectType<{
         points: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
     }>, []>>>, []>>, false>;
     melee_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
-        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", Object<{
-            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", ObjectType<{
+            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", ObjectType<{
                 number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                 sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
             }>, []>>, true>;
             flat: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
         }>, []>>, true>;
         damage_threshold: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"PrimaryAttributeDamageThreshold", {
-            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", Object<{
+            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", ObjectType<{
                 threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
             }>, []>>>;
-            List: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", Object<{
-                list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", Object<{
+            List: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", ObjectType<{
+                list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", ObjectType<{
                     attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
                     threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                 }>, []>>>, true>;
@@ -55,7 +55,7 @@ export declare const Weapon: Entity<"Weapon", {
         size: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ShieldSize", {
             Small: import("tsondb/schema/def").EnumCaseDecl<null>;
             Medium: import("tsondb/schema/def").EnumCaseDecl<null>;
-            Large: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", Object<{
+            Large: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", ObjectType<{
                 attack_penalty: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
             }>, []>>>;
         }, []>>, false>;
@@ -65,8 +65,8 @@ export declare const Weapon: Entity<"Weapon", {
     }>, false>;
     ranged_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
         damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"RangedDamage", {
-            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", Object<{
-                dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", ObjectType<{
+                dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", ObjectType<{
                     number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                     sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
                 }>, []>>, true>;
@@ -75,10 +75,10 @@ export declare const Weapon: Entity<"Weapon", {
             NotApplicable: import("tsondb/schema/def").EnumCaseDecl<null>;
             Special: import("tsondb/schema/def").EnumCaseDecl<null>;
         }, []>>, true>;
-        reload_time: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
+        reload_time: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"ReloadTime", ObjectType<{
             value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
         }>, []>>>, true>;
-        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
+        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", ObjectType<{
             close: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
             medium: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
             far: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
@@ -87,20 +87,20 @@ export declare const Weapon: Entity<"Weapon", {
         length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", import("tsondb/schema/def").IntegerType, []>>, false>;
         is_improvised_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
     }>, false>;
-    restrictedTo: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedTo", Object<{
-        races: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToRaces", Object<{
+    restrictedTo: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedTo", ObjectType<{
+        races: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToRaces", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToCultures", Object<{
+        cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToCultures", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        professions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToProfessions", Object<{
+        professions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToProfessions", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        magicalTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToMagicalTraditions", Object<{
+        magicalTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToMagicalTraditions", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        blessedTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToBlessedTraditions", Object<{
+        blessedTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToBlessedTraditions", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"RestrictedToBlessedTraditionsScope", {
                 Specific: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>>;
                 Church: import("tsondb/schema/def").EnumCaseDecl<null>;
@@ -109,12 +109,12 @@ export declare const Weapon: Entity<"Weapon", {
             isSanctifiedBy: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
         }>, []>>, false>;
     }>, []>>, false>;
-    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PublicationRef", ObjectType<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
         occurrences: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
-            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", ObjectType<{
                 printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
-                pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", ObjectType<{
                     first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
                         InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
                         InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
@@ -128,9 +128,9 @@ export declare const Weapon: Entity<"Weapon", {
                 }>, []>>>, true>;
             }>, []>>, true>;
             revisions: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
-                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Since", ObjectType<{
                     printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
-                    pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", ObjectType<{
                         first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
                             InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
                             InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
@@ -143,7 +143,7 @@ export declare const Weapon: Entity<"Weapon", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                 }>, []>>>;
-                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Deprecation", ObjectType<{
                     printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                 }>, []>>>;
             }, []>>>, false>;
@@ -156,27 +156,27 @@ export declare const Weapon: Entity<"Weapon", {
         rules: import("tsondb/schema/def").MemberDecl<String, false>;
         advantage: import("tsondb/schema/def").MemberDecl<String, false>;
         disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
-        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"Erratum", ObjectType<{
             date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
             description: import("tsondb/schema/def").MemberDecl<String, true>;
         }>, []>>>, []>>, false>;
     }>, true>;
 }, undefined>;
-export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", Object<{
+export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", ObjectType<{
     melee_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
-        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", Object<{
-            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", ObjectType<{
+            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", ObjectType<{
                 number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                 sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
             }>, []>>, true>;
             flat: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
         }>, []>>, true>;
         damage_threshold: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"PrimaryAttributeDamageThreshold", {
-            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", Object<{
+            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", ObjectType<{
                 threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
             }>, []>>>;
-            List: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", Object<{
-                list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", Object<{
+            List: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", ObjectType<{
+                list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", ObjectType<{
                     attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
                     threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                 }>, []>>>, true>;
@@ -189,7 +189,7 @@ export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", Object<{
         size: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ShieldSize", {
             Small: import("tsondb/schema/def").EnumCaseDecl<null>;
             Medium: import("tsondb/schema/def").EnumCaseDecl<null>;
-            Large: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", Object<{
+            Large: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", ObjectType<{
                 attack_penalty: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
             }>, []>>>;
         }, []>>, false>;
@@ -199,8 +199,8 @@ export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", Object<{
     }>, false>;
     ranged_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
         damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"RangedDamage", {
-            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", Object<{
-                dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+            Default: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", ObjectType<{
+                dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", ObjectType<{
                     number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
                     sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
                 }>, []>>, true>;
@@ -209,10 +209,10 @@ export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", Object<{
             NotApplicable: import("tsondb/schema/def").EnumCaseDecl<null>;
             Special: import("tsondb/schema/def").EnumCaseDecl<null>;
         }, []>>, true>;
-        reload_time: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
+        reload_time: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"ReloadTime", ObjectType<{
             value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
         }>, []>>>, true>;
-        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
+        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", ObjectType<{
             close: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
             medium: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
             far: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
@@ -221,20 +221,20 @@ export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", Object<{
         length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", import("tsondb/schema/def").IntegerType, []>>, false>;
         is_improvised_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
     }>, false>;
-    restrictedTo: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedTo", Object<{
-        races: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToRaces", Object<{
+    restrictedTo: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedTo", ObjectType<{
+        races: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToRaces", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToCultures", Object<{
+        cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToCultures", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        professions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToProfessions", Object<{
+        professions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToProfessions", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        magicalTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToMagicalTraditions", Object<{
+        magicalTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToMagicalTraditions", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
         }>, []>>, false>;
-        blessedTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToBlessedTraditions", Object<{
+        blessedTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToBlessedTraditions", ObjectType<{
             scope: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"RestrictedToBlessedTraditionsScope", {
                 Specific: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>>;
                 Church: import("tsondb/schema/def").EnumCaseDecl<null>;

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

@@ -1,4 +1,4 @@
-import { Entity, IncludeIdentifier, NestedEntityMap, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { Entity, IncludeIdentifier, NestedEntityMap, ObjectType, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
@@ -6,10 +6,11 @@ import { src } from "../../source/_PublicationRef.js";
 import { Complexity, Cost, RestrictedTo, StructurePoints, Weight } from "./_Item.js";
 import { MeleeWeapon } from "./_MeleeWeapon.js";
 import { RangedWeapon } from "./_RangedWeapon.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const Weapon = Entity(import.meta.url, {
     name: "Weapon",
     namePlural: "Weapons",
-    type: () => Object({
+    type: () => ObjectType({
         cost: Required({
             comment: "The cost in silverthalers.",
             type: IncludeIdentifier(Cost),
@@ -49,7 +50,7 @@ export const Weapon = Entity(import.meta.url, {
             type: IncludeIdentifier(RestrictedTo),
         }),
         src,
-        translations: NestedTranslationMap(Required, "Weapon", Object({
+        translations: NestedTranslationMap(Required, "Weapon", ObjectType({
             name: Required({
                 comment: "The item’s name.",
                 type: String({ minLength: 1 }),
@@ -80,10 +81,17 @@ export const Weapon = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: params => checkWeaponCombatTechniqueIntegrity(params, false),
 });
 export const ImprovisedWeapon = TypeAlias(import.meta.url, {
     name: "ImprovisedWeapon",
-    type: () => Object({
+    type: () => ObjectType({
         melee_uses: Optional({
             comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
             type: NestedEntityMap({
@@ -106,7 +114,7 @@ export const ImprovisedWeapon = TypeAlias(import.meta.url, {
             comment: "Define if during character creation this weapon can only be bought by a specific subset of characters.",
             type: IncludeIdentifier(RestrictedTo),
         }),
-        translations: NestedTranslationMap(Optional, "ImprovisedWeapon", Object({
+        translations: NestedTranslationMap(Optional, "ImprovisedWeapon", ObjectType({
             advantage: Optional({
                 comment: "The weapon advantage text.",
                 type: String({ minLength: 1, isMarkdown: true }),

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

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const WeaponAccessory = Entity(import.meta.url, {
     name: "WeaponAccessory",
     namePlural: "WeaponAccessories",
@@ -29,4 +30,19 @@ export const WeaponAccessory = Entity(import.meta.url, {
         translations: DefaultItemTranslations("WeaponAccessory"),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

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

@@ -3,8 +3,10 @@ import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifi
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 import { SecondaryArmor } from "./Armor.js";
 import { ImprovisedWeapon } from "./Weapon.js";
+const COMBAT_USE = "combat_use";
 export const DefaultItem = (sourceUrl, singularName, pluralName) => Entity(sourceUrl, {
     name: singularName,
     namePlural: pluralName ?? `${singularName}s`,
@@ -25,7 +27,7 @@ export const DefaultItem = (sourceUrl, singularName, pluralName) => Entity(sourc
             comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
             type: IncludeIdentifier(StructurePoints),
         }),
-        combat_use: Optional({
+        [COMBAT_USE]: Optional({
             comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
             type: IncludeIdentifier(CombatUse),
         }),
@@ -33,6 +35,22 @@ export const DefaultItem = (sourceUrl, singularName, pluralName) => Entity(sourc
         translations: DefaultItemTranslations(singularName),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        const combatUse = instanceContent.combat_use;
+        if (combatUse && combatUse.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: combatUse.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });
 export const DefaultItemTranslations = (singularName) => NestedTranslationMap(Required, singularName, Object({
     name: Required({

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

@@ -1,13 +1,22 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+import { Array, Enum, EnumCase, IncludeIdentifier, Integer, ObjectType, TypeAlias, type GetDisplayNameWithId, type GetInstanceById } from "tsondb/schema/def";
+import type { MeleeWeapon, RangedWeapon } from "../../../../gen/types.js";
 export declare const PrimaryAttributeDamageThreshold: Enum<"PrimaryAttributeDamageThreshold", {
-    Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", Object<{
+    Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", ObjectType<{
         threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
     }>, []>>>;
-    List: EnumCase<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", Object<{
-        list: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", Object<{
+    List: EnumCase<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", ObjectType<{
+        list: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", ObjectType<{
             attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
             threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
         }>, []>>>, true>;
     }>, []>>>;
 }, []>;
 export declare const Length: TypeAlias<"Length", Integer, []>;
+export declare const checkWeaponCombatTechniqueIntegrity: ({ instanceContent, getInstanceById, getDisplayNameWithId, }: {
+    instanceContent: {
+        melee_uses?: Record<string, MeleeWeapon>;
+        ranged_uses?: Record<string, RangedWeapon>;
+    };
+    getInstanceById: GetInstanceById;
+    getDisplayNameWithId: GetDisplayNameWithId;
+}, _secondary: boolean) => string[];

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

@@ -1,4 +1,4 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, Object, Required, TypeAlias, } from "tsondb/schema/def";
+import { Array, Enum, EnumCase, IncludeIdentifier, Integer, ObjectType, Required, TypeAlias, } from "tsondb/schema/def";
 import { AttributeIdentifier } from "../../_Identifier.js";
 export const PrimaryAttributeDamageThreshold = Enum(import.meta.url, {
     name: "PrimaryAttributeDamageThreshold",
@@ -10,7 +10,7 @@ export const PrimaryAttributeDamageThreshold = Enum(import.meta.url, {
 });
 const DefaultPrimaryAttributeDamageThreshold = TypeAlias(import.meta.url, {
     name: "DefaultPrimaryAttributeDamageThreshold",
-    type: () => Object({
+    type: () => ObjectType({
         threshold: Required({
             comment: "The attribute value representing the damage threshold for the primary attribute of the item's combat technique.",
             type: Integer({ minimum: 1 }),
@@ -19,7 +19,7 @@ const DefaultPrimaryAttributeDamageThreshold = TypeAlias(import.meta.url, {
 });
 const PrimaryAttributeDamageThresholdList = TypeAlias(import.meta.url, {
     name: "PrimaryAttributeDamageThresholdList",
-    type: () => Object({
+    type: () => ObjectType({
         list: Required({
             comment: "A list of primary attributes with their associated threshold.",
             type: Array(IncludeIdentifier(SinglePrimaryAttributeDamageThreshold), {
@@ -31,7 +31,7 @@ const PrimaryAttributeDamageThresholdList = TypeAlias(import.meta.url, {
 });
 const SinglePrimaryAttributeDamageThreshold = TypeAlias(import.meta.url, {
     name: "SinglePrimaryAttributeDamageThreshold",
-    type: () => Object({
+    type: () => ObjectType({
         attribute: Required({
             comment: "The primary attribute.",
             type: AttributeIdentifier(),
@@ -47,3 +47,31 @@ export const Length = TypeAlias(import.meta.url, {
     comment: "The length of the weapon in cm/halffingers.",
     type: () => Integer({ minimum: 1 }),
 });
+export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstanceById, getDisplayNameWithId, }, _secondary) => {
+    const checkPart = (rule, value, name, type, id) => (rule.kind === "Prohibited") === (value === undefined) || rule.kind === "Optional"
+        ? undefined
+        : `${name} must${rule.kind === "Required" ? "" : " not"} be provided for ${type} combat technique ${getDisplayNameWithId(type === "close" ? "CloseCombatTechnique" : "RangedCombatTechnique", id)}`;
+    return [
+        instanceContent.melee_uses === undefined && instanceContent.ranged_uses === undefined
+            ? "either melee uses or ranged uses have to be provided"
+            : undefined,
+        ...Object.entries(instanceContent.melee_uses ?? {}).flatMap(([ctId, meleeUse]) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- integrity has been checked, it must be present
+            const ct = getInstanceById("CloseCombatTechnique", ctId);
+            return [
+                checkPart(ct.special.can_parry, meleeUse.parryModifier, "a parry modifier", "close", ctId),
+                checkPart(ct.special.has_damage_threshold, meleeUse.damage_threshold, "a damage threshold", "close", ctId),
+                checkPart(ct.special.has_length, meleeUse.length, "a length", "close", ctId),
+                checkPart(ct.special.has_reach, meleeUse.reach, "a reach", "close", ctId),
+                checkPart(ct.special.has_shield_size, meleeUse.size, "a shield size", "close", ctId),
+            ].filter(v => v !== undefined);
+        }),
+        ...Object.entries(instanceContent.ranged_uses ?? {}).flatMap(([ctId, rangedUse]) => {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- integrity has been checked, it must be present
+            const ct = getInstanceById("RangedCombatTechnique", ctId);
+            return [
+                checkPart(ct.special.has_ammunition, rangedUse.ammunition, "an ammunition", "ranged", ctId),
+            ].filter(v => v !== undefined);
+        }),
+    ].filter(v => v !== undefined);
+};

package/lib/types/equipment/item/sub/ArmorType.js

@@ -16,4 +16,10 @@ export const ArmorType = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/equipment/item/sub/Reach.js

@@ -12,4 +12,10 @@ export const Reach = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/magicalActions/AnimistPower.js

@@ -74,6 +74,12 @@ If no tribe tradition is given, the animist power is generally available to all
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const AnimistPowerLevel = TypeAlias(import.meta.url, {
     name: "AnimistPowerLevel",

package/lib/types/magicalActions/AnimistPower_Tribe.js

@@ -17,4 +17,10 @@ export const Tribe = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/magicalActions/Curse.js

@@ -53,6 +53,12 @@ export const Curse = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const CursePerformanceParameters = TypeAlias(import.meta.url, {
     name: "CursePerformanceParameters",

package/lib/types/magicalActions/DominationRitual.js

@@ -52,6 +52,12 @@ export const DominationRitual = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const DominationRitualPerformanceParameters = TypeAlias(import.meta.url, {
     name: "DominationRitualPerformanceParameters",

package/lib/types/magicalActions/ElvenMagicalSong.js

@@ -61,6 +61,12 @@ export const ElvenMagicalSong = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const ElvenMagicalSongPerformanceParameters = TypeAlias(import.meta.url, {
     name: "ElvenMagicalSongPerformanceParameters",

package/lib/types/magicalActions/GeodeRitual.js

@@ -71,6 +71,12 @@ export const GeodeRitual = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const GeodeRitualPerformanceParameters = TypeAlias(import.meta.url, {
     name: "GeodeRitualPerformanceParameters",

package/lib/types/magicalActions/JesterTrick.js

@@ -73,6 +73,12 @@ export const JesterTrick = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 export const JesterTrickPerformanceParameters = TypeAlias(import.meta.url, {
     name: "JesterTrickPerformanceParameters",

package/lib/types/magicalActions/MagicalDance.js

@@ -60,6 +60,12 @@ export const MagicalDance = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const MagicalDancePerformanceParameters = TypeAlias(import.meta.url, {
     name: "MagicalDancePerformanceParameters",