@optolith/database-schema 0.79.0 → 0.80.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.80.0](https://github.com/Optolith/database-schema/compare/v0.79.1...v0.80.0) (2026-10-06)
+
+### ⚠ BREAKING CHANGES
+
+* culture-only language specialization flag
+* invaluable item cost translation
+
+### Features
+
+* culture-only language specialization flag ([e7e35cd](https://github.com/Optolith/database-schema/commit/e7e35cdb78c9b1e92353f64bfb6858a32fdbdd40))
+* invaluable item cost translation ([61e6e22](https://github.com/Optolith/database-schema/commit/61e6e22b19a761309c4666ba03d4770c5a59e86d))
+
+## [0.79.1](https://github.com/Optolith/database-schema/compare/v0.79.0...v0.79.1) (2026-10-05)
+
+### Bug Fixes
+
+* custom combat value constraints for generic item ([10a042a](https://github.com/Optolith/database-schema/commit/10a042ad9e72d65f1b8cb75b1f9bf3eff7badf31))
+
 ## [0.79.0](https://github.com/Optolith/database-schema/compare/v0.78.0...v0.79.0) (2026-10-05)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -736,6 +736,7 @@ export type TypeAliasMap = {
   IntoxicantAddictionCheck: IntoxicantAddictionCheck
   IntoxicantAddictionWithdrawalPrevention: IntoxicantAddictionWithdrawalPrevention
   IntoxicantLegality: IntoxicantLegality
+  InvaluableCost: InvaluableCost
   JesterTrickCastingTime: JesterTrickCastingTime
   JesterTrickCost: JesterTrickCost
   JesterTrickPerformanceParameters: JesterTrickPerformanceParameters
@@ -5714,6 +5715,11 @@ export interface LanguageSpecialization {
    */
   parent: Language_ID
 
+  /**
+   * The specialization is only mentioned in a culture’s description and not where the language itself is defined.
+   */
+  onlyForCulture: boolean
+
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
    */
@@ -9862,7 +9868,7 @@ export interface CultureLanguageTranslation {
   specialization?: string
 
   /**
-   * A different promt fro the language specialization, if the language allows to specify arbitrary text.
+   * A different prompt for the language specialization, if the language allows to specify arbitrary text.
    */
   specializationPrompt?: string
 }
@@ -12417,6 +12423,7 @@ export type Cost =
   }
   | {
     kind: "Invaluable"
+    Invaluable: InvaluableCost
   }
   | {
     kind: "Fixed"
@@ -12427,6 +12434,22 @@ export type Cost =
     Range: CostRange
   }
 
+export interface InvaluableCost {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations?: {
+    [localeId: string]: InvaluableCostTranslation
+  }
+}
+
+export interface InvaluableCostTranslation {
+  /**
+   * The cost get wrapped by this text using a placeholder in the text.
+   */
+  wrap_in_text: string
+}
+
 export interface FixedCost {
   /**
    * The cost in silverthalers.
@@ -23308,9 +23331,9 @@ export interface SecondaryArmor {
   has_additional_penalties: HasAdditionalPenalties
 
   /**
-   * The standard armor this armor is a variant of.
+   * The armor type.
    */
-  variantOf: Armor_ID
+  armorType: ArmorType
 
   /**
    * Specify if armor is only available for a specific hit zone.

package/lib/types/Culture.js

@@ -122,7 +122,7 @@ const CultureLanguage = DB.TypeAlias(import.meta.url, {
                 type: DB.String({ minLength: 1 }),
             }),
             specializationPrompt: DB.Optional({
-                comment: "A different promt fro the language specialization, if the language allows to specify arbitrary text.",
+                comment: "A different prompt for the language specialization, if the language allows to specify arbitrary text.",
                 type: DB.String({ minLength: 1 }),
             }),
         }, { minProperties: 1 })),

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

@@ -3,7 +3,11 @@ export declare const Ammunition: DB.Entity<"Ammunition", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Animal: DB.Entity<"Animal", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -5,7 +5,11 @@ export declare const AnimalCare: DB.Entity<"AnimalCare", {
             cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
                 Free: DB.EnumCase<null>;
                 Various: DB.EnumCase<null>;
-                Invaluable: DB.EnumCase<null>;
+                Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                        wrap_in_text: DB.MemberDecl<DB.String, true>;
+                    }>, false>;
+                }>, []>>>;
                 Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
                     value: DB.MemberDecl<DB.Float, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Armor: DB.Entity<"Armor", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -224,7 +228,18 @@ export declare const SecondaryArmor: DB.TypeAlias<"SecondaryArmor", DB.Object<{
     protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
     encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
     has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+        Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+            sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+    }, []>>, true>;
     hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
         Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
             combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -112,7 +112,9 @@ const StandardArmorType = DB.TypeAlias(import.meta.url, {
     }),
 });
 const validateArmorTypeReference = (deps) => [
-    deps.getInstanceById("Armor", deps.instanceContent.variantOf)?.armorType.kind !== "Standard"
+    deps.getInstanceById("Armor", deps.instanceContent.variantOf)?.armorType.kind !== "Standard" &&
+        deps.getInstanceById("Item", deps.instanceContent.variantOf)?.armorUse?.armorType.kind !==
+            "Standard"
         ? "The armor is a variant of a standard armor, but the referenced armor is not a standard armor."
         : undefined,
 ].filter(isNotNullish);
@@ -157,9 +159,9 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
             comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
             type: DB.IncludeIdentifier(HasAdditionalPenalties),
         }),
-        variantOf: DB.Required({
-            comment: "The standard armor this armor is a variant of.",
-            type: ArmorIdentifier(),
+        armorType: DB.Required({
+            comment: "The armor type.",
+            type: DB.IncludeIdentifier(ArmorType),
         }),
         hit_zone: DB.Optional({
             comment: "Specify if armor is only available for a specific hit zone.",
@@ -180,7 +182,14 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
             }),
         }, { minProperties: 1 })),
     }),
-    customConstraints: validateArmorTypeReference,
+    customConstraints: ({ instanceContent, ...deps }) => instanceContent.armorType.kind !== "Standard"
+        ? validateArmorTypeReference({
+            ...deps,
+            instanceContent: instanceContent.armorType.kind === "Variant"
+                ? instanceContent.armorType.Variant
+                : instanceContent.armorType.StandardVariant,
+        })
+        : [],
 });
 const ArmorComplexity = DB.Enum(import.meta.url, {
     name: "ArmorComplexity",

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

@@ -3,7 +3,11 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -148,7 +152,18 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -19,7 +19,11 @@ export declare const Book: DB.Entity<"Book", {
                 cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
                     Free: DB.EnumCase<null>;
                     Various: DB.EnumCase<null>;
-                    Invaluable: DB.EnumCase<null>;
+                    Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
                     Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
                         value: DB.MemberDecl<DB.Float, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -50,7 +54,11 @@ export declare const Book: DB.Entity<"Book", {
                 cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
                     Free: DB.EnumCase<null>;
                     Various: DB.EnumCase<null>;
-                    Invaluable: DB.EnumCase<null>;
+                    Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                            wrap_in_text: DB.MemberDecl<DB.String, true>;
+                        }>, false>;
+                    }>, []>>>;
                     Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
                         value: DB.MemberDecl<DB.Float, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -149,7 +153,18 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -3,7 +3,11 @@ export declare const Clothes: DB.Entity<"Clothes", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -148,7 +152,18 @@ export declare const Clothes: DB.Entity<"Clothes", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -3,7 +3,11 @@ export declare const ClothingPackage: DB.Entity<"ClothingPackage", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const Container: DB.Entity<"Container", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -148,7 +152,18 @@ export declare const Container: DB.Entity<"Container", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -3,7 +3,11 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -121,7 +125,18 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -3,7 +3,11 @@ export declare const GemOrPreciousStone: DB.Entity<"GemOrPreciousStone", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {

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

@@ -3,7 +3,11 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -157,7 +161,18 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -3,7 +3,11 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -148,7 +152,18 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -4,7 +4,11 @@ export declare const Item: DB.Entity<"Item", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
@@ -129,7 +133,18 @@ export declare const Item: DB.Entity<"Item", {
         protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
         encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
         has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-        variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+            Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            }>, []>>>;
+        }, []>>, true>;
         hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
             Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                 combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

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

@@ -115,22 +115,26 @@ export const Item = DB.Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
-    customConstraints: ({ instanceContent, ...rest }) => checkWeaponCombatTechniqueIntegrity({
-        ...rest,
-        instanceContent,
-    }).concat(checkEquipmentCategoryConstraintsWithItem(instanceContent, rest.getInstanceById)),
+    customConstraints: ({ instanceContent, ...rest }) => checkEquipmentCategoryConstraintsWithItem(instanceContent, rest.getInstanceById, rest.getDisplayNameAndId),
 });
-const checkEquipmentCategoryConstraintsWithItem = (item, getInstanceById) => {
+const checkEquipmentCategoryConstraintsWithItem = (item, getInstanceById, getDisplayNameAndId) => {
     const categories = item.categories.map(categoryId => getInstanceById("EquipmentCategory", categoryId));
     if (isNotEmpty(categories)) {
         if (categories.every(isNotNullish)) {
             if (categories.every(isEquipmentCategoryOfDefaultType)) {
                 const mergedRules = mergeAllValueRules(categories.map(c => c.type.Default));
                 const errors = [];
-                if (mergedRules.combatValues.isWeaponAllowed &&
-                    item.meleeUses === undefined &&
-                    item.rangedUses === undefined) {
-                    errors.push("A weapon must defined at least one melee use or ranged use.");
+                if (mergedRules.combatValues.isWeaponAllowed) {
+                    if (item.meleeUses === undefined && item.rangedUses === undefined) {
+                        errors.push("A weapon must defined at least one melee use or ranged use.");
+                    }
+                    else {
+                        errors.push(...checkWeaponCombatTechniqueIntegrity({
+                            instanceContent: item,
+                            getInstanceById,
+                            getDisplayNameAndId,
+                        }));
+                    }
                 }
                 if (mergedRules.combatValues.isArmorAllowed && item.armorUse === undefined) {
                     errors.push("An armor must defined an armor use.");

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

@@ -3,7 +3,11 @@ export declare const Laboratory: DB.Entity<"Laboratory", {
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
         Free: DB.EnumCase<null>;
         Various: DB.EnumCase<null>;
-        Invaluable: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
             value: DB.MemberDecl<DB.Float, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {