@optolith/database-schema 0.94.0 → 0.95.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.95.0](https://github.com/Optolith/database-schema/compare/v0.94.0...v0.95.0) (2026-10-12)
+
+### ⚠ BREAKING CHANGES
+
+* armor accessory entity
+* rearrange book values for Aventurische Bibliothek
+
+### Features
+
+* armor accessory entity ([3ecd251](https://github.com/Optolith/database-schema/commit/3ecd25145811c115228fb2c10e31501ff7e1acd2))
+* rearrange book values for Aventurische Bibliothek ([bc36e58](https://github.com/Optolith/database-schema/commit/bc36e58957e3e9ac96d40998e762dff72b62bdaa)), closes [#154](https://github.com/Optolith/database-schema/issues/154), references [#153](https://github.com/Optolith/database-schema/issues/153)
+
 ## [0.94.0](https://github.com/Optolith/database-schema/compare/v0.93.0...v0.94.0) (2026-10-12)
 
 ### ⚠ BREAKING CHANGES

package/gen/types.d.ts

@@ -21,6 +21,7 @@ export type EntityMap = {
   ArcaneDancerTradition: ArcaneDancerTradition
   ArcaneOrbEnchantment: ArcaneOrbEnchantment
   Armor: Armor
+  ArmorAccessory: ArmorAccessory
   Aspect: Aspect
   AttireEnchantment: AttireEnchantment
   Attribute: Attribute
@@ -271,6 +272,7 @@ export type EnumMap = {
   BookContentQuality: BookContentQuality
   BookCost: BookCost
   BookCostVariant: BookCostVariant
+  BookPrerequisiteGroup: BookPrerequisiteGroup
   BookRules: BookRules
   BookType: BookType
   BurningTime: BurningTime
@@ -570,6 +572,7 @@ export type TypeAliasMap = {
   BlessedTraditionPrerequisite: BlessedTraditionPrerequisite
   BlessedTraditionsSelectOptionCategory: BlessedTraditionsSelectOptionCategory
   BlessingPerformanceParameters: BlessingPerformanceParameters
+  BookPrerequisites: BookPrerequisites
   BookRulesByEdition: BookRulesByEdition
   BookRulesOfEdition: BookRulesOfEdition
   BySizeCategory: BySizeCategory<unknown>
@@ -750,6 +753,7 @@ export type TypeAliasMap = {
   JewelryMaterialDifference: JewelryMaterialDifference<unknown>
   KnownItemSpecifics: KnownItemSpecifics
   KnownItemSpecificsTranslation: KnownItemSpecificsTranslation
+  LanguagePrerequisite: LanguagePrerequisite
   LanguagePrerequisites: LanguagePrerequisites
   LanguagesScriptsOptions: LanguagesScriptsOptions
   LanguagesSelectOptionCategory: LanguagesSelectOptionCategory
@@ -906,6 +910,7 @@ export type TypeAliasMap = {
   ReversalisEffect: ReversalisEffect
   RulePrerequisite: RulePrerequisite
   RulePrerequisites: RulePrerequisites
+  ScriptPrerequisite: ScriptPrerequisite
   SecondaryArmor: SecondaryArmor
   SelectableAttributeAdjustment: SelectableAttributeAdjustment
   SelectOptionRule: SelectOptionRule
@@ -2661,6 +2666,7 @@ export interface Locale {
     "Helmets": string
     "Pieces of Armor": string
     "Weapon Accessories": string
+    "Armor Accessories": string
     "Clothes": string
     "Clothing Packages for Social Status": string
     "Travel Gear and Tools": string
@@ -23875,7 +23881,7 @@ export interface HeadHitZoneCombinationPossibilities {
   protection?: number
 }
 
-export interface BandageOrRemedy {
+export interface ArmorAccessory {
   /**
    * The cost in silverthalers.
    */
@@ -23884,7 +23890,7 @@ export interface BandageOrRemedy {
   /**
    * The weight in kg.
    */
-  weight: Weight
+  weight?: Weight
 
   /**
    * The complexity of crafting the item.
@@ -23910,16 +23916,16 @@ export interface BandageOrRemedy {
    * All translations for the entry, identified by IETF language tag (BCP47).
    */
   translations: {
-    [localeId: string]: BandageOrRemedyTranslation
+    [localeId: string]: ArmorAccessoryTranslation
   }
 }
 
 /**
  * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
  */
-export type BandageOrRemedy_ID = string
+export type ArmorAccessory_ID = string
 
-export interface BandageOrRemedyTranslation {
+export interface ArmorAccessoryTranslation {
   /**
    * The item’s name.
    */
@@ -24051,6 +24057,74 @@ export interface SecondaryArmorTranslation {
   disadvantage?: string
 }
 
+export interface BandageOrRemedy {
+  /**
+   * 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
+
+  /**
+   * 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.
+   */
+  combat_use?: CombatUse
+
+  /**
+   * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
+   */
+  src: PublicationRefs
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: BandageOrRemedyTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type BandageOrRemedy_ID = string
+
+export interface BandageOrRemedyTranslation {
+  /**
+   * The item’s name.
+   */
+  name: string
+
+  /**
+   * An auxiliary name or label of the item, if available.
+   */
+  secondary_name?: string
+
+  /**
+   * Note text.
+   */
+  note?: string
+
+  /**
+   * Special rules text.
+   */
+  rules?: string
+
+  errata?: Errata
+}
+
 export interface Biome {
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
@@ -24130,6 +24204,11 @@ export interface Book {
    */
   types: BookType[]
 
+  /**
+   * The language(s) and script(s) the book is written in.
+   */
+  languageAndScript?: BookPrerequisites
+
   /**
    * The cost in silverthalers.
    */
@@ -24155,6 +24234,11 @@ export interface Book {
    */
   contentQuality?: BookContentQuality
 
+  /**
+   * Skills and abilities you can learn by reading the book, as well as any other rules and effects concerning the book.
+   */
+  rules: BookRules
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -24185,25 +24269,15 @@ export interface BookTranslation {
   secondary_name?: string
 
   /**
-   * The language the book is written in, if specified.
+   * The language(s) and script(s) the book is written in.
    */
-  language?: string
-
-  /**
-   * The script that was used for the book, if specified.
-   */
-  script?: string
+  languageAndScript?: string
 
   /**
    * Note text.
    */
   note?: string
 
-  /**
-   * Special rules text.
-   */
-  rules?: BookRules
-
   /**
    * The legality of the item, if specified.
    */
@@ -24264,6 +24338,37 @@ export type MundaneBookType =
     ProfessionalPublication: Skill_ID
   }
 
+export type BookPrerequisites = PlainPrerequisites<BookPrerequisiteGroup>
+
+export type BookPrerequisiteGroup =
+  | {
+    kind: "Language"
+    Language: LanguagePrerequisite
+  }
+  | {
+    kind: "Script"
+    Script: ScriptPrerequisite
+  }
+
+export interface LanguagePrerequisite {
+  /**
+   * The language’s identifier.
+   */
+  id: Language_ID
+
+  /**
+   * The required minimum level of the language.
+   */
+  level: number
+}
+
+export interface ScriptPrerequisite {
+  /**
+   * The script’s identifier.
+   */
+  id: Script_ID
+}
+
 /**
  * The cost of the book, which may be a single value or multiple values that are defined by specific editions or other defining factors of the book.
  */
@@ -24373,6 +24478,15 @@ export type BookRules =
  * The book’s rules without any special effects or conditions.
  */
 export interface PlainBookRules {
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: PlainBookRulesTranslation
+  }
+}
+
+export interface PlainBookRulesTranslation {
   /**
    * The (main) rules text.
    */
@@ -24400,6 +24514,15 @@ export interface PlainBookRules {
 export interface BookRulesByEdition {
   editions: BookRulesOfEdition[]
 
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations?: {
+    [localeId: string]: BookRulesByEditionTranslation
+  }
+}
+
+export interface BookRulesByEditionTranslation {
   /**
    * Additional rules text that comes after all other rules.
    */
@@ -24407,11 +24530,30 @@ export interface BookRulesByEdition {
 }
 
 export interface BookRulesOfEdition {
+  /**
+   * The language(s) and script(s) the book is written in.
+   */
+  languageAndScript?: BookPrerequisites
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: BookRulesOfEditionTranslation
+  }
+}
+
+export interface BookRulesOfEditionTranslation {
   /**
    * The edition(s) the rules apply to.
    */
   label: string
 
+  /**
+   * The language(s) and script(s) the book is written in.
+   */
+  languageAndScript?: string
+
   /**
    * The rules text.
    */
@@ -25396,6 +25538,10 @@ export type EquipmentIdentifier =
     kind: "Armor"
     Armor: Armor_ID
   }
+  | {
+    kind: "ArmorAccessory"
+    ArmorAccessory: ArmorAccessory_ID
+  }
   | {
     kind: "BandageOrRemedy"
     BandageOrRemedy: BandageOrRemedy_ID
@@ -27842,6 +27988,11 @@ export interface Settings {
    * Style Special Abilities and Advanced Special Abilities are part of focus rules. This type defines which focus rule must be enabled in order to use any of these special abilities. Essentially, this is a default prerequisite all of these special abilities must meet, but manually inserting them with every special ability is a lot of work and error-prone. Therefore, in order to use any of these special abilities, prerequisites for the respective focus rule must be generated for every entry.
    */
   styles: StyleSpecialAbilitySettings
+
+  /**
+   * The publication that extends the description of books with additional information.
+   */
+  extendedBookDescriptionPublication: Publication_ID
 }
 
 /**

package/lib/cache/tradeSecrets.js

@@ -2,6 +2,7 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { Case } from "tsondb/schema/gen";
 const emptyDerivedEquipmentTradeSecretsCache = {
     Armor: {},
+    ArmorAccessory: {},
     Ammunition: {},
     BandageOrRemedy: {},
     Book: {},

package/lib/main.js

@@ -21,6 +21,7 @@ export const schema = new Schema([
     Types.ArcaneDancerTradition,
     Types.ArcaneOrbEnchantment,
     Types.Armor,
+    Types.ArmorAccessory,
     Types.Aspect,
     Types.AttireEnchantment,
     Types.Attribute,

package/lib/types/Locale.d.ts

@@ -1507,6 +1507,7 @@ export declare const Locale: DB.Entity<"Locale", {
         Helmets: null;
         "Pieces of Armor": null;
         "Weapon Accessories": null;
+        "Armor Accessories": null;
         Clothes: null;
         "Clothing Packages for Social Status": null;
         "Travel Gear and Tools": null;

package/lib/types/Locale.js

@@ -1550,6 +1550,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Helmets": null,
                 "Pieces of Armor": null,
                 "Weapon Accessories": null,
+                "Armor Accessories": null,
                 "Clothes": null,
                 "Clothing Packages for Social Status": null,
                 "Travel Gear and Tools": null,

package/lib/types/Settings.d.ts

@@ -183,4 +183,5 @@ export declare const Settings: DB.SingletonEntity<"Settings", {
         magic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         liturgical: DB.MemberDecl<DB.ReferenceIdentifier, true>;
     }>, []>>, true>;
+    extendedBookDescriptionPublication: DB.MemberDecl<DB.ReferenceIdentifier, true>;
 }>;

package/lib/types/Settings.js

@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
-import { AdvantageIdentifier, DerivedCharacteristicIdentifier, ExperienceLevelIdentifier, FocusRuleIdentifier, } from "./_Identifier.js";
+import { AdvantageIdentifier, DerivedCharacteristicIdentifier, ExperienceLevelIdentifier, FocusRuleIdentifier, PublicationIdentifier, } from "./_Identifier.js";
 import { SpecialAbilityIdentifier } from "./_IdentifierGroup.js";
 export const Settings = DB.SingletonEntity(import.meta.url, {
     name: "Settings",
@@ -27,6 +27,10 @@ export const Settings = DB.SingletonEntity(import.meta.url, {
             comment: StyleSpecialAbilitySettings.comment,
             type: DB.IncludeIdentifier(StyleSpecialAbilitySettings),
         }),
+        extendedBookDescriptionPublication: DB.Required({
+            comment: "The publication that extends the description of books with additional information.",
+            type: PublicationIdentifier(),
+        }),
     }),
 });
 const SupernaturalBaseAdvantageSettings = DB.TypeAlias(import.meta.url, {

package/lib/types/_Identifier.d.ts

@@ -18,6 +18,7 @@ export declare const ArcaneBardTraditionIdentifier: () => R;
 export declare const ArcaneDancerTraditionIdentifier: () => R;
 export declare const ArcaneOrbEnchantmentIdentifier: () => R;
 export declare const ArmorIdentifier: () => R;
+export declare const ArmorAccessoryIdentifier: () => R;
 export declare const AspectIdentifier: () => R;
 export declare const AttireEnchantmentIdentifier: () => R;
 export declare const AttributeIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -23,6 +23,7 @@ import { Ammunition } from "./equipment/item/Ammunition.js";
 import { Animal } from "./equipment/item/Animal.js";
 import { AnimalCare } from "./equipment/item/AnimalCare.js";
 import { Armor } from "./equipment/item/Armor.js";
+import { ArmorAccessory } from "./equipment/item/ArmorAccessory.js";
 import { BandageOrRemedy } from "./equipment/item/BandageOrRemedy.js";
 import { Book } from "./equipment/item/Book.js";
 import { CeremonialItem } from "./equipment/item/CeremonialItem.js";
@@ -186,6 +187,7 @@ export const ArcaneBardTraditionIdentifier = () => R(ArcaneBardTradition);
 export const ArcaneDancerTraditionIdentifier = () => R(ArcaneDancerTradition);
 export const ArcaneOrbEnchantmentIdentifier = () => R(ArcaneOrbEnchantment);
 export const ArmorIdentifier = () => R(Armor);
+export const ArmorAccessoryIdentifier = () => R(ArmorAccessory);
 export const AspectIdentifier = () => R(Aspect);
 export const AttireEnchantmentIdentifier = () => R(AttireEnchantment);
 export const AttributeIdentifier = () => R(Attribute);

package/lib/types/_IdentifierGroup.d.ts

@@ -436,6 +436,7 @@ export declare const EquipmentIdentifier: DB.Enum<"EquipmentIdentifier", {
     Animal: DB.EnumCase<DB.ReferenceIdentifier>;
     AnimalCare: DB.EnumCase<DB.ReferenceIdentifier>;
     Armor: DB.EnumCase<DB.ReferenceIdentifier>;
+    ArmorAccessory: DB.EnumCase<DB.ReferenceIdentifier>;
     BandageOrRemedy: DB.EnumCase<DB.ReferenceIdentifier>;
     Book: DB.EnumCase<DB.ReferenceIdentifier>;
     CeremonialItem: DB.EnumCase<DB.ReferenceIdentifier>;

package/lib/types/_IdentifierGroup.js

@@ -1,6 +1,6 @@
 import { sortObjectKeys } from "@elyukai/utils/object";
 import * as DB from "tsondb/schema/dsl";
-import { AdvancedCombatSpecialAbilityIdentifier, AdvancedKarmaSpecialAbilityIdentifier, AdvancedMagicalSpecialAbilityIdentifier, AdvancedSkillSpecialAbilityIdentifier, AdvantageIdentifier, AmmunitionIdentifier, AncestorGlyphIdentifier, AnimalCareIdentifier, AnimalIdentifier, AnimalShapeIdentifier, AnimalShapeSizeIdentifier, AnimistPowerIdentifier, ArcaneBardTraditionIdentifier, ArcaneDancerTraditionIdentifier, ArcaneOrbEnchantmentIdentifier, ArmorIdentifier, AspectIdentifier, AttireEnchantmentIdentifier, AttributeIdentifier, BandageOrRemedyIdentifier, BannzeichenIdentifier, BeutelzauberIdentifier, BlessedTraditionIdentifier, BlessingIdentifier, BookIdentifier, BowlEnchantmentIdentifier, BrawlingSpecialAbilityIdentifier, CantripIdentifier, CauldronEnchantmentIdentifier, CeremonialItemIdentifier, CeremonialItemSpecialAbilityIdentifier, CeremonyIdentifier, ChronicleEnchantmentIdentifier, CloseCombatTechniqueIdentifier, ClothesIdentifier, ClothingPackageIdentifier, CombatSpecialAbilityIdentifier, CombatStyleSpecialAbilityIdentifier, CommandSpecialAbilityIdentifier, ContainerIdentifier, CultureIdentifier, CurseIdentifier, DaggerRitualIdentifier, DisadvantageIdentifier, DiseaseIdentifier, DominationRitualIdentifier, ElementIdentifier, ElixirIdentifier, ElvenMagicalSongIdentifier, EnhancementIdentifier, EquipmentOfBlessedOnesIdentifier, FamiliarSpecialAbilityIdentifier, FatePointSexSpecialAbilityIdentifier, FatePointSpecialAbilityIdentifier, FocusRuleIdentifier, FoolsHatEnchantmentIdentifier, GemOrPreciousStoneIdentifier, GeneralIdentifier, GeneralSpecialAbilityIdentifier, GeodeRitualIdentifier, GoblinRitualIdentifier, HaubenzauberIdentifier, HauerkettenzauberIdentifier, IlluminationLightSourceIdentifier, IlluminationRefillOrSupplyIdentifier, InstrumentEnchantmentIdentifier, JesterTrickIdentifier, JewelryIdentifier, KarmaSpecialAbilityIdentifier, KeulenzauberIdentifier, KrallenkettenzauberIdentifier, KristallkugelzauberIdentifier, LaboratoryIdentifier, LanguageIdentifier, LiebesspielzeugIdentifier, LiturgicalChantIdentifier, LiturgicalStyleSpecialAbilityIdentifier, LuxuryGoodIdentifier, LycantropicGiftIdentifier, MagicalArtifactIdentifier, MagicalDanceIdentifier, MagicalMelodyIdentifier, MagicalRuneIdentifier, MagicalSignIdentifier, MagicalSpecialAbilityIdentifier, MagicalTraditionIdentifier, MagicStyleSpecialAbilityIdentifier, MusicalInstrumentIdentifier, NewspaperIdentifier, OptionalRuleIdentifier, OrbEnchantmentIdentifier, OrienteeringAidIdentifier, PactGiftIdentifier, PatronIdentifier, PoisonIdentifier, PropertyIdentifier, ProtectiveWardingCircleSpecialAbilityIdentifier, RaceIdentifier, RangedCombatTechniqueIdentifier, RingEnchantmentIdentifier, RitualIdentifier, RopeOrChainIdentifier, SchweinetrommelzauberIdentifier, ScriptIdentifier, SermonIdentifier, SexPracticeIdentifier, SexSpecialAbilityIdentifier, SickleRitualIdentifier, SikaryanDrainSpecialAbilityIdentifier, SkillApplicationIdentifier, SkillGroupIdentifier, SkillIdentifier, SkillStyleSpecialAbilityIdentifier, SpellIdentifier, SpellSwordEnchantmentIdentifier, StaffEnchantmentIdentifier, StationeryIdentifier, TargetCategoryIdentifier, ThievesToolIdentifier, ToolOfTheTradeIdentifier, ToyEnchantmentIdentifier, TradeSecretIdentifier, TravelGearOrToolIdentifier, TrinkhornzauberIdentifier, VampiricGiftIdentifier, VehicleIdentifier, VisionIdentifier, WandEnchantmentIdentifier, WeaponAccessoryIdentifier, WeaponEnchantmentIdentifier, WeaponIdentifier, WorkingSupernaturalCreatureIdentifier, ZibiljaRitualIdentifier, } from "./_Identifier.js";
+import { AdvancedCombatSpecialAbilityIdentifier, AdvancedKarmaSpecialAbilityIdentifier, AdvancedMagicalSpecialAbilityIdentifier, AdvancedSkillSpecialAbilityIdentifier, AdvantageIdentifier, AmmunitionIdentifier, AncestorGlyphIdentifier, AnimalCareIdentifier, AnimalIdentifier, AnimalShapeIdentifier, AnimalShapeSizeIdentifier, AnimistPowerIdentifier, ArcaneBardTraditionIdentifier, ArcaneDancerTraditionIdentifier, ArcaneOrbEnchantmentIdentifier, ArmorAccessoryIdentifier, ArmorIdentifier, AspectIdentifier, AttireEnchantmentIdentifier, AttributeIdentifier, BandageOrRemedyIdentifier, BannzeichenIdentifier, BeutelzauberIdentifier, BlessedTraditionIdentifier, BlessingIdentifier, BookIdentifier, BowlEnchantmentIdentifier, BrawlingSpecialAbilityIdentifier, CantripIdentifier, CauldronEnchantmentIdentifier, CeremonialItemIdentifier, CeremonialItemSpecialAbilityIdentifier, CeremonyIdentifier, ChronicleEnchantmentIdentifier, CloseCombatTechniqueIdentifier, ClothesIdentifier, ClothingPackageIdentifier, CombatSpecialAbilityIdentifier, CombatStyleSpecialAbilityIdentifier, CommandSpecialAbilityIdentifier, ContainerIdentifier, CultureIdentifier, CurseIdentifier, DaggerRitualIdentifier, DisadvantageIdentifier, DiseaseIdentifier, DominationRitualIdentifier, ElementIdentifier, ElixirIdentifier, ElvenMagicalSongIdentifier, EnhancementIdentifier, EquipmentOfBlessedOnesIdentifier, FamiliarSpecialAbilityIdentifier, FatePointSexSpecialAbilityIdentifier, FatePointSpecialAbilityIdentifier, FocusRuleIdentifier, FoolsHatEnchantmentIdentifier, GemOrPreciousStoneIdentifier, GeneralIdentifier, GeneralSpecialAbilityIdentifier, GeodeRitualIdentifier, GoblinRitualIdentifier, HaubenzauberIdentifier, HauerkettenzauberIdentifier, IlluminationLightSourceIdentifier, IlluminationRefillOrSupplyIdentifier, InstrumentEnchantmentIdentifier, JesterTrickIdentifier, JewelryIdentifier, KarmaSpecialAbilityIdentifier, KeulenzauberIdentifier, KrallenkettenzauberIdentifier, KristallkugelzauberIdentifier, LaboratoryIdentifier, LanguageIdentifier, LiebesspielzeugIdentifier, LiturgicalChantIdentifier, LiturgicalStyleSpecialAbilityIdentifier, LuxuryGoodIdentifier, LycantropicGiftIdentifier, MagicalArtifactIdentifier, MagicalDanceIdentifier, MagicalMelodyIdentifier, MagicalRuneIdentifier, MagicalSignIdentifier, MagicalSpecialAbilityIdentifier, MagicalTraditionIdentifier, MagicStyleSpecialAbilityIdentifier, MusicalInstrumentIdentifier, NewspaperIdentifier, OptionalRuleIdentifier, OrbEnchantmentIdentifier, OrienteeringAidIdentifier, PactGiftIdentifier, PatronIdentifier, PoisonIdentifier, PropertyIdentifier, ProtectiveWardingCircleSpecialAbilityIdentifier, RaceIdentifier, RangedCombatTechniqueIdentifier, RingEnchantmentIdentifier, RitualIdentifier, RopeOrChainIdentifier, SchweinetrommelzauberIdentifier, ScriptIdentifier, SermonIdentifier, SexPracticeIdentifier, SexSpecialAbilityIdentifier, SickleRitualIdentifier, SikaryanDrainSpecialAbilityIdentifier, SkillApplicationIdentifier, SkillGroupIdentifier, SkillIdentifier, SkillStyleSpecialAbilityIdentifier, SpellIdentifier, SpellSwordEnchantmentIdentifier, StaffEnchantmentIdentifier, StationeryIdentifier, TargetCategoryIdentifier, ThievesToolIdentifier, ToolOfTheTradeIdentifier, ToyEnchantmentIdentifier, TradeSecretIdentifier, TravelGearOrToolIdentifier, TrinkhornzauberIdentifier, VampiricGiftIdentifier, VehicleIdentifier, VisionIdentifier, WandEnchantmentIdentifier, WeaponAccessoryIdentifier, WeaponEnchantmentIdentifier, WeaponIdentifier, WorkingSupernaturalCreatureIdentifier, ZibiljaRitualIdentifier, } from "./_Identifier.js";
 export const ActivatableIdentifier = DB.Enum(import.meta.url, {
     name: "ActivatableIdentifier",
     values: () => ({
@@ -310,6 +310,7 @@ export const EquipmentIdentifier = DB.Enum(import.meta.url, {
         Animal: DB.EnumCase({ type: AnimalIdentifier() }),
         AnimalCare: DB.EnumCase({ type: AnimalCareIdentifier() }),
         Armor: DB.EnumCase({ type: ArmorIdentifier() }),
+        ArmorAccessory: DB.EnumCase({ type: ArmorAccessoryIdentifier() }),
         BandageOrRemedy: DB.EnumCase({ type: BandageOrRemedyIdentifier() }),
         Book: DB.EnumCase({ type: BookIdentifier() }),
         CeremonialItem: DB.EnumCase({ type: CeremonialItemIdentifier() }),

package/lib/types/_Prerequisite.d.ts

@@ -423,3 +423,27 @@ export declare const EnhancementPrerequisites: DB.TypeAlias<"EnhancementPrerequi
         }>, true>;
     }>, [T: DB.Param<"T", DB.Type>]>>>;
 }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>;
+export declare const BookPrerequisites: DB.TypeAlias<"BookPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+    Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+    Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+        list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+        display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+            Hide: DB.EnumCase<null>;
+            ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                    Standalone: DB.EnumCase<null>;
+                    Connected: DB.EnumCase<null>;
+                }, []>>, false>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                    replacement: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, false>;
+    }>, [T: DB.Param<"T", DB.Type>]>>>;
+    Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+        list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+            text: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }>, [T: DB.Param<"T", DB.Type>]>>>;
+}, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>;

package/lib/types/_Prerequisite.js

@@ -4,7 +4,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { DisplayOption } from "./prerequisites/DisplayOption.js";
-import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, RulePrerequisiteGroup, SpellworkPrerequisiteGroup, TribePrerequisiteGroup, } from "./prerequisites/PrerequisiteGroups.js";
+import { AdvantageDisadvantagePrerequisiteGroup, AnimistPowerPrerequisiteGroup, ArcaneTraditionPrerequisiteGroup, BookPrerequisiteGroup, DerivedCharacteristicPrerequisiteGroup, EnhancementPrerequisiteGroup, GeneralPrerequisiteGroup, GeodeRitualPrerequisiteGroup, InfluencePrerequisiteGroup, LanguagePrerequisiteGroup, LiturgyPrerequisiteGroup, PersonalityTraitPrerequisiteGroup, ProfessionPrerequisiteGroup, PublicationPrerequisiteGroup, RulePrerequisiteGroup, SpellworkPrerequisiteGroup, TribePrerequisiteGroup, } from "./prerequisites/PrerequisiteGroups.js";
 const PrerequisiteGroup = DB.GenTypeAlias(import.meta.url, {
     name: "PrerequisiteGroup",
     comment: "A prerequisite group has no influence on validation logic. It serves as a single unit for displaying purposes, where the source uses a prerequisites item that cannot be represented as a single prerequisite.",
@@ -188,3 +188,7 @@ export const EnhancementPrerequisites = DB.TypeAlias(import.meta.url, {
         DB.IncludeIdentifier(EnhancementPrerequisiteGroup),
     ]),
 });
+export const BookPrerequisites = DB.TypeAlias(import.meta.url, {
+    name: "BookPrerequisites",
+    type: () => DB.GenIncludeIdentifier(PlainPrerequisites, [DB.IncludeIdentifier(BookPrerequisiteGroup)]),
+});

package/lib/types/equipment/EquipmentPackage.d.ts

@@ -6,6 +6,7 @@ export declare const EquipmentPackage: DB.Entity<"EquipmentPackage", {
             Animal: DB.EnumCase<DB.ReferenceIdentifier>;
             AnimalCare: DB.EnumCase<DB.ReferenceIdentifier>;
             Armor: DB.EnumCase<DB.ReferenceIdentifier>;
+            ArmorAccessory: DB.EnumCase<DB.ReferenceIdentifier>;
             BandageOrRemedy: DB.EnumCase<DB.ReferenceIdentifier>;
             Book: DB.EnumCase<DB.ReferenceIdentifier>;
             CeremonialItem: DB.EnumCase<DB.ReferenceIdentifier>;

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

@@ -0,0 +1,281 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ArmorAccessory: DB.Entity<"ArmorAccessory", {
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+        Free: DB.EnumCase<null>;
+        Various: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"InvaluableCost", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"InvaluableCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>;
+        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, []>>, 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>;
+            prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                        Hide: DB.EnumCase<null>;
+                        ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                            sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                Standalone: DB.EnumCase<null>;
+                                Connected: DB.EnumCase<null>;
+                            }, []>>, false>;
+                            translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                replacement: DB.MemberDecl<DB.String, true>;
+                            }>, true>;
+                        }>, []>>>;
+                    }, []>>, false>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+                Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                    list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                        text: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, [T: DB.Param<"T", DB.Type>]>>>;
+            }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, 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>;
+            }>, []>>>, []>>, false>;
+        }>, []>>>;
+    }, []>>, 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>;
+    combat_use: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatUse", {
+        Weapon: DB.EnumCase<DB.IncludeIdentifier<[], 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>;
+        }>, []>>>;
+        Armor: DB.EnumCase<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>;
+            armorType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorType", {
+                Standard: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardArmorType", DB.Object<{
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                StandardVariant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"StandardVariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                    sturdinessRating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                Variant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"VariantArmorType", DB.Object<{
+                    variantOf: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                }>, []>>>;
+            }, []>>, 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>;
+    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/ArmorAccessory.js

@@ -0,0 +1,48 @@
+import * as DB from "tsondb/schema/dsl";
+import { src } from "../../source/_PublicationRef.js";
+import { CombatUse, Complexity, Cost, DefaultItemTranslations, StructurePoints, Weight, } from "./_Item.js";
+import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
+export const ArmorAccessory = DB.Entity(import.meta.url, {
+    name: "ArmorAccessory",
+    namePlural: "ArmorAccessories",
+    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),
+        }),
+        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),
+        }),
+        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("ArmorAccessory"),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+    customConstraints: ({ instanceContent, ...rest }) => {
+        if (instanceContent.combat_use && instanceContent.combat_use.kind === "Weapon") {
+            return checkWeaponCombatTechniqueIntegrity({
+                ...rest,
+                instanceContent: instanceContent.combat_use.Weapon,
+            });
+        }
+        return [];
+    },
+});

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

@@ -13,6 +13,30 @@ export declare const Book: DB.Entity<"Book", {
         Magical: DB.EnumCase<null>;
         Religious: DB.EnumCase<null>;
     }, []>>>, true>;
+    languageAndScript: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BookPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookCost", {
         Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"BookCostVariant", {
             Definite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefiniteBookCostVariant", DB.Object<{
@@ -166,6 +190,55 @@ export declare const Book: DB.Entity<"Book", {
         Average: DB.EnumCase<null>;
         Demanding: DB.EnumCase<DB.Integer>;
     }, []>>, false>;
+    rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookRules", {
+        Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainBookRules", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PlainBookRulesTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+                reconstruction: DB.MemberDecl<DB.String, false>;
+                references: DB.MemberDecl<DB.String, false>;
+                textAfter: DB.MemberDecl<DB.String, false>;
+            }>, true>;
+        }>, []>>>;
+        Entertainment: DB.EnumCase<null>;
+        ByEdition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesByEdition", DB.Object<{
+            editions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesOfEdition", DB.Object<{
+                languageAndScript: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BookPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+                    Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+                    Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+                        list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                        display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                            Hide: DB.EnumCase<null>;
+                            ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                                sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                                    Standalone: DB.EnumCase<null>;
+                                    Connected: DB.EnumCase<null>;
+                                }, []>>, false>;
+                                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                                    replacement: DB.MemberDecl<DB.String, true>;
+                                }>, true>;
+                            }>, []>>>;
+                        }, []>>, false>;
+                    }>, [T: DB.Param<"T", DB.Type>]>>>;
+                    Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+                        list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                            text: DB.MemberDecl<DB.String, true>;
+                        }>, true>;
+                    }>, [T: DB.Param<"T", DB.Type>]>>>;
+                }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"BookRulesOfEditionTranslation", {
+                    label: DB.MemberDecl<DB.String, true>;
+                    languageAndScript: DB.MemberDecl<DB.String, false>;
+                    text: DB.MemberDecl<DB.String, true>;
+                    reconstruction: DB.MemberDecl<DB.String, false>;
+                    references: DB.MemberDecl<DB.String, false>;
+                }>, true>;
+            }>, []>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"BookRulesByEditionTranslation", {
+                textAfter: DB.MemberDecl<DB.String, false>;
+            }>, false>;
+        }>, []>>>;
+    }, []>>, 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, {
@@ -210,27 +283,8 @@ export declare const Book: DB.Entity<"Book", {
     translations: DB.MemberDecl<DB.NestedEntityMap<"BookTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         secondary_name: DB.MemberDecl<DB.String, false>;
-        language: DB.MemberDecl<DB.String, false>;
-        script: DB.MemberDecl<DB.String, false>;
+        languageAndScript: DB.MemberDecl<DB.String, false>;
         note: DB.MemberDecl<DB.String, false>;
-        rules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BookRules", {
-            Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainBookRules", DB.Object<{
-                text: DB.MemberDecl<DB.String, true>;
-                reconstruction: DB.MemberDecl<DB.String, false>;
-                references: DB.MemberDecl<DB.String, false>;
-                textAfter: DB.MemberDecl<DB.String, false>;
-            }>, []>>>;
-            Entertainment: DB.EnumCase<null>;
-            ByEdition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesByEdition", DB.Object<{
-                editions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"BookRulesOfEdition", DB.Object<{
-                    label: DB.MemberDecl<DB.String, true>;
-                    text: DB.MemberDecl<DB.String, true>;
-                    reconstruction: DB.MemberDecl<DB.String, false>;
-                    references: DB.MemberDecl<DB.String, false>;
-                }>, []>>>, true>;
-                textAfter: DB.MemberDecl<DB.String, false>;
-            }>, []>>>;
-        }, []>>, false>;
         legality: DB.MemberDecl<DB.String, false>;
         availability: DB.MemberDecl<DB.String, false>;
         special: DB.MemberDecl<DB.String, false>;

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

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { SkillIdentifier } from "../../_Identifier.js";
+import { BookPrerequisites } from "../../_Prerequisite.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -12,6 +13,10 @@ export const Book = DB.Entity(import.meta.url, {
             comment: "The type of book.",
             type: DB.Array(DB.IncludeIdentifier(BookType), { minItems: 1, uniqueItems: true }),
         }),
+        languageAndScript: DB.Optional({
+            comment: "The language(s) and script(s) the book is written in.",
+            type: DB.IncludeIdentifier(BookPrerequisites),
+        }),
         cost: DB.Required({
             comment: "The cost in silverthalers.",
             type: DB.IncludeIdentifier(BookCost),
@@ -32,6 +37,10 @@ export const Book = DB.Entity(import.meta.url, {
             comment: "The quality of the book’s content.",
             type: DB.IncludeIdentifier(BookContentQuality),
         }),
+        rules: DB.Required({
+            comment: "Skills and abilities you can learn by reading the book, as well as any other rules and effects concerning the book.",
+            type: DB.IncludeIdentifier(BookRules),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Book", DB.Object({
             name: DB.Required({
@@ -42,22 +51,14 @@ export const Book = DB.Entity(import.meta.url, {
                 comment: "An auxiliary name or label of the item, if available.",
                 type: DB.String({ minLength: 1 }),
             }),
-            language: DB.Optional({
-                comment: "The language the book is written in, if specified.",
-                type: DB.String({ minLength: 1, markdown: "inline" }),
-            }),
-            script: DB.Optional({
-                comment: "The script that was used for the book, if specified.",
+            languageAndScript: DB.Optional({
+                comment: "The language(s) and script(s) the book is written in.",
                 type: DB.String({ minLength: 1, markdown: "inline" }),
             }),
             note: DB.Optional({
                 comment: "Note text.",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
-            rules: DB.Optional({
-                comment: "Special rules text.",
-                type: DB.IncludeIdentifier(BookRules),
-            }),
             legality: DB.Optional({
                 comment: "The legality of the item, if specified.",
                 type: DB.String({ minLength: 1, markdown: "inline" }),
@@ -217,22 +218,24 @@ const PlainBookRules = DB.TypeAlias(import.meta.url, {
     name: "PlainBookRules",
     comment: "The book’s rules without any special effects or conditions.",
     type: () => DB.Object({
-        text: DB.Required({
-            comment: "The (main) rules text.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
-        reconstruction: DB.Optional({
-            comment: "Rules for reconstructing certain skills or abilities from the book.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
-        references: DB.Optional({
-            comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
-        textAfter: DB.Optional({
-            comment: "Additional rules text that comes after all other rules.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
+        translations: NestedTranslationMap(DB.Required, "PlainBookRules", DB.Object({
+            text: DB.Required({
+                comment: "The (main) rules text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            reconstruction: DB.Optional({
+                comment: "Rules for reconstructing certain skills or abilities from the book.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            references: DB.Optional({
+                comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            textAfter: DB.Optional({
+                comment: "Additional rules text that comes after all other rules.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
     }),
 });
 const BookRulesByEdition = DB.TypeAlias(import.meta.url, {
@@ -242,30 +245,42 @@ const BookRulesByEdition = DB.TypeAlias(import.meta.url, {
         editions: DB.Required({
             type: DB.Array(DB.IncludeIdentifier(BookRulesOfEdition), { minItems: 1 }),
         }),
-        textAfter: DB.Optional({
-            comment: "Additional rules text that comes after all other rules.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
+        translations: NestedTranslationMap(DB.Optional, "BookRulesByEdition", DB.Object({
+            textAfter: DB.Optional({
+                comment: "Additional rules text that comes after all other rules.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
     }),
 });
 const BookRulesOfEdition = DB.TypeAlias(import.meta.url, {
     name: "BookRulesOfEdition",
     type: () => DB.Object({
-        label: DB.Required({
-            comment: "The edition(s) the rules apply to.",
-            type: DB.String({ minLength: 1 }),
-        }),
-        text: DB.Required({
-            comment: "The rules text.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
-        reconstruction: DB.Optional({
-            comment: "Rules for reconstructing certain skills or abilities from the book.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
-        }),
-        references: DB.Optional({
-            comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
-            type: DB.String({ minLength: 1, markdown: "block" }),
+        languageAndScript: DB.Optional({
+            comment: "The language(s) and script(s) the book is written in.",
+            type: DB.IncludeIdentifier(BookPrerequisites),
         }),
+        translations: NestedTranslationMap(DB.Required, "BookRulesOfEdition", DB.Object({
+            label: DB.Required({
+                comment: "The edition(s) the rules apply to.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            languageAndScript: DB.Optional({
+                comment: "The language(s) and script(s) the book is written in.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+            text: DB.Required({
+                comment: "The rules text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            reconstruction: DB.Optional({
+                comment: "Rules for reconstructing certain skills or abilities from the book.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            references: DB.Optional({
+                comment: "References to skills and abilities that, while mentioned in the book, cannot be learned from this book alone.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
     }),
 });

package/lib/types/index.d.ts

@@ -21,6 +21,7 @@ export { Ammunition } from "./equipment/item/Ammunition.js";
 export { Animal } from "./equipment/item/Animal.js";
 export { AnimalCare } from "./equipment/item/AnimalCare.js";
 export { Armor } from "./equipment/item/Armor.js";
+export { ArmorAccessory } from "./equipment/item/ArmorAccessory.js";
 export { BandageOrRemedy } from "./equipment/item/BandageOrRemedy.js";
 export { Book } from "./equipment/item/Book.js";
 export { CeremonialItem } from "./equipment/item/CeremonialItem.js";

package/lib/types/index.js

@@ -21,6 +21,7 @@ export { Ammunition } from "./equipment/item/Ammunition.js";
 export { Animal } from "./equipment/item/Animal.js";
 export { AnimalCare } from "./equipment/item/AnimalCare.js";
 export { Armor } from "./equipment/item/Armor.js";
+export { ArmorAccessory } from "./equipment/item/ArmorAccessory.js";
 export { BandageOrRemedy } from "./equipment/item/BandageOrRemedy.js";
 export { Book } from "./equipment/item/Book.js";
 export { CeremonialItem } from "./equipment/item/CeremonialItem.js";

package/lib/types/prerequisites/PrerequisiteGroups.d.ts

@@ -2211,6 +2211,15 @@ export declare const EnhancementPrerequisiteGroup: DB.Enum<"EnhancementPrerequis
         }, []>>, false>;
     }>, []>>>;
 }, []>;
+export declare const BookPrerequisiteGroup: DB.Enum<"BookPrerequisiteGroup", {
+    Language: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LanguagePrerequisite", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        level: DB.MemberDecl<DB.Integer, true>;
+    }>, []>>>;
+    Script: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ScriptPrerequisite", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    }>, []>>>;
+}, []>;
 export declare const PreconditionGroup: DB.Enum<"PreconditionGroup", {
     Publication: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationPrerequisite", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;

package/lib/types/prerequisites/PrerequisiteGroups.js

@@ -7,6 +7,7 @@ import { CulturePrerequisite } from "./single/CulturePrerequisite.js";
 import { EnergyPrerequisite } from "./single/EnergyPrerequisite.js";
 import { EnhancementPrerequisite } from "./single/EnhancementPrerequisite.js";
 import { InfluencePrerequisite } from "./single/InfluencePrerequisite.js";
+import { LanguagePrerequisite } from "./single/LanguagePrerequisite.js";
 import { PactPrerequisite } from "./single/PactPrerequisite.js";
 import { PersonalityTraitPrerequisite } from "./single/PersonalityTraitPrerequisite.js";
 import { PrimaryAttributePrerequisite } from "./single/PrimaryAttributePrerequisite.js";
@@ -17,6 +18,7 @@ import { RatedMinimumNumberPrerequisite } from "./single/RatedMinimumNumberPrere
 import { RatedPrerequisite } from "./single/RatedPrerequisite.js";
 import { RatedSumPrerequisite } from "./single/RatedSumPrerequisite.js";
 import { RulePrerequisite } from "./single/RulePrerequisite.js";
+import { ScriptPrerequisite } from "./single/ScriptPrerequisite.js";
 import { SexPrerequisite } from "./single/SexPrerequisite.js";
 import { SexualCharacteristicPrerequisite } from "./single/SexualCharacteristicPrerequisite.js";
 import { SocialStatusPrerequisite } from "./single/SocialStatusPrerequisite.js";
@@ -176,6 +178,13 @@ export const EnhancementPrerequisiteGroup = DB.Enum(import.meta.url, {
         Rated: DB.EnumCase({ type: DB.IncludeIdentifier(RatedPrerequisite) }),
     }),
 });
+export const BookPrerequisiteGroup = DB.Enum(import.meta.url, {
+    name: "BookPrerequisiteGroup",
+    values: () => ({
+        Language: DB.EnumCase({ type: DB.IncludeIdentifier(LanguagePrerequisite) }),
+        Script: DB.EnumCase({ type: DB.IncludeIdentifier(ScriptPrerequisite) }),
+    }),
+});
 export const PreconditionGroup = DB.Enum(import.meta.url, {
     name: "PreconditionGroup",
     values: () => ({

package/lib/types/prerequisites/single/LanguagePrerequisite.d.ts

@@ -0,0 +1,5 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const LanguagePrerequisite: DB.TypeAlias<"LanguagePrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    level: DB.MemberDecl<DB.Integer, true>;
+}>, []>;

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

@@ -0,0 +1,15 @@
+import * as DB from "tsondb/schema/dsl";
+import { LanguageIdentifier } from "../../_Identifier.js";
+export const LanguagePrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "LanguagePrerequisite",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The language’s identifier.",
+            type: LanguageIdentifier(),
+        }),
+        level: DB.Required({
+            comment: "The required minimum level of the language.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});

package/lib/types/prerequisites/single/ScriptPrerequisite.d.ts

@@ -0,0 +1,4 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ScriptPrerequisite: DB.TypeAlias<"ScriptPrerequisite", DB.Object<{
+    id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+}>, []>;

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

@@ -0,0 +1,11 @@
+import * as DB from "tsondb/schema/dsl";
+import { ScriptIdentifier } from "../../_Identifier.js";
+export const ScriptPrerequisite = DB.TypeAlias(import.meta.url, {
+    name: "ScriptPrerequisite",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The script’s identifier.",
+            type: ScriptIdentifier(),
+        }),
+    }),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.94.0",
+  "version": "0.95.0",
   "description": "Definitions and utilities for the flat-file database of Optolith, a character creation tool for the Pen and Paper RPG “The Dark Eye 5”, and its external integrations into other software.",
   "keywords": [
     "tde",