optolith-database-schema 0.25.0 → 0.26.1

package/lib/main.d.ts

@@ -1,2 +1,9 @@
 import { Schema } from "tsondb/schema";
+import type { ChildEntityMap, EntityMap } from "../gen/types.js";
+declare module "tsondb/schema" {
+    interface Register {
+        entityMap: EntityMap;
+        childEntityMap: ChildEntityMap;
+    }
+}
 export declare const schema: Schema;

package/lib/types/Advantage.d.ts

@@ -14,6 +14,7 @@ export declare const Advantage: Entity<"Advantage", {
             Races: import("tsondb/schema/def").EnumCaseDecl<null>;
             Cultures: import("tsondb/schema/def").EnumCaseDecl<null>;
             RacesAndCultures: import("tsondb/schema/def").EnumCaseDecl<null>;
+            HomunculusTypes: import("tsondb/schema/def").EnumCaseDecl<null>;
             BlessedTraditions: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"BlessedTraditionsSelectOptionCategory", Object<{
                 require_principles: import("tsondb/schema/def").MemberDecl<Boolean, false>;
             }>, []>>>;
@@ -661,6 +662,15 @@ export declare const Advantage: Entity<"Advantage", {
                         }, []>>>, false>;
                     }>, [Ref: import("tsondb/schema/def").TypeParameter<"Ref", import("tsondb/schema/def").Type>]>>>;
                 }, []>>>, true>;
+                bindingCost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"SelectOptionsBindingCostValue", {
+                    Fixed: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"SelectOptionsFixedBindingCostValue", Object<{
+                        map: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"SelectOptionsFixedBindingCostValueMapping", Object<{
+                            id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>>, true>;
+                            bindingCost: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                        }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>, true>;
+                        default: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>;
+                }, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>, false>;
                 ap_value: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"SelectOptionsAdventurePointsValue", {
                     DerivedFromImprovementCost: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"SelectOptionsDeriveAdventurePointsValueFromImprovementCost", Object<{
                         multiplier: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
@@ -1043,6 +1053,7 @@ export declare const Advantage: Entity<"Advantage", {
         }>, []>>>;
         DerivedFromSelection: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDerivedFromSelection", Object<{
             translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"AdventurePointsDerivedFromSelectionTranslation", {
+                listPrepend: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
                 replacement: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
             }>, false>;
         }>, []>>>;

package/lib/types/CombatTechnique.d.ts

@@ -1,19 +1,39 @@
-import { Array, Boolean, Entity, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
 export declare const CloseCombatTechnique: Entity<"CloseCombatTechnique", {
     special: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CloseCombatTechniqueSpecialRules", Object<{
-        can_parry: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-        has_damage_threshold: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-        has_reach: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-        has_length: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-        has_shield_size: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        can_parry: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"WeaponCombatTechniqueValueRule", {
+            Required: EnumCase<null>;
+            Optional: EnumCase<null>;
+            Prohibited: EnumCase<null>;
+        }, []>>, true>;
+        has_damage_threshold: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"WeaponCombatTechniqueValueRule", {
+            Required: EnumCase<null>;
+            Optional: EnumCase<null>;
+            Prohibited: EnumCase<null>;
+        }, []>>, true>;
+        has_reach: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"WeaponCombatTechniqueValueRule", {
+            Required: EnumCase<null>;
+            Optional: EnumCase<null>;
+            Prohibited: EnumCase<null>;
+        }, []>>, true>;
+        has_length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"WeaponCombatTechniqueValueRule", {
+            Required: EnumCase<null>;
+            Optional: EnumCase<null>;
+            Prohibited: EnumCase<null>;
+        }, []>>, true>;
+        has_shield_size: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"WeaponCombatTechniqueValueRule", {
+            Required: EnumCase<null>;
+            Optional: EnumCase<null>;
+            Prohibited: EnumCase<null>;
+        }, []>>, true>;
     }>, []>>, true>;
     primary_attribute: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
     breaking_point_rating: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ImprovementCost", {
-        A: import("tsondb/schema/def").EnumCaseDecl<null>;
-        B: import("tsondb/schema/def").EnumCaseDecl<null>;
-        C: import("tsondb/schema/def").EnumCaseDecl<null>;
-        D: import("tsondb/schema/def").EnumCaseDecl<null>;
+    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ImprovementCost", {
+        A: EnumCase<null>;
+        B: EnumCase<null>;
+        C: EnumCase<null>;
+        D: EnumCase<null>;
     }, []>>, true>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
@@ -21,35 +41,35 @@ export declare const CloseCombatTechnique: Entity<"CloseCombatTechnique", {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
                     }, []>>, true>;
-                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
                     }, []>>, false>;
                 }>, []>>>, true>;
             }>, []>>, true>;
