@optolith/database-schema 0.78.0 → 0.79.1

package/lib/types/_ActivatableSelectOptions.js

@@ -18,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({
@@ -101,123 +105,140 @@ 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.
  */

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

@@ -224,7 +224,18 @@ export declare const SecondaryArmor: DB.TypeAlias<"SecondaryArmor", DB.Object<{
     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/Armor.js

@@ -112,7 +112,9 @@ const StandardArmorType = DB.TypeAlias(import.meta.url, {
     }),
 });
 const validateArmorTypeReference = (deps) => [
-    deps.getInstanceById("Armor", deps.instanceContent.variantOf)?.armorType.kind !== "Standard"
+    deps.getInstanceById("Armor", deps.instanceContent.variantOf)?.armorType.kind !== "Standard" &&
+        deps.getInstanceById("Item", deps.instanceContent.variantOf)?.armorUse?.armorType.kind !==
+            "Standard"
         ? "The armor is a variant of a standard armor, but the referenced armor is not a standard armor."
         : undefined,
 ].filter(isNotNullish);
@@ -157,9 +159,9 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
             comment: "Does the armor have additional penalties (MOV -1, INI -1)?",
             type: DB.IncludeIdentifier(HasAdditionalPenalties),
         }),
-        variantOf: DB.Required({
-            comment: "The standard armor this armor is a variant of.",
-            type: ArmorIdentifier(),
+        armorType: DB.Required({
+            comment: "The armor type.",
+            type: DB.IncludeIdentifier(ArmorType),
         }),
         hit_zone: DB.Optional({
             comment: "Specify if armor is only available for a specific hit zone.",
@@ -180,7 +182,14 @@ export const SecondaryArmor = DB.TypeAlias(import.meta.url, {
             }),
         }, { minProperties: 1 })),
     }),
-    customConstraints: validateArmorTypeReference,
+    customConstraints: ({ instanceContent, ...deps }) => instanceContent.armorType.kind !== "Standard"
+        ? validateArmorTypeReference({
+            ...deps,
+            instanceContent: instanceContent.armorType.kind === "Variant"
+                ? instanceContent.armorType.Variant
+                : instanceContent.armorType.StandardVariant,
+        })
+        : [],
 });
 const ArmorComplexity = DB.Enum(import.meta.url, {
     name: "ArmorComplexity",

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

@@ -148,7 +148,18 @@ export declare const BandageOrRemedy: DB.Entity<"BandageOrRemedy", {
             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/CeremonialItem.d.ts

@@ -149,7 +149,18 @@ export declare const CeremonialItem: DB.Entity<"CeremonialItem", {
             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/Clothes.d.ts

@@ -148,7 +148,18 @@ export declare const Clothes: DB.Entity<"Clothes", {
             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/Container.d.ts

@@ -148,7 +148,18 @@ export declare const Container: DB.Entity<"Container", {
             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/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/EquipmentOfBlessedOnes.d.ts

@@ -121,7 +121,18 @@ export declare const EquipmentOfBlessedOnes: DB.Entity<"EquipmentOfBlessedOnes",
             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/IlluminationLightSource.d.ts

@@ -157,7 +157,18 @@ export declare const IlluminationLightSource: DB.Entity<"IlluminationLightSource
             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<{
@@ -249,3 +260,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/IlluminationRefillOrSupply.d.ts

@@ -148,7 +148,18 @@ export declare const IlluminationRefillOrSupply: DB.Entity<"IlluminationRefillOr
             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

@@ -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", {
@@ -120,7 +129,18 @@ export declare const Item: DB.Entity<"Item", {
         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<{