@optolith/database-schema 0.73.0 → 0.75.1

package/lib/types/_SkillCheck.js

@@ -1,5 +1,6 @@
+import { isNotNullish, nullableToArray } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
-import { AttributeIdentifier } from "./_Identifier.js";
+import { AttributeIdentifier, DerivedCharacteristicIdentifier } from "./_Identifier.js";
 export const SkillCheck = DB.TypeAlias(import.meta.url, {
     name: "SkillCheck",
     comment: "The attributes’ identifiers of the skill check.",
@@ -12,12 +13,57 @@ export const SkillCheckPenalty = DB.Enum(import.meta.url, {
     name: "SkillCheckPenalty",
     comment: "A specific value that represents a penalty for the associated skill check.",
     values: () => ({
-        Spirit: DB.EnumCase({ type: null }),
-        HalfOfSpirit: DB.EnumCase({ type: null }),
-        Toughness: DB.EnumCase({ type: null }),
-        HigherOfSpiritAndToughness: DB.EnumCase({ type: null }),
+        DerivedCharacteristic: DB.EnumCase({
+            type: DB.IncludeIdentifier(DerivedCharacteristicSkillCheckPenalty),
+        }),
         SummoningDifficulty: DB.EnumCase({ type: null }),
         CreationDifficulty: DB.EnumCase({ type: null }),
         Object: DB.EnumCase({ type: null }),
     }),
 });
+const DerivedCharacteristicSkillCheckPenalty = DB.Enum(import.meta.url, {
+    name: "DerivedCharacteristicSkillCheckPenalty",
+    comment: "A derived characteristic that classifies as a resistance that represents a penalty for the associated skill check.",
+    values: () => ({
+        Single: DB.EnumCase({
+            type: DB.IncludeIdentifier(SingleDerivedCharacteristicSkillCheckPenalty),
+        }),
+        Maximum: DB.EnumCase({
+            type: DB.IncludeIdentifier(MaximumDerivedCharacteristicSkillCheckPenalty),
+        }),
+    }),
+});
+const checkDerivedCharacteristicIsResistance = (id, getInstanceById) => getInstanceById("DerivedCharacteristic", id)?.type?.kind !== "Resistance"
+    ? `The derived characteristic with the identifier "${id}" is not a resistance.`
+    : undefined;
+const SingleDerivedCharacteristicSkillCheckPenalty = DB.TypeAlias(import.meta.url, {
+    name: "SingleDerivedCharacteristicSkillCheckPenalty",
+    comment: "A single derived characteristic that classifies as a resistance that represents a penalty for the associated skill check. It may be halved for the skill check.",
+    type: () => DB.Object({
+        derivedCharacteristic: DB.Required({
+            comment: "The derived characteristic that is used for the skill check.",
+            type: DerivedCharacteristicIdentifier(),
+        }),
+        halved: DB.Required({
+            comment: "Is the penalty halved for this skill check?",
+            type: DB.Boolean(),
+        }),
+    }),
+    customConstraints: ({ instanceContent, getInstanceById }) => nullableToArray(checkDerivedCharacteristicIsResistance(instanceContent.derivedCharacteristic, getInstanceById)),
+});
+const MaximumDerivedCharacteristicSkillCheckPenalty = DB.TypeAlias(import.meta.url, {
+    name: "MaximumDerivedCharacteristicSkillCheckPenalty",
+    comment: "Multiple derived characteristics that classify as resistances whose maximum value represents a penalty for the associated skill check.",
+    type: () => DB.Object({
+        derivedCharacteristics: DB.Required({
+            comment: "The derived characteristic that is used for the skill check.",
+            type: DB.Array(DerivedCharacteristicIdentifier(), {
+                minItems: 2,
+                uniqueItems: true,
+            }),
+        }),
+    }),
+    customConstraints: ({ instanceContent, getInstanceById }) => instanceContent.derivedCharacteristics
+        .map(id => checkDerivedCharacteristicIsResistance(id, getInstanceById))
+        .filter(isNotNullish),
+});

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/Poison.d.ts

@@ -289,9 +289,12 @@ export declare const Poison: DB.Entity<"Poison", {
         }>, []>>>;
     }, []>>, true>;
     resistance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Resistance", {
-        Spirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        LowerOfSpiritAndToughness: DB.EnumCase<null>;
+        Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleResistance", DB.Object<{
+            derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+        Minimum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MinimumResistance", DB.Object<{
+            derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>>;
     }, []>>, true>;
     start: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonStart", {
         Immediate: DB.EnumCase<null>;

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";
@@ -96,6 +95,7 @@ export { FocusRule } from "./rule/FocusRule.js";
 export { Subject } from "./rule/FocusRule_Subject.js";
 export { OptionalRule } from "./rule/OptionalRule.js";
 export { Service } from "./Service.js";
