optolith-database-schema 0.40.0 → 0.41.0

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

@@ -20,33 +20,37 @@ export declare const Poison: DB.Entity<"Poison", {
                 }>>, []>>>;
             }, []>>, true>;
             is_extractable: DB.MemberDecl<DB.Boolean, true>;
-            trade_secret: DB.MemberDecl<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>;
-            }>, []>>, false>;
+            complexity: DB.MemberDecl<DB.IncludeIdentifier<[], 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>;
+                }>, []>>>;
+            }, []>>, false>;
         }>, []>>>;
         AlchemicalPoison: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AlchemicalPoison", DB.Object<{
             effect_types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
@@ -209,21 +213,8 @@ export declare const Poison: DB.Entity<"Poison", {
     }, []>>, true>;
     start: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonStart", {
         Immediate: DB.EnumCase<null>;
-        Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantPoisonTime", DB.Object<{
-            value: DB.MemberDecl<DB.Integer, true>;
-            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonTimeUnit", {
-                CombatRounds: DB.EnumCase<null>;
-                Minutes: DB.EnumCase<null>;
-                Hours: DB.EnumCase<null>;
-                Days: DB.EnumCase<null>;
-            }, []>>, true>;
-        }>, []>>>;
-        DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedPoisonTime", DB.Object<{
-            dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                number: DB.MemberDecl<DB.Integer, true>;
-                sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-            }>, []>>, true>;
-            flat: DB.MemberDecl<DB.Integer, false>;
+        ExpressionBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ExpressionBasedPoisonTime", DB.Object<{
+            value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ExpressionBasedPoisonTimeValue", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
             unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonTimeUnit", {
                 CombatRounds: DB.EnumCase<null>;
                 Minutes: DB.EnumCase<null>;
@@ -328,28 +319,6 @@ export declare const IndefinitePoisonCost: DB.TypeAlias<"IndefinitePoisonCost",
         description: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }>, []>;
-export declare const ConstantPoisonTime: DB.TypeAlias<"ConstantPoisonTime", DB.Object<{
-    value: DB.MemberDecl<DB.Integer, true>;
-    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonTimeUnit", {
-        CombatRounds: DB.EnumCase<null>;
-        Minutes: DB.EnumCase<null>;
-        Hours: DB.EnumCase<null>;
-        Days: DB.EnumCase<null>;
-    }, []>>, true>;
-}>, []>;
-export declare const DiceBasedPoisonTime: DB.TypeAlias<"DiceBasedPoisonTime", DB.Object<{
-    dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-        number: DB.MemberDecl<DB.Integer, true>;
-        sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-    }>, []>>, true>;
-    flat: DB.MemberDecl<DB.Integer, false>;
-    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonTimeUnit", {
-        CombatRounds: DB.EnumCase<null>;
-        Minutes: DB.EnumCase<null>;
-        Hours: DB.EnumCase<null>;
-        Days: DB.EnumCase<null>;
-    }, []>>, true>;
-}>, []>;
 export declare const ExpressionBasedPoisonTime: DB.TypeAlias<"ExpressionBasedPoisonTime", DB.Object<{
     value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ExpressionBasedPoisonTimeValue", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], MathOperation>, []>>, true>;
     unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PoisonTimeUnit", {
@@ -385,33 +354,37 @@ export declare const AnimalVenom: DB.TypeAlias<"AnimalVenom", DB.Object<{
         }>>, []>>>;
     }, []>>, true>;
     is_extractable: DB.MemberDecl<DB.Boolean, true>;
-    trade_secret: DB.MemberDecl<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>;
-    }>, []>>, false>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], 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>;
+        }>, []>>>;
+    }, []>>, false>;
 }>, []>;
 export declare const AlchemicalPoison: DB.TypeAlias<"AlchemicalPoison", DB.Object<{
     effect_types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {

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>;