optolith-database-schema 0.40.0 → 0.42.0

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

@@ -7,7 +7,7 @@ import { DiseaseIdentifier } from "../../_Identifier.js";
 import { MathOperation } from "../../_MathExpression.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
-import { EffectType, LaboratoryLevel, RecipeTradeSecret } from "./_Herbary.js";
+import { EffectType, LaboratoryLevel, RecipeComplexity, RecipeTradeSecret } from "./_Herbary.js";
 export const Poison = DB.Entity(import.meta.url, {
     name: "Poison",
     namePlural: "Poisons",
@@ -89,8 +89,7 @@ const PoisonStart = DB.Enum(import.meta.url, {
     name: "PoisonStart",
     values: () => ({
         Immediate: DB.EnumCase({ type: null }),
-        Constant: DB.EnumCase({ type: DB.IncludeIdentifier(ConstantPoisonTime) }),
-        DiceBased: DB.EnumCase({ type: DB.IncludeIdentifier(DiceBasedPoisonTime) }),
+        ExpressionBased: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedPoisonTime) }),
         Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePoisonTime) }),
     }),
 });
@@ -98,8 +97,6 @@ const PoisonDuration = DB.Enum(import.meta.url, {
     name: "PoisonDuration",
     values: () => ({
         Instant: DB.EnumCase({ type: null }),
-        Constant: DB.EnumCase({ type: DB.IncludeIdentifier(ConstantPoisonTime) }),
-        DiceBased: DB.EnumCase({ type: DB.IncludeIdentifier(DiceBasedPoisonTime) }),
         ExpressionBased: DB.EnumCase({ type: DB.IncludeIdentifier(ExpressionBasedPoisonTime) }),
         Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePoisonTime) }),
     }),
@@ -153,32 +150,6 @@ const DependingOnPurchaseOrSalePoisonCost = DB.TypeAlias(import.meta.url, {
         }),
     }),
 });
-export const ConstantPoisonTime = DB.TypeAlias(import.meta.url, {
-    name: "ConstantPoisonTime",
-    type: () => DB.Object({
-        value: DB.Required({
-            type: DB.Integer({ minimum: 1 }),
-        }),
-        unit: DB.Required({
-            type: DB.IncludeIdentifier(PoisonTimeUnit),
-        }),
-    }),
-});
-export const DiceBasedPoisonTime = DB.TypeAlias(import.meta.url, {
-    name: "DiceBasedPoisonTime",
-    type: () => DB.Object({
-        dice: DB.Required({
-            type: DB.IncludeIdentifier(Dice),
-        }),
-        flat: DB.Optional({
-            comment: "The value to add to the result of the dice roll(s).",
-            type: DB.Integer(),
-        }),
-        unit: DB.Required({
-            type: DB.IncludeIdentifier(PoisonTimeUnit),
-        }),
-    }),
-});
 export const ExpressionBasedPoisonTime = DB.TypeAlias(import.meta.url, {
     name: "ExpressionBasedPoisonTime",
     type: () => DB.Object({
@@ -249,9 +220,9 @@ export const AnimalVenom = DB.TypeAlias(import.meta.url, {
             comment: "If `false`, the poison cannot be extracted.",
             type: DB.Boolean(),
         }),
-        trade_secret: DB.Optional({
-            comment: "AP value and prerequisites of the poison’s trade secret.",
-            type: DB.IncludeIdentifier(RecipeTradeSecret),
+        complexity: DB.Optional({
+            comment: "The complexity of the poison. Complex poisons define AP value and prerequisites of the poison’s trade secret.",
+            type: DB.IncludeIdentifier(RecipeComplexity),
         }),
     }),
 });

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

@@ -45,7 +45,7 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
                 }, []>>, false>;
                 attackModifier: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"AttackModifier", import("tsondb/schema/dsl").Integer, []>>, false>;
                 parryModifier: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ParryModifier", import("tsondb/schema/dsl").Integer, []>>, false>;
-                reach: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, false>;
+                reach: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").ReferenceIdentifier>, false>;
                 length: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Length", import("tsondb/schema/dsl").Integer, []>>, false>;
                 size: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ShieldSize", {
                     Small: import("tsondb/schema/dsl").EnumCase<null>;
@@ -68,7 +68,10 @@ export declare const RopeOrChain: import("tsondb/schema/dsl").Entity<string, {
                     medium: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
                     far: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
                 }>, []>>, true>;
-                ammunition: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, false>;
+                ammunition: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"AmmunitionishIdentifier", {
+                    Ammunition: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").ReferenceIdentifier>;
+                    Weapon: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").ReferenceIdentifier>;
+                }, []>>, false>;
                 length: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Length", import("tsondb/schema/dsl").Integer, []>>, false>;
                 is_improvised_weapon: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Boolean, true>;
             }>, false>;

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