-            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
-                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
                     printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
                     pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
                         }, []>>, true>;
-                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
                         }, []>>, false>;
                     }>, []>>>, true>;
                 }>, []>>>;
-                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
                     printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
                 }>, []>>>;
             }, []>>>, false>;
@@ -66,15 +86,19 @@ export declare const CloseCombatTechnique: Entity<"CloseCombatTechnique", {
 }, undefined>;
 export declare const RangedCombatTechnique: Entity<"RangedCombatTechnique", {
     special: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangedCombatTechniqueSpecialRules", Object<{
-        has_ammunition: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        has_ammunition: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"WeaponCombatTechniqueValueRule", {
+            Required: EnumCase<null>;
+            Optional: EnumCase<null>;
+            Prohibited: EnumCase<null>;
+        }, []>>, true>;
     }>, []>>, true>;
     primary_attribute: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
     breaking_point_rating: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ImprovementCost", {
-        A: import("tsondb/schema/def").EnumCaseDecl<null>;
-        B: import("tsondb/schema/def").EnumCaseDecl<null>;
-        C: import("tsondb/schema/def").EnumCaseDecl<null>;
-        D: import("tsondb/schema/def").EnumCaseDecl<null>;
+    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ImprovementCost", {
+        A: EnumCase<null>;
+        B: EnumCase<null>;
+        C: EnumCase<null>;
+        D: EnumCase<null>;
     }, []>>, true>;
     src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
         id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
@@ -82,35 +106,35 @@ export declare const RangedCombatTechnique: Entity<"RangedCombatTechnique", {
             initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
                 printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
                 pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
                     }, []>>, true>;
-                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
                     }, []>>, false>;
                 }>, []>>>, true>;
             }>, []>>, true>;
-            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
-                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
                     printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
                     pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
                         }, []>>, true>;
-                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
                         }, []>>, false>;
                     }>, []>>>, true>;
                 }>, []>>>;
-                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
                     printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
                 }>, []>>>;
             }, []>>>, false>;

package/lib/types/CombatTechnique.js

@@ -1,4 +1,4 @@
-import { Array, Boolean, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
 import { AttributeIdentifier } from "./_Identifier.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -47,18 +47,36 @@ export const CloseCombatTechnique = Entity(import.meta.url, {
         },
     ],
 });
