@optolith/database-schema 0.42.1 → 0.42.4

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 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.42.4](https://github.com/Optolith/database-schema/compare/v0.42.3...v0.42.4) (2026-04-10)
+
+
+### Features
+
+* add replacement text option to known item specifics ([4a6648e](https://github.com/Optolith/database-schema/commit/4a6648e307a35a62422c923de59b156811da1119))
+
+## [0.42.3](https://github.com/Optolith/database-schema/compare/v0.42.2...v0.42.3) (2026-04-10)
+
+## [0.42.2](https://github.com/elyukai/optolith-database-schema/compare/v0.42.1...v0.42.2) (2026-04-10)
+
+
+### Features
+
+* known item specifics ([9a9a2bd](https://github.com/elyukai/optolith-database-schema/commit/9a9a2bd6a1a2ff3ee7a3c14cea064a0cce1ee52f))
+
 ## [0.42.1](https://github.com/elyukai/optolith-database-schema/compare/v0.42.0...v0.42.1) (2026-03-31)
 
 

package/gen/types.d.ts

@@ -258,6 +258,7 @@ export type EnumMap = {
   CastingTimeDuringLovemakingUnit: CastingTimeDuringLovemakingUnit
   CheckResultArithmetic: CheckResultArithmetic
   CheckResultValue: CheckResultValue
+  CollectorsValue: CollectorsValue
   CombatAnimalPowerType: CombatAnimalPowerType
   CombatRelatedSpecialAbilityIdentifier: CombatRelatedSpecialAbilityIdentifier
   CombatSpecialAbilityType: CombatSpecialAbilityType
@@ -322,6 +323,9 @@ export type EnumMap = {
   IntoxicantAddictionWithdrawalPreventionInterval: IntoxicantAddictionWithdrawalPreventionInterval
   JesterTrickDuration: JesterTrickDuration
   JesterTrickRange: JesterTrickRange
+  KnownItemAge: KnownItemAge
+  KnownItemCondition: KnownItemCondition
+  KnownItemStabilityRating: KnownItemStabilityRating
   LaboratoryLevel: LaboratoryLevel
   LanguagePrerequisiteGroup: LanguagePrerequisiteGroup
   LanguagesSelectOptionCategoryPrerequisite: LanguagesSelectOptionCategoryPrerequisite
@@ -534,6 +538,7 @@ export type TypeAliasMap = {
   CommonnessRatedSkill: CommonnessRatedSkill
   CommonProfessionConstraints: CommonProfessionConstraints<unknown>
   ComplexComplexity: ComplexComplexity
+  ConstantCollectorsValue: ConstantCollectorsValue
   ConstantDemonicPoisonLevel: ConstantDemonicPoisonLevel
   ConstantIntoxicantAddictionInterval: ConstantIntoxicantAddictionInterval
   ConstantMagicalSignCost: ConstantMagicalSignCost
@@ -669,6 +674,8 @@ export type TypeAliasMap = {
   JesterTrickCost: JesterTrickCost
   JesterTrickPerformanceParameters: JesterTrickPerformanceParameters
   JewelryMaterialDifference: JewelryMaterialDifference<unknown>
+  KnownItemSpecifics: KnownItemSpecifics
+  KnownItemSpecificsTranslation: KnownItemSpecificsTranslation
   LanguagePrerequisites: LanguagePrerequisites
   LanguagesScriptsOptions: LanguagesScriptsOptions
   LanguagesSelectOptionCategory: LanguagesSelectOptionCategory
@@ -698,6 +705,7 @@ export type TypeAliasMap = {
   MeleeDamage: MeleeDamage
   MeleeWeapon: MeleeWeapon
   MineralPoison: MineralPoison
+  MinimumCollectorsValue: MinimumCollectorsValue
   ModifiableCastingTime: ModifiableCastingTime
   ModifiableOneTimeCost: ModifiableOneTimeCost
   ModifiableRange: ModifiableRange
@@ -10995,6 +11003,11 @@ export interface Weapon {
    */
   restrictedTo?: RestrictedTo
 
+  /**
+   * The weapon is a known item, which implies some additional values.
+   */
+  knownItemSpecifics?: KnownItemSpecifics
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -11048,6 +11061,11 @@ export interface WeaponTranslation {
    */
   disadvantage?: string
 
+  /**
+   * The weapon is a known item, which implies some additional values.
+   */
+  knownItemSpecifics?: KnownItemSpecificsTranslation
+
   errata?: Errata
 }
 
@@ -11596,6 +11614,151 @@ export type RestrictedToBlessedTraditionsScope =
     kind: "Shamanistic"
   }
 
+export interface KnownItemSpecifics {
+  /**
+   * The age of the item is known.
+   */
+  age?: KnownItemAge
+
+  /**
+   * The condition of the item is known and well specified.
+   */
+  condition?: KnownItemCondition
+
+  /**
+   * The breaking point rating (weapon) or sturdiness rating (armor) of the item. Either a specific rating or a general unbreakability.
+   */
+  stabilityRating?: KnownItemStabilityRating
+
+  /**
+   * The *Damaged* (weapon) or *Wear* (armor) level of the item, if any.
+   */
+  damageLevel?: number
+
+  /**
+   * The collector’s value of the known item.
+   */
+  collectorsValue: CollectorsValue
+}
+
+/**
+ * The age of the item is known.
+ */
+export type KnownItemAge =
+  | {
+    kind: "Antique"
+  }
+  | {
+    kind: "Old"
+  }
+
+/**
+ * The condition of the item is known and well specified.
+ */
+export type KnownItemCondition =
+  | {
+    kind: "Broken"
+  }
+  | {
+    kind: "Poor"
+  }
+  | {
+    kind: "Good"
+  }
+  | {
+    kind: "VeryGood"
+  }
+  | {
+    kind: "AsNew"
+  }
+
+/**
+ * Either a specific rating or a general unbreakability.
+ */
+export type KnownItemStabilityRating =
+  | {
+    kind: "Constant"
+    Constant: number
+  }
+  | {
+    kind: "Unbreakable"
+  }
+
+/**
+ * The item has a collector’s value.
+ */
+export type CollectorsValue =
+  | {
+    kind: "Constant"
+    Constant: ConstantCollectorsValue
+  }
+  | {
+    kind: "Minimum"
+    Minimum: MinimumCollectorsValue
+  }
+  | {
+    kind: "Invaluable"
+  }
+
+export interface ConstantCollectorsValue {
+  /**
+   * The collector’s value is a fixed price in silverthalers.
+   */
+  value: number
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations?: {
+    [localeId: string]: ConstantCollectorsValueTranslation
+  }
+}
+
+export interface ConstantCollectorsValueTranslation {
+  /**
+   * A note, appended to the generated string in parenthesis.
+   */
+  note?: ResponsiveTextOptional
+
+  /**
+   * A replacement string.
+   */
+  replacement?: ResponsiveTextReplace
+}
+
+export interface MinimumCollectorsValue {
+  /**
+   * The collector’s value is a range with an open end and the specified price in silverthalers as the minimum.
+   */
+  value: number
+
+  /**
+   * All translations for the entry, identified by IETF language tag (BCP47).
+   */
+  translations?: {
+    [localeId: string]: MinimumCollectorsValueTranslation
+  }
+}
+
+export interface MinimumCollectorsValueTranslation {
+  /**
+   * A note, appended to the generated string in parenthesis.
+   */
+  note?: ResponsiveTextOptional
+
+  /**
+   * A replacement string.
+   */
+  replacement?: ResponsiveTextReplace
+}
+
+export interface KnownItemSpecificsTranslation {
+  /**
+   * The condition of the item.
+   */
+  condition: string
+}
+
 export interface CauldronEnchantment {
   /**
    * Number of available levels.
@@ -20463,6 +20626,11 @@ export interface Armor {
    */
   restrictedTo?: RestrictedTo
 
+  /**
+   * The armor is a known item, which implies some additional values.
+   */
+  knownItemSpecifics?: KnownItemSpecifics
+
   /**
    * References to where in which publications this entry has been defined. Entries may also be added or removed in later printings.
    */
@@ -20512,6 +20680,11 @@ export interface ArmorTranslation {
    */
   disadvantage?: string
 
+  /**
+   * The weapon is a known item, which implies some additional values.
+   */
+  knownItemSpecifics?: KnownItemSpecificsTranslation
+
   errata?: Errata
 }
 

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

@@ -64,6 +64,53 @@ export declare const Armor: DB.Entity<"Armor", {
             isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
         }>, []>>, false>;
     }>, []>>, false>;
+    knownItemSpecifics: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"KnownItemSpecifics", DB.Object<{
+        age: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemAge", {
+            Antique: DB.EnumCase<null>;
+            Old: DB.EnumCase<null>;
+        }, []>>, false>;
+        condition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemCondition", {
+            Broken: DB.EnumCase<null>;
+            Poor: DB.EnumCase<null>;
+            Good: DB.EnumCase<null>;
+            VeryGood: DB.EnumCase<null>;
+            AsNew: DB.EnumCase<null>;
+        }, []>>, false>;
+        stabilityRating: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemStabilityRating", {
+            Constant: DB.EnumCase<DB.Integer>;
+            Unbreakable: DB.EnumCase<null>;
+        }, []>>, false>;
+        damageLevel: DB.MemberDecl<DB.Integer, false>;
+        collectorsValue: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CollectorsValue", {
+            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantCollectorsValue", DB.Object<{
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ConstantCollectorsValueTranslation", {
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Minimum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MinimumCollectorsValue", DB.Object<{
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"MinimumCollectorsValueTranslation", {
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Invaluable: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
@@ -112,6 +159,9 @@ export declare const Armor: DB.Entity<"Armor", {
         rules: DB.MemberDecl<DB.String, false>;
         advantage: DB.MemberDecl<DB.String, false>;
         disadvantage: DB.MemberDecl<DB.String, false>;
+        knownItemSpecifics: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"KnownItemSpecificsTranslation", DB.Object<{
+            condition: DB.MemberDecl<DB.String, true>;
+        }>, []>>, 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>;

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

@@ -3,7 +3,7 @@ import { ArmorIdentifier, ArmorTypeIdentifier } from "../../_Identifier.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
-import { ComplexComplexity, Cost, RestrictedTo, Weight } from "./_Item.js";
+import { ComplexComplexity, Cost, KnownItemSpecifics, KnownItemSpecificsTranslation, RestrictedTo, Weight, } from "./_Item.js";
 export const Armor = DB.Entity(import.meta.url, {
     name: "Armor",
     namePlural: "Armor",
@@ -44,6 +44,10 @@ export const Armor = DB.Entity(import.meta.url, {
             comment: "Define if during character creation this weapon can only be bought by a specific subset of characters.",
             type: DB.IncludeIdentifier(RestrictedTo),
         }),
+        knownItemSpecifics: DB.Optional({
+            comment: "The armor is a known item, which implies some additional values.",
+            type: DB.IncludeIdentifier(KnownItemSpecifics),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Armor", DB.Object({
             name: DB.Required({
@@ -70,6 +74,10 @@ export const Armor = DB.Entity(import.meta.url, {
                 comment: "The armor disadvantage text.",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
+            knownItemSpecifics: DB.Optional({
+                comment: "The weapon is a known item, which implies some additional values.",
+                type: DB.IncludeIdentifier(KnownItemSpecificsTranslation),
+            }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
             }),

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

@@ -96,6 +96,53 @@ export declare const Weapon: DB.Entity<"Weapon", {
             isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
         }>, []>>, false>;
     }>, []>>, false>;
+    knownItemSpecifics: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"KnownItemSpecifics", DB.Object<{
+        age: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemAge", {
+            Antique: DB.EnumCase<null>;
+            Old: DB.EnumCase<null>;
+        }, []>>, false>;
+        condition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemCondition", {
+            Broken: DB.EnumCase<null>;
+            Poor: DB.EnumCase<null>;
+            Good: DB.EnumCase<null>;
+            VeryGood: DB.EnumCase<null>;
+            AsNew: DB.EnumCase<null>;
+        }, []>>, false>;
+        stabilityRating: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemStabilityRating", {
+            Constant: DB.EnumCase<DB.Integer>;
+            Unbreakable: DB.EnumCase<null>;
+        }, []>>, false>;
+        damageLevel: DB.MemberDecl<DB.Integer, false>;
+        collectorsValue: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CollectorsValue", {
+            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantCollectorsValue", DB.Object<{
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ConstantCollectorsValueTranslation", {
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Minimum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MinimumCollectorsValue", DB.Object<{
+                value: DB.MemberDecl<DB.Float, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"MinimumCollectorsValueTranslation", {
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
+                    }>, []>>, false>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
+                    }>, []>>, false>;
+                }>, false>;
+            }>, []>>>;
+            Invaluable: DB.EnumCase<null>;
+        }, []>>, true>;
+    }>, []>>, false>;
     src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
         id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
         occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
@@ -144,6 +191,9 @@ export declare const Weapon: DB.Entity<"Weapon", {
         rules: DB.MemberDecl<DB.String, false>;
         advantage: DB.MemberDecl<DB.String, false>;
         disadvantage: DB.MemberDecl<DB.String, false>;
+        knownItemSpecifics: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"KnownItemSpecificsTranslation", DB.Object<{
+            condition: DB.MemberDecl<DB.String, true>;
+        }>, []>>, 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>;

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

@@ -3,7 +3,7 @@ import { CloseCombatTechnique, RangedCombatTechnique } from "../../CombatTechniq
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
-import { Complexity, Cost, RestrictedTo, StructurePoints, Weight } from "./_Item.js";
+import { Complexity, Cost, KnownItemSpecifics, KnownItemSpecificsTranslation, RestrictedTo, StructurePoints, Weight, } from "./_Item.js";
 import { MeleeWeapon } from "./_MeleeWeapon.js";
 import { RangedWeapon } from "./_RangedWeapon.js";
 import { checkWeaponCombatTechniqueIntegrity } from "./_Weapon.js";
@@ -51,6 +51,10 @@ export const Weapon = DB.Entity(import.meta.url, {
             comment: "Define if during character creation this weapon can only be bought by a specific subset of characters.",
             type: DB.IncludeIdentifier(RestrictedTo),
         }),
+        knownItemSpecifics: DB.Optional({
+            comment: "The weapon is a known item, which implies some additional values.",
+            type: DB.IncludeIdentifier(KnownItemSpecifics),
+        }),
         src,
         translations: NestedTranslationMap(DB.Required, "Weapon", DB.Object({
             name: DB.Required({
@@ -77,6 +81,10 @@ export const Weapon = DB.Entity(import.meta.url, {
                 comment: "The weapon disadvantage text.",
                 type: DB.String({ minLength: 1, markdown: "block" }),
             }),
+            knownItemSpecifics: DB.Optional({
+                comment: "The weapon is a known item, which implies some additional values.",
+                type: DB.IncludeIdentifier(KnownItemSpecificsTranslation),
+            }),
             errata: DB.Optional({
                 type: DB.IncludeIdentifier(Errata),
             }),

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

@@ -412,3 +412,53 @@ export declare const RestrictedToBlessedTraditionsScope: DB.Enum<"RestrictedToBl
     Church: DB.EnumCase<null>;
     Shamanistic: DB.EnumCase<null>;
 }, []>;
+export declare const KnownItemSpecifics: DB.TypeAlias<"KnownItemSpecifics", DB.Object<{
+    age: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemAge", {
+        Antique: DB.EnumCase<null>;
+        Old: DB.EnumCase<null>;
+    }, []>>, false>;
+    condition: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemCondition", {
+        Broken: DB.EnumCase<null>;
+        Poor: DB.EnumCase<null>;
+        Good: DB.EnumCase<null>;
+        VeryGood: DB.EnumCase<null>;
+        AsNew: DB.EnumCase<null>;
+    }, []>>, false>;
+    stabilityRating: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"KnownItemStabilityRating", {
+        Constant: DB.EnumCase<DB.Integer>;
+        Unbreakable: DB.EnumCase<null>;
+    }, []>>, false>;
+    damageLevel: DB.MemberDecl<DB.Integer, false>;
+    collectorsValue: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CollectorsValue", {
+        Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantCollectorsValue", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ConstantCollectorsValueTranslation", {
+                note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    full: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, false>;
+                }>, []>>, false>;
+                replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                    full: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, true>;
+                }>, []>>, false>;
+            }>, false>;
+        }>, []>>>;
+        Minimum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MinimumCollectorsValue", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"MinimumCollectorsValueTranslation", {
+                note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                    full: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, false>;
+                }>, []>>, false>;
+                replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                    full: DB.MemberDecl<DB.String, true>;
+                    compressed: DB.MemberDecl<DB.String, true>;
+                }>, []>>, false>;
+            }>, false>;
+        }>, []>>>;
+        Invaluable: DB.EnumCase<null>;
+    }, []>>, true>;
+}>, []>;
+export declare const KnownItemSpecificsTranslation: DB.TypeAlias<"KnownItemSpecificsTranslation", DB.Object<{
+    condition: DB.MemberDecl<DB.String, true>;
+}>, []>;

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

@@ -1,5 +1,6 @@
 import * as DB from "tsondb/schema/dsl";
 import { BlessedTraditionIdentifier, CultureIdentifier, MagicalTraditionIdentifier, ProfessionIdentifier, RaceIdentifier, } from "../../_Identifier.js";
+import { ResponsiveTextOptional, ResponsiveTextReplace } from "../../_ResponsiveText.js";
 import { NestedTranslationMap } from "../../Locale.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
@@ -252,3 +253,177 @@ export const RestrictedToBlessedTraditionsScope = DB.Enum(import.meta.url, {
         Shamanistic: DB.EnumCase({ type: null }),
     }),
 });
+export const KnownItemSpecifics = DB.TypeAlias(import.meta.url, {
+    name: "KnownItemSpecifics",
+    type: () => DB.Object({
+        age: DB.Optional({
+            comment: "The age of the item is known.",
+            type: DB.IncludeIdentifier(KnownItemAge),
+        }),
+        condition: DB.Optional({
+            comment: "The condition of the item is known and well specified.",
+            type: DB.IncludeIdentifier(KnownItemCondition),
+        }),
+        stabilityRating: DB.Optional({
+            comment: "The breaking point rating (weapon) or sturdiness rating (armor) of the item. Either a specific rating or a general unbreakability.",
+            type: DB.IncludeIdentifier(KnownItemStabilityRating),
+        }),
+        damageLevel: DB.Optional({
+            comment: "The *Damaged* (weapon) or *Wear* (armor) level of the item, if any.",
+            type: DB.Integer({ minimum: 1, maximum: 4 }),
+        }),
+        collectorsValue: DB.Required({
+            comment: "The collector’s value of the known item.",
+            type: DB.IncludeIdentifier(CollectorsValue),
+        }),
+    }),
+});
+export const KnownItemSpecificsTranslation = DB.TypeAlias(import.meta.url, {
+    name: "KnownItemSpecificsTranslation",
+    type: () => DB.Object({
+        condition: DB.Required({
+            comment: "The condition of the item.",
+            type: DB.String({ minLength: 1, markdown: "inline" }),
+        }),
+    }),
+});
+const KnownItemAge = DB.Enum(import.meta.url, {
+    name: "KnownItemAge",
+    comment: "The age of the item is known.",
+    values: () => ({
+        Antique: DB.EnumCase({ type: null }),
+        Old: DB.EnumCase({ type: null }),
+    }),
+});
+const KnownItemCondition = DB.Enum(import.meta.url, {
+    name: "KnownItemCondition",
+    comment: "The condition of the item is known and well specified.",
+    values: () => ({
+        Broken: DB.EnumCase({ type: null }),
+        Poor: DB.EnumCase({ type: null }),
+        Good: DB.EnumCase({ type: null }),
+        VeryGood: DB.EnumCase({ type: null }),
+        AsNew: DB.EnumCase({ type: null }),
+    }),
+});
+const KnownItemStabilityRating = DB.Enum(import.meta.url, {
+    name: "KnownItemStabilityRating",
+    comment: "Either a specific rating or a general unbreakability.",
+    values: () => ({
+        Constant: DB.EnumCase({ type: DB.Integer({ minimum: 1 }) }),
+        Unbreakable: DB.EnumCase({ type: null }),
+    }),
+});
+const CollectorsValue = DB.Enum(import.meta.url, {
+    name: "CollectorsValue",
+    comment: "The item has a collector’s value.",
+    values: () => ({
+        Constant: DB.EnumCase({
+            comment: "The collector’s value is a fixed price in silverthalers.",
+            type: DB.IncludeIdentifier(ConstantCollectorsValue),
+        }),
+        Minimum: DB.EnumCase({
+            comment: "The collector’s value is a range with an open end and the specified price in silverthalers as the minimum.",
+            type: DB.IncludeIdentifier(MinimumCollectorsValue),
+        }),
+        Invaluable: DB.EnumCase({
+            comment: "The item is invaluable to collectors.",
+            type: null,
+        }),
+    }),
+});
+const ConstantCollectorsValue = DB.TypeAlias(import.meta.url, {
+    name: "ConstantCollectorsValue",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The collector’s value is a fixed price in silverthalers.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "ConstantCollectorsValue", DB.Object({
+            note: DB.Optional({
+                comment: "A note, appended to the generated string in parenthesis.",
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            replacement: DB.Optional({
+                comment: "A replacement string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+const MinimumCollectorsValue = DB.TypeAlias(import.meta.url, {
+    name: "MinimumCollectorsValue",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The collector’s value is a range with an open end and the specified price in silverthalers as the minimum.",
+            type: DB.Float({ minimum: { value: 0, isExclusive: true } }),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "MinimumCollectorsValue", DB.Object({
+            note: DB.Optional({
+                comment: "A note, appended to the generated string in parenthesis.",
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
+            }),
+            replacement: DB.Optional({
+                comment: "A replacement string.",
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
+            }),
+        }, { minProperties: 1 })),
+    }),
+});
+/*
+
+Possible known item conditions:
+-------------------------------
+
+Die Waffe ist antik, aber gut erhalten.
+Der Schild ist antik, aber gut erhalten.
+Die Waffe ist antik, aber sehr gut erhalten und sieht aus wie neu.
+Die Waffe ist antik, aber sehr gut erhalten.
+Die Waffe ist zwar antik, aber sehr gut erhalten.
+Die Waffe ist antik und weist einige Scharten in der Klinge auf.
+Die Waffe ist antik und zerbrochen.
+Die Waffe ist antik, aber neuwertig.
+Die Waffe ist alt.
+Die Waffe ist alt, aber gut gepflegt.
+Der Magierstab ist alt, aber gut gepflegt.
+Die Waffen sind alt, aber gut gepflegt.
+Die Waffe ist alt, aber neuwertig.
+Das Schwert ist alt, aber neuwertig.
+Die Waffe ist alt, aber gut erhalten.
+Die Waffe ist alt, aber sie wurde vermutlich niemals eingesetzt und ist gut erhalten.
+Die Waffe ist alt und in schlechtem Zustand.
+Die Waffe ist alt und schlecht gepflegt.
+Die Waffe ist alt, aber in gepflegtem Zustand.
+Die Waffe ist gebraucht.
+Die Waffe ist gebraucht, aber neuwertig.
+Die Waffe ist gebraucht, aber unzerbrechlich.
+Die Waffe ist gebraucht, aber gepflegt.
+Die Rüstung ist gebraucht, aber gut erhalten.
+Die Rüstung ist gebraucht und in einem schlechten Zustand.
+Die Waffe ist neuwertig.
+Die Waffe ist neuwertig und unbenutzt.
+*leer*
+
+Wenn er gebunden wird, wird der
+Stab wie alle Traditionsartefakte nahezu unzerbrechlich.
+Sie weist 1 Stufe Beschädigung auf.
+Er weist 1 Stufe Beschädigung auf.
+Der Bruchfaktor beträgt 14.
+Der Bruchfaktor beträgt 12 und sie weist 3 Stufen Beschädigung auf.
+Sie ist unzerbrechlich.
+Einzig elementares Feuer, das heißer brennt als ein Drachenodem oder ein IGNIFAXIUS, oder aber das Eingreifen eines Gottes können die Axt zerstören.
+Einzig elementares Feuer, das heißer brennt als ein Drachenodem oder ein IGNIFAXIUS, spezielle Zauberei oder das Eingreifen eines Gottes können die Axt zerstören.
+Die Waffe war lange Zeit dem Salzwasser der Zyklopensee ausgesetzt, was allerdings bei Weitem nicht so große Schäden angerichtet hat, wie zu erwarten wäre.
+Die Waffe kann nicht benutzt werden, bis die geborstene Klinge neu geschmiedet wurde.
+Sie weist 3 Stufen Verschleiß auf und ist unbrauchbar, bis sie repariert wurde.
+
+Possible collector's values:
+----------------------------
+
+750+ S (nur Personen mit sehr zweifelhaftem Ruf würden eine solche Waffe erwerben)
+1.500+ S
+2.500 S
+500+ S (1.500+ S für ein zusammenpassendes Paar)
+unbezahlbar
+
+*/

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

@@ -64,14 +64,14 @@ export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstan
                 checkPart(ct.special.has_length, meleeUse.length, "a length", "close", ctId),
                 checkPart(ct.special.has_reach, meleeUse.reach, "a reach", "close", ctId),
                 checkPart(ct.special.has_shield_size, meleeUse.size, "a shield size", "close", ctId),
-            ].filter(v => v !== undefined);
+            ];
         }),
         ...Object.entries(instanceContent.ranged_uses ?? {}).flatMap(([ctId, rangedUse]) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- integrity has been checked, it must be present
             const ct = getInstanceById("RangedCombatTechnique", ctId);
             return [
                 checkPart(ct.special.has_ammunition, rangedUse.ammunition, "an ammunition", "ranged", ctId),
-            ].filter(v => v !== undefined);
+            ];
         }),
     ].filter(v => v !== undefined);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optolith/database-schema",
-  "version": "0.42.1",
+  "version": "0.42.4",
   "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",
@@ -53,9 +53,9 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.1"
   },
-  "repository": "github:elyukai/optolith-database-schema",
+  "repository": "github:Optolith/database-schema",
   "bugs": {
-    "url": "https://github.com/elyukai/optolith-database-schema/issues"
+    "url": "https://github.com/Optolith/database-schema/issues"
   },
   "type": "module"
 }