@optolith/database-schema 0.107.1 → 0.109.0

package/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 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.109.0](https://github.com/Optolith/database-schema/compare/v0.108.1...v0.109.0) (2026-10-17)
+
+### ⚠ BREAKING CHANGES
+
+* item component references special ammunition only
+
+### Features
+
+* special ammunition entity ([0b149a9](https://github.com/Optolith/database-schema/commit/0b149a9073f02f425cb56c52c0b4e60b819b3024))
+
+### Bug Fixes
+
+* derived trade secrets for special ammunition ([83b8d14](https://github.com/Optolith/database-schema/commit/83b8d1410886d87b6f790fa4bb96c100f5c04ee8))
+* item component references special ammunition only ([a200ecd](https://github.com/Optolith/database-schema/commit/a200ecd5bd31e4d4bdc4cf1f13f11d73b22d88ce))
+
+## [0.108.1](https://github.com/Optolith/database-schema/compare/v0.108.0...v0.108.1) (2026-10-17)
+
+### Bug Fixes
+
+* property specialization translation name ([4049f08](https://github.com/Optolith/database-schema/commit/4049f0841e53da33e83f92d541d54093f1514914))
+
+## [0.108.0](https://github.com/Optolith/database-schema/compare/v0.107.1...v0.108.0) (2026-10-17)
+
+### ⚠ BREAKING CHANGES
+
+* gems with associated properties and optional color
+
+### Features
+
+* gems with associated properties and optional color ([48a4a5e](https://github.com/Optolith/database-schema/commit/48a4a5eea0cc07336bb49aef02f5e9118664a34e))
+* property specializations ([83b38df](https://github.com/Optolith/database-schema/commit/83b38df2f64a61c63062dca23d127080605ae9a0))
+
+### Bug Fixes
+
+* **cache:** talisman trade secret prerequisites include associated tradition ([9935e24](https://github.com/Optolith/database-schema/commit/9935e24fbf4788a84b27a5f115f74d0d6a6990e0))
+
 ## [0.107.1](https://github.com/Optolith/database-schema/compare/v0.107.0...v0.107.1) (2026-10-16)
 
 ### Features

package/gen/types.d.ts

@@ -145,6 +145,7 @@ export type EntityMap = {
   ProfessionVariant: ProfessionVariant
   ProfessionVersion: ProfessionVersion
   Property: Property
+  PropertySpecialization: PropertySpecialization
   ProtectiveWardingCircleSpecialAbility: ProtectiveWardingCircleSpecialAbility
   Publication: Publication
   Race: Race
@@ -170,6 +171,7 @@ export type EntityMap = {
   SkillStyleSpecialAbility: SkillStyleSpecialAbility
   SkillUse: SkillUse
   SocialStatus: SocialStatus
+  SpecialAmmunition: SpecialAmmunition
   Spell: Spell
   SpellSwordEnchantment: SpellSwordEnchantment
   StaffEnchantment: StaffEnchantment
@@ -217,6 +219,7 @@ export type ChildEntityMap = {
   ProfessionPackage: [ProfessionPackage, "profession_version", ProfessionPackage["profession_version"]]
   ProfessionVariant: [ProfessionVariant, "profession_package", ProfessionVariant["profession_package"]]
   ProfessionVersion: [ProfessionVersion, "profession", ProfessionVersion["profession"]]
+  PropertySpecialization: [PropertySpecialization, "parent", PropertySpecialization["parent"]]
   RaceVariant: [RaceVariant, "race", RaceVariant["race"]]
   SkillApplication: [SkillApplication, "parent", SkillApplication["parent"]]
   SkillUse: [SkillUse, "parent", SkillUse["parent"]]
@@ -247,6 +250,7 @@ export type EnumMap = {
   AnimistPowerImprovementCost: AnimistPowerImprovementCost
   AnimistPowerPerformanceParameters: AnimistPowerPerformanceParameters
   AnimistPowerPrerequisiteGroup: AnimistPowerPrerequisiteGroup
+  AnyPropertySpecializationIdentifier: AnyPropertySpecializationIdentifier
   ApplicableAmmunitionCategory: ApplicableAmmunitionCategory
   ApplicableArmorCategory: ApplicableArmorCategory
   ApplicableCombatTechniques: ApplicableCombatTechniques
@@ -321,6 +325,7 @@ export type EnumMap = {
   DerivedCharacteristicPrimaryAttributeValue: DerivedCharacteristicPrimaryAttributeValue
   DerivedCharacteristicSkillCheckPenalty: DerivedCharacteristicSkillCheckPenalty
   DerivedCharacteristicType: DerivedCharacteristicType
+  DerivedPropertySpecializations: DerivedPropertySpecializations
   DisplayOption: DisplayOption
   DominationRitualDuration: DominationRitualDuration
   DurationForOneTime: DurationForOneTime
@@ -724,6 +729,7 @@ export type TypeAliasMap = {
   FixedRange: FixedRange
   FixedSustainedAnimistPowerCost: FixedSustainedAnimistPowerCost
   FixedVolume: FixedVolume
+  GemOrPreviousStoneProperty: GemOrPreviousStoneProperty
   GeneralAnimalCare: GeneralAnimalCare
   GeneralPrerequisites: GeneralPrerequisites
   GenericSkillsSelectOptionCategoryCategory: GenericSkillsSelectOptionCategoryCategory<unknown>
@@ -5477,6 +5483,11 @@ export interface Property {
    */
   check?: SkillCheck
 
+  /**
+   * The property’s derived specializations.
+   */
+  derivedSpecializations?: DerivedPropertySpecializations
+
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
    */
@@ -5497,6 +5508,37 @@ export interface PropertyTranslation {
   name: string
 }
 
+export interface PropertySpecialization {
+  /**
+   * The associated property.
+   */
+  parent: Property_ID
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations: {
+    [localeId: string]: PropertySpecializationTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type PropertySpecialization_ID = string
+
+export interface PropertySpecializationTranslation {
+  /**
+   * The property’s name.
+   */
+  name: string
+}
+
+export type DerivedPropertySpecializations =
+  | {
+    kind: "Elements"
+  }
+
 export interface Aspect {
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
@@ -8683,6 +8725,11 @@ export interface Spell {
    */
   property: Property_ID
 
+  /**
+   * The associated property specialization.
+   */
+  propertySpecialization?: AnyPropertySpecializationIdentifier
+
   /**
    * The tradition(s) the spell is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.
    */
@@ -8745,6 +8792,16 @@ export interface SpellTranslation {
   errata?: Errata
 }
 
+export type AnyPropertySpecializationIdentifier =
+  | {
+    kind: "General"
+    General: PropertySpecialization_ID
+  }
+  | {
+    kind: "Element"
+    Element: Element_ID
+  }
+
 /**
  * The tradition(s) the spell or ritual is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.
  */
@@ -9190,6 +9247,11 @@ export interface Ritual {
    */
   property: Property_ID
 
+  /**
+   * The associated property specialization.
+   */
+  propertySpecialization?: AnyPropertySpecializationIdentifier
+
   /**
    * The tradition(s) the ritual is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.
    */
@@ -26130,6 +26192,11 @@ export interface GemOrPreciousStone {
    */
   weight?: Weight
 
+  /**
+   * The associated property.
+   */
+  property?: GemOrPreviousStoneProperty
+
   /**
    * The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.
    */
@@ -26167,7 +26234,7 @@ export interface GemOrPreciousStoneTranslation {
   /**
    * The color of the gem or stone.
    */
-  color: string
+  color?: string
 
   /**
    * Note text.
@@ -26182,6 +26249,18 @@ export interface GemOrPreciousStoneTranslation {
   errata?: Errata
 }
 
+export interface GemOrPreviousStoneProperty {
+  /**
+   * The associated property.
+   */
+  base: Property_ID
+
+  /**
+   * The associated property specialization.
+   */
+  specialization?: AnyPropertySpecializationIdentifier
+}
+
 export interface IlluminationLightSource {
   /**
    * The cost in silverthalers.
@@ -26650,7 +26729,7 @@ export interface ApplicableAmmunition {
   /**
    * Specific ammunition this component can be applied to.
    */
-  ammunition?: Ammunition_ID[]
+  ammunition?: SpecialAmmunition_ID[]
 
   /**
    * Whether the list of ammunition is inverted, i.e. whether the component can be applied to all ammunition – or those of the specified category – except for the listed ammunition.
@@ -26663,6 +26742,69 @@ export interface ApplicableAmmunition {
   category?: ApplicableAmmunitionCategory
 }
 
+export interface SpecialAmmunition {
+  /**
+   * The base ammunition type that is affected by this specialization.
+   */
+  applicableTo: Ammunition_ID[]
+
+  /**
+   * The cost modifier for the base price of affected ammunition.
+   */
+  costModifier: number
+
+  /**
+   * The complexity of crafting the item.
+   */
+  complexity?: Complexity
+
+  /**
+   * The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.
+   */
+  prerequisites?: EquipmentPrerequisites
+
+  /**
+   * 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]: SpecialAmmunitionTranslation
+  }
+}
+
+/**
+ * The entity’s identifier. A UUID or a locale code if it is registered as the locale entity.
+ */
+export type SpecialAmmunition_ID = string
+
+export interface SpecialAmmunitionTranslation {
+  /**
+   * 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 type ApplicableAmmunitionCategory =
   | {
     kind: "ArrowOrBolt"

package/lib/cache/tradeSecrets.d.ts

@@ -5,7 +5,7 @@ type EquipmentEntitiesWithComplexities = {
     [K in EquipmentIdentifier["kind"]]: EntityMap[K] extends {
         complexity?: Complexity | ArmorComplexity;
     } ? K : never;
-}[EquipmentIdentifier["kind"]];
+}[EquipmentIdentifier["kind"]] | "SpecialAmmunition";
 type HerbaryEntitiesWithTradeSecrets = "Disease" | "Elixir" | "HerbalAid" | "Poison";
 export type DerivedTradeSecretsCache = {
     equipment: {

package/lib/cache/tradeSecrets.js

@@ -1,3 +1,5 @@
+import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { nullableToArray } from "@elyukai/utils/nullable";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { Case } from "tsondb/schema/gen";
 const emptyDerivedEquipmentTradeSecretsCache = {
@@ -20,6 +22,7 @@ const emptyDerivedEquipmentTradeSecretsCache = {
     MusicalInstrument: {},
     OrienteeringAid: {},
     RopeOrChain: {},
+    SpecialAmmunition: {},
     Stationery: {},
     ThievesTool: {},
     ToolOfTheTrade: {},
@@ -146,6 +149,19 @@ export const buildDerivedTradeSecretsCache = (database, settings) => {
                         id: Case("FocusRule", settings.derivedTradeSecrets.requiredFocusRuleForTalismans),
                         active: true,
                     })),
+                    ...nullableToArray(container.content.tradition === undefined || !isNotEmpty(container.content.tradition)
+                        ? undefined
+                        : container.content.tradition.length === 1
+                            ? Case("Single", Case("Activatable", {
+                                id: Case("BlessedTradition", container.content.tradition[0]),
+                                active: true,
+                            }))
+                            : Case("Disjunction", {
+                                list: container.content.tradition.map(tradition => Case("Activatable", {
+                                    id: Case("BlessedTradition", tradition),
+                                    active: true,
+                                })),
+                            })),
                 ],
                 src: container.content.src,
                 translations: Object.fromEntries(Object.entries(container.content.translations).map(([lang, translation]) => [

package/lib/main.js

@@ -153,6 +153,7 @@ export const schema = new Schema((await import("../package.json", { with: { type
     Types.SkillModificationLevel,
     Types.SkillStyleSpecialAbility,
     Types.SocialStatus,
+    Types.SpecialAmmunition,
     Types.Spell,
     Types.SpellSwordEnchantment,
     Types.StaffEnchantment,

package/lib/types/Property.d.ts

@@ -1,7 +1,22 @@
 import * as DB from "tsondb/schema/dsl";
 export declare const Property: DB.Entity<"Property", {
     check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, false>;
+    specializations: DB.MemberDecl<DB.ChildEntities<DB.Entity<"PropertySpecialization", {
+        parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PropertySpecializationTranslation", {
+            name: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }, "parent">>, true>;
+    derivedSpecializations: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DerivedPropertySpecializations", {
+        Elements: DB.EnumCase<null>;
+    }, []>>, false>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"PropertyTranslation", {
         name: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }, undefined>;
+export declare const PropertySpecialization: DB.Entity<"PropertySpecialization", {
+    parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PropertySpecializationTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, "parent">;

package/lib/types/Property.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { PropertyIdentifier } from "./_Identifier.js";
 import { SkillCheck } from "./_SkillCheck.js";
 import { NestedTranslationMap } from "./Locale.js";
 export const Property = DB.Entity(import.meta.url, {
@@ -9,6 +10,14 @@ export const Property = DB.Entity(import.meta.url, {
             comment: "The property check’s attributes. Only the properties from the Core Rules have defined property checks.",
             type: DB.IncludeIdentifier(SkillCheck),
         }),
+        specializations: DB.Required({
+            comment: "The property’s specializations.",
+            type: DB.ChildEntities(PropertySpecialization),
+        }),
+        derivedSpecializations: DB.Optional({
+            comment: "The property’s derived specializations.",
+            type: DB.IncludeIdentifier(DerivedPropertySpecializations),
+        }),
         translations: NestedTranslationMap(DB.Required, "Property", DB.Object({
             name: DB.Required({
                 comment: "The property’s name.",
@@ -24,3 +33,33 @@ export const Property = DB.Entity(import.meta.url, {
         },
     ],
 });
+const DerivedPropertySpecializations = DB.Enum(import.meta.url, {
+    name: "DerivedPropertySpecializations",
+    values: () => ({
+        Elements: DB.EnumCase({ type: null }),
+    }),
+});
+export const PropertySpecialization = DB.Entity(import.meta.url, {
+    name: "PropertySpecialization",
+    namePlural: "PropertySpecializations",
+    type: () => DB.Object({
+        parent: DB.Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Required, "PropertySpecialization", DB.Object({
+            name: DB.Required({
+                comment: "The property’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/Ritual.d.ts

@@ -560,6 +560,10 @@ export declare const Ritual: DB.Entity<"Ritual", {
         }>, false>;
     }>, []>>>, []>>, true>;
     property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    propertySpecialization: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnyPropertySpecializationIdentifier", {
+        General: DB.EnumCase<DB.ReferenceIdentifier>;
+        Element: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, false>;
     traditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkTraditions", {
         General: DB.EnumCase<null>;
         Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;

package/lib/types/Ritual.js

@@ -4,6 +4,7 @@ import { ActivatableSkillEffect } from "./_ActivatableSkillEffect.js";
 import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
 import { Enhancement } from "./_Enhancements.js";
 import { PropertyIdentifier } from "./_Identifier.js";
+import { AnyPropertySpecializationIdentifier } from "./_IdentifierGroup.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
 import { SpellworkPrerequisites } from "./_Prerequisite.js";
 import { SkillCheck, SkillCheckPenalty } from "./_SkillCheck.js";
@@ -35,6 +36,10 @@ export const Ritual = DB.Entity(import.meta.url, {
             comment: "The associated property.",
             type: PropertyIdentifier(),
         }),
+        propertySpecialization: DB.Optional({
+            comment: "The associated property specialization.",
+            type: DB.IncludeIdentifier(AnyPropertySpecializationIdentifier),
+        }),
         traditions: DB.Required({
             comment: "The tradition(s) the ritual is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.",
             type: DB.IncludeIdentifier(SpellworkTraditions),

package/lib/types/Spell.d.ts

@@ -560,6 +560,10 @@ export declare const Spell: DB.Entity<"Spell", {
         }>, false>;
     }>, []>>>, []>>, true>;
     property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    propertySpecialization: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnyPropertySpecializationIdentifier", {
+        General: DB.EnumCase<DB.ReferenceIdentifier>;
+        Element: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, false>;
     traditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkTraditions", {
         General: DB.EnumCase<null>;
         Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;

package/lib/types/Spell.js

@@ -4,6 +4,7 @@ import { ActivatableSkillEffect } from "./_ActivatableSkillEffect.js";
 import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
 import { Enhancement } from "./_Enhancements.js";
 import { PropertyIdentifier } from "./_Identifier.js";
+import { AnyPropertySpecializationIdentifier } from "./_IdentifierGroup.js";
 import { ImprovementCost } from "./_ImprovementCost.js";
 import { SpellworkPrerequisites } from "./_Prerequisite.js";
 import { SkillCheck, SkillCheckPenalty } from "./_SkillCheck.js";
@@ -35,6 +36,10 @@ export const Spell = DB.Entity(import.meta.url, {
             comment: "The associated property.",
             type: PropertyIdentifier(),
         }),
+        propertySpecialization: DB.Optional({
+            comment: "The associated property specialization.",
+            type: DB.IncludeIdentifier(AnyPropertySpecializationIdentifier),
+        }),
         traditions: DB.Required({
             comment: "The tradition(s) the spell is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.",
             type: DB.IncludeIdentifier(SpellworkTraditions),

package/lib/types/_Identifier.d.ts

@@ -135,6 +135,7 @@ export declare const ProfessionPackageIdentifier: () => R;
 export declare const ProfessionVersionIdentifier: () => R;
 export declare const ProfessionVariantIdentifier: () => R;
 export declare const PropertyIdentifier: () => R;
+export declare const PropertySpecializationIdentifier: () => R;
 export declare const ProtectiveWardingCircleSpecialAbilityIdentifier: () => R;
 export declare const PublicationIdentifier: () => R;
 export declare const RaceIdentifier: () => R;
@@ -160,6 +161,7 @@ export declare const SkillIdentifier: () => R;
 export declare const SkillModificationLevelIdentifier: () => R;
 export declare const SkillStyleSpecialAbilityIdentifier: () => R;
 export declare const SocialStatusIdentifier: () => R;
+export declare const SpecialAmmunitionIdentifier: () => R;
 export declare const SpellIdentifier: () => R;
 export declare const SpellSwordEnchantmentIdentifier: () => R;
 export declare const StaffEnchantmentIdentifier: () => R;

package/lib/types/_Identifier.js

@@ -51,6 +51,7 @@ import { OrienteeringAid } from "./equipment/item/OrienteeringAid.js";
 import { Plant } from "./equipment/item/Plant.js";
 import { Poison } from "./equipment/item/Poison.js";
 import { RopeOrChain } from "./equipment/item/RopeOrChain.js";
+import { SpecialAmmunition } from "./equipment/item/SpecialAmmunition.js";
 import { Stationery } from "./equipment/item/Stationery.js";
 import { Biome } from "./equipment/item/sub/Biome.js";
 import { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";
@@ -87,7 +88,7 @@ import { Patron } from "./Patron.js";
 import { PatronCategory } from "./PatronCategory.js";
 import { PersonalityTrait } from "./PersonalityTrait.js";
 import { Profession, ProfessionPackage, ProfessionVariant, ProfessionVersion, } from "./Profession.js";
-import { Property } from "./Property.js";
+import { Property, PropertySpecialization } from "./Property.js";
 import { Race, RaceVariant } from "./Race.js";
 import { Ritual } from "./Ritual.js";
 import { AlternativeRule } from "./rule/AlternativeRule.js";
@@ -305,6 +306,7 @@ export const ProfessionPackageIdentifier = () => R(ProfessionPackage);
 export const ProfessionVersionIdentifier = () => R(ProfessionVersion);
 export const ProfessionVariantIdentifier = () => R(ProfessionVariant);
 export const PropertyIdentifier = () => R(Property);
+export const PropertySpecializationIdentifier = () => R(PropertySpecialization);
 export const ProtectiveWardingCircleSpecialAbilityIdentifier = () => R(PWCSpecialAbility);
 export const PublicationIdentifier = () => R(Publication);
 export const RaceIdentifier = () => R(Race);
@@ -330,6 +332,7 @@ export const SkillIdentifier = () => R(Skill);
 export const SkillModificationLevelIdentifier = () => R(SkillModificationLevel);
 export const SkillStyleSpecialAbilityIdentifier = () => R(SkillStyleSpecialAbility);
 export const SocialStatusIdentifier = () => R(SocialStatus);
+export const SpecialAmmunitionIdentifier = () => R(SpecialAmmunition);
 export const SpellIdentifier = () => R(Spell);
 export const SpellSwordEnchantmentIdentifier = () => R(SpellSwordEnchantment);
 export const StaffEnchantmentIdentifier = () => R(StaffEnchantment);

package/lib/types/_IdentifierGroup.d.ts

@@ -480,3 +480,7 @@ export declare const TinyActivatableIdentifier: DB.Enum<"TinyActivatableIdentifi
     Blessing: DB.EnumCase<DB.ReferenceIdentifier>;
     Cantrip: DB.EnumCase<DB.ReferenceIdentifier>;
 }, []>;
+export declare const AnyPropertySpecializationIdentifier: DB.Enum<"AnyPropertySpecializationIdentifier", {
+    General: DB.EnumCase<DB.ReferenceIdentifier>;
+    Element: 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, 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, ItemComponentIdentifier, 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, ItemComponentIdentifier, 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, PropertySpecializationIdentifier, 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: () => ({
@@ -364,3 +364,10 @@ export const TinyActivatableIdentifier = DB.Enum(import.meta.url, {
         Cantrip: DB.EnumCase({ type: CantripIdentifier() }),
     }),
 });
+export const AnyPropertySpecializationIdentifier = DB.Enum(import.meta.url, {
+    name: "AnyPropertySpecializationIdentifier",
+    values: () => ({
+        General: DB.EnumCase({ type: PropertySpecializationIdentifier() }),
+        Element: DB.EnumCase({ type: ElementIdentifier() }),
+    }),
+});

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

@@ -23,6 +23,13 @@ export declare const GemOrPreciousStone: DB.Entity<"GemOrPreciousStone", {
         }>, []>>>;
     }, []>>, true>;
     weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, false>;
+    property: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"GemOrPreviousStoneProperty", DB.Object<{
+        base: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        specialization: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnyPropertySpecializationIdentifier", {
+            General: DB.EnumCase<DB.ReferenceIdentifier>;
+            Element: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, false>;
+    }>, []>>, false>;
     prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", 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<{
@@ -91,7 +98,7 @@ export declare const GemOrPreciousStone: DB.Entity<"GemOrPreciousStone", {
     translations: DB.MemberDecl<DB.NestedEntityMap<"GemOrPreciousStoneTranslation", {
         name: DB.MemberDecl<DB.String, true>;
         secondary_name: DB.MemberDecl<DB.String, false>;
-        color: DB.MemberDecl<DB.String, true>;
+        color: 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<{

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

@@ -1,4 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
+import { PropertyIdentifier } from "../../_Identifier.js";
+import { AnyPropertySpecializationIdentifier } from "../../_IdentifierGroup.js";
 import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
@@ -16,6 +18,10 @@ export const GemOrPreciousStone = DB.Entity(import.meta.url, {
             comment: "The weight in kg.",
             type: DB.IncludeIdentifier(Weight),
         }),
+        property: DB.Optional({
+            comment: "The associated property.",
+            type: DB.IncludeIdentifier(GemOrPreviousStoneProperty),
+        }),
         prerequisites: DB.Optional({
             comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
             type: DB.IncludeIdentifier(EquipmentPrerequisites),
@@ -30,7 +36,7 @@ export const GemOrPreciousStone = DB.Entity(import.meta.url, {
                 comment: "An auxiliary name or label of the item, if available.",
                 type: DB.String({ minLength: 1 }),
             }),
-            color: DB.Required({
+            color: DB.Optional({
                 comment: "The color of the gem or stone.",
                 type: DB.String({ minLength: 1 }),
             }),
@@ -55,3 +61,16 @@ export const GemOrPreciousStone = DB.Entity(import.meta.url, {
         },
     ],
 });
+const GemOrPreviousStoneProperty = DB.TypeAlias(import.meta.url, {
+    name: "GemOrPreviousStoneProperty",
+    type: () => DB.Object({
+        base: DB.Required({
+            comment: "The associated property.",
+            type: PropertyIdentifier(),
+        }),
+        specialization: DB.Optional({
+            comment: "The associated property specialization.",
+            type: DB.IncludeIdentifier(AnyPropertySpecializationIdentifier),
+        }),
+    }),
+});

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

@@ -1,5 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
-import { AmmunitionIdentifier, ArmorIdentifier, CloseCombatTechniqueIdentifier, ItemComponentIdentifier, RangedCombatTechniqueIdentifier, WeaponIdentifier, } from "../../_Identifier.js";
+import { ArmorIdentifier, CloseCombatTechniqueIdentifier, ItemComponentIdentifier, RangedCombatTechniqueIdentifier, SpecialAmmunitionIdentifier, WeaponIdentifier, } from "../../_Identifier.js";
 import { EquipmentPrerequisites } from "../../_Prerequisite.js";
 import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechnique.js";
 import { NestedTranslationMap } from "../../Locale.js";
@@ -258,7 +258,7 @@ const ApplicableAmmunition = DB.TypeAlias(import.meta.url, {
     type: () => DB.Object({
         ammunition: DB.Optional({
             comment: "Specific ammunition this component can be applied to.",
-            type: DB.Array(AmmunitionIdentifier(), {
+            type: DB.Array(SpecialAmmunitionIdentifier(), {
                 minItems: 1,
                 uniqueItems: true,
             }),

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

@@ -0,0 +1,152 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const SpecialAmmunition: DB.Entity<"SpecialAmmunition", {
+    applicableTo: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    costModifier: DB.MemberDecl<DB.Integer, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Complexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
+            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>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EquipmentPrerequisites", 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>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SpecialAmmunitionTranslation", {
+        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/SpecialAmmunition.js

@@ -0,0 +1,58 @@
+import * as DB from "tsondb/schema/dsl";
+import { AmmunitionIdentifier } from "../../_Identifier.js";
+import { EquipmentPrerequisites } from "../../_Prerequisite.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { Errata } from "../../source/_Erratum.js";
+import { src } from "../../source/_PublicationRef.js";
+import { Complexity } from "./_Item.js";
+export const SpecialAmmunition = DB.Entity(import.meta.url, {
+    name: "SpecialAmmunition",
+    namePlural: "SpecialAmmunition",
+    type: () => DB.Object({
+        applicableTo: DB.Required({
+            comment: "The base ammunition type that is affected by this specialization.",
+            type: DB.Array(AmmunitionIdentifier(), { minItems: 1 }),
+        }),
+        costModifier: DB.Required({
+            comment: "The cost modifier for the base price of affected ammunition.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        complexity: DB.Optional({
+            comment: "The complexity of crafting the item.",
+            type: DB.IncludeIdentifier(Complexity),
+        }),
+        prerequisites: DB.Optional({
+            comment: "The prerequisites of the item, if any. Note that this is fully separate from the prerequisites of the item’s trade secret, which are defined independently from this.",
+            type: DB.IncludeIdentifier(EquipmentPrerequisites),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "SpecialAmmunition", DB.Object({
+            name: DB.Required({
+                comment: "The item’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            secondary_name: DB.Optional({
+                comment: "An auxiliary name or label of the item, if available.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            note: DB.Optional({
+                comment: "Note text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            rules: DB.Optional({
+                comment: "Special rules text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/index.d.ts

@@ -49,6 +49,7 @@ export { OrienteeringAid } from "./equipment/item/OrienteeringAid.js";
 export { Plant } from "./equipment/item/Plant.js";
 export { Poison } from "./equipment/item/Poison.js";
 export { RopeOrChain } from "./equipment/item/RopeOrChain.js";
+export { SpecialAmmunition } from "./equipment/item/SpecialAmmunition.js";
 export { Stationery } from "./equipment/item/Stationery.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";

package/lib/types/index.js

@@ -49,6 +49,7 @@ export { OrienteeringAid } from "./equipment/item/OrienteeringAid.js";
 export { Plant } from "./equipment/item/Plant.js";
 export { Poison } from "./equipment/item/Poison.js";
 export { RopeOrChain } from "./equipment/item/RopeOrChain.js";
+export { SpecialAmmunition } from "./equipment/item/SpecialAmmunition.js";
 export { Stationery } from "./equipment/item/Stationery.js";
 export { Biome } from "./equipment/item/sub/Biome.js";
 export { BotanicRegion } from "./equipment/item/sub/BotanicRegion.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.107.1",
+  "version": "0.109.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",