@optolith/database-schema 0.74.0 → 0.76.0

package/lib/types/_ActivatableSelectOptions.d.ts

@@ -15,19 +15,137 @@ export declare const select_options: DB.MemberDecl<DB.IncludeIdentifier<[], DB.T
         HomunculusTypes: DB.EnumCase<null>;
         BlessedTraditions: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BlessedTraditionsSelectOptionCategory", DB.Object<{
             require_principles: DB.MemberDecl<DB.Boolean, false>;
+            onlyType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BlessedTraditionTypeForSelectOptionCategory", {
+                Church: DB.EnumCase<null>;
+                Shamanistic: DB.EnumCase<null>;
+            }, []>>, false>;
         }>, []>>>;
         Elements: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ElementsSelectOptionCategory", DB.Object<{
             specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         }>, []>>>;
         Properties: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PropertiesSelectOptionCategory", DB.Object<{
-            require_knowledge: DB.MemberDecl<DB.Boolean, false>;
+            requireActiveSelectionOnEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+                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>;
+            }, []>>, false>;
             require_minimum_spellworks_on: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RequiredMinimumSkillsToBeOnSkillRating", DB.Object<{
                 number: DB.MemberDecl<DB.Integer, true>;
                 rating: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, false>;
         }>, []>>>;
         Aspects: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AspectSelectOptionCategory", DB.Object<{
-            require_knowledge: DB.MemberDecl<DB.Boolean, false>;
+            requireActiveSelectionOnEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+                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>;
+            }, []>>, false>;
             use_master_of_suffix_as_name: DB.MemberDecl<DB.Boolean, false>;
             require_minimum_liturgies_on: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RequiredMinimumSkillsToBeOnSkillRating", DB.Object<{
                 number: DB.MemberDecl<DB.Integer, true>;

package/lib/types/_ActivatableSkill.d.ts

@@ -133,6 +133,7 @@ export declare const OneTimePerformanceParameters: DB.TypeAlias<"OneTimePerforma
                     style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                         Compressed: DB.EnumCase<null>;
                         Verbose: DB.EnumCase<null>;
+                        Grouped: DB.EnumCase<null>;
                     }, []>>, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -156,6 +157,7 @@ export declare const OneTimePerformanceParameters: DB.TypeAlias<"OneTimePerforma
                     style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                         Compressed: DB.EnumCase<null>;
                         Verbose: DB.EnumCase<null>;
+                        Grouped: DB.EnumCase<null>;
                     }, []>>, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -424,6 +426,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -447,6 +450,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -664,6 +668,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -713,6 +718,7 @@ export declare const FastPerformanceParameters: DB.Enum<"FastPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -951,6 +957,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -974,6 +981,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -1191,6 +1199,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -1240,6 +1249,7 @@ export declare const SlowPerformanceParameters: DB.Enum<"SlowPerformanceParamete
                         style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                             Compressed: DB.EnumCase<null>;
                             Verbose: DB.EnumCase<null>;
