@optolith/database-schema 0.77.1 → 0.79.0

package/lib/types/_ActivatableSelectOptions.js

@@ -1,4 +1,6 @@
+import { isEmpty, isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import * as DB from "tsondb/schema/dsl";
+import { Case, fromUniformCase, } from "tsondb/schema/gen";
 import { NestedTranslationMap } from "./Locale.js";
 import { SelectOptionCategory } from "./_ActivatableSelectOptionCategory.js";
 import { NewSkillApplication, SkillUse } from "./_ActivatableSkillApplicationsAndUses.js";
@@ -16,6 +18,10 @@ Note that this is only a full definition of options for simple logic that can be
             comment: `An entry category with optional further configuration. All available entries from the specified categories will be included as separate select options. You can also specify a set of groups that should only be included. Groups not mentioned will be excluded then.`,
             type: DB.IncludeIdentifier(SelectOptionCategory),
         }),
+        rules: DB.Optional({
+            comment: `Rules for how options can be selected and relate to each other. Defaults to a single predefined option if the entry has select options defined, otherwise undefined.`,
+            type: DB.IncludeIdentifier(SelectOptionRules),
+        }),
     }, { minProperties: 1 }),
 });
 export const select_options = DB.Optional({
@@ -99,120 +105,175 @@ export const explicit_select_options = DB.Required({
 Note that this is only a full definition of options for simple logic that can be made explicit using the more detailed configuration for both derived categories and explicit options. There are quite a few entries whose option logic cannot be fully represented here, so that it needs to be implemented manually.`,
     type: DB.ChildEntities(GeneralSelectOption),
 });
-// "Options": {
-//   "$comment": "Unfinished generalized options handling.",
-//   "type": "array",
-//   "minItems": 1,
-//   "items": {
-//     "oneOf": [
-//       {
-//         "type": "object",
-//         "properties": {
-//           "type": { "const": "List" },
-//           "value": {
-//             "type": "object",
-//             "properties": {
-//               "list": {
-//                 "oneOf": [
-//                   {
-//                     "type": "object",
-//                     "properties": {
-//                       "type": { "const": "Generate" },
-//                       "value": { "$ref": "#/definitions/SelectOptionCategories" }
-//                     },
-//                     "required": ["type", "value"],
-//                     "additionalProperties": false
-//                   },
-//                   {
-//                     "type": "object",
-//                     "properties": {
-//                       "type": { "const": "Explicit" },
-//                       "value": { "$ref": "#/definitions/SelectOptions" }
-//                     },
-//                     "required": ["type", "value"],
-//                     "additionalProperties": false
-//                   }
-//                 ]
-//               },
-//               "multiple": {
-//                 "description": "Sometimes, multiple options from a single list have to or can be chosen. Its possible to define a number of options that have to be selected or a range of numbers of options that can be selected.",
-//                 "oneOf": [
-//                   {
-//                     "type": "object",
-//                     "properties": {
-//                       "type": { "const": "Fixed" },
-//                       "value": {
-//                         "description": "The number of options that have to be selected.",
-//                         "type": "integer",
-//                         "minimum": 2
-//                       }
-//                     },
-//                     "required": ["type", "value"],
-//                     "additionalProperties": false
-//                   },
-//                   {
-//                     "type": "object",
-//                     "properties": {
-//                       "type": { "const": "Range" },
-//                       "value": {
-//                         "type": "object",
-//                         "properties": {
-//                           "min": {
-//                             "description": "The minimum number of options that need to be selected. If left empty it defaults to 1.",
-//                             "type": "integer",
-//                             "minimum": 2
-//                           },
-//                           "max": {
-//                             "description": "The maximum number of options that need to be selected.",
-//                             "type": "integer",
-//                             "minimum": 2
-//                           }
-//                         },
-//                         "required": ["max"],
-//                         "additionalProperties": false
-//                       }
-//                     },
-//                     "required": ["type", "value"],
-//                     "additionalProperties": false
-//                   }
-//                 ]
-//               }
-//             },
-//             "required": ["list"],
-//             "additionalProperties": false
-//           }
-//         },
-//         "required": ["type", "value"],
-//         "additionalProperties": false
-//       },
-//       {
-//         "type": "object",
-//         "properties": {
-//           "type": { "const": "TextInput" },
-//           "value": {
-//             "type": "object",
-//             "properties": {
-//               "label": {
-//                 "type": "object",
-//                 "description": "All translations for the entry, identified by IETF language tag (BCP47).",
-//                 "patternProperties": {
-//                   "^[a-z]{2}-[A-Z]{2}$": {
-//                     "description": "The text input label.",
-//                     "type": "string",
-//                     "minLength": 1
-//                   }
-//                 },
-//                 "minProperties": 1,
-//                 "additionalProperties": false
-//               }
-//             },
-//             "required": ["label"],
-//             "additionalProperties": false
-//           }
-//         },
-//         "required": ["type", "value"],
-//         "additionalProperties": false
-//       }
-//     ]
-//   }
-// },
+const ChildEntityForSelectOption = DB.Enum(import.meta.url, {
+    name: "ChildEntityForSelectOption",
+    comment: `The possible child entities for select options.`,
+    values: () => ({
+        SkillApplication: DB.EnumCase({ type: null }),
+    }),
+});
+const ChildSelectOptionRuleValue = DB.TypeAlias(import.meta.url, {
+    name: "ChildSelectOptionRuleValue",
+    type: () => DB.Object({
+        parentIndex: DB.Required({
+            comment: "The index of the parent select option in the list of selected options.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        entity: DB.Required({
+            comment: "The entity you can choose from.",
+            type: DB.IncludeIdentifier(ChildEntityForSelectOption),
+        }),
+    }),
+});
+const PredefinedOrTextInputSelectOptionRuleValue = DB.TypeAlias(import.meta.url, {
+    name: "PredefinedOrTextInputSelectOptionRuleValue",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "PredefinedOrTextInputSelectOptionRuleValue", DB.Object({
+            inputLabel: DB.Required({
+                comment: "The label for the text input field.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            optionLabel: DB.Required({
+                comment: "The label for the extra option in the list of select options that unlocks the text input field.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+const TextInputSelectOptionRuleValue = DB.TypeAlias(import.meta.url, {
+    name: "TextInputSelectOptionRuleValue",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "TextInputSelectOptionRuleValue", DB.Object({
+            inputLabel: DB.Required({
+                comment: "The label for the text input field.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+const SelectOptionRuleValue = DB.Enum(import.meta.url, {
+    name: "SelectOptionRuleValue",
+    comment: `The possible values for select option rules.`,
+    values: () => ({
+        Predefined: DB.EnumCase({
+            comment: "An entry that has been defined explicitly or derived from a category.",
+            type: null,
+        }),
+        PredefinedOrTextInput: DB.EnumCase({
+            comment: "An entry that has been defined explicitly or derived from a category, or a text input if the user sees none of the predefined options fit.",
+            type: DB.IncludeIdentifier(PredefinedOrTextInputSelectOptionRuleValue),
+        }),
+        Child: DB.EnumCase({
+            comment: "A child instance of a selected entry, e.g. a skill application for a skill.",
+            type: DB.IncludeIdentifier(ChildSelectOptionRuleValue),
+        }),
+        TextInput: DB.EnumCase({
+            comment: "A text input field that can be filled in by the user.",
+            type: DB.IncludeIdentifier(TextInputSelectOptionRuleValue),
+        }),
+    }),
+});
+const SelectOptionRuleMultiple = DB.Enum(import.meta.url, {
+    name: "SelectOptionRuleMultiple",
+    values: () => ({
+        Constant: DB.EnumCase({
+            comment: "A fixed number of options that have to be selected.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
+        Range: DB.EnumCase({
+            comment: "A range of numbers of options that can be selected.",
+            type: DB.Object({
+                min: DB.Optional({
+                    comment: "The minimum number of options that need to be selected. If left empty it defaults to 1.",
+                    type: DB.Integer({ minimum: 2 }),
+                }),
+                max: DB.Required({
+                    comment: "The maximum number of options that need to be selected.",
+                    type: DB.Integer({ minimum: 2 }),
+                }),
+            }),
+        }),
+    }),
+});
+const SelectOptionRule = DB.TypeAlias(import.meta.url, {
+    name: "SelectOptionRule",
+    comment: `A rule for how options can be selected and relate to each other.`,
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The value of the rule.",
+            type: DB.IncludeIdentifier(SelectOptionRuleValue),
+        }),
+        multiple: DB.Optional({
+            comment: "Sometimes, multiple options from a single list have to or can be chosen.",
+            type: DB.IncludeIdentifier(SelectOptionRuleMultiple),
+        }),
+    }),
+});
+export const SelectOptionRules = DB.TypeAlias(import.meta.url, {
+    name: "SelectOptionRules",
+    comment: `Rules for how options can be selected and relate to each other. Defaults to a single predefined option if the entry has select options defined, otherwise undefined.`,
+    type: () => DB.Array(DB.IncludeIdentifier(SelectOptionRule), { minItems: 1 }),
+});
+export const verifySelectOptionRules = (_entity, deps) => {
+    const errorMessages = [];
+    const rules = deps.instanceContent.select_options?.rules;
+    if (rules) {
+        const normalizedRules = rules.flatMap(rule => rule.multiple
+            ? Array.from({
+                length: rule.multiple.kind === "Constant"
+                    ? rule.multiple.Constant
+                    : rule.multiple.Range.max,
+            }, () => rule)
+            : [rule]);
+        for (const [ruleIndex, rule] of rules.entries()) {
+            if (rule.multiple?.kind === "Range" && ruleIndex !== rules.length - 1) {
+                errorMessages.push("A select option rule with a range of multiple options can only be the last rule in the list.");
+            }
+            if (rule.value.kind === "Child") {
+                const parentRule = normalizedRules[rule.value.Child.parentIndex];
+                if (!parentRule || parentRule.value.kind !== "Predefined") {
+                    errorMessages.push("A child select option rule must reference a predefined select option rule as its parent.");
+                }
+            }
+        }
+    }
+    return errorMessages;
+};
+/**
+ * Stub for once option rules are formalized in the database schema.
+ */
+export const verifyOptionsForActivatableEntry = (value, getInstanceById, getAllChildInstancesForParent) => {
+    if (value.id.kind === "Enhancement") {
+        return [];
+    }
+    const referencedInstance = getInstanceById(value.id);
+    if (!referencedInstance) {
+        return [
+            `Referenced instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)} not found.`,
+        ];
+    }
+    const generalSelectOptions = getAllChildInstancesForParent("GeneralSelectOption", value.id);
+    const errorMessages = [];
+    if (!("levels" in referencedInstance && typeof referencedInstance.levels === "number") &&
+        value.level !== undefined) {
+        errorMessages.push(`The referenced instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)} does not have levels, but a level was specified in the prerequisite.`);
+    }
+    if ((("select_options" in referencedInstance &&
+        referencedInstance.select_options?.derived !== undefined) ||
+        isNotEmpty(generalSelectOptions)) &&
+        (value.options === undefined || isEmpty(value.options))) {
+        errorMessages.push(`The referenced instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)} has select options, but no options were specified in the prerequisite.`);
+    }
+    for (const option of value.options ?? []) {
+        if (option.kind === "General") {
+            const referencedOption = getInstanceById(Case("GeneralSelectOption", option.General));
+            if (!referencedOption) {
+                errorMessages.push(`Referenced select option of entity GeneralSelectOption with id ${fromUniformCase(option)} not found.`);
+            }
+            if (referencedOption?.parent !== value.id) {
+                errorMessages.push(`Referenced select option of entity GeneralSelectOption with id ${fromUniformCase(option)} does not belong to the instance of entity ${value.id.kind} with id ${fromUniformCase(value.id)}.`);
+            }
+        }
+    }
+    return [];
+};

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

@@ -33,6 +33,11 @@ declare const EquipmentCategoryType: DB.Enum<"EquipmentCategoryType", {
             Optional: DB.EnumCase<null>;
             Prohibited: DB.EnumCase<null>;
         }, []>>, true>;
+        burningTime: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+            Required: DB.EnumCase<null>;
+            Optional: DB.EnumCase<null>;
+            Prohibited: DB.EnumCase<null>;
+        }, []>>, true>;
     }>, []>>>;
     Special: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpecialEquipmentCategoryEntity", {
         AnimalCare: DB.EnumCase<null>;
@@ -69,6 +74,11 @@ declare const DefaultEquipmentCategoryTypeRules: DB.TypeAlias<"DefaultEquipmentC
         Optional: DB.EnumCase<null>;
         Prohibited: DB.EnumCase<null>;
     }, []>>, true>;
+    burningTime: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+        Required: DB.EnumCase<null>;
+        Optional: DB.EnumCase<null>;
+        Prohibited: DB.EnumCase<null>;
+    }, []>>, true>;
 }>, []>;
 export declare const EquipmentCategory: DB.Entity<"EquipmentCategory", {
     position: DB.MemberDecl<DB.Integer, true>;
@@ -98,6 +108,11 @@ export declare const EquipmentCategory: DB.Entity<"EquipmentCategory", {
                 Optional: DB.EnumCase<null>;
                 Prohibited: DB.EnumCase<null>;
             }, []>>, true>;
+            burningTime: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueRule", {
+                Required: DB.EnumCase<null>;
+                Optional: DB.EnumCase<null>;
+                Prohibited: DB.EnumCase<null>;
+            }, []>>, true>;
         }>, []>>>;
         Special: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpecialEquipmentCategoryEntity", {
             AnimalCare: DB.EnumCase<null>;

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

@@ -68,6 +68,10 @@ const DefaultEquipmentCategoryTypeRules = DB.TypeAlias(import.meta.url, {
             comment: "Presence of complexity to certain groups for items in this category.",
             type: DB.IncludeIdentifier(ValueRule),
         }),
+        burningTime: DB.Required({
+            comment: "Presence of burning time to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
     }),
 });
 const SpecialEquipmentCategoryEntity = DB.Enum(import.meta.url, {
@@ -128,4 +132,5 @@ export const mergeAllValueRules = (categories) => ({
     structurePoints: { kind: mergeValueRules(categories.map(category => category.structurePoints)) },
     weight: { kind: mergeValueRules(categories.map(category => category.weight)) },
     complexity: { kind: mergeValueRules(categories.map(category => category.complexity)) },
+    burningTime: { kind: mergeValueRules(categories.map(category => category.burningTime)) },
 });

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

@@ -249,3 +249,12 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
         }>, []>>>, []>>, false>;
     }>, true>;
 }, undefined>;
+export declare const BurningTime: DB.Enum<"BurningTime", {
+    Unlimited: DB.EnumCase<null>;
+    Limited: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LimitedBurningTime", DB.Object<{
+        value: DB.MemberDecl<DB.Float, true>;
+        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"LimitedBurningTimeUnit", {
+            Hours: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>>;
+}, []>;

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

@@ -50,7 +50,7 @@ export const IlluminationLightSource = DB.Entity(import.meta.url, {
         return [];
     },
 });
-const BurningTime = DB.Enum(import.meta.url, {
+export const BurningTime = DB.Enum(import.meta.url, {
     name: "BurningTime",
     values: () => ({
         Unlimited: DB.EnumCase({ type: null }),

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

@@ -71,6 +71,15 @@ export declare const Item: DB.Entity<"Item", {
     structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
         points: DB.MemberDecl<DB.Integer, true>;
     }>, []>>>, []>>, true>;
+    burningTime: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BurningTime", {
+        Unlimited: DB.EnumCase<null>;
+        Limited: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LimitedBurningTime", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"LimitedBurningTimeUnit", {
+                Hours: DB.EnumCase<null>;
+            }, []>>, true>;
+        }>, []>>>;
+    }, []>>, false>;
     meleeUses: DB.MemberDecl<DB.NestedEntityMap<string, {
         damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
         damage_threshold: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PrimaryAttributeDamageThreshold", {

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({
@@ -149,6 +154,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/prerequisites/single/ActivatablePrerequisite.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { verifyOptionsForActivatableEntry } from "../../_ActivatableSelectOptions.js";
 import { ActivatableIdentifier, RequirableSelectOptionIdentifier } from "../../_IdentifierGroup.js";
 import { Preconditions } from "../ConditionalPrerequisites.js";
 import { DisplayOption } from "../DisplayOption.js";
@@ -29,4 +30,5 @@ export const ActivatablePrerequisite = DB.TypeAlias(import.meta.url, {
             type: DB.IncludeIdentifier(Preconditions),
         }),
     }),
+    customConstraints: ({ instanceContent, getInstanceById, getAllChildInstancesForParent }) => verifyOptionsForActivatableEntry(instanceContent, getInstanceById, getAllChildInstancesForParent),
 });

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),
 });