@optolith/database-schema 0.78.0 → 0.79.1

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

@@ -12,6 +12,7 @@ import { RangedWeapon } from "./_RangedWeapon.js";
 import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
 import { SecondaryArmor } from "./Armor.js";
 import { isEquipmentCategoryOfDefaultType, mergeAllValueRules } from "./EquipmentCategory.js";
+import { BurningTime } from "./IlluminationLightSource.js";
 export const Item = DB.Entity(import.meta.url, {
     name: "Item",
     namePlural: "Items",
@@ -36,6 +37,10 @@ export const Item = DB.Entity(import.meta.url, {
             comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
             type: DB.IncludeIdentifier(StructurePoints),
         }),
+        burningTime: DB.Optional({
+            comment: "The burning time is the time how long the light source can be lit. After that time you have to use a new light source.",
+            type: DB.IncludeIdentifier(BurningTime),
+        }),
         meleeUses: DB.Optional({
             comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
             type: DB.NestedEntityMap({
@@ -110,22 +115,26 @@ export const Item = DB.Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
-    customConstraints: ({ instanceContent, ...rest }) => checkWeaponCombatTechniqueIntegrity({
-        ...rest,
-        instanceContent,
-    }).concat(checkEquipmentCategoryConstraintsWithItem(instanceContent, rest.getInstanceById)),
+    customConstraints: ({ instanceContent, ...rest }) => checkEquipmentCategoryConstraintsWithItem(instanceContent, rest.getInstanceById, rest.getDisplayNameAndId),
 });
-const checkEquipmentCategoryConstraintsWithItem = (item, getInstanceById) => {
+const checkEquipmentCategoryConstraintsWithItem = (item, getInstanceById, getDisplayNameAndId) => {
     const categories = item.categories.map(categoryId => getInstanceById("EquipmentCategory", categoryId));
     if (isNotEmpty(categories)) {
         if (categories.every(isNotNullish)) {
             if (categories.every(isEquipmentCategoryOfDefaultType)) {
                 const mergedRules = mergeAllValueRules(categories.map(c => c.type.Default));
                 const errors = [];
-                if (mergedRules.combatValues.isWeaponAllowed &&
-                    item.meleeUses === undefined &&
-                    item.rangedUses === undefined) {
-                    errors.push("A weapon must defined at least one melee use or ranged use.");
+                if (mergedRules.combatValues.isWeaponAllowed) {
+                    if (item.meleeUses === undefined && item.rangedUses === undefined) {
+                        errors.push("A weapon must defined at least one melee use or ranged use.");
+                    }
+                    else {
+                        errors.push(...checkWeaponCombatTechniqueIntegrity({
+                            instanceContent: item,
+                            getInstanceById,
+                            getDisplayNameAndId,
+                        }));
+                    }
                 }
                 if (mergedRules.combatValues.isArmorAllowed && item.armorUse === undefined) {
                     errors.push("An armor must defined an armor use.");
@@ -149,6 +158,7 @@ const checkEquipmentCategoryConstraintsWithItem = (item, getInstanceById) => {
                 applyValueRule(mergedRules.restrictedTo, item.restrictedTo, "Restriction are");
                 applyValueRule(mergedRules.structurePoints, item.structurePoints, "Structure points are");
                 applyValueRule(mergedRules.weight, item.weight, "A weight is");
+                applyValueRule(mergedRules.burningTime, item.burningTime, "A burning time is");
                 return errors;
             }
             else {

package/lib/types/equipment/item/Liebesspielzeug.d.ts

@@ -148,7 +148,18 @@ export declare const Liebesspielzeug: DB.Entity<"Liebesspielzeug", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/equipment/item/LuxuryGood.d.ts

@@ -148,7 +148,18 @@ export declare const LuxuryGood: DB.Entity<"LuxuryGood", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/equipment/item/MagicalArtifact.d.ts

@@ -148,7 +148,18 @@ export declare const MagicalArtifact: DB.Entity<"MagicalArtifact", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/equipment/item/MusicalInstrument.d.ts

@@ -148,7 +148,18 @@ export declare const MusicalInstrument: DB.Entity<"MusicalInstrument", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/equipment/item/OrienteeringAid.d.ts

@@ -147,7 +147,18 @@ export declare const OrienteeringAid: import("tsondb/schema/dsl").Entity<string,
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                StandardVariant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardVariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                Variant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"VariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

package/lib/types/equipment/item/RopeOrChain.d.ts

@@ -147,7 +147,18 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                StandardVariant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardVariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                Variant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"VariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

package/lib/types/equipment/item/Stationery.d.ts

@@ -147,7 +147,18 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                StandardVariant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardVariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                Variant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"VariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

package/lib/types/equipment/item/ThievesTool.d.ts

@@ -147,7 +147,18 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
             protection: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Protection", import("tsondb/schema/dsl").Integer, []>>, true>;
             encumbrance: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Encumbrance", import("tsondb/schema/dsl").Integer, []>>, true>;
             has_additional_penalties: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HasAdditionalPenalties", import("tsondb/schema/dsl").Boolean, []>>, true>;
-            variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+            armorType: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ArmorType", {
+                Standard: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardArmorType", import("tsondb/schema/dsl").Object<{
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                StandardVariant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"StandardVariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                    sturdinessRating: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
+                }>, []>>>;
+                Variant: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"VariantArmorType", import("tsondb/schema/dsl").Object<{
+                    variantOf: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"HitZone", {
                 Head: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZone", import("tsondb/schema/dsl").Object<{
                     combination_possibilities: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"HeadHitZoneCombinationPossibilities", import("tsondb/schema/dsl").Object<{

package/lib/types/equipment/item/TravelGearOrTool.d.ts

@@ -148,7 +148,18 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/equipment/item/WeaponAccessory.d.ts

@@ -148,7 +148,18 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/equipment/item/_Item.d.ts

@@ -148,7 +148,18 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
             protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
             encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
             has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-            variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, true>;
             hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
                 Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                     combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{
@@ -328,7 +339,18 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
         protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
         encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
         has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
-        variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+            Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            }>, []>>>;
+        }, []>>, true>;
         hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
             Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
                 combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{

package/lib/types/specialAbility/AdvancedCombatSpecialAbility.d.ts

@@ -850,6 +850,35 @@ export declare const AdvancedCombatSpecialAbility: DB.Entity<"AdvancedCombatSpec
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/specialAbility/AdvancedCombatSpecialAbility.js

@@ -3,7 +3,7 @@ import { input, levels, maximum, name, name_in_library, rules } from "../_Activa
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { combat_techniques, penalty, special_ability_usage_type, type, } from "../_ActivatableCombat.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
-import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
@@ -51,4 +51,5 @@ export const AdvancedCombatSpecialAbility = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("AdvancedCombatSpecialAbility", deps),
 });

package/lib/types/specialAbility/AdvancedKarmaSpecialAbility.d.ts

@@ -841,6 +841,35 @@ export declare const AdvancedKarmaSpecialAbility: DB.Entity<"AdvancedKarmaSpecia
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/specialAbility/AdvancedKarmaSpecialAbility.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
-import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
@@ -45,4 +45,5 @@ export const AdvancedKarmaSpecialAbility = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("AdvancedKarmaSpecialAbility", deps),
 });

package/lib/types/specialAbility/AdvancedMagicalSpecialAbility.d.ts

@@ -841,6 +841,35 @@ export declare const AdvancedMagicalSpecialAbility: DB.Entity<"AdvancedMagicalSp
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/specialAbility/AdvancedMagicalSpecialAbility.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
-import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
@@ -45,4 +45,5 @@ export const AdvancedMagicalSpecialAbility = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("AdvancedMagicalSpecialAbility", deps),
 });

package/lib/types/specialAbility/AdvancedSkillSpecialAbility.d.ts

@@ -841,6 +841,35 @@ export declare const AdvancedSkillSpecialAbility: DB.Entity<"AdvancedSkillSpecia
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/specialAbility/AdvancedSkillSpecialAbility.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
-import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "../_ActivatableSkillApplicationsAndUses.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
@@ -45,4 +45,5 @@ export const AdvancedSkillSpecialAbility = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("AdvancedSkillSpecialAbility", deps),
 });

package/lib/types/specialAbility/AncestorGlyph.d.ts

@@ -841,6 +841,35 @@ export declare const AncestorGlyph: DB.Entity<"AncestorGlyph", {
                 }>, []>>>, true>;
             }>, []>>>;
         }, []>>, false>;
+        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRules", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SelectOptionRule", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleValue", {
+                Predefined: DB.EnumCase<null>;
+                PredefinedOrTextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PredefinedOrTextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PredefinedOrTextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                        optionLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+                Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildSelectOptionRuleValue", DB.Object<{
+                    parentIndex: DB.MemberDecl<DB.Integer, true>;
+                    entity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ChildEntityForSelectOption", {
+                        SkillApplication: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>>;
+                TextInput: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextInputSelectOptionRuleValue", DB.Object<{
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"TextInputSelectOptionRuleValueTranslation", {
+                        inputLabel: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            multiple: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionRuleMultiple", {
+                Constant: DB.EnumCase<DB.Integer>;
+                Range: DB.EnumCase<DB.Object<{
+                    min: DB.MemberDecl<DB.Integer, false>;
+                    max: DB.MemberDecl<DB.Integer, true>;
+                }>>;
+            }, []>>, false>;
+        }>, []>>>, []>>, false>;
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {

package/lib/types/specialAbility/AncestorGlyph.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { levels, maximum, name, name_in_library, rules } from "../_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
 import { activatableDisplayNameCustomizer, nameBuilderRules } from "../_ActivatableNames.js";
-import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
+import { explicit_select_options, select_options, verifySelectOptionRules, } from "../_ActivatableSelectOptions.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
@@ -46,4 +46,5 @@ export const AncestorGlyph = DB.Entity(import.meta.url, {
             keyPathInEntityMapFallback: "name",
         },
     ],
+    customConstraints: deps => verifySelectOptionRules("AncestorGlyph", deps),
 });