+                            Grouped: DB.EnumCase<null>;
                         }, []>>, true>;
                         translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                             listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{

package/lib/types/_ActivatableSkillCost.d.ts

@@ -127,6 +127,7 @@ export declare const OneTimeCost: DB.Enum<"OneTimeCost", {
                 style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
+                    Grouped: DB.EnumCase<null>;
                 }, []>>, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -150,6 +151,7 @@ export declare const OneTimeCost: DB.Enum<"OneTimeCost", {
                 style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
+                    Grouped: DB.EnumCase<null>;
                 }, []>>, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -284,6 +286,7 @@ export declare const SustainedCost: DB.Enum<"SustainedCost", {
                 style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
+                    Grouped: DB.EnumCase<null>;
                 }, []>>, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -333,6 +336,7 @@ export declare const SustainedCost: DB.Enum<"SustainedCost", {
                 style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
+                    Grouped: DB.EnumCase<null>;
                 }, []>>, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -425,6 +429,7 @@ export declare const StandaloneCostMap: DB.TypeAlias<"StandaloneCostMap", DB.Inc
     style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
         Compressed: DB.EnumCase<null>;
         Verbose: DB.EnumCase<null>;
+        Grouped: DB.EnumCase<null>;
     }, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{

package/lib/types/_ActivatableSkillParameterMap.d.ts

@@ -4,6 +4,7 @@ export declare const ValueMap: DB.TypeAlias<"ValueMap", DB.Object<{
     style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
         Compressed: DB.EnumCase<null>;
         Verbose: DB.EnumCase<null>;
+        Grouped: DB.EnumCase<null>;
     }, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
@@ -25,6 +26,7 @@ export declare const ParameterMap: DB.TypeAlias<"ParameterMap", DB.IncludeIdenti
     style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
         Compressed: DB.EnumCase<null>;
         Verbose: DB.EnumCase<null>;
+        Grouped: DB.EnumCase<null>;
     }, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{

package/lib/types/_ActivatableSkillParameterMap.js

@@ -46,10 +46,20 @@ The \`an item the size of a\` would be the *list prefix* string, while the list
 });
 const ValueMapStyle = DB.Enum(import.meta.url, {
     name: "ValueMapStyle",
-    comment: "The style of the generated string. It may either be displayed in a compressed way (e.g. `1/2/3 AE for a small/medium/large object`) or in a verbose way (e.g. `1 AE for a small object, 2 AE for a medium object, 3 AE for a large object`).",
+    comment: "The style of the generated string. It may be displayed\n\n- in a `compressed` way (e.g. *1/1/2 AE for a small/medium/large object*),\n- in a `verbose` way (e.g. *1 AE for a small object, 1 AE for a medium object, 2 AE for a large object*),\n- or in a `grouped` way (e.g. *small/medium object: 1 AE, large object: 2 AE*).\n\nA `grouped` style only really makes sense if multiple options share the same value.",
     values: () => ({
-        Compressed: DB.EnumCase({ type: null }),
-        Verbose: DB.EnumCase({ type: null }),
+        Compressed: DB.EnumCase({
+            comment: "Prints a map in a compressed way, e.g. *1/2/3 AE for a small/medium/large object*.",
+            type: null,
+        }),
+        Verbose: DB.EnumCase({
+            comment: "Prints a map in a verbose way, e.g. *1 AE for a small object, 2 AE for a medium object, 3 AE for a large object*.",
+            type: null,
+        }),
+        Grouped: DB.EnumCase({
+            comment: "Prints a map in a grouped way, e.g. *small/medium object: 1 AE, large object: 2 AE*.",
+            type: null,
+        }),
     }),
 });
 export const createValueMapOption = (name, parameters, getOptionValues, includeStandaloneLabel = true) => DB.GenTypeAlias(import.meta.url, {

package/lib/types/_DiseasePoison.d.ts

@@ -4,14 +4,20 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const level: DB.MemberDecl<DB.Integer, true>;
 export declare const Resistance: 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>;
+    }>, []>>>;
 }, []>;
 export declare const 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>;
 export declare const Cause: DB.TypeAlias<"Cause", DB.Object<{
     chance: DB.MemberDecl<DB.Integer, false>;

package/lib/types/_DiseasePoison.js

@@ -1,9 +1,11 @@
 /**
  * This file defines some shared types for different diseases and poisons.
  */
+import { isNotNullish, nullableToArray } from "@elyukai/utils/nullable";
 import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { AlternativeName } from "./_AlternativeNames.js";
+import { DerivedCharacteristicIdentifier } from "./_Identifier.js";
 import { Errata } from "./source/_Erratum.js";
 export const level = DB.Required({
     comment: "The disease’s level.",
@@ -11,17 +13,50 @@ export const level = DB.Required({
 });
 export const Resistance = DB.Enum(import.meta.url, {
     name: "Resistance",
-    comment: "Depending on the disease, apply Spirit or Toughness as a penalty to the disease roll. It may also happen that the lower of both is applied as a penalty.",
+    comment: "Depending on the disease or poison, apply a resistance as a penalty to the disease or poison roll. It may also happen that the minimum is applied as a penalty.",
     values: () => ({
-        Spirit: DB.EnumCase({ type: null }),
-        Toughness: DB.EnumCase({ type: null }),
-        LowerOfSpiritAndToughness: DB.EnumCase({ type: null }),
+        Single: DB.EnumCase({
+            type: DB.IncludeIdentifier(SingleResistance),
+        }),
+        Minimum: DB.EnumCase({
+            type: DB.IncludeIdentifier(MinimumResistance),
+        }),
     }),
 });
 export const resistance = DB.Required({
-    comment: "Depending on the disease, apply Spirit or Toughness as a penalty to the disease roll. It may also happen that the lower of both is applied as a penalty.",
+    comment: "Depending on the disease or poison, apply Spirit or Toughness as a penalty to the disease or poison roll. It may also happen that the minimum is applied as a penalty.",
     type: DB.IncludeIdentifier(Resistance),
 });
+const checkDerivedCharacteristicIsResistance = (id, getInstanceById) => getInstanceById("DerivedCharacteristic", id)?.type?.kind !== "Resistance"
+    ? `The derived characteristic with the identifier "${id}" is not a resistance.`
+    : undefined;
+const SingleResistance = DB.TypeAlias(import.meta.url, {
+    name: "SingleResistance",
+    comment: "A single derived characteristic that classifies as a resistance.",
+    type: () => DB.Object({
+        derivedCharacteristic: DB.Required({
+            comment: "The derived characteristic that is used for the skill check.",
+            type: DerivedCharacteristicIdentifier(),
+        }),
+    }),
+    customConstraints: ({ instanceContent, getInstanceById }) => nullableToArray(checkDerivedCharacteristicIsResistance(instanceContent.derivedCharacteristic, getInstanceById)),
+});
+const MinimumResistance = DB.TypeAlias(import.meta.url, {
+    name: "MinimumResistance",
+    comment: "Multiple derived characteristics that classify as resistances whose minimum value represents the actual resistance against the disease.",
+    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),
+});
 export const Cause = DB.TypeAlias(import.meta.url, {
     name: "Cause",
     comment: "What causes the disease? The GM rolls 1D20 to see if a character gets infected. If the infection check succeeds, the GM makes a disease check to determine the severity of the infection.",

package/lib/types/_Identifier.d.ts

@@ -23,6 +23,7 @@ export declare const AttireEnchantmentIdentifier: () => R;
 export declare const AttributeIdentifier: () => R;
 export declare const BandageOrRemedyIdentifier: () => R;
 export declare const BannzeichenIdentifier: () => R;
+export declare const BannzeichenOptionIdentifier: () => R;
 export declare const BeutelzauberIdentifier: () => R;
 export declare const BiomeIdentifier: () => R;
 export declare const BlessedTraditionIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -67,7 +67,7 @@ import { Curriculum, Guideline, LessonPackage } from "./Lessons.js";
 import { LiturgicalChant } from "./LiturgicalChant.js";
 import { AnimistPower } from "./magicalActions/AnimistPower.js";
 import { Tribe } from "./magicalActions/AnimistPower_Tribe.js";
-import { Bannzeichen } from "./magicalActions/Bannzeichen.js";
+import { Bannzeichen, BannzeichenOption } from "./magicalActions/Bannzeichen.js";
 import { Curse } from "./magicalActions/Curse.js";
 import { DominationRitual } from "./magicalActions/DominationRitual.js";
 import { ElvenMagicalSong } from "./magicalActions/ElvenMagicalSong.js";
@@ -187,6 +187,7 @@ export const AttireEnchantmentIdentifier = () => R(AttireEnchantment);
 export const AttributeIdentifier = () => R(Attribute);
 export const BandageOrRemedyIdentifier = () => R(BandageOrRemedy);
 export const BannzeichenIdentifier = () => R(Bannzeichen);
+export const BannzeichenOptionIdentifier = () => R(BannzeichenOption);
 export const BeutelzauberIdentifier = () => R(Beutelzauber);
 export const BiomeIdentifier = () => R(Biome);
 export const BlessedTraditionIdentifier = () => R(BlessedTradition);

package/lib/types/_SkillCheck.d.ts

@@ -1,10 +1,15 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const SkillCheck: DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>;
 export declare const SkillCheckPenalty: 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/_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/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/index.d.ts

@@ -95,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

@@ -95,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/Bannzeichen.d.ts

@@ -56,6 +56,7 @@ export declare const Bannzeichen: DB.Entity<"Bannzeichen", {
                 style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                     Compressed: DB.EnumCase<null>;
                     Verbose: DB.EnumCase<null>;
+                    Grouped: DB.EnumCase<null>;
                 }, []>>, true>;
                 translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                     listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{

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>;