@optolith/database-schema 0.73.0 → 0.74.0

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 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.74.0](https://github.com/Optolith/database-schema/compare/v0.73.0...v0.74.0) (2026-09-29)
+
+### ⚠ BREAKING CHANGES
+
+* consolidate armor type entity into armor entity
+
+### Features
+
+* consolidate armor type entity into armor entity ([10ab468](https://github.com/Optolith/database-schema/commit/10ab4689c273ca3effe56770b05c769dc3321d12))
 ## [0.73.0](https://github.com/Optolith/database-schema/compare/v0.72.1...v0.73.0) (2026-09-29)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -21,7 +21,6 @@ export type EntityMap = {
   ArcaneDancerTradition: ArcaneDancerTradition
   ArcaneOrbEnchantment: ArcaneOrbEnchantment
   Armor: Armor
-  ArmorType: ArmorType
   Aspect: Aspect
   AttireEnchantment: AttireEnchantment
   Attribute: Attribute
@@ -244,6 +243,7 @@ export type EnumMap = {
   ArcaneEnergyCostByLevelStyle: ArcaneEnergyCostByLevelStyle
   ArcaneTraditionPrerequisiteGroup: ArcaneTraditionPrerequisiteGroup
   ArmorComplexity: ArmorComplexity
+  ArmorType: ArmorType
   AttributeColor: AttributeColor
   AutomaticEntryAction: AutomaticEntryAction
   AutomaticEntryTarget: AutomaticEntryTarget
@@ -922,6 +922,8 @@ export type TypeAliasMap = {
   SpellworkPrerequisites: SpellworkPrerequisites
   SpellworksOptions: SpellworksOptions
   StandaloneCostMap: StandaloneCostMap
+  StandardArmorType: StandardArmorType
+  StandardVariantArmorType: StandardVariantArmorType
   StatePrerequisite: StatePrerequisite
   StructurePoints: StructurePoints
   StructurePointsComponent: StructurePointsComponent
@@ -941,6 +943,7 @@ export type TypeAliasMap = {
   TradeSecretSelectOptions: TradeSecretSelectOptions
   TribePrerequisites: TribePrerequisites
   ValueMap: ValueMap<unknown>
+  VariantArmorType: VariantArmorType
   VolumeByLevel: VolumeByLevel
   VolumeByLevelItem: VolumeByLevelItem
   VolumeDerivedFromSelection: VolumeDerivedFromSelection
@@ -2578,6 +2581,10 @@ export interface Locale {
     "Melee Weapons": string
     "Ranged Weapons": string
     "Armor": string
+    "Standard Armor": string
+    "Special Armor": string
+    "Helmets": string
+    "Pieces of Armor": string
     "Weapon Accessories": string
     "Clothes": string
     "Clothing Packages for Social Status": string
@@ -22642,9 +22649,9 @@ export interface Armor {
   has_additional_penalties: HasAdditionalPenalties
 
   /**
-   * The armor type..
+   * The armor type.
    */
-  armor_type: ArmorType_ID
+  armorType: ArmorType
 
   /**
    * Specify if armor is only available for a specific hit zone.
@@ -22751,30 +22758,56 @@ export type Encumbrance = number
  */
 export type HasAdditionalPenalties = boolean
 
-export interface ArmorType {
+/**
+ * The armor type.
+ */
+export type ArmorType =
+  | {
+    kind: "Standard"
+    Standard: StandardArmorType
+  }
+  | {
+    kind: "StandardVariant"
+    StandardVariant: StandardVariantArmorType
+  }
+  | {
+    kind: "Variant"
+    Variant: VariantArmorType
+  }
+
+/**
+ * A standard armor.
+ */
+export interface StandardArmorType {
   /**
    * An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.
    */
-  sturdiness_rating?: number
+  sturdinessRating: number
+}
 
+/**
+ * The armor is a variant of a standard armor but still defines its own sturdiness rating and thus its own armor type.
+ */
+export interface StandardVariantArmorType {
   /**
-   * All translations for the entry, identified by IETF language tag (BCP47).
+   * The standard armor this armor is a variant of.
    */
-  translations: {
-    [localeId: string]: ArmorTypeTranslation
-  }
+  variantOf: Armor_ID
+
+  /**
+   * An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.
+   */
+  sturdinessRating: number
 }
 
 /**
- * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ * The armor is a variant of a standard armor but also defines its own .
  */
-export type ArmorType_ID = string
-
-export interface ArmorTypeTranslation {
+export interface VariantArmorType {
   /**
-   * The armor type’s name.
+   * The standard armor this armor is a variant of.
    */
-  name: string
+  variantOf: Armor_ID
 }
 
 /**
@@ -22956,9 +22989,9 @@ export interface SecondaryArmor {
   has_additional_penalties: HasAdditionalPenalties
 
   /**
-   * The armor type..
+   * The standard armor this armor is a variant of.
    */
-  armor_type: ArmorType_ID
+  variantOf: Armor_ID
 
   /**
    * Specify if armor is only available for a specific hit zone.

package/lib/main.js

@@ -21,7 +21,6 @@ export const schema = new Schema([
     Types.ArcaneDancerTradition,
     Types.ArcaneOrbEnchantment,
     Types.Armor,
-    Types.ArmorType,
     Types.Aspect,
     Types.AttireEnchantment,
     Types.Attribute,

package/lib/types/Locale.d.ts

@@ -1496,6 +1496,10 @@ export declare const Locale: DB.Entity<"Locale", {
         "Melee Weapons": null;
         "Ranged Weapons": null;
         Armor: null;
+        "Standard Armor": null;
+        "Special Armor": null;
+        Helmets: null;
+        "Pieces of Armor": null;
         "Weapon Accessories": null;
         Clothes: null;
         "Clothing Packages for Social Status": null;

package/lib/types/Locale.js

@@ -1538,6 +1538,10 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Ranged Weapons": null,
                 // "Ammunition": null,
                 "Armor": null,
+                "Standard Armor": null,
+                "Special Armor": null,
+                "Helmets": null,
+                "Pieces of Armor": null,
                 "Weapon Accessories": null,
                 "Clothes": null,
                 "Clothing Packages for Social Status": null,

package/lib/types/_Identifier.d.ts

@@ -18,7 +18,6 @@ export declare const ArcaneBardTraditionIdentifier: () => R;
 export declare const ArcaneDancerTraditionIdentifier: () => R;
 export declare const ArcaneOrbEnchantmentIdentifier: () => R;
 export declare const ArmorIdentifier: () => R;
-export declare const ArmorTypeIdentifier: () => R;
 export declare const AspectIdentifier: () => R;
 export declare const AttireEnchantmentIdentifier: () => R;
 export declare const AttributeIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -48,7 +48,6 @@ import { Plant } from "./equipment/item/Plant.js";
 import { Poison } from "./equipment/item/Poison.js";
 import { RopeOrChain } from "./equipment/item/RopeOrChain.js";
 import { Stationery } from "./equipment/item/Stationery.js";
-import { ArmorType } from "./equipment/item/sub/ArmorType.js";
 import { Biome } from "./equipment/item/sub/Biome.js";
 import { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
 import { Reach } from "./equipment/item/sub/Reach.js";
@@ -183,7 +182,6 @@ export const ArcaneBardTraditionIdentifier = () => R(ArcaneBardTradition);
 export const ArcaneDancerTraditionIdentifier = () => R(ArcaneDancerTradition);
 export const ArcaneOrbEnchantmentIdentifier = () => R(ArcaneOrbEnchantment);
 export const ArmorIdentifier = () => R(Armor);
-export const ArmorTypeIdentifier = () => R(ArmorType);
 export const AspectIdentifier = () => R(Aspect);
 export const AttireEnchantmentIdentifier = () => R(AttireEnchantment);
 export const AttributeIdentifier = () => R(Attribute);

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

@@ -71,7 +71,18 @@ export declare const Armor: DB.Entity<"Armor", {
     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>;
-    armor_type: 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<{
@@ -213,7 +224,7 @@ 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>;
-    armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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

@@ -1,5 +1,6 @@
+import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
-import { ArmorIdentifier, ArmorTypeIdentifier } from "../../_Identifier.js";
+import { ArmorIdentifier } from "../../_Identifier.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -32,9 +33,9 @@ export const Armor = DB.Entity(import.meta.url, {
             comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
             type: DB.IncludeIdentifier(HasAdditionalPenalties),
         }),
-        armor_type: DB.Required({
-            comment: "The armor type..",
-            type: ArmorTypeIdentifier(),
+        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.",
@@ -91,6 +92,56 @@ export const Armor = DB.Entity(import.meta.url, {
         },
     ],
 });
+const ArmorType = DB.Enum(import.meta.url, {
+    name: "ArmorType",
+    comment: "The armor type.",
+    values: () => ({
+        Standard: DB.EnumCase({ type: DB.IncludeIdentifier(StandardArmorType) }),
+        StandardVariant: DB.EnumCase({ type: DB.IncludeIdentifier(StandardVariantArmorType) }),
+        Variant: DB.EnumCase({ type: DB.IncludeIdentifier(VariantArmorType) }),
+    }),
+});
+const StandardArmorType = DB.TypeAlias(import.meta.url, {
+    name: "StandardArmorType",
+    comment: "A standard armor.",
+    type: () => DB.Object({
+        sturdinessRating: DB.Required({
+            comment: "An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.",
+            type: DB.Integer({ minimum: 1, maximum: 20 }),
+        }),
+    }),
+});
+const validateArmorTypeReference = (deps) => [
+    deps.getInstanceById("Armor", deps.instanceContent.variantOf)?.armorType.kind !== "Standard"
+        ? "The armor is a variant of a standard armor, but the referenced armor is not a standard armor."
+        : undefined,
+].filter(isNotNullish);
+const StandardVariantArmorType = DB.TypeAlias(import.meta.url, {
+    name: "StandardVariantArmorType",
+    comment: "The armor is a variant of a standard armor but still defines its own sturdiness rating and thus its own armor type.",
+    type: () => DB.Object({
+        variantOf: DB.Required({
+            comment: "The standard armor this armor is a variant of.",
+            type: ArmorIdentifier(),
+        }),
+        sturdinessRating: DB.Required({
+            comment: "An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.",
+            type: DB.Integer({ minimum: 1, maximum: 20 }),
+        }),
+    }),
+    customConstraints: validateArmorTypeReference,
+});
+const VariantArmorType = DB.TypeAlias(import.meta.url, {
+    name: "VariantArmorType",
+    comment: "The armor is a variant of a standard armor but also defines its own .",
+    type: () => DB.Object({
+        variantOf: DB.Required({
+            comment: "The standard armor this armor is a variant of.",
+            type: ArmorIdentifier(),
+        }),
+    }),
+    customConstraints: validateArmorTypeReference,
+});
 export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
     name: "SecondaryArmor",
     type: () => DB.Object({
@@ -106,9 +157,9 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
             comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
             type: DB.IncludeIdentifier(HasAdditionalPenalties),
         }),
-        armor_type: DB.Required({
-            comment: "The armor type..",
-            type: ArmorTypeIdentifier(),
+        variantOf: DB.Required({
+            comment: "The standard armor this armor is a variant of.",
+            type: ArmorIdentifier(),
         }),
         hit_zone: DB.Optional({
             comment: "Specify if armor is only available for a specific hit zone.",
@@ -129,6 +180,7 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
             }),
         }, { minProperties: 1 })),
     }),
+    customConstraints: validateArmorTypeReference,
 });
 const ArmorComplexity = DB.Enum(import.meta.url, {
     name: "ArmorComplexity",

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

@@ -148,7 +148,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/CeremonialItem.d.ts

@@ -149,7 +149,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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

@@ -148,7 +148,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/Container.d.ts

@@ -148,7 +148,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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

@@ -121,7 +121,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/IlluminationLightSource.d.ts

@@ -157,7 +157,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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

@@ -148,7 +148,7 @@ 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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/Liebesspielzeug.d.ts

@@ -148,7 +148,7 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/LuxuryGood.d.ts

@@ -148,7 +148,7 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/MagicalArtifact.d.ts

@@ -148,7 +148,7 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/MusicalInstrument.d.ts

@@ -148,7 +148,7 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/OrienteeringAid.d.ts

@@ -147,7 +147,7 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            armor_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

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

@@ -147,7 +147,7 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            armor_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

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

@@ -147,7 +147,7 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            armor_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

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

@@ -147,7 +147,7 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            armor_type: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

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

@@ -148,7 +148,7 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/WeaponAccessory.d.ts

@@ -148,7 +148,7 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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

@@ -148,7 +148,7 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
             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>;
-            armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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<{
@@ -328,7 +328,7 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
         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>;
-        armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        variantOf: DB.MemberDecl<DB.ReferenceIdentifier, 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/index.d.ts

@@ -46,7 +46,6 @@ export { Plant } from "./equipment/item/Plant.js";
 export { Poison } from "./equipment/item/Poison.js";
 export { RopeOrChain } from "./equipment/item/RopeOrChain.js";
 export { Stationery } from "./equipment/item/Stationery.js";
-export { ArmorType } from "./equipment/item/sub/ArmorType.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
 export { Reach } from "./equipment/item/sub/Reach.js";

package/lib/types/index.js

@@ -46,7 +46,6 @@ export { Plant } from "./equipment/item/Plant.js";
 export { Poison } from "./equipment/item/Poison.js";
 export { RopeOrChain } from "./equipment/item/RopeOrChain.js";
 export { Stationery } from "./equipment/item/Stationery.js";
-export { ArmorType } from "./equipment/item/sub/ArmorType.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
 export { Reach } from "./equipment/item/sub/Reach.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",

package/lib/types/equipment/item/sub/ArmorType.d.ts

@@ -1,7 +0,0 @@
-import * as DB from "tsondb/schema/dsl";
-export declare const ArmorType: DB.Entity<"ArmorType", {
-    sturdiness_rating: DB.MemberDecl<DB.Integer, false>;
-    translations: DB.MemberDecl<DB.NestedEntityMap<"ArmorTypeTranslation", {
-        name: DB.MemberDecl<DB.String, true>;
-    }>, true>;
-}, undefined>;

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

@@ -1,25 +0,0 @@
-import * as DB from "tsondb/schema/dsl";
-import { NestedTranslationMap } from "../../../Locale.js";
-export const ArmorType = DB.Entity(import.meta.url, {
-    name: "ArmorType",
-    namePlural: "ArmorTypes",
-    type: () => DB.Object({
-        sturdiness_rating: DB.Optional({
-            comment: "An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.",
-            type: DB.Integer({ minimum: 1, maximum: 20 }),
-        }),
-        translations: NestedTranslationMap(DB.Required, "ArmorType", DB.Object({
-            name: DB.Required({
-                comment: "The armor type’s name.",
-                type: DB.String({ minLength: 1 }),
-            }),
-        })),
-    }),
-    instanceDisplayName: {},
-    uniqueConstraints: [
-        {
-            entityMapKeyPath: "translations",
-            keyPathInEntityMap: "name",
-        },
-    ],
-});