+export { Settings } from "./Settings.ts";
 export { SexPractice } from "./SexPractice.js";
 export { Skill } from "./Skill.js";
 export { SkillGroup } from "./SkillGroup.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";
@@ -96,6 +95,7 @@ export { FocusRule } from "./rule/FocusRule.js";
 export { Subject } from "./rule/FocusRule_Subject.js";
 export { OptionalRule } from "./rule/OptionalRule.js";
 export { Service } from "./Service.js";
+export { Settings } from "./Settings.js";
 export { SexPractice } from "./SexPractice.js";
 export { Skill } from "./Skill.js";
 export { SkillGroup } from "./SkillGroup.js";

package/lib/types/magicalActions/AnimistPower.d.ts

@@ -2,10 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const AnimistPower: DB.Entity<"AnimistPower", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
     check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
-        Spirit: DB.EnumCase<null>;
-        HalfOfSpirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        DerivedCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicSkillCheckPenalty", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                halved: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>>;
+            Maximum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MaximumDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
+        }, []>>>;
         SummoningDifficulty: DB.EnumCase<null>;
         CreationDifficulty: DB.EnumCase<null>;
         Object: DB.EnumCase<null>;

package/lib/types/magicalActions/Curse.d.ts

@@ -2,10 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const Curse: DB.Entity<"Curse", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
     check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
-        Spirit: DB.EnumCase<null>;
-        HalfOfSpirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        DerivedCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicSkillCheckPenalty", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                halved: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>>;
+            Maximum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MaximumDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
+        }, []>>>;
         SummoningDifficulty: DB.EnumCase<null>;
         CreationDifficulty: DB.EnumCase<null>;
         Object: DB.EnumCase<null>;

package/lib/types/magicalActions/DominationRitual.d.ts

@@ -2,10 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const DominationRitual: DB.Entity<"DominationRitual", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
     check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
-        Spirit: DB.EnumCase<null>;
-        HalfOfSpirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        DerivedCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicSkillCheckPenalty", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                halved: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>>;
+            Maximum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MaximumDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
+        }, []>>>;
         SummoningDifficulty: DB.EnumCase<null>;
         CreationDifficulty: DB.EnumCase<null>;
         Object: DB.EnumCase<null>;

package/lib/types/magicalActions/ElvenMagicalSong.d.ts

@@ -2,10 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const ElvenMagicalSong: DB.Entity<"ElvenMagicalSong", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
     check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
-        Spirit: DB.EnumCase<null>;
-        HalfOfSpirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        DerivedCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicSkillCheckPenalty", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                halved: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>>;
+            Maximum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MaximumDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
+        }, []>>>;
         SummoningDifficulty: DB.EnumCase<null>;
         CreationDifficulty: DB.EnumCase<null>;
         Object: DB.EnumCase<null>;

package/lib/types/magicalActions/GoblinRitual.d.ts

@@ -2,10 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const GoblinRitual: DB.Entity<"GoblinRitual", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
     check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
-        Spirit: DB.EnumCase<null>;
-        HalfOfSpirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        DerivedCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicSkillCheckPenalty", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                halved: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>>;
+            Maximum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MaximumDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
+        }, []>>>;
         SummoningDifficulty: DB.EnumCase<null>;
         CreationDifficulty: DB.EnumCase<null>;
         Object: DB.EnumCase<null>;

package/lib/types/magicalActions/JesterTrick.d.ts

@@ -2,10 +2,15 @@ import * as DB from "tsondb/schema/dsl";
 export declare const JesterTrick: DB.Entity<"JesterTrick", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
     check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
-        Spirit: DB.EnumCase<null>;
-        HalfOfSpirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        DerivedCharacteristic: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"DerivedCharacteristicSkillCheckPenalty", {
+            Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                halved: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>>;
+            Maximum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MaximumDerivedCharacteristicSkillCheckPenalty", DB.Object<{
+                derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>>;
+        }, []>>>;
         SummoningDifficulty: DB.EnumCase<null>;
         CreationDifficulty: DB.EnumCase<null>;
         Object: DB.EnumCase<null>;