@optolith/database-schema 0.111.0 → 0.112.0

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 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.112.0](https://github.com/Optolith/database-schema/compare/v0.111.1...v0.112.0) (2026-10-24)
+
+### ⚠ BREAKING CHANGES
+
+* custom additional penalties
+* define skill and combat technique rating bonus entries
+* optional armor weight
+
+### Features
+
+* custom additional penalties ([1c56824](https://github.com/Optolith/database-schema/commit/1c56824e11b36a9fdbc3b6cb57588dc0a684358e))
+* define skill and combat technique rating bonus entries ([efe4a54](https://github.com/Optolith/database-schema/commit/efe4a549c01e4ee4ed8710f6447059a5b60cd0b9))
+* optional armor weight ([35729c4](https://github.com/Optolith/database-schema/commit/35729c42a7dd7152be8c3146032a5e42a7ea915a))
+
+### Bug Fixes
+
+* skill descriptions support markdown ([1aeb838](https://github.com/Optolith/database-schema/commit/1aeb838e43bde7a31b8f34ff965b3e06ae3d2c82))
+
+## [0.111.1](https://github.com/Optolith/database-schema/compare/v0.111.0...v0.111.1) (2026-10-18)
+
 ## [0.111.0](https://github.com/Optolith/database-schema/compare/v0.110.1...v0.111.0) (2026-10-18)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -362,6 +362,7 @@ export type EnumMap = {
   GoblinRitualPerformanceParameters: GoblinRitualPerformanceParameters
   GoblinRitualRangeValue: GoblinRitualRangeValue
   GradientColor: GradientColor
+  HasAdditionalPenalties: HasAdditionalPenalties
   HerbalAidCombatUse: HerbalAidCombatUse
   HerbalPreservationLongevity: HerbalPreservationLongevity
   HerbalPreservationLongevityValue: HerbalPreservationLongevityValue
@@ -645,6 +646,7 @@ export type TypeAliasMap = {
   CursesOptions: CursesOptions
   CustomBannzeichenSuboption: CustomBannzeichenSuboption
   CustomDurationUnit: CustomDurationUnit
+  CustomHasAdditionalPenalties: CustomHasAdditionalPenalties
   CustomMagicalRuneSuboption: CustomMagicalRuneSuboption
   DaggerRitualArcaneEnergyCost: DaggerRitualArcaneEnergyCost
   DefaultEquipmentCategoryTypeRules: DefaultEquipmentCategoryTypeRules
@@ -745,7 +747,6 @@ export type TypeAliasMap = {
   GoblinRitualSustainedCost: GoblinRitualSustainedCost
   GoblinRitualSustainedPerformanceParameters: GoblinRitualSustainedPerformanceParameters
   GroupedCommonProfessions: GroupedCommonProfessions
-  HasAdditionalPenalties: HasAdditionalPenalties
   HeadHitZone: HeadHitZone
   HeadHitZoneCombinationPossibilities: HeadHitZoneCombinationPossibilities
   HerbalAidRecipe: HerbalAidRecipe
@@ -24228,7 +24229,7 @@ export interface Armor {
   /**
    * The weight in kg.
    */
-  weight: Weight
+  weight?: Weight
 
   /**
    * The complexity of crafting the item.
@@ -24363,7 +24364,26 @@ export type Encumbrance = number
 /**
  * Does the armor have additional penalties (MOV -1, INI -1)?
  */
-export type HasAdditionalPenalties = boolean
+export type HasAdditionalPenalties =
+  | {
+    kind: "Standard"
+    Standard: boolean
+  }
+  | {
+    kind: "Custom"
+    Custom: CustomHasAdditionalPenalties
+  }
+
+export type CustomHasAdditionalPenalties = {
+  [derivedCharacteristicId: string]: CustomAdditionalPenalty
+}
+
+export interface CustomAdditionalPenalty {
+  /**
+   * The value of the additional penalty.
+   */
+  value: number
+}
 
 /**
  * The armor type.
@@ -29244,6 +29264,16 @@ export interface Settings {
    * The publication that extends the description of books with additional information.
    */
   extendedBookDescriptionPublication: Publication_ID
+
+  /**
+   * The entry that grants a bonus of 1 towards the maximum skill rating per selection.
+   */
+  maximumSkillRatingBonusEntry: ActivatableIdentifier
+
+  /**
+   * The entry that grants a bonus of 1 towards the maximum skill rating per selection.
+   */
+  maximumCombatTechniqueRatingBonusEntry: ActivatableIdentifier
 }
 
 /**

package/lib/cache/index.d.ts

@@ -1,4 +1,4 @@
-import type { TSONDB } from "tsondb";
+import type { ReadonlyTSONDB } from "tsondb/readonly";
 import type { TSONDBTypes } from "../main.ts";
 import { type ActivatableSelectOptionsCache, type ResolvedSelectOption, type ResolvedSelectOptionIdentifier } from "./activatableSelectOptions.ts";
 import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts";
@@ -22,4 +22,4 @@ export type { ActivatableSelectOptionsCache, AncestorBloodAdvantagesCache, Magic
  * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
  * @returns The created cache object.
  */
-export declare const createCache: (db: TSONDB<TSONDBTypes>) => Cache;
+export declare const createCache: (db: ReadonlyTSONDB<TSONDBTypes>) => Cache;

package/lib/cache/internal.d.ts

@@ -1,4 +1,4 @@
-import type { TSONDB } from "tsondb";
+import type { ReadonlyTSONDB } from "tsondb/readonly";
 import type { Settings } from "../../gen/types.js";
 import type { TSONDBTypes } from "../main.ts";
-export type CacheBuilder<T = unknown, Args extends unknown[] = []> = (db: TSONDB<TSONDBTypes>, settings: Settings, ...args: Args) => T;
+export type CacheBuilder<T = unknown, Args extends unknown[] = []> = (db: ReadonlyTSONDB<TSONDBTypes>, settings: Settings, ...args: Args) => T;

package/lib/types/Settings.d.ts

@@ -187,4 +187,122 @@ export declare const Settings: DB.SingletonEntity<"Settings", {
         liturgical: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     }>, []>>, true>;
     extendedBookDescriptionPublication: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    maximumSkillRatingBonusEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+        Adoruzepterzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+        BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+        SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    maximumCombatTechniqueRatingBonusEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+        Adoruzepterzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+        SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+        WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+        BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+        MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+        SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+        VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+        Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+        Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+        Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
 }>;

package/lib/types/Settings.js

@@ -1,6 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { AdvantageIdentifier, DerivedCharacteristicIdentifier, ExperienceLevelIdentifier, FocusRuleIdentifier, PublicationIdentifier, } from "./_Identifier.js";
-import { SpecialAbilityIdentifier } from "./_IdentifierGroup.js";
+import { ActivatableIdentifier, SpecialAbilityIdentifier } from "./_IdentifierGroup.js";
 export const Settings = DB.SingletonEntity(import.meta.url, {
     name: "Settings",
     type: () => DB.Object({
@@ -31,6 +31,14 @@ export const Settings = DB.SingletonEntity(import.meta.url, {
             comment: "The publication that extends the description of books with additional information.",
             type: PublicationIdentifier(),
         }),
+        maximumSkillRatingBonusEntry: DB.Required({
+            comment: "The entry that grants a bonus of 1 towards the maximum skill rating per selection.",
+            type: DB.IncludeIdentifier(ActivatableIdentifier),
+        }),
+        maximumCombatTechniqueRatingBonusEntry: DB.Required({
+            comment: "The entry that grants a bonus of 1 towards the maximum skill rating per selection.",
+            type: DB.IncludeIdentifier(ActivatableIdentifier),
+        }),
     }),
 });
 const SupernaturalBaseAdvantageSettings = DB.TypeAlias(import.meta.url, {

package/lib/types/Skill.js

@@ -48,23 +48,23 @@ export const Skill = DB.Entity(import.meta.url, {
             }),
             tools: DB.Optional({
                 comment: "Mentions any tools from the equipment list that are necessary to employ the skill.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             quality: DB.Required({
                 comment: "Gives examples of the effects that various QL might provide.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             failed: DB.Required({
                 comment: "Lists examples of results for a failed check.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             critical: DB.Required({
                 comment: "Lists examples of results for a critical success.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             botch: DB.Required({
                 comment: "Lists examples of results for botches.",
-                type: DB.String({ minLength: 1 }),
+                type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),

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

@@ -22,7 +22,7 @@ export declare const Armor: DB.Entity<"Armor", {
             }>, false>;
         }>, []>>>;
     }, []>>, true>;
-    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, false>;
     complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorComplexity", {
         Primitive: DB.EnumCase<null>;
         Simple: DB.EnumCase<null>;
@@ -98,7 +98,12 @@ export declare const Armor: DB.Entity<"Armor", {
     }, []>>, false>;
     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>;
+    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+        Standard: DB.EnumCase<DB.Boolean>;
+        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+    }, []>>, 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>;
@@ -300,7 +305,12 @@ export declare const Armor: DB.Entity<"Armor", {
 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>;
+    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+        Standard: DB.EnumCase<DB.Boolean>;
+        Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+    }, []>>, 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>;
@@ -378,4 +388,9 @@ export declare const SecondaryArmor: DB.TypeAlias<"SecondaryArmor", DB.Object<{
 }>, []>;
 export declare const Protection: DB.TypeAlias<"Protection", DB.Integer, []>;
 export declare const Encumbrance: DB.TypeAlias<"Encumbrance", DB.Integer, []>;
-export declare const HasAdditionalPenalties: DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>;
+export declare const HasAdditionalPenalties: DB.Enum<"HasAdditionalPenalties", {
+    Standard: DB.EnumCase<DB.Boolean>;
+    Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+        value: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>;
+}, []>;

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

@@ -2,6 +2,7 @@ import { isNotNullish } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { ArmorIdentifier } from "../../_Identifier.js";
 import { EquipmentPrerequisites } from "../../_Prerequisite.js";
+import { DerivedCharacteristic } from "../../DerivedCharacteristic.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -14,7 +15,7 @@ export const Armor = DB.Entity(import.meta.url, {
             comment: "The cost in silverthalers.",
             type: DB.IncludeIdentifier(Cost),
         }),
-        weight: DB.Required({
+        weight: DB.Optional({
             comment: "The weight in kg.",
             type: DB.IncludeIdentifier(Weight),
         }),
@@ -234,10 +235,28 @@ export const Encumbrance = DB.TypeAlias(import.meta.url, {
     comment: "The ENC value.",
     type: () => DB.Integer({ minimum: 0 }),
 });
-export const HasAdditionalPenalties = DB.TypeAlias(import.meta.url, {
+export const HasAdditionalPenalties = DB.Enum(import.meta.url, {
     name: "HasAdditionalPenalties",
     comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
-    type: () => DB.Boolean(),
+    values: () => ({
+        Standard: DB.EnumCase({ type: DB.Boolean() }),
+        Custom: DB.EnumCase({ type: DB.IncludeIdentifier(CustomHasAdditionalPenalties) }),
+    }),
+});
+const CustomHasAdditionalPenalties = DB.TypeAlias(import.meta.url, {
+    name: "CustomHasAdditionalPenalties",
+    type: () => DB.NestedEntityMap({
+        name: "CustomAdditionalPenalty",
+        namePlural: "CustomAdditionalPenalties",
+        secondaryEntity: DerivedCharacteristic,
+        type: DB.Object({
+            value: DB.Required({
+                comment: "The value of the additional penalty.",
+                type: DB.Integer(),
+            }),
+        }),
+        minProperties: 1,
+    }),
 });
 const HitZone = DB.Enum(import.meta.url, {
     name: "HitZone",

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

@@ -194,7 +194,12 @@ export declare const ArmorAccessory: DB.Entity<"ArmorAccessory", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -199,7 +199,12 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const Clothes: DB.Entity<"Clothes", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const Container: DB.Entity<"Container", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -125,7 +125,12 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -203,7 +203,12 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -159,7 +159,12 @@ export declare const Item: DB.Entity<"Item", {
     armorUse: DB.MemberDecl<DB.IncludeIdentifier<[], 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>;
+        has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+            Standard: DB.EnumCase<DB.Boolean>;
+            Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -193,7 +193,12 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             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>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

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

@@ -193,7 +193,12 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             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>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

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

@@ -193,7 +193,12 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             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>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

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

@@ -193,7 +193,12 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
         Armor: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"SecondaryArmor", import("tsondb/schema/dsl").Object<{
             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>;
+            has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HasAdditionalPenalties", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").Boolean>;
+                Custom: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"CustomHasAdditionalPenalties", import("tsondb/schema/dsl").NestedEntityMap<string, {
+                    value: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
             armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
                 Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
                     sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;

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

@@ -194,7 +194,12 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;

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

@@ -194,7 +194,12 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
         Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+            has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+                Standard: DB.EnumCase<DB.Boolean>;
+                Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, 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>;
@@ -450,7 +455,12 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
     Armor: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+        has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HasAdditionalPenalties", {
+            Standard: DB.EnumCase<DB.Boolean>;
+            Custom: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CustomHasAdditionalPenalties", DB.NestedEntityMap<string, {
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>, 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>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.111.0",
+  "version": "0.112.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",
@@ -39,7 +39,7 @@
   "license": "MPL-2.0",
   "dependencies": {
     "@elyukai/utils": "^0.3.6",
-    "tsondb": "^0.23.0"
+    "tsondb": "^0.23.2"
   },
   "devDependencies": {
     "@elyukai/oxc-config": "^0.1.0",