@optolith/database-schema 0.77.0 → 0.77.1

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

@@ -0,0 +1,131 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../../Locale.js";
+const ValueRule = DB.Enum(import.meta.url, {
+    name: "ValueRule",
+    comment: "Defines if an instance MUST/CAN/MUST NOT define a value for this parameter. If multiple rules apply to the same parameter, the order of precedence is Required > Optional > Prohibited.",
+    values: () => ({
+        Required: DB.EnumCase({
+            comment: "The parameter MUST be present in all instances the rule applies to.",
+            type: null,
+        }),
+        Optional: DB.EnumCase({
+            comment: "The parameter CAN be present in any instances the rule applies to.",
+            type: null,
+        }),
+        Prohibited: DB.EnumCase({
+            comment: "The parameter MUST NOT be present in any instances the rule applies to.",
+            type: null,
+        }),
+    }),
+});
+const AllowedCombatValues = DB.TypeAlias(import.meta.url, {
+    name: "AllowedCombatValues",
+    comment: "The combat values that are allowed for this category. If any combat value is allowed and used, advantages, disadvantages and known item specifics are also allowed to be defined for the item.",
+    type: () => DB.Object({
+        isWeaponAllowed: DB.Required({
+            comment: "Is the item allowed to be used as a weapon?",
+            type: DB.Boolean(),
+        }),
+        isArmorAllowed: DB.Required({
+            comment: "Is the item allowed to be used as an armor?",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const EquipmentCategoryType = DB.Enum(import.meta.url, {
+    name: "EquipmentCategoryType",
+    values: () => ({
+        Default: DB.EnumCase({
+            comment: "Items that can be expressed using the generic Item entity.",
+            type: DB.IncludeIdentifier(DefaultEquipmentCategoryTypeRules),
+        }),
+        Special: DB.EnumCase({
+            comment: "Items whose rules and/or values cannot be expressed using the generic Item entity.",
+            type: DB.IncludeIdentifier(SpecialEquipmentCategoryEntity),
+        }),
+    }),
+});
+const DefaultEquipmentCategoryTypeRules = DB.TypeAlias(import.meta.url, {
+    name: "DefaultEquipmentCategoryTypeRules",
+    type: () => DB.Object({
+        combatValues: DB.Required({
+            comment: "The combat values that are allowed for this category. If any combat value is allowed and used, advantages, disadvantages and known item specifics are also allowed to be defined for the item.",
+            type: DB.IncludeIdentifier(AllowedCombatValues),
+        }),
+        restrictedTo: DB.Required({
+            comment: "Presence of restrictions to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+        structurePoints: DB.Required({
+            comment: "Presence of structure points to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+        weight: DB.Required({
+            comment: "Presence of weight to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+        complexity: DB.Required({
+            comment: "Presence of complexity to certain groups for items in this category.",
+            type: DB.IncludeIdentifier(ValueRule),
+        }),
+    }),
+});
+const SpecialEquipmentCategoryEntity = DB.Enum(import.meta.url, {
+    name: "SpecialEquipmentCategoryEntity",
+    values: () => ({
+        AnimalCare: DB.EnumCase({ type: null }),
+        Book: DB.EnumCase({ type: null }),
+        Elixir: DB.EnumCase({ type: null }),
+        GemOrPreciousStone: DB.EnumCase({ type: null }),
+        Newspaper: DB.EnumCase({ type: null }),
+        Poison: DB.EnumCase({ type: null }),
+        WorkingSupernaturalCreature: DB.EnumCase({ type: null }),
+    }),
+});
+export const EquipmentCategory = DB.Entity(import.meta.url, {
+    name: "EquipmentCategory",
+    namePlural: "EquipmentCategories",
+    type: () => DB.Object({
+        position: DB.Required({
+            comment: "The position of the category in the list. This has to be a unique value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        type: DB.Required({
+            comment: "The type of the equipment category.",
+            type: DB.IncludeIdentifier(EquipmentCategoryType),
+        }),
+        translations: NestedTranslationMap(DB.Required, "EquipmentCategory", DB.Object({
+            name: DB.Required({
+                comment: "The equipment category’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    sortOrder: { keyPath: "position", isIndex: true },
+    uniqueConstraints: [
+        {
+            keyPath: "position",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+export const isEquipmentCategoryOfDefaultType = (category) => category.type.kind === "Default";
+export const mergeValueRules = (categories) => categories.reduce((acc, elem) => acc === "Required" || elem.kind === "Required"
+    ? "Required"
+    : acc === "Optional" || elem.kind === "Optional"
+        ? "Optional"
+        : "Prohibited", "Prohibited");
+export const mergeAllValueRules = (categories) => ({
+    combatValues: {
+        isWeaponAllowed: categories.some(category => category.combatValues.isWeaponAllowed),
+        isArmorAllowed: categories.some(category => category.combatValues.isArmorAllowed),
+    },
+    restrictedTo: { kind: mergeValueRules(categories.map(category => category.restrictedTo)) },
+    structurePoints: { kind: mergeValueRules(categories.map(category => category.structurePoints)) },
+    weight: { kind: mergeValueRules(categories.map(category => category.weight)) },
+    complexity: { kind: mergeValueRules(categories.map(category => category.complexity)) },
+});

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

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

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

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

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

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

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 [];
     },