@@ -45,7 +45,7 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
                 }, []>>, false>;
                 attackModifier: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"AttackModifier", import("tsondb/schema/dsl").Integer, []>>, false>;
                 parryModifier: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ParryModifier", import("tsondb/schema/dsl").Integer, []>>, false>;
-                reach: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, false>;
+                reach: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").ReferenceIdentifier>, false>;
                 length: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Length", import("tsondb/schema/dsl").Integer, []>>, false>;
                 size: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ShieldSize", {
                     Small: import("tsondb/schema/dsl").EnumCase<null>;
@@ -68,7 +68,10 @@ export declare const Stationery: import("tsondb/schema/dsl").Entity<string, {
                     medium: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
                     far: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
                 }>, []>>, true>;
-                ammunition: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, false>;
+                ammunition: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"AmmunitionishIdentifier", {
+                    Ammunition: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").ReferenceIdentifier>;
+                    Weapon: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").ReferenceIdentifier>;
+                }, []>>, false>;
                 length: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Length", import("tsondb/schema/dsl").Integer, []>>, false>;
                 is_improvised_weapon: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Boolean, true>;
             }>, false>;

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

@@ -45,7 +45,7 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
                 }, []>>, false>;
                 attackModifier: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"AttackModifier", import("tsondb/schema/dsl").Integer, []>>, false>;
                 parryModifier: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"ParryModifier", import("tsondb/schema/dsl").Integer, []>>, false>;
-                reach: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, false>;
+                reach: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Array<import("tsondb/schema/dsl").ReferenceIdentifier>, false>;
                 length: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Length", import("tsondb/schema/dsl").Integer, []>>, false>;
                 size: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"ShieldSize", {
                     Small: import("tsondb/schema/dsl").EnumCase<null>;
@@ -68,7 +68,10 @@ export declare const ThievesTool: import("tsondb/schema/dsl").Entity<string, {
                     medium: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
                     far: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Integer, true>;
                 }>, []>>, true>;
-                ammunition: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").ReferenceIdentifier, false>;
+                ammunition: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").Enum<"AmmunitionishIdentifier", {
+                    Ammunition: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").ReferenceIdentifier>;
+                    Weapon: import("tsondb/schema/dsl").EnumCase<import("tsondb/schema/dsl").ReferenceIdentifier>;
+                }, []>>, false>;
                 length: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").IncludeIdentifier<[], import("tsondb/schema/dsl").TypeAlias<"Length", import("tsondb/schema/dsl").Integer, []>>, false>;
                 is_improvised_weapon: import("tsondb/schema/dsl").MemberDecl<import("tsondb/schema/dsl").Boolean, true>;
             }>, false>;

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

@@ -46,7 +46,7 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
                 }, []>>, false>;
                 attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
                 parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-                reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
                 size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
                     Small: DB.EnumCase<null>;
@@ -69,7 +69,10 @@ export declare const TravelGearOrTool: DB.Entity<"TravelGearOrTool", {
                     medium: DB.MemberDecl<DB.Integer, true>;
                     far: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, true>;
-                ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                    Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
                 length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
                 is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
             }>, false>;

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

@@ -44,7 +44,7 @@ export declare const Weapon: DB.Entity<"Weapon", {
         }, []>>, false>;
         attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
         parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-        reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
         size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
             Small: DB.EnumCase<null>;
@@ -67,7 +67,10 @@ export declare const Weapon: DB.Entity<"Weapon", {
             medium: DB.MemberDecl<DB.Integer, true>;
             far: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, true>;
-        ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+            Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+            Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, false>;
         length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
         is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
     }>, false>;
@@ -163,7 +166,7 @@ export declare const ImprovisedWeapon: DB.TypeAlias<"ImprovisedWeapon", DB.Objec
         }, []>>, false>;
         attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
         parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-        reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
         size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
             Small: DB.EnumCase<null>;