+const WeaponCombatTechniqueValueRule = Enum(import.meta.url, {
+    name: "WeaponCombatTechniqueValueRule",
+    comment: "Defines if the weapon must/can/must not define a value for this parameter.",
+    values: () => ({
+        Required: EnumCase({
+            comment: "The parameter must be present in all weapons for this combat technique.",
+            type: null,
+        }),
+        Optional: EnumCase({
+            comment: "The parameter can be present in any weapons for this combat technique.",
+            type: null,
+        }),
+        Prohibited: EnumCase({
+            comment: "The parameter must not be present in any weapon for this combat technique.",
+            type: null,
+        }),
+    }),
+});
 const CloseCombatTechniqueSpecialRules = TypeAlias(import.meta.url, {
     name: "CloseCombatTechniqueSpecialRules",
     comment: "Special rules for the combat technique that apply to all weapons in this category.",
     type: () => Object({
         can_parry: Required({
             comment: "Is parrying possible with this combat technique?",
-            type: Boolean(),
+            type: IncludeIdentifier(WeaponCombatTechniqueValueRule),
         }),
-        has_damage_threshold: Required({ type: Boolean() }),
-        has_reach: Required({ type: Boolean() }),
-        has_length: Required({ type: Boolean() }),
-        has_shield_size: Required({ type: Boolean() }),
+        has_damage_threshold: Required({ type: IncludeIdentifier(WeaponCombatTechniqueValueRule) }),
+        has_reach: Required({ type: IncludeIdentifier(WeaponCombatTechniqueValueRule) }),
+        has_length: Required({ type: IncludeIdentifier(WeaponCombatTechniqueValueRule) }),
+        has_shield_size: Required({ type: IncludeIdentifier(WeaponCombatTechniqueValueRule) }),
     }),
 });
 export const RangedCombatTechnique = Entity(import.meta.url, {
@@ -108,6 +126,6 @@ const RangedCombatTechniqueSpecialRules = TypeAlias(import.meta.url, {
     name: "RangedCombatTechniqueSpecialRules",
     comment: "Special rules for the combat technique that apply to all weapons in this category.",
     type: () => Object({
-        has_ammunition: Required({ type: Boolean() }),
+        has_ammunition: Required({ type: IncludeIdentifier(WeaponCombatTechniqueValueRule) }),
     }),
 });

package/lib/types/Disadvantage.d.ts

@@ -14,6 +14,7 @@ export declare const Disadvantage: Entity<"Disadvantage", {
             Races: import("tsondb/schema/def").EnumCaseDecl<null>;
             Cultures: import("tsondb/schema/def").EnumCaseDecl<null>;
             RacesAndCultures: import("tsondb/schema/def").EnumCaseDecl<null>;
+            HomunculusTypes: import("tsondb/schema/def").EnumCaseDecl<null>;
             BlessedTraditions: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"BlessedTraditionsSelectOptionCategory", Object<{
                 require_principles: import("tsondb/schema/def").MemberDecl<Boolean, false>;
             }>, []>>>;
@@ -661,6 +662,15 @@ export declare const Disadvantage: Entity<"Disadvantage", {
                         }, []>>>, false>;
                     }>, [Ref: import("tsondb/schema/def").TypeParameter<"Ref", import("tsondb/schema/def").Type>]>>>;
                 }, []>>>, true>;
+                bindingCost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"SelectOptionsBindingCostValue", {
+                    Fixed: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"SelectOptionsFixedBindingCostValue", Object<{
+                        map: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"SelectOptionsFixedBindingCostValueMapping", Object<{
+                            id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>>, true>;
+                            bindingCost: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                        }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>, true>;
+                        default: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>>;
+                }, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>>, false>;
                 ap_value: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"SelectOptionsAdventurePointsValue", {
                     DerivedFromImprovementCost: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"SelectOptionsDeriveAdventurePointsValueFromImprovementCost", Object<{
                         multiplier: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
@@ -970,6 +980,7 @@ export declare const Disadvantage: Entity<"Disadvantage", {
         }>, []>>>;
         DerivedFromSelection: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AdventurePointsDerivedFromSelection", Object<{
             translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"AdventurePointsDerivedFromSelectionTranslation", {
+                listPrepend: import("tsondb/schema/def").MemberDecl<String, false>;
                 replacement: import("tsondb/schema/def").MemberDecl<String, false>;
             }>, false>;
         }>, []>>>;

package/lib/types/HomunculusType.d.ts

@@ -0,0 +1,6 @@
+import { Entity, String } from "tsondb/schema/def";
+export declare const HomunculusType: Entity<"HomunculusType", {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"HomunculusTypeTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/HomunculusType.js

@@ -0,0 +1,15 @@
+import { Entity, Object, Required, String } from "tsondb/schema/def";
+import { NestedTranslationMap } from "./Locale.js";
+export const HomunculusType = Entity(import.meta.url, {
+    name: "HomunculusType",
+    namePlural: "HomunculusTypes",
+    type: () => Object({
+        translations: NestedTranslationMap(Required, "HomunculusType", Object({
+            name: Required({
+                comment: "The homunculus type’s name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    displayName: {},
+});

package/lib/types/Profession.d.ts

@@ -76,6 +76,9 @@ export declare const Profession: Entity<"Profession", {
                     group: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
                     ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
                 }>, []>>, false>;
+                liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"LiturgiesOptions", ObjectType<{
+                    ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>, false>;
             }>, []>>, false>;
             special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"ProfessionSpecialAbility", {
                 Constant: EnumCase<IncludeIdentifier<[], TypeAlias<"ConstantProfessionSpecialAbility", ObjectType<{
@@ -332,6 +335,10 @@ export declare const Profession: Entity<"Profession", {
                         Remove: EnumCase<null>;
                         Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
                     }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
+                    liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"VariantOptionAction", {
+                        Remove: EnumCase<null>;
+                        Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+                    }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
                 }>, []>>, false>;
                 special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ProfessionVariantSpecialAbility", ObjectType<{
                     action: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"VariantSpecialAbilityAction", {
@@ -692,6 +699,9 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
                 group: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
                 ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
             }>, []>>, false>;
+            liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"LiturgiesOptions", ObjectType<{
+                ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            }>, []>>, false>;
         }>, []>>, false>;
         special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"ProfessionSpecialAbility", {
             Constant: EnumCase<IncludeIdentifier<[], TypeAlias<"ConstantProfessionSpecialAbility", ObjectType<{
@@ -948,6 +958,10 @@ export declare const ProfessionVersion: Entity<"ProfessionVersion", {
                     Remove: EnumCase<null>;
                     Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
                 }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
+                liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"VariantOptionAction", {
+                    Remove: EnumCase<null>;
+                    Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+                }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
             }>, []>>, false>;
             special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ProfessionVariantSpecialAbility", ObjectType<{
                 action: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"VariantSpecialAbilityAction", {
@@ -1300,6 +1314,9 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
             group: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
             ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
         }>, []>>, false>;
+        liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"LiturgiesOptions", ObjectType<{
+            ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        }>, []>>, false>;
     }>, []>>, false>;
     special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"ProfessionSpecialAbility", {
         Constant: EnumCase<IncludeIdentifier<[], TypeAlias<"ConstantProfessionSpecialAbility", ObjectType<{
@@ -1556,6 +1573,10 @@ export declare const ProfessionPackage: Entity<"ProfessionPackage", {
                 Remove: EnumCase<null>;
                 Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
             }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
+            liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"VariantOptionAction", {
+                Remove: EnumCase<null>;
+                Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+            }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
         }>, []>>, false>;
         special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ProfessionVariantSpecialAbility", ObjectType<{
             action: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"VariantSpecialAbilityAction", {
@@ -1828,6 +1849,10 @@ export declare const ProfessionVariant: Entity<"ProfessionVariant", {
             Remove: EnumCase<null>;
             Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
         }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
+        liturgies: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"VariantOptionAction", {
+            Remove: EnumCase<null>;
+            Override: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+        }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, false>;
     }>, []>>, false>;
     special_abilities: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ProfessionVariantSpecialAbility", ObjectType<{
         action: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"VariantSpecialAbilityAction", {

package/lib/types/Profession.js

@@ -363,7 +363,7 @@ const MagicalSkillRating = TypeAlias(import.meta.url, {
             type: Array(IncludeIdentifier(ProfessionMagicalSkillIdentifier), { minItems: 1 }),
         }),
         rating_modifier: Required({
-            comment: "The rating bonus provided for the (selected) magical skill. If used in a profession variant, it can also be used to lower the bonus of the base profession.\n\n**Note:** This is a rating *bonus*, so it will be *added* to the default value of 6.",
+            comment: "The rating bonus provided for the (selected) magical skill. If used in a profession variant, it can also be used to lower the bonus of the base profession.\n\n**Note:** If due to a variant a spell rating is lowered to 0, the spell is considered deactivated. Both setting the value for a spell and deactivating it by setting it to 0 takes into account the additional activation cost for spells.",
             type: Integer(),
         }),
     }),
@@ -405,7 +405,7 @@ const LiturgicalChantRating = TypeAlias(import.meta.url, {
             type: Array(IncludeIdentifier(LiturgyIdentifier), { minItems: 1 }),
         }),
         rating_modifier: Required({
-            comment: "The rating bonus provided for the selected liturgical chant. If used in a profession variant, it can also be used to lower the bonus of the base profession.\n\n**Note:** This is a rating *bonus*, so it will be *added* to the default value of 6.",
+            comment: "The rating bonus provided for the selected liturgical chant. If used in a profession variant, it can also be used to lower the bonus of the base profession.\n\n**Note:** If due to a variant a liturgical chant rating is lowered to 0, the liturgical chant is considered deactivated. Both setting the value for a liturgical chant and deactivating it by setting it to 0 takes into account the additional activation cost for liturgical chants.",
             type: Integer(),
         }),
     }),
@@ -435,6 +435,9 @@ const ProfessionPackageOptions = TypeAlias(import.meta.url, {
         skills: Optional({
             type: IncludeIdentifier(SkillsOptions),
         }),
+        liturgies: Optional({
+            type: IncludeIdentifier(LiturgiesOptions),
+        }),
     }, { minProperties: 1 }),
 });
 const ProfessionVariantPackageOptions = TypeAlias(import.meta.url, {
@@ -470,6 +473,9 @@ const ProfessionVariantPackageOptions = TypeAlias(import.meta.url, {
         skills: Optional({
             type: GenIncludeIdentifier(VariantOptionAction, [IncludeIdentifier(SkillsOptions)]),
         }),
+        liturgies: Optional({
+            type: GenIncludeIdentifier(VariantOptionAction, [IncludeIdentifier(LiturgiesOptions)]),
+        }),
     }, { minProperties: 1 }),
 });
 const VariantOptionAction = GenEnum(import.meta.url, {
@@ -589,6 +595,16 @@ const SkillsOptions = TypeAlias(import.meta.url, {
         }),
     }),
 });
+const LiturgiesOptions = TypeAlias(import.meta.url, {
+    name: "LiturgiesOptions",
+    comment: `Buy liturgical chants and ceremonies for a specific amount of AP.`,
+    type: () => ObjectType({
+        ap_value: Required({
+            comment: "The AP value you can buy liturgical chants and ceremonies for.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
 const ProfessionName = TypeAlias(import.meta.url, {
     name: "ProfessionName",
     comment: "The name of the profession that may have sex-specific names. Useful if the term in generell is different (i.e. actor/actress) or if the language uses gendered nouns. The default name is also used in case neither the male nor female name strictly applies.",

package/lib/types/_ActivatableAdventurePointsValue.d.ts

@@ -14,6 +14,7 @@ export declare const ap_value: import("tsondb/schema/def").MemberDecl<IncludeIde
     }>, []>>>;
     DerivedFromSelection: EnumCase<IncludeIdentifier<[], TypeAlias<"AdventurePointsDerivedFromSelection", Object<{
         translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"AdventurePointsDerivedFromSelectionTranslation", {
+            listPrepend: import("tsondb/schema/def").MemberDecl<String, false>;
             replacement: import("tsondb/schema/def").MemberDecl<String, false>;
         }>, false>;
     }>, []>>>;

package/lib/types/_ActivatableAdventurePointsValue.js

@@ -58,6 +58,10 @@ const AdventurePointsDerivedFromSelection = TypeAlias(import.meta.url, {
     comment: "The adventure points value is derived from the selection of the special ability. Its display value may be able to be derived from the given information for the select options. If that is not the case or the generated text would not match the original one, a replacement text can be provided.",
     type: () => Object({
         translations: NestedTranslationMap(Optional, "AdventurePointsDerivedFromSelection", Object({
+            listPrepend: Optional({
+                comment: "Place a string between the `for` and the grouped option names.",
+                type: String({ minLength: 1 }),
+            }),
             replacement: Optional({
                 comment: "A replacement for the generated text if it would not match the original one.",
                 type: String({ minLength: 1, isMarkdown: true }),

package/lib/types/_ActivatableNonMundane.d.ts

@@ -145,7 +145,7 @@ export declare const cost: import("tsondb/schema/def").MemberDecl<IncludeIdentif
                         full: import("tsondb/schema/def").MemberDecl<String, true>;
                         compressed: import("tsondb/schema/def").MemberDecl<String, false>;
                     }>, []>>, false>;
-                }>, false>;
+                }>, true>;
             }>, []>>>, true>;
             translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"BindingCostMapTranslation", {
                 list_prepend: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextOptional", Object<{
@@ -164,6 +164,10 @@ export declare const cost: import("tsondb/schema/def").MemberDecl<IncludeIdentif
         }>, []>>>;
         DerivedFromSelection: EnumCase<IncludeIdentifier<[], TypeAlias<"BindingCostDerivedFromSelection", Object<{
             fallback: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"BindingCostDerivedFromSelectionTranslation", {
+                listPrepend: import("tsondb/schema/def").MemberDecl<String, false>;
+                replacement: import("tsondb/schema/def").MemberDecl<String, false>;
+            }>, false>;
         }>, []>>>;
     }, []>>>;
 }, []>>, false>;
@@ -365,7 +369,7 @@ export declare const BindingCost: Enum<"BindingCost", {
                     full: import("tsondb/schema/def").MemberDecl<String, true>;
                     compressed: import("tsondb/schema/def").MemberDecl<String, false>;
                 }>, []>>, false>;
-            }>, false>;
+            }>, true>;
         }>, []>>>, true>;
         translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"BindingCostMapTranslation", {
             list_prepend: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextOptional", Object<{
@@ -384,6 +388,10 @@ export declare const BindingCost: Enum<"BindingCost", {
     }>, []>>>;
     DerivedFromSelection: EnumCase<IncludeIdentifier<[], TypeAlias<"BindingCostDerivedFromSelection", Object<{
         fallback: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"BindingCostDerivedFromSelectionTranslation", {
+            listPrepend: import("tsondb/schema/def").MemberDecl<String, false>;
+            replacement: import("tsondb/schema/def").MemberDecl<String, false>;
+        }>, false>;
     }>, []>>>;
 }, []>;
 export declare const bindingCost: import("tsondb/schema/def").MemberDecl<String, false>;

package/lib/types/_ActivatableNonMundane.js

@@ -445,7 +445,7 @@ const BindingCostMapOption = TypeAlias(import.meta.url, {
             comment: "The full permanent AE cost value for this option.",
             type: Integer({ minimum: 1 }),
         }),
-        translations: NestedTranslationMap(Optional, "BindingCostMapOption", Object({
+        translations: NestedTranslationMap(Required, "BindingCostMapOption", Object({
             label: Required({
                 comment: "The description of the option for cost string generation.",
                 type: IncludeIdentifier(ResponsiveTextOptional),
@@ -464,6 +464,16 @@ const BindingCostDerivedFromSelection = TypeAlias(import.meta.url, {
             comment: "The binding cost for the selection if it does not define a specific one.",
             type: Integer({ minimum: 0 }),
         }),
+        translations: NestedTranslationMap(Optional, "BindingCostDerivedFromSelection", Object({
+            listPrepend: Optional({
+                comment: "Place a string between the `for` and the grouped option names.",
+                type: String({ minLength: 1 }),
+            }),
+            replacement: Optional({
+                comment: "A replacement for the generated text if it would not match the original one.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        }, { minProperties: 1 })),
     }),
 });
 const PropertyDeclaration = Enum(import.meta.url, {