optolith-database-schema 0.25.0 → 0.26.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.26.0](https://github.com/elyukai/optolith-database-schema/compare/v0.25.0...v0.26.0) (2025-12-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* Combat techniques need to specify special rules
+differently.
+
+### Features
+
+* add profession liturgies for ap sum option ([a1316af](https://github.com/elyukai/optolith-database-schema/commit/a1316af0c1f8b85e79f5f393eed2c3bec5204645)), closes [#86](https://github.com/elyukai/optolith-database-schema/issues/86)
+* custom constraint for weapon values ([02be29d](https://github.com/elyukai/optolith-database-schema/commit/02be29dab7bca40fb4c370c48a9f775ccf8aaf7d))
+
 ## [0.25.0](https://github.com/elyukai/optolith-database-schema/compare/v0.24.3...v0.25.0) (2025-12-14)
 
 

package/gen/types.d.ts

@@ -4131,17 +4131,31 @@ export interface CloseCombatTechniqueSpecialRules {
   /**
    * Is parrying possible with this combat technique?
    */
-  can_parry: boolean
+  can_parry: WeaponCombatTechniqueValueRule
 
-  has_damage_threshold: boolean
+  has_damage_threshold: WeaponCombatTechniqueValueRule
 
-  has_reach: boolean
+  has_reach: WeaponCombatTechniqueValueRule
 
-  has_length: boolean
+  has_length: WeaponCombatTechniqueValueRule
 
-  has_shield_size: boolean
+  has_shield_size: WeaponCombatTechniqueValueRule
 }
 
+/**
+ * Defines if the weapon must/can/must not define a value for this parameter.
+ */
+export type WeaponCombatTechniqueValueRule =
+  | {
+    kind: "Required"
+  }
+  | {
+    kind: "Optional"
+  }
+  | {
+    kind: "Prohibited"
+  }
+
 export interface RangedCombatTechnique {
   /**
    * Special rules for the combat technique that apply to all weapons in this category.
@@ -4199,7 +4213,7 @@ export interface RangedCombatTechniqueTranslation {
  * Special rules for the combat technique that apply to all weapons in this category.
  */
 export interface RangedCombatTechniqueSpecialRules {
-  has_ammunition: boolean
+  has_ammunition: WeaponCombatTechniqueValueRule
 }
 
 export interface Property {
@@ -7737,6 +7751,7 @@ export interface ProfessionPackageOptions {
   curses?: CursesOptions
   terrain_knowledge?: TerrainKnowledgeOptions
   skills?: SkillsOptions
+  liturgies?: LiturgiesOptions
 }
 
 /**
@@ -8043,6 +8058,16 @@ export interface SkillsOptions {
   ap_value: number
 }
 
+/**
+ * Buy liturgical chants and ceremonies for a specific amount of AP.
+ */
+export interface LiturgiesOptions {
+  /**
+   * The AP value you can buy liturgical chants and ceremonies for.
+   */
+  ap_value: number
+}
+
 export type ProfessionSpecialAbility =
   | {
     kind: "Constant"
@@ -17226,6 +17251,7 @@ export interface ProfessionVariantPackageOptions {
   curses?: VariantOptionAction<CursesOptions>
   terrain_knowledge?: VariantOptionAction<TerrainKnowledgeOptions>
   skills?: VariantOptionAction<SkillsOptions>
+  liturgies?: VariantOptionAction<LiturgiesOptions>
 }
 
 export type VariantOptionAction<T> =

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

@@ -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/equipment/item/BandageOrRemedy.js

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const BandageOrRemedy = Entity(import.meta.url, {
     name: "BandageOrRemedy",
     namePlural: "BandagesAndRemedies",
@@ -35,4 +36,13 @@ export const BandageOrRemedy = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

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

@@ -2,6 +2,7 @@ import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/sc
 import { BlessedTraditionIdentifier } from "../../_Identifier.js";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const CeremonialItem = Entity(import.meta.url, {
     name: "CeremonialItem",
     namePlural: "CeremonialItems",
@@ -40,4 +41,13 @@ export const CeremonialItem = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

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

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const Clothes = Entity(import.meta.url, {
     name: "Clothes",
     namePlural: "Clothes",
@@ -35,4 +36,13 @@ export const Clothes = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

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

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const Container = Entity(import.meta.url, {
     name: "Container",
     namePlural: "Containers",
@@ -35,4 +36,13 @@ export const Container = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

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

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Cost, DefaultItemTranslations, RestrictedTo, StructurePoints } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const EquipmentOfBlessedOnes = Entity(import.meta.url, {
     name: "EquipmentOfBlessedOnes",
     namePlural: "EquipmentOfBlessedOnes",
@@ -31,4 +32,13 @@ export const EquipmentOfBlessedOnes = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });

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

@@ -1,6 +1,7 @@
 import { Entity, Enum, EnumCase, Float, IncludeIdentifier, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const IlluminationLightSource = Entity(import.meta.url, {
     name: "IlluminationLightSource",
     namePlural: "IlluminationLightSources",
@@ -39,6 +40,15 @@ export const IlluminationLightSource = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });
 const BurningTime = Enum(import.meta.url, {
     name: "BurningTime",

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

@@ -1,6 +1,7 @@
 import { Entity, IncludeIdentifier, Object, Optional, Required } from "tsondb/schema/def";
 import { src } from "../../source/_PublicationRef.js";
 import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 export const IlluminationRefillOrSupply = Entity(import.meta.url, {
     name: "IlluminationRefillOrSupply",
     namePlural: "IlluminationRefillsAndSupplies",
@@ -35,4 +36,13 @@ export const IlluminationRefillOrSupply = Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            }, true);
+        }
+        return [];
+    },
 });