@optolith/database-schema 0.77.0 → 0.78.0

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

@@ -0,0 +1,287 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Item: DB.Entity<"Item", {
+    categories: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+        Free: DB.EnumCase<null>;
+        Various: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<null>;
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+        Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+            from: DB.MemberDecl<DB.Float, true>;
+            to: DB.MemberDecl<DB.Float, false>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+            src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+                    initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, false>;
+                        pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                            first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, true>;
+                            last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, false>;
+                        }>, []>>>, true>;
+                        isRemoved: DB.MemberDecl<DB.Boolean, false>;
+                    }>, []>>, true>;
+                    revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                        Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                            pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                                first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, true>;
+                                last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, false>;
+                            }>, []>>>, true>;
+                        }>, []>>>;
+                        Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>;
+                    }, []>>>, false>;
+                }>, true>;
+            }>, []>>>, []>>, false>;
+        }>, []>>>;
+    }, []>>, false>;
+    structurePoints: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
+        points: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>, []>>, true>;
+    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", {
+            Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultPrimaryAttributeDamageThreshold", DB.Object<{
+                threshold: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            List: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PrimaryAttributeDamageThresholdList", DB.Object<{
+                list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SinglePrimaryAttributeDamageThreshold", DB.Object<{
+                    attribute: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    threshold: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>, true>;
+            }>, []>>>;
+        }, []>>, 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.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>;
+            Medium: DB.EnumCase<null>;
+            Large: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LargeShieldSize", DB.Object<{
+                attack_penalty: DB.MemberDecl<DB.Integer, false>;
+            }>, []>>>;
+        }, []>>, false>;
+        is_parrying_weapon: DB.MemberDecl<DB.Boolean, true>;
+        is_two_handed_weapon: DB.MemberDecl<DB.Boolean, true>;
+        is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+    }>, false>;
+    rangedUses: DB.MemberDecl<DB.NestedEntityMap<string, {
+        damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+        reload_time: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ReloadTime", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>, true>;
+        range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RangeBrackets", DB.Object<{
+            close: DB.MemberDecl<DB.Integer, true>;
+            medium: DB.MemberDecl<DB.Integer, true>;
+            far: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>, true>;
+        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>;
+    armorUse: DB.MemberDecl<DB.IncludeIdentifier<[], 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>;
+        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<{
+                    armors: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                    protection: DB.MemberDecl<DB.Integer, false>;
+                }>, []>>, false>;
+            }>, []>>>;
+            Torso: DB.EnumCase<null>;
+            Arms: DB.EnumCase<null>;
+            Legs: DB.EnumCase<null>;
+        }, []>>, false>;
+        restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+            races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+                scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>, false>;
+            cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+                scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>, false>;
+            professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+                scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>, false>;
+            magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+                scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+            }>, []>>, false>;
+            blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+                scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                    Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                    Church: DB.EnumCase<null>;
+                    Shamanistic: DB.EnumCase<null>;
+                }, []>>, true>;
+                isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
+            }>, []>>, false>;
+        }>, []>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SecondaryArmorTranslation", {
+            advantage: DB.MemberDecl<DB.String, false>;
+            disadvantage: DB.MemberDecl<DB.String, false>;
+        }>, false>;
+    }>, []>>, false>;
+    restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+        races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>, false>;
+        cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>, false>;
+        professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>, false>;
+        magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>, false>;
+        blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+            scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                Church: DB.EnumCase<null>;
+                Shamanistic: DB.EnumCase<null>;
+            }, []>>, true>;
+            isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
+        }>, []>>, false>;
+    }>, []>>, false>;
+    knownItemSpecifics: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"KnownItemSpecifics", DB.Object<{
+        age: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemAge", {
+            Antique: DB.EnumCase<null>;
+            Old: DB.EnumCase<null>;
+        }, []>>, false>;
+        condition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemCondition", {
+            Broken: DB.EnumCase<null>;
+            Poor: DB.EnumCase<null>;
+            Good: DB.EnumCase<null>;
+            VeryGood: DB.EnumCase<null>;
+            AsNew: DB.EnumCase<null>;
+        }, []>>, false>;
+        stabilityRating: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemStabilityRating", {
+            Constant: DB.EnumCase<DB.Integer>;
+            Unbreakable: DB.EnumCase<null>;
+        }, []>>, false>;
+        damageLevel: DB.MemberDecl<DB.Integer, false>;
+        collectorsValue: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CollectorsValue", {
+            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantCollectorsValue", DB.Object<{
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ConstantCollectorsValueTranslation", {
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Minimum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MinimumCollectorsValue", DB.Object<{
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"MinimumCollectorsValueTranslation", {
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Invaluable: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
+    src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ItemTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        secondaryName: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.String, false>;
+        advantage: DB.MemberDecl<DB.String, false>;
+        disadvantage: DB.MemberDecl<DB.String, false>;
+        knownItemSpecifics: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"KnownItemSpecificsTranslation", DB.Object<{
+            condition: DB.MemberDecl<DB.String, true>;
+        }>, []>>, false>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

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

@@ -0,0 +1,167 @@
+import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { isNotNullish } from "@elyukai/utils/nullable";
+import * as DB from "tsondb/schema/dsl";
+import { EquipmentCategoryIdentifier } from "../../_Identifier.js";
+import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity, Cost, KnownItemSpecifics, KnownItemSpecificsTranslation, RestrictedTo, StructurePoints, Weight, } from "./_Item.js";
+import { MeleeWeapon } from "./_MeleeWeapon.js";
+import { RangedWeapon } from "./_RangedWeapon.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
+import { SecondaryArmor } from "./Armor.js";
+import { isEquipmentCategoryOfDefaultType, mergeAllValueRules } from "./EquipmentCategory.js";
+export const Item = DB.Entity(import.meta.url, {
+    name: "Item",
+    namePlural: "Items",
+    type: () => DB.Object({
+        categories: DB.Required({
+            comment: "The categories this item belongs to.",
+            type: DB.Array(EquipmentCategoryIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.IncludeIdentifier(Cost),
+        }),
+        weight: DB.Required({
+            comment: "The weight in kg.",
+            type: DB.IncludeIdentifier(Weight),
+        }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
+        structurePoints: DB.Required({
+            comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
+            type: DB.IncludeIdentifier(StructurePoints),
+        }),
+        meleeUses: DB.Optional({
+            comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
+            type: DB.NestedEntityMap({
+                name: "MeleeWeaponUse2",
+                namePlural: "MeleeWeaponUses2",
+                secondaryEntity: CloseCombatTechnique,
+                type: DB.IncludeIdentifier(MeleeWeapon),
+                minProperties: 1,
+            }),
+        }),
+        rangedUses: DB.Optional({
+            comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
+            type: DB.NestedEntityMap({
+                name: "RangedWeaponUse2",
+                namePlural: "RangedWeaponUses2",
+                secondaryEntity: RangedCombatTechnique,
+                type: DB.IncludeIdentifier(RangedWeapon),
+                minProperties: 1,
+            }),
+        }),
+        armorUse: DB.Optional({
+            comment: "Stats for this item being used as an armor.",
+            type: DB.IncludeIdentifier(SecondaryArmor),
+        }),
+        restrictedTo: DB.Optional({
+            comment: "Define if during character creation this weapon can only be bought by a specific subset of characters.",
+            type: DB.IncludeIdentifier(RestrictedTo),
+        }),
+        knownItemSpecifics: DB.Optional({
+            comment: "The weapon is a known item, which implies some additional values.",
+            type: DB.IncludeIdentifier(KnownItemSpecifics),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Item", DB.Object({
+            name: DB.Required({
+                comment: "The item’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            secondaryName: DB.Optional({
+                comment: "An auxiliary name or label of the item, if available.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            note: DB.Optional({
+                comment: "Note text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            rules: DB.Optional({
+                comment: "Special rules text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            advantage: DB.Optional({
+                comment: "The weapon advantage text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            disadvantage: DB.Optional({
+                comment: "The weapon disadvantage text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            knownItemSpecifics: DB.Optional({
+                comment: "The weapon is a known item, which implies some additional values.",
+                type: DB.IncludeIdentifier(KnownItemSpecificsTranslation),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, ...rest }) => checkWeaponCombatTechniqueIntegrity({
+        ...rest,
+        instanceContent,
+    }).concat(checkEquipmentCategoryConstraintsWithItem(instanceContent, rest.getInstanceById)),
+});
+const checkEquipmentCategoryConstraintsWithItem = (item, getInstanceById) => {
+    const categories = item.categories.map(categoryId => getInstanceById("EquipmentCategory", categoryId));
+    if (isNotEmpty(categories)) {
+        if (categories.every(isNotNullish)) {
+            if (categories.every(isEquipmentCategoryOfDefaultType)) {
+                const mergedRules = mergeAllValueRules(categories.map(c => c.type.Default));
+                const errors = [];
+                if (mergedRules.combatValues.isWeaponAllowed &&
+                    item.meleeUses === undefined &&
+                    item.rangedUses === undefined) {
+                    errors.push("A weapon must defined at least one melee use or ranged use.");
+                }
+                if (mergedRules.combatValues.isArmorAllowed && item.armorUse === undefined) {
+                    errors.push("An armor must defined an armor use.");
+                }
+                if (!mergedRules.combatValues.isWeaponAllowed &&
+                    !mergedRules.combatValues.isArmorAllowed &&
+                    Object.values(item.translations).some(t => t.advantage !== undefined ||
+                        t.disadvantage !== undefined ||
+                        t.knownItemSpecifics !== undefined)) {
+                    errors.push("Advantages, disadvantages and known item specifics may only be specified for weapons and armor.");
+                }
+                const applyValueRule = (rule, value, valueName) => {
+                    if (rule.kind === "Required" && value === undefined) {
+                        errors.push(`${valueName} required for this item.`);
+                    }
+                    else if (rule.kind === "Prohibited" && value !== undefined) {
+                        errors.push(`${valueName} prohibited for this item.`);
+                    }
+                };
+                applyValueRule(mergedRules.complexity, item.complexity, "A complexity is");
+                applyValueRule(mergedRules.restrictedTo, item.restrictedTo, "Restriction are");
+                applyValueRule(mergedRules.structurePoints, item.structurePoints, "Structure points are");
+                applyValueRule(mergedRules.weight, item.weight, "A weight is");
+                return errors;
+            }
+            else {
+                return [
+                    "One or more categories of this item are not of the default type, which cannot be chosen items of this entity.",
+                ];
+            }
+        }
+        else {
+            return ["One or more categories of this item could not be found."];
+        }
+    }
+    else {
+        return ["At least one category must be chosen for an item."];
+    }
+};

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

@@ -41,7 +41,7 @@ export const Liebesspielzeug = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -41,7 +41,7 @@ export const LuxuryGood = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -75,7 +75,7 @@ export const MagicalArtifact = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -41,7 +41,7 @@ export const MusicalInstrument = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -41,7 +41,7 @@ export const TravelGearOrTool = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -97,7 +97,7 @@ export const Weapon = DB.Entity(import.meta.url, {
             keyPathInEntityMap: "name",
         },
     ],
-    customConstraints: params => checkWeaponCombatTechniqueIntegrity(params, { secondary: false }),
+    customConstraints: params => checkWeaponCombatTechniqueIntegrity(params),
 });
 export const ImprovisedWeapon = DB.TypeAlias(import.meta.url, {
     name: "ImprovisedWeapon",

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

@@ -41,7 +41,7 @@ export const WeaponAccessory = DB.Entity(import.meta.url, {
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: instanceContent.combat_use.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -48,7 +48,7 @@ export const DefaultItem = (sourceUrl, singularName, pluralName) => DB.Entity(so
             return checkWeaponCombatTechniqueIntegrity({
                 ...rest,
                 instanceContent: combatUse.Weapon,
-            }, { secondary: true });
+            });
         }
         return [];
     },

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

@@ -16,10 +16,10 @@ export declare const Length: DB.TypeAlias<"Length", DB.Integer, []>;
 export declare const checkWeaponCombatTechniqueIntegrity: ({ instanceContent, getInstanceById, getDisplayNameAndId, }: {
     instanceContent: {
         melee_uses?: Record<string, GenMeleeWeapon<unknown>>;
+        meleeUses?: Record<string, GenMeleeWeapon<unknown>>;
         ranged_uses?: Record<string, GenRangedWeapon<unknown>>;
+        rangedUses?: Record<string, GenRangedWeapon<unknown>>;
     };
     getInstanceById: GetInstanceById;
     getDisplayNameAndId: GetDisplayNameAndId;
-}, { secondary: _secondary }: {
-    secondary: boolean;
 }) => string[];

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

@@ -47,15 +47,18 @@ export const Length = DB.TypeAlias(import.meta.url, {
     comment: "The length of the weapon in cm/halffingers.",
     type: () => DB.Integer({ minimum: 1 }),
 });
-export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstanceById, getDisplayNameAndId, }, { secondary: _secondary }) => {
+export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstanceById, getDisplayNameAndId, }) => {
     const checkPart = (rule, value, name, type, id) => (rule.kind === "Prohibited") === (value === undefined) || rule.kind === "Optional"
         ? undefined
         : `${name} must${rule.kind === "Required" ? "" : " not"} be provided for ${type} combat technique ${getDisplayNameAndId(type === "close" ? "CloseCombatTechnique" : "RangedCombatTechnique", id)}`;
     return [
-        instanceContent.melee_uses === undefined && instanceContent.ranged_uses === undefined
+        instanceContent.melee_uses === undefined &&
+            instanceContent.ranged_uses === undefined &&
+            instanceContent.meleeUses === undefined &&
+            instanceContent.rangedUses === undefined
             ? "either melee uses or ranged uses have to be provided"
             : undefined,
-        ...Object.entries(instanceContent.melee_uses ?? {}).flatMap(([ctId, meleeUse]) => {
+        ...Object.entries(instanceContent.melee_uses ?? instanceContent.meleeUses ?? {}).flatMap(([ctId, meleeUse]) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- integrity has been checked, it must be present
             const ct = getInstanceById("CloseCombatTechnique", ctId);
             return [
@@ -66,7 +69,7 @@ export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstan
                 checkPart(ct.special.has_shield_size, meleeUse.size, "a shield size", "close", ctId),
             ];
         }),
-        ...Object.entries(instanceContent.ranged_uses ?? {}).flatMap(([ctId, rangedUse]) => {
+        ...Object.entries(instanceContent.ranged_uses ?? instanceContent.rangedUses ?? {}).flatMap(([ctId, rangedUse]) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- integrity has been checked, it must be present
             const ct = getInstanceById("RangedCombatTechnique", ctId);
             return [

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

@@ -16,9 +16,7 @@ export const Reach = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
-    sortOrder: {
-        keyPath: "position",
-    },
+    sortOrder: { keyPath: "position", isIndex: true },
     uniqueConstraints: [
         {
             entityMapKeyPath: "translations",

package/lib/types/index.d.ts

@@ -28,12 +28,14 @@ export { Clothes } from "./equipment/item/Clothes.js";
 export { ClothingPackage } from "./equipment/item/ClothingPackage.js";
 export { Container } from "./equipment/item/Container.js";
 export { Elixir } from "./equipment/item/Elixir.js";
+export { EquipmentCategory } from "./equipment/item/EquipmentCategory.ts";
 export { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js";
 export { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js";
 export { HerbalAid } from "./equipment/item/HerbalAid.js";
 export { HerbalPreservation } from "./equipment/item/HerbalPreservation.js";
 export { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js";
 export { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js";
+export { Item } from "./equipment/item/Item.js";
 export { Jewelry } from "./equipment/item/Jewelry.js";
 export { Laboratory } from "./equipment/item/Laboratory.js";
 export { Liebesspielzeug } from "./equipment/item/Liebesspielzeug.js";

package/lib/types/index.js

@@ -28,12 +28,14 @@ export { Clothes } from "./equipment/item/Clothes.js";
 export { ClothingPackage } from "./equipment/item/ClothingPackage.js";
 export { Container } from "./equipment/item/Container.js";
 export { Elixir } from "./equipment/item/Elixir.js";
+export { EquipmentCategory } from "./equipment/item/EquipmentCategory.js";
 export { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js";
 export { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js";
 export { HerbalAid } from "./equipment/item/HerbalAid.js";
 export { HerbalPreservation } from "./equipment/item/HerbalPreservation.js";
 export { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js";
 export { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js";
+export { Item } from "./equipment/item/Item.js";
 export { Jewelry } from "./equipment/item/Jewelry.js";
 export { Laboratory } from "./equipment/item/Laboratory.js";
 export { Liebesspielzeug } from "./equipment/item/Liebesspielzeug.js";

package/lib/types/prerequisites/single/ActivatablePrerequisite.js

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