@optolith/database-schema 0.42.1

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

@@ -0,0 +1,80 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Vehicle: DB.Entity<"Vehicle", {
+    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, true>;
+            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, []>>, false>;
+    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>;
+        }>, []>>>;
+    }, []>>, 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<`${string}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.String, 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/Vehicle.js

@@ -0,0 +1,30 @@
+import * as DB from "tsondb/schema/dsl";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity, Cost, DefaultItemTranslations, Weight } from "./_Item.js";
+export const Vehicle = DB.Entity(import.meta.url, {
+    name: "Vehicle",
+    namePlural: "Vehicles",
+    type: () => DB.Object({
+        cost: DB.Required({
+            comment: "The cost in silverthalers.",
+            type: DB.IncludeIdentifier(Cost),
+        }),
+        weight: DB.Optional({
+            comment: "The weight in kg.",
+            type: DB.IncludeIdentifier(Weight),
+        }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
+        src,
+        translations: DefaultItemTranslations("Vehicle"),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

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

@@ -0,0 +1,225 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Weapon: DB.Entity<"Weapon", {
+    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, true>;
+            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>;
+        }>, []>>>;
+    }, []>>, false>;
+    structure_points: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePoints", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"StructurePointsComponent", DB.Object<{
+        points: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>, []>>, false>;
+    melee_uses: 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>;
+    ranged_uses: 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>;
+    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>;
+    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<"WeaponTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: 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>;
+        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>;
+export declare const ImprovisedWeapon: DB.TypeAlias<"ImprovisedWeapon", DB.Object<{
+    melee_uses: 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>;
+    ranged_uses: 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>;
+    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<"ImprovisedWeaponTranslation", {
+        advantage: DB.MemberDecl<DB.String, false>;
+        disadvantage: DB.MemberDecl<DB.String, false>;
+    }>, false>;
+}>, []>;

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

@@ -0,0 +1,132 @@
+import * as DB from "tsondb/schema/dsl";
+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, RestrictedTo, StructurePoints, Weight } from "./_Item.js";
+import { MeleeWeapon } from "./_MeleeWeapon.js";
+import { RangedWeapon } from "./_RangedWeapon.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
+export const Weapon = DB.Entity(import.meta.url, {
+    name: "Weapon",
+    namePlural: "Weapons",
+    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.Optional({
+            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),
+        }),
+        melee_uses: DB.Optional({
+            comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
+            type: DB.NestedEntityMap({
+                name: "MeleeWeaponUse",
+                namePlural: "MeleeWeaponUses",
+                secondaryEntity: CloseCombatTechnique,
+                type: DB.IncludeIdentifier(MeleeWeapon),
+                minProperties: 1,
+            }),
+        }),
+        ranged_uses: DB.Optional({
+            comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
+            type: DB.NestedEntityMap({
+                name: "RangedWeaponUse",
+                namePlural: "RangedWeaponUses",
+                secondaryEntity: RangedCombatTechnique,
+                type: DB.IncludeIdentifier(RangedWeapon),
+                minProperties: 1,
+            }),
+        }),
+        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),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Weapon", 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" }),
+            }),
+            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" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: params => checkWeaponCombatTechniqueIntegrity(params, { secondary: false }),
+});
+export const ImprovisedWeapon = DB.TypeAlias(import.meta.url, {
+    name: "ImprovisedWeapon",
+    type: () => DB.Object({
+        melee_uses: DB.Optional({
+            comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
+            type: DB.NestedEntityMap({
+                name: "ImprovisedMeleeWeaponUse",
+                namePlural: "ImprovisedMeleeWeaponUses",
+                secondaryEntity: CloseCombatTechnique,
+                type: DB.IncludeIdentifier(MeleeWeapon),
+                minProperties: 1,
+            }),
+        }),
+        ranged_uses: DB.Optional({
+            comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
+            type: DB.NestedEntityMap({
+                name: "ImprovisedRangedWeaponUse",
+                namePlural: "ImprovisedRangedWeaponUses",
+                secondaryEntity: RangedCombatTechnique,
+                type: DB.IncludeIdentifier(RangedWeapon),
+                minProperties: 1,
+            }),
+        }),
+        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),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "ImprovisedWeapon", DB.Object({
+            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" }),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});