@@ -186,7 +189,10 @@ export declare const ImprovisedWeapon: DB.TypeAlias<"ImprovisedWeapon", DB.Objec
             medium: DB.MemberDecl<DB.Integer, true>;
             far: DB.MemberDecl<DB.Integer, true>;
         }>, []>>, true>;
-        ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+            Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+            Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, false>;
         length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
         is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
     }>, false>;

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

@@ -46,7 +46,7 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
                 }, []>>, false>;
                 attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
                 parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-                reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
                 size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
                     Small: DB.EnumCase<null>;
@@ -69,7 +69,10 @@ export declare const WeaponAccessory: DB.Entity<"WeaponAccessory", {
                     medium: DB.MemberDecl<DB.Integer, true>;
                     far: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, true>;
-                ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                    Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
                 length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
                 is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
             }>, false>;

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

@@ -16,6 +16,37 @@ export declare const LaboratoryLevel: DB.Enum<"LaboratoryLevel", {
     WitchKitchen: DB.EnumCase<null>;
     AlchemistsLaboratory: DB.EnumCase<null>;
 }, []>;
+export declare const RecipeComplexity: DB.Enum<"RecipeComplexity", {
+    Primitive: DB.EnumCase<null>;
+    Simple: DB.EnumCase<null>;
+    Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RecipeTradeSecret", DB.Object<{
+        ap_value: DB.MemberDecl<DB.Integer, true>;
+        prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+            Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+            Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                    Hide: DB.EnumCase<null>;
+                    ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                        sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                            Standalone: DB.EnumCase<null>;
+                            Connected: DB.EnumCase<null>;
+                        }, []>>, false>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                            replacement: DB.MemberDecl<DB.String, true>;
+                        }>, true>;
+                    }>, []>>>;
+                }, []>>, false>;
+            }>, [T: DB.Param<"T", DB.Type>]>>>;
+            Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                    text: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, [T: DB.Param<"T", DB.Type>]>>>;
+        }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+    }>, []>>>;
+}, []>;
 export declare const RecipeTradeSecret: DB.TypeAlias<"RecipeTradeSecret", DB.Object<{
     ap_value: DB.MemberDecl<DB.Integer, true>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {

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

@@ -24,6 +24,15 @@ export const LaboratoryLevel = DB.Enum(import.meta.url, {
         AlchemistsLaboratory: DB.EnumCase({ type: null }),
     }),
 });
+export const RecipeComplexity = DB.Enum(import.meta.url, {
+    name: "RecipeComplexity",
+    comment: "The complexity of crafting the recipe.",
+    values: () => ({
+        Primitive: DB.EnumCase({ type: null }),
+        Simple: DB.EnumCase({ type: null }),
+        Complex: DB.EnumCase({ type: DB.IncludeIdentifier(RecipeTradeSecret) }),
+    }),
+});
 export const RecipeTradeSecret = DB.TypeAlias(import.meta.url, {
     name: "RecipeTradeSecret",
     type: () => DB.Object({

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

@@ -46,7 +46,7 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
                 }, []>>, false>;
                 attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
                 parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-                reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
                 length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
                 size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
                     Small: DB.EnumCase<null>;
@@ -69,7 +69,10 @@ export declare const DefaultItem: (sourceUrl: string, singularName: string, plur
                     medium: DB.MemberDecl<DB.Integer, true>;
                     far: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, true>;
-                ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+                ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                    Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
                 length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
                 is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
             }>, false>;
@@ -223,7 +226,7 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
             }, []>>, false>;
             attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
             parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-            reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
             size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
                 Small: DB.EnumCase<null>;
@@ -246,7 +249,10 @@ export declare const CombatUse: DB.Enum<"CombatUse", {
                 medium: DB.MemberDecl<DB.Integer, true>;
                 far: DB.MemberDecl<DB.Integer, true>;
             }>, []>>, true>;
-            ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+                Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+                Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, false>;
             length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
             is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
         }>, false>;

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

@@ -19,7 +19,7 @@ export declare const MeleeWeapon: DB.TypeAlias<"MeleeWeapon", DB.IncludeIdentifi
     }, []>>, false>;
     attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
     parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-    reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
     size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
         Small: DB.EnumCase<null>;
