optolith-database-schema 0.24.3 → 0.26.0

package/CHANGELOG.md

@@ -2,6 +2,31 @@
 
 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)
+
+
+### ⚠ BREAKING CHANGES
+
+* add unique constraints
+
+### Features
+
+* add unique constraints ([8bacb48](https://github.com/elyukai/optolith-database-schema/commit/8bacb489d804d280801b38111d96732fb9a317fc))
+* adjust display names of pact domains and types ([6086a6d](https://github.com/elyukai/optolith-database-schema/commit/6086a6d89160f7f09f9f6474cc240acd4d518f43))
+
 ## [0.24.3](https://github.com/elyukai/optolith-database-schema/compare/v0.24.2...v0.24.3) (2025-12-09)
 
 

package/gen/types.d.ts

@@ -176,6 +176,23 @@ export type EntityMap = {
   ZibiljaRitual: ZibiljaRitual
 }
 
+export type ChildEntityMap = {
+  Enhancement: [Enhancement, "parent", Enhancement["parent"]]
+  GeneralSelectOption: [GeneralSelectOption, "parent", GeneralSelectOption["parent"]]
+  LanguageSpecialization: [LanguageSpecialization, "parent", LanguageSpecialization["parent"]]
+  LessonPackage: [LessonPackage, "curriculum", LessonPackage["curriculum"]]
+  MagicalRuneOption: [MagicalRuneOption, "parent", MagicalRuneOption["parent"]]
+  NewSkillApplication: [NewSkillApplication, "parent", NewSkillApplication["parent"]]
+  PactDomain: [PactDomain, "parent", PactDomain["parent"]]
+  PactType: [PactType, "parent", PactType["parent"]]
+  ProfessionPackage: [ProfessionPackage, "profession_version", ProfessionPackage["profession_version"]]
+  ProfessionVariant: [ProfessionVariant, "profession_package", ProfessionVariant["profession_package"]]
+  ProfessionVersion: [ProfessionVersion, "profession", ProfessionVersion["profession"]]
+  RaceVariant: [RaceVariant, "race", RaceVariant["race"]]
+  SkillApplication: [SkillApplication, "parent", SkillApplication["parent"]]
+  SkillUse: [SkillUse, "parent", SkillUse["parent"]]
+}
+
 export type StringableTranslationParameter = {
   toString(): string
 }
@@ -4114,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.
@@ -4182,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 {
@@ -7720,6 +7751,7 @@ export interface ProfessionPackageOptions {
   curses?: CursesOptions
   terrain_knowledge?: TerrainKnowledgeOptions
   skills?: SkillsOptions
+  liturgies?: LiturgiesOptions
 }
 
 /**
@@ -8026,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"
@@ -17209,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/test.d.ts

@@ -1 +1 @@
-import "./main.js";
+export {};

package/lib/test.js

@@ -1,2 +1,11 @@
+import { stderr } from "node:process";
+import { styleText } from "node:util";
 // importing the main file will run the schema checks
-import "./main.js";
+import("./main.js")
+    .then(() => {
+    console.log(styleText("green", "Schema is valid"));
+})
+    .catch((err) => {
+    console.error(styleText("red", err instanceof Error ? err.message : String(err), { stream: stderr }));
+    process.exitCode = 1;
+});

package/lib/types/Advantage.js

@@ -46,4 +46,11 @@ export const Advantage = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name_in_library",
+            keyPathInEntityMapFallback: "name",
+        },
+    ],
 });

package/lib/types/AnimalDisease.js

@@ -26,4 +26,10 @@ If no causes are given, the disease is not communicable to intelligent creatures
         translations: NestedTranslationMap(Required, "AnimalDisease", DiseaseTranslation),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/AnimalType.js

@@ -12,4 +12,10 @@ export const AnimalType = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/ArcaneBardTradition.js

@@ -5,4 +5,10 @@ export const ArcaneBardTradition = Entity(import.meta.url, {
     namePlural: "ArcaneBardTraditions",
     type: ArcaneTraditionType("ArcaneBardTraditionTranslation"),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/ArcaneDancerTradition.js

@@ -5,4 +5,10 @@ export const ArcaneDancerTradition = Entity(import.meta.url, {
     namePlural: "ArcaneDancerTraditions",
     type: ArcaneTraditionType("ArcaneDancerTraditionTranslation"),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/Aspect.js

@@ -18,4 +18,10 @@ export const Aspect = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/Attribute.js

@@ -21,4 +21,14 @@ export const Attribute = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "abbreviation",
+        },
+    ],
 });

package/lib/types/Blessing.js

@@ -45,6 +45,12 @@ export const Blessing = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const BlessingPerformanceParameters = TypeAlias(import.meta.url, {
     name: "BlessingPerformanceParameters",

package/lib/types/Cantrip.js

@@ -56,6 +56,12 @@ export const Cantrip = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const CantripNote = Enum(import.meta.url, {
     name: "CantripNote",

package/lib/types/Ceremony.js

@@ -85,4 +85,10 @@ export const Ceremony = Entity(import.meta.url, {
         }),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

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";
@@ -40,6 +40,30 @@ export const CloseCombatTechnique = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+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",
@@ -47,12 +71,12 @@ const CloseCombatTechniqueSpecialRules = TypeAlias(import.meta.url, {
     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, {
@@ -91,11 +115,17 @@ export const RangedCombatTechnique = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 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/Condition.js

@@ -29,4 +29,10 @@ export const Condition = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/Continent.js

@@ -13,4 +13,10 @@ export const Continent = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });

package/lib/types/Culture.js

@@ -94,6 +94,12 @@ export const Culture = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });
 const AreaKnowledge = TypeAlias(import.meta.url, {
     name: "AreaKnowledge",

package/lib/types/DerivedCharacteristic.js

@@ -26,6 +26,16 @@ export const DerivedCharacteristic = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "abbreviation",
+        },
+    ],
 });
 const CalculationTranslation = TypeAlias(import.meta.url, {
     name: "CalculationTranslation",

package/lib/types/Disadvantage.js

@@ -47,4 +47,11 @@ export const Disadvantage = Entity(import.meta.url, {
         })),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name_in_library",
+            keyPathInEntityMapFallback: "name",
+        },
+    ],
 });

package/lib/types/Disease.js

@@ -18,4 +18,10 @@ export const Disease = Entity(import.meta.url, {
         translations: NestedTranslationMap(Required, "Disease", DiseaseTranslation),
     }),
     displayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
 });