optolith-database-schema 0.17.0 → 0.18.1

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

@@ -1,166 +1,223 @@
-/**
- * @main Weapon
- */
-import { TypeConfig } from "../../../typeConfig.js";
-import { LocaleMap } from "../../_LocaleMap.js";
-import { NonEmptyMarkdown, NonEmptyString } from "../../_NonEmptyString.js";
-import { BlessedTraditionReference, CultureReference, MagicalTraditionReference, RaceReference } from "../../_SimpleReferences.js";
-import { Errata } from "../../source/_Erratum.js";
-import { PublicationRefs } from "../../source/_PublicationRef.js";
-import { Complexity, Cost, StructurePoints, Weight } from "./_Item.js";
-import { MeleeWeapon } from "./_MeleeWeapon.js";
-import { RangedWeapon } from "./_RangedWeapon.js";
-export type Weapon = {
-    /**
-     * The cost in silverthalers.
-     */
-    cost: Cost;
-    /**
-     * The weight in kg.
-     */
-    weight: Weight;
-    /**
-     * The complexity of crafting the item.
-     */
-    complexity: Complexity;
-    /**
-     * The structure points of the item. Use an array if the item consists of
-     * multiple components that have individual structure points.
-     */
-    structure_points?: StructurePoints;
-    /**
-     * A list of stat blocks for each combat technique this weapon can be used
-     * with.
-     * @minItems 1
-     */
-    uses: WeaponUse[];
-    /**
-     * If the weapon is sanctified by a god and thus restricted to it's Blessed
-     * Ones.
-     */
-    sanctified_by?: SanctifiedBy;
-    /**
-     * Define if during character creation this weapon can only be bought by
-     * characters of a specific race or culture.
-     */
-    restricted_to_cultures?: RestrictedToCultures;
-    /**
-     * Define if during character creation this weapon can only be bought by
-     * characters of specific magical or blessed traditions.
-     * @minItems 1
-     */
-    restricted_to_traditions?: MagicalTraditionReference[];
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<WeaponTranslation>;
-};
-export type WeaponTranslation = {
-    /**
-     * The name of the item.
-     */
-    name: NonEmptyString;
-    /**
-     * An auxiliary name or label of the item, if available.
-     */
-    secondary_name?: NonEmptyString;
-    /**
-     * Note text.
-     */
-    note?: NonEmptyMarkdown;
-    /**
-     * Special rules text.
-     */
-    rules?: NonEmptyMarkdown;
-    /**
-     * The weapon advantage text.
-     */
-    advantage?: NonEmptyMarkdown;
-    /**
-     * The weapon disadvantage text.
-     */
-    disadvantage?: NonEmptyMarkdown;
-    errata?: Errata;
-};
-export type SecondaryWeapon = {
-    /**
-     * A list of stat blocks for each combat technique this weapon can be used
-     * with.
-     * @minItems 1
-     */
-    uses: WeaponUse[];
-    /**
-     * If the weapon is sanctified by a god and thus restricted to it's Blessed
-     * Ones.
-     */
-    sanctified_by?: SanctifiedBy;
-    /**
-     * Define if during character creation this weapon can only be bought by
-     * characters of a specific race or culture.
-     */
-    restricted_to_cultures?: RestrictedToCultures;
-    /**
-     * Define if during character creation this weapon can only be bought by
-     * characters of specific magical or blessed traditions.
-     * @minItems 1
-     */
-    restricted_to_traditions?: MagicalTraditionReference[];
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations?: LocaleMap<ImprovisedWeaponTranslation>;
-};
-/**
- * @minProperties 1
- */
-export type ImprovisedWeaponTranslation = {
-    /**
-     * The weapon advantage text.
-     */
-    advantage?: NonEmptyMarkdown;
-    /**
-     * The weapon disadvantage text.
-     */
-    disadvantage?: NonEmptyMarkdown;
-};
-export type WeaponUse = {
-    /**
-     * An increasing integer for use identification.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    values: WeaponUseValues;
-};
-export type WeaponUseValues = {
-    tag: "Melee";
-    melee: MeleeWeapon;
-} | {
-    tag: "Ranged";
-    ranged: RangedWeapon;
-};
-/**
- * If the weapon is sanctified by a god and thus restricted to it's Blessed
- * Ones.
- * @minItems 1
- */
-export type SanctifiedBy = BlessedTraditionReference[];
-/**
- * Define if during character creation this weapon can only be bought by
- * characters of a specific race or culture.
- */
-export type RestrictedToCultures = {
-    tag: "CulturesOfRace";
-    cultures_of_race: RaceReference;
-} | {
-    tag: "Cultures";
-    cultures: RestrictedToSpecificCultures;
-};
-export type RestrictedToSpecificCultures = {
-    /**
-     * @minitems 1
-     */
-    list: CultureReference[];
-};
-export declare const config: TypeConfig<Weapon, number, "Weapon">;
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, NestedEntityMap, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const Weapon: Entity<"Weapon", {
+    cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Cost", {
+        Free: EnumCase<null>;
+        Various: EnumCase<null>;
+        Invaluable: EnumCase<null>;
+        Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
+            value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+            translations: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"FixedCostTranslation", {
+                wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, false>;
+        }>, []>>>;
+        Range: EnumCase<IncludeIdentifier<[], TypeAlias<"CostRange", Object<{
+            from: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+            to: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
+            translations: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"CostRangeTranslation", {
+                wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, true>;
+    weight: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Weight", import("tsondb/schema/def").FloatType, []>>, true>;
+    complexity: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Complexity", {
+        Primitive: EnumCase<null>;
+        Simple: EnumCase<null>;
+        Complex: EnumCase<IncludeIdentifier<[], TypeAlias<"ComplexComplexity", Object<{
+            ap_value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    structure_points: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"StructurePoints", Array<IncludeIdentifier<[], TypeAlias<"StructurePointsComponent", Object<{
+        points: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+    }>, []>>>, []>>, false>;
+    melee_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
+        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", Object<{
+            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+                number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
+            }>, []>>, true>;
+            flat: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+        }>, []>>, true>;
+        damage_threshold: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"PrimaryAttributeDamageThreshold", {
+            Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", Object<{
+                threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            }>, []>>>;
+            List: EnumCase<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", Object<{
+                list: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", Object<{
+                    attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+                    threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                }>, []>>>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+        attackModifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AttackModifier", import("tsondb/schema/def").IntegerType, []>>, true>;
+        parryModifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ParryModifier", import("tsondb/schema/def").IntegerType, []>>, false>;
+        reach: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
+        length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", import("tsondb/schema/def").IntegerType, []>>, false>;
+        size: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ShieldSize", {
+            Small: EnumCase<null>;
+            Medium: EnumCase<null>;
+            Large: EnumCase<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", Object<{
+                attack_penalty: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+            }>, []>>>;
+        }, []>>, false>;
+        is_parrying_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+        is_two_handed_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+        is_improvised_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+    }>, false>;
+    ranged_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
+        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangedDamage", {
+            Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", Object<{
+                dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+                    number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
+                }>, []>>, true>;
+                flat: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+            }>, []>>>;
+            NotApplicable: EnumCase<null>;
+            Special: EnumCase<null>;
+        }, []>>, true>;
+        reload_time: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
+            value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+        }>, []>>>, true>;
+        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
+            close: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            medium: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            far: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+        }>, []>>, true>;
+        ammunition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
+        length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", import("tsondb/schema/def").IntegerType, []>>, true>;
+        is_improvised_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+    }>, false>;
+    sanctified_by: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SanctifiedBy", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, false>;
+    restricted_to_cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RestrictedToCultures", {
+        CulturesOfRace: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Cultures: EnumCase<IncludeIdentifier<[], TypeAlias<"RestrictedToSpecificCultures", Object<{
+            list: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    restricted_to_traditions: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, false>;
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        occurrences: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"Occurrence", {
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"WeaponTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        secondary_name: import("tsondb/schema/def").MemberDecl<String, false>;
+        note: import("tsondb/schema/def").MemberDecl<String, false>;
+        rules: import("tsondb/schema/def").MemberDecl<String, false>;
+        advantage: import("tsondb/schema/def").MemberDecl<String, false>;
+        disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;
+export declare const ImprovisedWeapon: TypeAlias<"ImprovisedWeapon", Object<{
+    melee_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
+        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MeleeDamage", Object<{
+            dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+                number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
+            }>, []>>, true>;
+            flat: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+        }>, []>>, true>;
+        damage_threshold: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"PrimaryAttributeDamageThreshold", {
+            Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", Object<{
+                threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            }>, []>>>;
+            List: EnumCase<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", Object<{
+                list: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", Object<{
+                    attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+                    threshold: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                }>, []>>>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+        attackModifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AttackModifier", import("tsondb/schema/def").IntegerType, []>>, true>;
+        parryModifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ParryModifier", import("tsondb/schema/def").IntegerType, []>>, false>;
+        reach: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
+        length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", import("tsondb/schema/def").IntegerType, []>>, false>;
+        size: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ShieldSize", {
+            Small: EnumCase<null>;
+            Medium: EnumCase<null>;
+            Large: EnumCase<IncludeIdentifier<[], TypeAlias<"LargeShieldSize", Object<{
+                attack_penalty: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+            }>, []>>>;
+        }, []>>, false>;
+        is_parrying_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+        is_two_handed_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+        is_improvised_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+    }>, false>;
+    ranged_uses: import("tsondb/schema/def").MemberDecl<NestedEntityMap<string, {
+        damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangedDamage", {
+            Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultRangedDamage", Object<{
+                dice: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Dice", Object<{
+                    number: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", import("tsondb/schema/def").IntegerType, []>>, true>;
+                }>, []>>, true>;
+                flat: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+            }>, []>>>;
+            NotApplicable: EnumCase<null>;
+            Special: EnumCase<null>;
+        }, []>>, true>;
+        reload_time: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
+            value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+        }>, []>>>, true>;
+        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
+            close: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            medium: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+            far: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+        }>, []>>, true>;
+        ammunition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
+        length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", import("tsondb/schema/def").IntegerType, []>>, true>;
+        is_improvised_weapon: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, true>;
+    }>, false>;
+    sanctified_by: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SanctifiedBy", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, false>;
+    restricted_to_cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RestrictedToCultures", {
+        CulturesOfRace: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Cultures: EnumCase<IncludeIdentifier<[], TypeAlias<"RestrictedToSpecificCultures", Object<{
+            list: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    restricted_to_traditions: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, false>;
+    translations: import("tsondb/schema/def").MemberDecl<NestedEntityMap<"ImprovisedWeaponTranslation", {
+        advantage: import("tsondb/schema/def").MemberDecl<String, false>;
+        disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, false>;
+}>, []>;
+export declare const SanctifiedBy: TypeAlias<"SanctifiedBy", Array<import("tsondb/schema/def").ReferenceIdentifierType>, []>;

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

@@ -1,14 +1,154 @@
-/**
- * @main Weapon
- */
-import { todo } from "../../../validation/builders/integrity.js";
-import { validateEntityFileName } from "../../../validation/builders/naming.js";
-import { createSchemaValidator } from "../../../validation/builders/schema.js";
-import { getFilenamePrefixAsNumericId } from "../../../validation/filename.js";
-export const config = {
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, NestedEntityMap, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifier, RaceIdentifier, } from "../../_Identifier.js";
+import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
+import { NestedLocaleMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity, Cost, StructurePoints, Weight } from "./_Item.js";
+import { MeleeWeapon } from "./_MeleeWeapon.js";
+import { RangedWeapon } from "./_RangedWeapon.js";
+export const Weapon = Entity(import.meta.url, {
     name: "Weapon",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("Weapon"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "Weapons",
+    type: () => Object({
+        cost: Required({
+            comment: "The cost in silverthalers.",
+            type: IncludeIdentifier(Cost),
+        }),
+        weight: Required({
+            comment: "The weight in kg.",
+            type: IncludeIdentifier(Weight),
+        }),
+        complexity: Optional({
+            comment: "The complexity of crafting the item.",
+            type: IncludeIdentifier(Complexity),
+        }),
+        structure_points: Optional({
+            comment: "The structure points of the item. Use an array if the item consists of multiple components that have individual structure points.",
+            type: IncludeIdentifier(StructurePoints),
+        }),
+        melee_uses: Optional({
+            comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
+            type: NestedEntityMap({
+                name: "MeleeWeaponUse",
+                secondaryEntity: CloseCombatTechnique,
+                type: IncludeIdentifier(MeleeWeapon),
+            }),
+        }),
+        ranged_uses: Optional({
+            comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
+            type: NestedEntityMap({
+                name: "RangedWeaponUse",
+                secondaryEntity: RangedCombatTechnique,
+                type: IncludeIdentifier(RangedWeapon),
+            }),
+        }),
+        sanctified_by: Optional({
+            comment: "If the weapon is sanctified by a god and thus restricted to it's Blessed Ones.",
+            type: IncludeIdentifier(SanctifiedBy),
+        }),
+        restricted_to_cultures: Optional({
+            comment: "Define if during character creation this weapon can only be bought by characters of a specific race or culture.",
+            type: IncludeIdentifier(RestrictedToCultures),
+        }),
+        restricted_to_traditions: Optional({
+            comment: "Define if during character creation this weapon can only be bought by characters of specific magical or blessed traditions.",
+            type: Array(MagicalTraditionIdentifier(), { minItems: 1 }),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "WeaponTranslation", Object({
+            name: Required({
+                comment: "The item’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            secondary_name: Optional({
+                comment: "An auxiliary name or label of the item, if available.",
+                type: String({ minLength: 1 }),
+            }),
+            note: Optional({
+                comment: "Note text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            rules: Optional({
+                comment: "Special rules text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            advantage: Optional({
+                comment: "The weapon advantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            disadvantage: Optional({
+                comment: "The weapon disadvantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+export const ImprovisedWeapon = TypeAlias(import.meta.url, {
+    name: "ImprovisedWeapon",
+    type: () => Object({
+        melee_uses: Optional({
+            comment: "A list of stat blocks for each close combat technique this weapon can be used with.",
+            type: NestedEntityMap({
+                name: "ImprovisedMeleeWeaponUse",
+                secondaryEntity: CloseCombatTechnique,
+                type: IncludeIdentifier(MeleeWeapon),
+            }),
+        }),
+        ranged_uses: Optional({
+            comment: "A list of stat blocks for each ranged combat technique this weapon can be used with.",
+            type: NestedEntityMap({
+                name: "ImprovisedRangedWeaponUse",
+                secondaryEntity: RangedCombatTechnique,
+                type: IncludeIdentifier(RangedWeapon),
+            }),
+        }),
+        sanctified_by: Optional({
+            comment: "If the weapon is sanctified by a god and thus restricted to it's Blessed Ones.",
+            type: IncludeIdentifier(SanctifiedBy),
+        }),
+        restricted_to_cultures: Optional({
+            comment: "Define if during character creation this weapon can only be bought by characters of a specific race or culture.",
+            type: IncludeIdentifier(RestrictedToCultures),
+        }),
+        restricted_to_traditions: Optional({
+            comment: "Define if during character creation this weapon can only be bought by characters of specific magical or blessed traditions.",
+            type: Array(MagicalTraditionIdentifier(), { minItems: 1 }),
+        }),
+        translations: NestedLocaleMap(Optional, "ImprovisedWeaponTranslation", Object({
+            advantage: Optional({
+                comment: "The weapon advantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            disadvantage: Optional({
+                comment: "The weapon disadvantage text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+export const SanctifiedBy = TypeAlias(import.meta.url, {
+    name: "SanctifiedBy",
+    comment: "If the weapon is sanctified by a god and thus restricted to it's Blessed Ones.",
+    type: () => Array(BlessedTraditionIdentifier(), { minItems: 1 }),
+});
+const RestrictedToCultures = Enum(import.meta.url, {
+    name: "RestrictedToCultures",
+    comment: "Define if during character creation this weapon can only be bought by characters of a specific race or culture.",
+    values: () => ({
+        CulturesOfRace: EnumCase({ type: RaceIdentifier() }),
+        Cultures: EnumCase({ type: IncludeIdentifier(RestrictedToSpecificCultures) }),
+    }),
+});
+const RestrictedToSpecificCultures = TypeAlias(import.meta.url, {
+    name: "RestrictedToSpecificCultures",
+    type: () => Object({
+        list: Required({
+            type: Array(CultureIdentifier(), { minItems: 1 }),
+        }),
+    }),
+});