@@ -47,7 +47,7 @@ export declare const GenMeleeWeapon: DB.TypeAlias<"GenMeleeWeapon", DB.Object<{
     }, []>>, false>;
     attackModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AttackModifier", DB.Integer, []>>, false>;
     parryModifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ParryModifier", DB.Integer, []>>, false>;
-    reach: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    reach: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
     size: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ShieldSize", {
         Small: DB.EnumCase<null>;

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

@@ -74,7 +74,7 @@ export const GenMeleeWeapon = DB.GenTypeAlias(import.meta.url, {
         }),
         reach: DB.Optional({
             comment: "The reach of the weapon.",
-            type: ReachIdentifier(),
+            type: DB.Array(ReachIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
         length: DB.Optional({
             comment: "The length of the weapon in cm/halffingers.",

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

@@ -12,7 +12,10 @@ export declare const RangedWeapon: DB.TypeAlias<"RangedWeapon", DB.IncludeIdenti
         medium: DB.MemberDecl<DB.Integer, true>;
         far: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
-    ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+        Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+        Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, false>;
     length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
     is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
 }>, [Damage: DB.Param<"Damage", DB.Type>]>>, []>;
@@ -26,7 +29,10 @@ export declare const GenRangedWeapon: DB.TypeAlias<"GenRangedWeapon", DB.Object<
         medium: DB.MemberDecl<DB.Integer, true>;
         far: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
-    ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    ammunition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AmmunitionishIdentifier", {
+        Ammunition: DB.EnumCase<DB.ReferenceIdentifier>;
+        Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, false>;
     length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
     is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
 }>, [Damage: DB.Param<"Damage", DB.Type>]>;

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

@@ -3,7 +3,7 @@
  */
 import * as DB from "tsondb/schema/dsl";
 import { Dice } from "../../_Dice.js";
-import { AmmunitionIdentifier } from "../../_Identifier.js";
+import { AmmunitionishIdentifier } from "../../_IdentifierGroup.js";
 import { Length } from "./_Weapon.js";
 const RangedDamage = DB.Enum(import.meta.url, {
     name: "RangedDamage",
@@ -53,7 +53,7 @@ export const GenRangedWeapon = DB.GenTypeAlias(import.meta.url, {
         }),
         ammunition: DB.Optional({
             comment: "The needed ammunition.",
-            type: AmmunitionIdentifier(),
+            type: DB.IncludeIdentifier(AmmunitionishIdentifier),
         }),
         length: DB.Optional({
             comment: "The length of the weapon in cm/halffingers.",

package/lib/types/equipment/item/sub/Reach.d.ts

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const Reach: DB.Entity<"Reach", {
+    position: DB.MemberDecl<DB.Integer, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"ReachTranslation", {
         name: DB.MemberDecl<DB.String, true>;
     }>, true>;

package/lib/types/equipment/item/sub/Reach.js

@@ -4,6 +4,10 @@ export const Reach = DB.Entity(import.meta.url, {
     name: "Reach",
     namePlural: "Reaches",
     type: () => DB.Object({
+        position: DB.Required({
+            comment: "The position of the reach in lists. Lower values indicate a shorter range; higher values a larger range. This has to be a unique value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
         translations: NestedTranslationMap(DB.Required, "Reach", DB.Object({
             name: DB.Required({
                 comment: "The reach’s name.",
@@ -12,6 +16,9 @@ export const Reach = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
+    sortOrder: {
+        keyPath: "position",
+    },
     uniqueConstraints: [
         {
             entityMapKeyPath: "translations",

package/lib/types/magicalActions/AnimistPower.d.ts

@@ -68,6 +68,7 @@ export declare const AnimistPower: DB.Entity<"AnimistPower", {
                     base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                         QualityLevels: DB.EnumCase<null>;
                         SkillPoints: DB.EnumCase<null>;
+                        SkillRating: DB.EnumCase<null>;
                     }, []>>, true>;
                     modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                         arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/magicalActions/Curse.d.ts

@@ -56,6 +56,7 @@ export declare const Curse: DB.Entity<"Curse", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -105,6 +106,7 @@ export declare const Curse: DB.Entity<"Curse", {
                         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                             QualityLevels: DB.EnumCase<null>;
                             SkillPoints: DB.EnumCase<null>;
+                            SkillRating: DB.EnumCase<null>;
                         }, []>>, true>;
                         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/magicalActions/DominationRitual.d.ts

@@ -41,6 +41,7 @@ export declare const DominationRitual: DB.Entity<"DominationRitual", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -90,6 +91,7 @@ export declare const DominationRitual: DB.Entity<"DominationRitual", {
                         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                             QualityLevels: DB.EnumCase<null>;
                             SkillPoints: DB.EnumCase<null>;
+                            SkillRating: DB.EnumCase<null>;
                         }, []>>, true>;
                         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/magicalActions/GeodeRitual.d.ts

@@ -76,6 +76,7 @@ export declare const GeodeRitual: DB.Entity<"GeodeRitual", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/magicalActions/JesterTrick.d.ts

@@ -46,6 +46,7 @@ export declare const JesterTrick: DB.Entity<"JesterTrick", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -212,6 +213,7 @@ export declare const JesterTrickPerformanceParameters: DB.TypeAlias<"JesterTrick
             base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                 QualityLevels: DB.EnumCase<null>;
                 SkillPoints: DB.EnumCase<null>;
+                SkillRating: DB.EnumCase<null>;
             }, []>>, true>;
             modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                 arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -272,6 +274,7 @@ export declare const JesterTrickDuration: DB.Enum<"JesterTrickDuration", {
         base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
             QualityLevels: DB.EnumCase<null>;
             SkillPoints: DB.EnumCase<null>;
+            SkillRating: DB.EnumCase<null>;
         }, []>>, true>;
         modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
             arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/magicalActions/MagicalMelody.d.ts

@@ -25,6 +25,21 @@ export declare const MagicalMelody: DB.Entity<"MagicalMelody", {
         cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MagicalMelodyCost", {
             Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedMagicalMelodyCost", DB.Object<{
                 value: DB.MemberDecl<DB.Integer, true>;
+                interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                        Seconds: DB.EnumCase<null>;
+                        Minutes: DB.EnumCase<null>;
+                        Hours: DB.EnumCase<null>;
+                        Days: DB.EnumCase<null>;
+                        Weeks: DB.EnumCase<null>;
+                        Months: DB.EnumCase<null>;
+                        Years: DB.EnumCase<null>;
+                        Centuries: DB.EnumCase<null>;
+                        Actions: DB.EnumCase<null>;
+                        CombatRounds: DB.EnumCase<null>;
+                    }, []>>, true>;
+                }>, []>>, false>;
             }>, []>>>;
             FirstPerson: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FirstPersonMagicalMelodyCost", DB.Object<{
                 value: DB.MemberDecl<DB.Integer, true>;

package/lib/types/magicalActions/MagicalMelody.js

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { OldParameter } from "../_ActivatableSkill.js";
+import { DurationUnitValue } from "../_ActivatableSkillDuration.js";
 import { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
 import { ArcaneBardTraditionIdentifier, PropertyIdentifier, SkillIdentifier, } from "../_Identifier.js";
 import { ImprovementCost } from "../_ImprovementCost.js";
@@ -105,6 +106,10 @@ const FixedMagicalMelodyCost = DB.TypeAlias(import.meta.url, {
             comment: "The (temporary) AE cost value.",
             type: DB.Integer({ minimum: 1 }),
         }),
+        interval: DB.Optional({
+            comment: "The interval at which to pay half the initial cost.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
     }),
 });
 const FirstPersonMagicalMelodyCost = DB.TypeAlias(import.meta.url, {

package/lib/types/magicalActions/MagicalRune.d.ts

@@ -85,6 +85,7 @@ export declare const MagicalRune: DB.Entity<"MagicalRune", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -117,6 +118,7 @@ export declare const MagicalRune: DB.Entity<"MagicalRune", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {

package/lib/types/magicalActions/ZibiljaRitual.d.ts

@@ -193,6 +193,7 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                     base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                         QualityLevels: DB.EnumCase<null>;
                         SkillPoints: DB.EnumCase<null>;
+                        SkillRating: DB.EnumCase<null>;
                     }, []>>, true>;
                     modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                         arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
@@ -278,6 +279,7 @@ export declare const ZibiljaRitual: DB.Entity<"ZibiljaRitual", {
                 base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
                     QualityLevels: DB.EnumCase<null>;
                     SkillPoints: DB.EnumCase<null>;
+                    SkillRating: DB.EnumCase<null>;
                 }, []>>, true>;
                 modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
                     arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {