@optolith/database-schema 0.42.1

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

@@ -0,0 +1,254 @@
+import * as DB from "tsondb/schema/dsl";
+import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, RaceIdentifier, } from "../../_Identifier.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
+import { SecondaryArmor } from "./Armor.js";
+import { ImprovisedWeapon } from "./Weapon.js";
+const COMBAT_USE = "combat_use";
+export const DefaultItem = (sourceUrl, singularName, pluralName) => DB.Entity(sourceUrl, {
+    name: singularName,
+    namePlural: pluralName ?? `${singularName}s`,
+    type: () => DB.Object({
+        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),
+        }),
+        structure_points: 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),
+        }),
+        [COMBAT_USE]: DB.Optional({
+            comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
+            type: DB.IncludeIdentifier(CombatUse),
+        }),
+        src,
+        translations: DefaultItemTranslations(singularName),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        const combatUse = instanceContent.combat_use;
+        if (combatUse && combatUse.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: combatUse.Weapon,
+            }, { secondary: true });
+        }
+        return [];
+    },
+});
+export const DefaultItemTranslations = (singularName) => NestedTranslationMap(DB.Required, singularName, DB.Object({
+    name: DB.Required({
+        comment: "The item’s name.",
+        type: DB.String({ minLength: 1 }),
+    }),
+    secondary_name: 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" }),
+    }),
+    errata: DB.Optional({
+        type: DB.IncludeIdentifier(Errata),
+    }),
+}));
+export const CombatUse = DB.Enum(import.meta.url, {
+    name: "CombatUse",
+    comment: "The item can also be used either as an improvised weapon or as an armor, although this is not the primary use case of the item.",
+    values: () => ({
+        Weapon: DB.EnumCase({ type: DB.IncludeIdentifier(ImprovisedWeapon) }),
+        Armor: DB.EnumCase({ type: DB.IncludeIdentifier(SecondaryArmor) }),
+    }),
+});
+export const StructurePoints = DB.TypeAlias(import.meta.url, {
+    name: "StructurePoints",
+    comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
+    type: () => DB.Array(DB.IncludeIdentifier(StructurePointsComponent), { minItems: 1 }),
+});
+const StructurePointsComponent = DB.TypeAlias(import.meta.url, {
+    name: "StructurePointsComponent",
+    type: () => DB.Object({
+        points: DB.Required({
+            comment: "The structure points.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+export const Cost = DB.Enum(import.meta.url, {
+    name: "Cost",
+    comment: "The cost in silverthalers.",
+    values: () => ({
+        Free: DB.EnumCase({ type: null }),
+        Various: DB.EnumCase({ type: null }),
+        Invaluable: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedCost) }),
+        Range: DB.EnumCase({ type: DB.IncludeIdentifier(CostRange) }),
+    }),
+});
+const wrap_in_text = DB.Required({
+    comment: "The cost get wrapped by this text using a placeholder in the text.",
+    type: DB.String({ minLength: 1, pattern: /\{0\}/ }),
+});
+export const FixedCost = DB.TypeAlias(import.meta.url, {
+    name: "FixedCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "FixedCost", DB.Object({
+            wrap_in_text,
+        })),
+    }),
+});
+const CostRange = DB.TypeAlias(import.meta.url, {
+    name: "CostRange",
+    type: () => DB.Object({
+        from: DB.Required({
+            comment: "The lower bound of the cost in silverthalers.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        to: DB.Required({
+            comment: "The upper bound of the cost in silverthalers.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "CostRange", DB.Object({
+            wrap_in_text,
+        })),
+    }),
+});
+export const Weight = DB.TypeAlias(import.meta.url, {
+    name: "Weight",
+    comment: "The weight in kg.",
+    type: () => DB.Float({ minimum: { value: 0, isExclusive: true }, fractionDigits: 3 }),
+});
+export const Complexity = DB.Enum(import.meta.url, {
+    name: "Complexity",
+    comment: "The complexity of crafting the item.",
+    values: () => ({
+        Primitive: DB.EnumCase({ type: null }),
+        Simple: DB.EnumCase({ type: null }),
+        Complex: DB.EnumCase({ type: DB.IncludeIdentifier(ComplexComplexity) }),
+    }),
+});
+export const ComplexComplexity = DB.TypeAlias(import.meta.url, {
+    name: "ComplexComplexity",
+    type: () => DB.Object({
+        ap_value: DB.Required({
+            comment: "The AP value for the trade secret.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+export const RestrictedTo = DB.TypeAlias(import.meta.url, {
+    name: "RestrictedTo",
+    comment: "If the item is in any case restricted to a subset of characters. The differenciating aspect may be tradition, race, culture, or a profession. Each element must be applicable to a character. ",
+    type: () => DB.Object({
+        races: DB.Optional({
+            comment: "The item is restricted to one of a list of races. If only one race is allowed, the list may only have a single element.",
+            type: DB.IncludeIdentifier(RestrictedToRaces),
+        }),
+        cultures: DB.Optional({
+            comment: "The item is restricted to one of a list of cultures. If only one culture is allowed, the list may only have a single element.",
+            type: DB.IncludeIdentifier(RestrictedToCultures),
+        }),
+        professions: DB.Optional({
+            comment: "The item is restricted to one of a list of professions. If only one profession is allowed, the list may only have a single element.",
+            type: DB.IncludeIdentifier(RestrictedToProfessions),
+        }),
+        magicalTraditions: DB.Optional({
+            comment: "The item is restricted to one of a list of magical traditions. If only one magical tradition is allowed, the list may only have a single element.",
+            type: DB.IncludeIdentifier(RestrictedToMagicalTraditions),
+        }),
+        blessedTraditions: DB.Optional({
+            comment: "The item is restricted to one of a list of blessed traditions. If only one blessed tradition is allowed, the list may only have a single element.",
+            type: DB.IncludeIdentifier(RestrictedToBlessedTraditions),
+        }),
+    }, { minProperties: 1 }),
+});
+export const RestrictedToRaces = DB.TypeAlias(import.meta.url, {
+    name: "RestrictedToRaces",
+    comment: "The item is restricted to one of a list of races. If only one race is allowed, the list may only have a single element.",
+    type: () => DB.Object({
+        scope: DB.Required({
+            comment: "The item is restricted to one of a list of races. If only one race is allowed, the list may only have a single element.",
+            type: DB.Array(RaceIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+    }),
+});
+export const RestrictedToCultures = DB.TypeAlias(import.meta.url, {
+    name: "RestrictedToCultures",
+    comment: "The item is restricted to one of a list of cultures. If only one culture is allowed, the list may only have a single element.",
+    type: () => DB.Object({
+        scope: DB.Required({
+            comment: "The item is restricted to one of a list of cultures. If only one culture is allowed, the list may only have a single element.",
+            type: DB.Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+    }),
+});
+export const RestrictedToProfessions = DB.TypeAlias(import.meta.url, {
+    name: "RestrictedToProfessions",
+    comment: "The item is restricted to one of a list of professions. If only one profession is allowed, the list may only have a single element.",
+    type: () => DB.Object({
+        scope: DB.Required({
+            comment: "The item is restricted to one of a list of professions. If only one profession is allowed, the list may only have a single element.",
+            type: DB.Array(ProfessionIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+    }),
+});
+export const RestrictedToMagicalTraditions = DB.TypeAlias(import.meta.url, {
+    name: "RestrictedToMagicalTraditions",
+    comment: "The item is restricted to one of a list of magical traditions. If only one magical tradition is allowed, the list may only have a single element.",
+    type: () => DB.Object({
+        scope: DB.Required({
+            comment: "The item is restricted to one of a list of magical traditions. If only one magical tradition is allowed, the list may only have a single element.",
+            type: DB.Array(MagicalTraditionIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+    }),
+});
+export const RestrictedToBlessedTraditions = DB.TypeAlias(import.meta.url, {
+    name: "RestrictedToBlessedTraditions",
+    comment: "The item is restricted to one of a list of blessed traditions. If only one blessed tradition is allowed, the list may only have a single element. The item may also be declared as sanctified.",
+    type: () => DB.Object({
+        scope: DB.Required({
+            comment: "The item is restricted to one of a list of blessed traditions. If only one blessed tradition is allowed, the list may only have a single element.",
+            type: DB.IncludeIdentifier(RestrictedToBlessedTraditionsScope),
+        }),
+        isSanctifiedBy: DB.Required({
+            comment: "The item is sanctified by the applicable listed tradition.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+export const RestrictedToBlessedTraditionsScope = DB.Enum(import.meta.url, {
+    name: "RestrictedToBlessedTraditionsScope",
+    comment: "The item is restricted to one of a list of blessed traditions. If only one blessed tradition is allowed, the list may only have a single element. Instead of providing an specific set of traditions, the restriction may also cover a category of blessed traditions.",
+    values: () => ({
+        Specific: DB.EnumCase({
+            type: DB.Array(BlessedTraditionIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        Church: DB.EnumCase({ type: null }),
+        Shamanistic: DB.EnumCase({ type: null }),
+    }),
+});

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

@@ -0,0 +1,62 @@
+/**
+ * Auxiliary types for melee weapons.
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const AttackModifier: DB.TypeAlias<"AttackModifier", DB.Integer, []>;
+export declare const ParryModifier: DB.TypeAlias<"ParryModifier", DB.Integer, []>;
+export declare const MeleeWeapon: DB.TypeAlias<"MeleeWeapon", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"GenMeleeWeapon", DB.Object<{
+    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>;
+}>, [Damage: DB.Param<"Damage", DB.Type>]>>, []>;
+export declare const GenMeleeWeapon: DB.TypeAlias<"GenMeleeWeapon", DB.Object<{
+    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>;
+}>, [Damage: DB.Param<"Damage", DB.Type>]>;

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

@@ -0,0 +1,100 @@
+/**
+ * Auxiliary types for melee weapons.
+ */
+import * as DB from "tsondb/schema/dsl";
+import { Dice } from "../../_Dice.js";
+import { ReachIdentifier } from "../../_Identifier.js";
+import { Length, PrimaryAttributeDamageThreshold } from "./_Weapon.js";
+export const AttackModifier = DB.TypeAlias(import.meta.url, {
+    name: "AttackModifier",
+    comment: "The AT modifier.",
+    type: () => DB.Integer(),
+});
+export const ParryModifier = DB.TypeAlias(import.meta.url, {
+    name: "ParryModifier",
+    comment: "The PA modifier.",
+    type: () => DB.Integer(),
+});
+const MeleeDamage = DB.TypeAlias(import.meta.url, {
+    name: "MeleeDamage",
+    comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+    type: () => DB.Object({
+        dice: DB.Required({
+            comment: "How many dice of which type are rolled to get the damage.",
+            type: DB.IncludeIdentifier(Dice),
+        }),
+        flat: DB.Optional({
+            comment: "Flat damage, if any. It gets added to the result of the dice rolls.",
+            type: DB.Integer(),
+        }),
+    }),
+});
+const ShieldSize = DB.Enum(import.meta.url, {
+    name: "ShieldSize",
+    comment: "The shield size and potential size-depending values.",
+    values: () => ({
+        Small: DB.EnumCase({ type: null }),
+        Medium: DB.EnumCase({ type: null }),
+        Large: DB.EnumCase({ type: DB.IncludeIdentifier(LargeShieldSize) }),
+    }),
+});
+const LargeShieldSize = DB.TypeAlias(import.meta.url, {
+    name: "LargeShieldSize",
+    comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+    type: () => DB.Object({
+        attack_penalty: DB.Optional({
+            comment: "The attack penalty from the shield, if any.",
+            type: DB.Integer(),
+        }),
+    }),
+});
+export const MeleeWeapon = DB.TypeAlias(import.meta.url, {
+    name: "MeleeWeapon",
+    type: () => DB.GenIncludeIdentifier(GenMeleeWeapon, [DB.IncludeIdentifier(MeleeDamage)]),
+});
+export const GenMeleeWeapon = DB.GenTypeAlias(import.meta.url, {
+    name: "GenMeleeWeapon",
+    parameters: [DB.Param("Damage")],
+    type: Damage => DB.Object({
+        damage: DB.Required({
+            comment: "The damage of a weapon can consist of random dice rolls and flat damage.",
+            type: DB.TypeArgument(Damage),
+        }),
+        damage_threshold: DB.Optional({
+            comment: "The primary attribute damage and threshold value.",
+            type: DB.IncludeIdentifier(PrimaryAttributeDamageThreshold),
+        }),
+        attackModifier: DB.Optional({
+            comment: "The AT modifier.",
+            type: DB.IncludeIdentifier(AttackModifier),
+        }),
+        parryModifier: DB.Optional({
+            comment: "The PA modifier.",
+            type: DB.IncludeIdentifier(ParryModifier),
+        }),
+        reach: DB.Optional({
+            comment: "The reach of the weapon.",
+            type: DB.Array(ReachIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        length: DB.Optional({
+            comment: "The length of the weapon in cm/halffingers.",
+            type: DB.IncludeIdentifier(Length),
+        }),
+        size: DB.Optional({
+            comment: "The shield size and potential size-depending values.",
+            type: DB.IncludeIdentifier(ShieldSize),
+        }),
+        is_parrying_weapon: DB.Required({
+            comment: "Is the weapon a parrying weapon?",
+            type: DB.Boolean(),
+        }),
+        is_two_handed_weapon: DB.Required({
+            comment: "Is the weapon a two-handed weapon?",
+            type: DB.Boolean(),
+        }),
+        is_improvised_weapon: DB.Required({
+            comment: "Is the weapon an improvised weapon?",
+            type: DB.Boolean(),
+        }),
+    }),
+});

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

@@ -0,0 +1,38 @@
+/**
+ * Auxiliary types for ranged weapons.
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const RangedWeapon: DB.TypeAlias<"RangedWeapon", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"GenRangedWeapon", DB.Object<{
+    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>;
+}>, [Damage: DB.Param<"Damage", DB.Type>]>>, []>;
+export declare const GenRangedWeapon: DB.TypeAlias<"GenRangedWeapon", DB.Object<{
+    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>;
+}>, [Damage: DB.Param<"Damage", DB.Type>]>;

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

@@ -0,0 +1,93 @@
+/**
+ * Auxiliary types for ranged weapons.
+ */
+import * as DB from "tsondb/schema/dsl";
+import { Dice } from "../../_Dice.js";
+import { AmmunitionishIdentifier } from "../../_IdentifierGroup.js";
+import { Length } from "./_Weapon.js";
+const RangedDamage = DB.Enum(import.meta.url, {
+    name: "RangedDamage",
+    comment: "The damage of a ranged weapon. It consists of a random part using dice and an optional flat part ny default. Some ranged weapons may work different so that damage is either not applicable at all or it is outlined as *Special* and further defined in a description.",
+    values: () => ({
+        Default: DB.EnumCase({ type: DB.IncludeIdentifier(DefaultRangedDamage) }),
+        NotApplicable: DB.EnumCase({ type: null }),
+        Special: DB.EnumCase({ type: null }),
+    }),
+});
+const DefaultRangedDamage = DB.TypeAlias(import.meta.url, {
+    name: "DefaultRangedDamage",
+    comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
+    type: () => DB.Object({
+        dice: DB.Required({
+            comment: "How many dice of which type are rolled to get the damage.",
+            type: DB.IncludeIdentifier(Dice),
+        }),
+        flat: DB.Optional({
+            comment: "Flat damage, if any. It gets added to the result of the dice rolls.",
+            type: DB.Integer(),
+        }),
+    }),
+});
+export const RangedWeapon = DB.TypeAlias(import.meta.url, {
+    name: "RangedWeapon",
+    type: () => DB.GenIncludeIdentifier(GenRangedWeapon, [DB.IncludeIdentifier(RangedDamage)]),
+});
+export const GenRangedWeapon = DB.GenTypeAlias(import.meta.url, {
+    name: "GenRangedWeapon",
+    parameters: [DB.Param("Damage")],
+    type: Damage => DB.Object({
+        damage: DB.Required({
+            comment: "The damage of a weapon can consist of random dice rolls and flat damage.",
+            type: DB.TypeArgument(Damage),
+        }),
+        reload_time: DB.Required({
+            comment: "One or multiple reload times.",
+            type: DB.Array(DB.IncludeIdentifier(ReloadTime), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        range: DB.Required({
+            comment: "The range brackets for the weapon: close, medium, far. Distances in m.",
+            type: DB.IncludeIdentifier(RangeBrackets),
+        }),
+        ammunition: DB.Optional({
+            comment: "The needed ammunition.",
+            type: DB.IncludeIdentifier(AmmunitionishIdentifier),
+        }),
+        length: DB.Optional({
+            comment: "The length of the weapon in cm/halffingers.",
+            type: DB.IncludeIdentifier(Length),
+        }),
+        is_improvised_weapon: DB.Required({
+            comment: "Is the weapon an improvised weapon?",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const RangeBrackets = DB.TypeAlias(import.meta.url, {
+    name: "RangeBrackets",
+    type: () => DB.Object({
+        close: DB.Required({
+            comment: "The close range bracket for the weapon. Distance in m.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        medium: DB.Required({
+            comment: "The medium range bracket for the weapon. Distance in m.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        far: DB.Required({
+            comment: "The far range bracket for the weapon. Distance in m.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+    }),
+});
+const ReloadTime = DB.TypeAlias(import.meta.url, {
+    name: "ReloadTime",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "A reload time value in actions.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});

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

@@ -0,0 +1,25 @@
+import * as DB from "tsondb/schema/dsl";
+import type { GetDisplayNameAndId, GetInstanceById } from "tsondb/schema/gen";
+import type { GenMeleeWeapon, GenRangedWeapon } from "../../../../gen/types.js";
+export declare const PrimaryAttributeDamageThreshold: 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>;
+    }>, []>>>;
+}, []>;
+export declare const Length: DB.TypeAlias<"Length", DB.Integer, []>;
+export declare const checkWeaponCombatTechniqueIntegrity: ({ instanceContent, getInstanceById, getDisplayNameAndId, }: {
+    instanceContent: {
+        melee_uses?: Record<string, GenMeleeWeapon<unknown>>;
+        ranged_uses?: Record<string, GenRangedWeapon<unknown>>;
+    };
+    getInstanceById: GetInstanceById;
+    getDisplayNameAndId: GetDisplayNameAndId;
+}, { secondary: _secondary }: {
+    secondary: boolean;
+}) => string[];

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

@@ -0,0 +1,77 @@
+import * as DB from "tsondb/schema/dsl";
+import { AttributeIdentifier } from "../../_Identifier.js";
+export const PrimaryAttributeDamageThreshold = DB.Enum(import.meta.url, {
+    name: "PrimaryAttributeDamageThreshold",
+    comment: "The primary attribute damage and threshold value. You can either use an integer, an object or a pair. Use an integer if you just have to define a single threshold value for the default primary attribute of the combat technique. Use an object if you need to define the value only or if you need to define the value as well as a single different primary attribute than which the combat technique uses. Use the pair if you need to set the primary attributes to AGI and STR (the combat technique has AGI but this item has AGI/STR) and/or if you need to set different thresholds for AGI and STR (e.g. AGI 14/STR 15). If the same values are in the pair, they will be merged (AGI 14/STR 14 will be AGI/STR 14).",
+    values: () => ({
+        Default: DB.EnumCase({ type: DB.IncludeIdentifier(DefaultPrimaryAttributeDamageThreshold) }),
+        List: DB.EnumCase({ type: DB.IncludeIdentifier(PrimaryAttributeDamageThresholdList) }),
+    }),
+});
+const DefaultPrimaryAttributeDamageThreshold = DB.TypeAlias(import.meta.url, {
+    name: "DefaultPrimaryAttributeDamageThreshold",
+    type: () => DB.Object({
+        threshold: DB.Required({
+            comment: "The attribute value representing the damage threshold for the primary attribute of the item's combat technique.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const PrimaryAttributeDamageThresholdList = DB.TypeAlias(import.meta.url, {
+    name: "PrimaryAttributeDamageThresholdList",
+    type: () => DB.Object({
+        list: DB.Required({
+            comment: "A list of primary attributes with their associated threshold.",
+            type: DB.Array(DB.IncludeIdentifier(SinglePrimaryAttributeDamageThreshold), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+    }),
+});
+const SinglePrimaryAttributeDamageThreshold = DB.TypeAlias(import.meta.url, {
+    name: "SinglePrimaryAttributeDamageThreshold",
+    type: () => DB.Object({
+        attribute: DB.Required({
+            comment: "The primary attribute.",
+            type: AttributeIdentifier(),
+        }),
+        threshold: DB.Required({
+            comment: "The attribute value representing the damage threshold.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+export const Length = DB.TypeAlias(import.meta.url, {
+    name: "Length",
+    comment: "The length of the weapon in cm/halffingers.",
+    type: () => DB.Integer({ minimum: 1 }),
+});
+export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstanceById, getDisplayNameAndId, }, { secondary: _secondary }) => {
+    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
+            ? "either melee uses or ranged uses have to be provided"
+            : undefined,
+        ...Object.entries(instanceContent.melee_uses ?? {}).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 [
+                checkPart(ct.special.can_parry, meleeUse.parryModifier, "a parry modifier", "close", ctId),
+                checkPart(ct.special.has_damage_threshold, meleeUse.damage_threshold, "a damage threshold", "close", ctId),
+                checkPart(ct.special.has_length, meleeUse.length, "a length", "close", ctId),
+                checkPart(ct.special.has_reach, meleeUse.reach, "a reach", "close", ctId),
+                checkPart(ct.special.has_shield_size, meleeUse.size, "a shield size", "close", ctId),
+            ].filter(v => v !== undefined);
+        }),
+        ...Object.entries(instanceContent.ranged_uses ?? {}).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 [
+                checkPart(ct.special.has_ammunition, rangedUse.ammunition, "an ammunition", "ranged", ctId),
+            ].filter(v => v !== undefined);
+        }),
+    ].filter(v => v !== undefined);
+};

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

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ArmorType: DB.Entity<"ArmorType", {
+    sturdiness_rating: DB.MemberDecl<DB.Integer, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ArmorTypeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;