optolith-database-schema 0.31.0 → 0.31.2

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 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.31.2](https://github.com/elyukai/optolith-database-schema/compare/v0.31.1...v0.31.2) (2026-02-15)
+
+
+### Features
+
+* add translations for poisons, elixirs, sex practices, diseases and personality traits ([3561289](https://github.com/elyukai/optolith-database-schema/commit/3561289fc1283bcecde3065bee5850b166ba3270))
+
+
+### Bug Fixes
+
+* incorrect comment ([c3a6124](https://github.com/elyukai/optolith-database-schema/commit/c3a61244cec93af6396f723ee972e7911f98c1fa))
+* poison addition interpretation ([a24aeb6](https://github.com/elyukai/optolith-database-schema/commit/a24aeb6dd1cf170afe0d7de1b23f5cdf0c11b5b3))
+
+## [0.31.1](https://github.com/elyukai/optolith-database-schema/compare/v0.31.0...v0.31.1) (2026-02-15)
+
+
+### Features
+
+* add rest of translations for equipment ([fa4b7b5](https://github.com/elyukai/optolith-database-schema/commit/fa4b7b5e68491aa367e65f14ebf6afdf636da1da))
+
 ## [0.31.0](https://github.com/elyukai/optolith-database-schema/compare/v0.30.1...v0.31.0) (2026-02-14)
 
 

package/gen/types.d.ts

@@ -299,7 +299,7 @@ export type EnumMap = {
   ImprovementCost: ImprovementCost
   IndefiniteArcaneEnergyCostModifierArithmetic: IndefiniteArcaneEnergyCostModifierArithmetic
   InfluencePrerequisiteGroup: InfluencePrerequisiteGroup
-  IntoxicantAddictionInterval: IntoxicantAddictionInterval
+  IntoxicantAddictionWithdrawalPreventionInterval: IntoxicantAddictionWithdrawalPreventionInterval
   JesterTrickDuration: JesterTrickDuration
   JesterTrickRange: JesterTrickRange
   LaboratoryLevel: LaboratoryLevel
@@ -621,6 +621,8 @@ export type TypeAliasMap = {
   IntervalArcaneEnergyCost: IntervalArcaneEnergyCost
   Intoxicant: Intoxicant
   IntoxicantAddiction: IntoxicantAddiction
+  IntoxicantAddictionCheck: IntoxicantAddictionCheck
+  IntoxicantAddictionWithdrawalPrevention: IntoxicantAddictionWithdrawalPrevention
   IntoxicantLegality: IntoxicantLegality
   JesterTrickCastingTime: JesterTrickCastingTime
   JesterTrickCost: JesterTrickCost
@@ -1227,6 +1229,7 @@ export interface Locale {
     "general.pricevalue": string
     "general.lengthvalue": string
     "D": string
+    "{$count}D{$sides}": string & { __params: { "count": StringableTranslationParameter; "sides": StringableTranslationParameter } }
     "general.none": string
     "general.or": string
     "general.and": string
@@ -2285,11 +2288,100 @@ export interface Locale {
     "Cost": string
     "Total": string
     ".input {$value :number} {{{$value} pounds}}": string & { __params: { "value": number } }
+    "{$value} pounds": string & { __params: { "value": StringableTranslationParameter } }
     ".input {$value :number} {{{$value} silverthalers}}": string & { __params: { "value": number } }
+    "{$value} silverthalers": string & { __params: { "value": StringableTranslationParameter } }
     ".input {$from :number} .input {$to :number} {{{$from}–{$to} pounds}}": string & { __params: { "from": number; "to": number } }
     ".input {$from :number} .input {$to :number} {{{$from}–{$to} silverthalers}}": string & { __params: { "from": number; "to": number } }
+    "free": string
+    "various": string
+    "invaluable": string
+    "Damage Points": string
+    "Primary Attribute + Damage Threshold": string
+    "Attack/Parry Modifier": string
+    "Reach": string
+    "Weight (Bronze/Silver/Gold)": string
+    "Length": string
+    "Cost (Bronze/Silver/Gold)": string
+    "Reload Time": string
+    "Range Brackets": string
+    "Ammunition": string
+    "Protection": string
+    "Additional Penalties": string
+    "Burning Time": string
+    "Color": string
+    "Language/Script": string
+    "Complexity": string
+    "Weapon Advantage": string
+    "Weapon Disadvantage": string
+    "Armor Advantage": string
+    "Armor Disadvantage": string
+    "Combat Technique {$name}": string & { __params: { "name": StringableTranslationParameter } }
+    "Primitive": string
+    "Simple": string
+    "Complex": string
     "Various": string
-    "Invaluable": string
+    "Parrying weapon (PA bonus +1 for the main weapon)": string
+    "To buy a {$itemName} during hero creation, the character must have Tradition ({$traditions}).": string & { __params: { "itemName": StringableTranslationParameter; "traditions": StringableTranslationParameter } }
+    "Sanctified ({$sanctifiedTraditions}); only Blessed Ones of {$traditions} may purchase weapons sanctified by {$traditions}, respectively.": string & { __params: { "sanctifiedTraditions": StringableTranslationParameter; "traditions": StringableTranslationParameter } }
+    "Sanctified ({$tradition}); only Blessed Ones of {$tradition} may purchase weapons sanctified by {$tradition}.": string & { __params: { "tradition": StringableTranslationParameter } }
+    "To buy a {$name} during hero creation, the character must be from the culture of the {$cultures}.": string & { __params: { "name": StringableTranslationParameter; "cultures": StringableTranslationParameter } }
+    "To buy a {$itemName} during hero creation, the character must have a shamanistic tradition.": string & { __params: { "itemName": StringableTranslationParameter } }
+    "To buy a {$name} during hero creation, the character must be from a culture common to the race of {$races}.": string & { __params: { "name": StringableTranslationParameter; "races": StringableTranslationParameter } }
+    ".input {$value :number} {{{$value} inches}}": string & { __params: { "value": number } }
+    "unlimited": string
+    "Structure Points": string
+    ".input {$value :number} {{{$value} Structure Points}}": string & { __params: { "value": number } }
+    "{$value} Structure Points": string & { __params: { "value": StringableTranslationParameter } }
+    "{$types} poison": string & { __params: { "types": StringableTranslationParameter } }
+    "Weapon": string
+    "Ingestion": string
+    "Inhalation": string
+    "Contact": string
+    "Level": string
+    "Type": string
+    "animal venom": string
+    "alchemical poison": string
+    "mineral poison": string
+    "plant poison": string
+    "demonic poison": string
+    "Archaic laboratory": string
+    "Witch kitchen": string
+    "Alchemist’s laboratory": string
+    "Resistance": string
+    "{$first} or {$second}, depending on which value is lower": string & { __params: { "first": StringableTranslationParameter; "second": StringableTranslationParameter } }
+    "Start": string
+    "immediate": string
+    "instant": string
+    "Typical Ingredients": string
+    "Price of Ingredients/Level": string
+    "Laboratory": string
+    "Brewing Difficulty": string
+    "Brewing Process": string
+    "Trade Secret": string
+    "The poison levels equals the QL.": string
+    ".input {$value :number} {{{$value} applications every {$interval}}}": string & { __params: { "value": number; "interval": StringableTranslationParameter } }
+    "{$valueRange} on {$dice}": string & { __params: { "valueRange": StringableTranslationParameter; "dice": StringableTranslationParameter } }
+    "Side Effect": string
+    "Overdose": string
+    "Legality": string
+    "legal": string
+    "illegal": string
+    "Addiction": string
+    "Value/Cost": string
+    "cannot be extracted": string
+    ".input {$hiddenCount :number} {{Alternative Names}}": string & { __params: { "hiddenCount": number } }
+    "Failed": string
+    "Progress": string
+    "Incubation Time": string
+    "Damage": string
+    "Causes": string
+    "Treatment": string
+    "Antidote": string
+    ".input {$value :number} {{{$value}%}}": string & { __params: { "value": number } }
+    "Animal Types": string
+    "Communicability to Intelligent Creatures": string
+    "Can be combined with": string
   }
 }
 
@@ -20561,7 +20653,7 @@ export interface ElixirTranslationTranslation {
   description?: string
 
   /**
-   * The recipe’s description.
+   * Special information about the elixir.
    */
   special?: string
 
@@ -21890,10 +21982,15 @@ export interface IntoxicantAddiction {
    */
   chance?: number
 
+  /**
+   * The interval at which to check for addiction after an ingestion. If set to one, every ingestion has to be checked for addiction. If set to two, every second ingestion has to be checked, and so on.
+   */
+  check: IntoxicantAddictionCheck
+
   /**
    * The maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.
    */
-  interval: IntoxicantAddictionInterval
+  withdrawalPrevention: IntoxicantAddictionWithdrawalPrevention
 
   /**
    * All translations for the entry, identified by IETF language tag (BCP47).
@@ -21910,10 +22007,34 @@ export interface IntoxicantAddictionTranslation {
   chance: string
 }
 
+/**
+ * The interval at which to check for addiction after an ingestion. If set to one, every ingestion has to be checked for addiction. If set to two, every second ingestion has to be checked, and so on.
+ */
+export interface IntoxicantAddictionCheck {
+  interval: number
+
+  /**
+   * If true, only ingestions in the same month count for the check interval.
+   */
+  onlySameMonth?: boolean
+}
+
+export interface IntoxicantAddictionWithdrawalPrevention {
+  /**
+   * The amount that must be ingested within the interval to prevent withdrawal symptoms.
+   */
+  amount: number
+
+  /**
+   * The maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.
+   */
+  interval: IntoxicantAddictionWithdrawalPreventionInterval
+}
+
 /**
  * The maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.
  */
-export type IntoxicantAddictionInterval =
+export type IntoxicantAddictionWithdrawalPreventionInterval =
   | {
     kind: "Constant"
     Constant: ConstantIntoxicantAddictionInterval

package/lib/types/Locale.d.ts

@@ -217,6 +217,7 @@ export declare const Locale: DB.Entity<"Locale", {
          * As in *2D6*.
          */
         D: null;
+        "{$count}D{$sides}": null;
         "general.none": null;
         "general.or": null;
         "general.and": null;
@@ -1368,11 +1369,100 @@ export declare const Locale: DB.Entity<"Locale", {
         Cost: null;
         Total: null;
         ".input {$value :number} {{{$value} pounds}}": null;
+        "{$value} pounds": null;
         ".input {$value :number} {{{$value} silverthalers}}": null;
+        "{$value} silverthalers": null;
         ".input {$from :number} .input {$to :number} {{{$from}\u2013{$to} pounds}}": null;
         ".input {$from :number} .input {$to :number} {{{$from}\u2013{$to} silverthalers}}": null;
+        free: null;
+        various: null;
+        invaluable: null;
+        "Damage Points": null;
+        "Primary Attribute + Damage Threshold": null;
+        "Attack/Parry Modifier": null;
+        Reach: null;
+        "Weight (Bronze/Silver/Gold)": null;
+        Length: null;
+        "Cost (Bronze/Silver/Gold)": null;
+        "Reload Time": null;
+        "Range Brackets": null;
+        Ammunition: null;
+        Protection: null;
+        "Additional Penalties": null;
+        "Burning Time": null;
+        Color: null;
+        "Language/Script": null;
+        Complexity: null;
+        "Weapon Advantage": null;
+        "Weapon Disadvantage": null;
+        "Armor Advantage": null;
+        "Armor Disadvantage": null;
+        "Combat Technique {$name}": null;
+        Primitive: null;
+        Simple: null;
+        Complex: null;
         Various: null;
-        Invaluable: null;
+        "Parrying weapon (PA bonus +1 for the main weapon)": null;
+        "To buy a {$itemName} during hero creation, the character must have Tradition ({$traditions}).": null;
+        "Sanctified ({$sanctifiedTraditions}); only Blessed Ones of {$traditions} may purchase weapons sanctified by {$traditions}, respectively.": null;
+        "Sanctified ({$tradition}); only Blessed Ones of {$tradition} may purchase weapons sanctified by {$tradition}.": null;
+        "To buy a {$name} during hero creation, the character must be from the culture of the {$cultures}.": null;
+        "To buy a {$itemName} during hero creation, the character must have a shamanistic tradition.": null;
+        "To buy a {$name} during hero creation, the character must be from a culture common to the race of {$races}.": null;
+        ".input {$value :number} {{{$value} inches}}": null;
+        unlimited: null;
+        "Structure Points": null;
+        ".input {$value :number} {{{$value} Structure Points}}": null;
+        "{$value} Structure Points": null;
+        "{$types} poison": null;
+        Weapon: null;
+        Ingestion: null;
+        Inhalation: null;
+        Contact: null;
+        Level: null;
+        Type: null;
+        "animal venom": null;
+        "alchemical poison": null;
+        "mineral poison": null;
+        "plant poison": null;
+        "demonic poison": null;
+        "Archaic laboratory": null;
+        "Witch kitchen": null;
+        "Alchemist\u2019s laboratory": null;
+        Resistance: null;
+        "{$first} or {$second}, depending on which value is lower": null;
+        Start: null;
+        immediate: null;
+        instant: null;
+        "Typical Ingredients": null;
+        "Price of Ingredients/Level": null;
+        Laboratory: null;
+        "Brewing Difficulty": null;
+        "Brewing Process": null;
+        "Trade Secret": null;
+        "The poison levels equals the QL.": null;
+        ".input {$value :number} {{{$value} applications every {$interval}}}": null;
+        "{$valueRange} on {$dice}": null;
+        "Side Effect": null;
+        Overdose: null;
+        Legality: null;
+        legal: null;
+        illegal: null;
+        Addiction: null;
+        "Value/Cost": null;
+        "cannot be extracted": null;
+        ".input {$hiddenCount :number} {{Alternative Names}}": null;
+        Failed: null;
+        Progress: null;
+        "Incubation Time": null;
+        Damage: null;
+        Causes: null;
+        Treatment: null;
+        Antidote: null;
+        ".input {$value :number} {{{$value}%}}": null;
+        "Animal Types": null;
+        "Communicability to Intelligent Creatures": null;
+        "Can be combined with": null;
     }>, false>;
 }, undefined>;
 export declare const NestedTranslationMap: <Name extends string, T extends Record<string, DB.MemberDecl>, R extends boolean>(MemberDeclCreator: <T_1 extends DB.Type>(options: {

package/lib/types/Locale.js

@@ -237,6 +237,7 @@ export const Locale = DB.Entity(import.meta.url, {
                  * As in *2D6*.
                  */
                 "D": null,
+                "{$count}D{$sides}": null,
                 "general.none": null,
                 "general.or": null,
                 "general.and": null,
@@ -1407,11 +1408,104 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Cost": null,
                 "Total": null,
                 ".input {$value :number} {{{$value} pounds}}": null,
+                "{$value} pounds": null,
                 ".input {$value :number} {{{$value} silverthalers}}": null,
+                "{$value} silverthalers": null,
                 ".input {$from :number} .input {$to :number} {{{$from}–{$to} pounds}}": null,
                 ".input {$from :number} .input {$to :number} {{{$from}–{$to} silverthalers}}": null,
+                "free": null,
+                "various": null,
+                "invaluable": null,
+                "Damage Points": null,
+                "Primary Attribute + Damage Threshold": null,
+                "Attack/Parry Modifier": null,
+                "Reach": null,
+                "Weight (Bronze/Silver/Gold)": null,
+                "Length": null,
+                "Cost (Bronze/Silver/Gold)": null,
+                "Reload Time": null,
+                "Range Brackets": null,
+                "Ammunition": null,
+                "Protection": null,
+                "Additional Penalties": null,
+                "Burning Time": null,
+                "Color": null,
+                "Language/Script": null,
+                "Complexity": null,
+                "Weapon Advantage": null,
+                "Weapon Disadvantage": null,
+                "Armor Advantage": null,
+                "Armor Disadvantage": null,
+                "Combat Technique {$name}": null,
+                "Primitive": null,
+                "Simple": null,
+                "Complex": null,
                 "Various": null,
-                "Invaluable": null,
+                "Parrying weapon (PA bonus +1 for the main weapon)": null,
+                "To buy a {$itemName} during hero creation, the character must have Tradition ({$traditions}).": null,
+                "Sanctified ({$sanctifiedTraditions}); only Blessed Ones of {$traditions} may purchase weapons sanctified by {$traditions}, respectively.": null,
+                "Sanctified ({$tradition}); only Blessed Ones of {$tradition} may purchase weapons sanctified by {$tradition}.": null,
+                "To buy a {$name} during hero creation, the character must be from the culture of the {$cultures}.": null,
+                "To buy a {$itemName} during hero creation, the character must have a shamanistic tradition.": null,
+                "To buy a {$name} during hero creation, the character must be from a culture common to the race of {$races}.": null,
+                ".input {$value :number} {{{$value} inches}}": null,
+                "unlimited": null,
+                "Structure Points": null,
+                ".input {$value :number} {{{$value} Structure Points}}": null,
+                "{$value} Structure Points": null,
+                // poisons/elixirs
+                "{$types} poison": null,
+                "Weapon": null,
+                "Ingestion": null,
+                "Inhalation": null,
+                "Contact": null,
+                "Level": null,
+                "Type": null,
+                "animal venom": null,
+                "alchemical poison": null,
+                "mineral poison": null,
+                "plant poison": null,
+                "demonic poison": null,
+                "Archaic laboratory": null,
+                "Witch kitchen": null,
+                "Alchemist’s laboratory": null,
+                "Resistance": null,
+                "{$first} or {$second}, depending on which value is lower": null,
+                "Start": null,
+                "immediate": null,
+                "instant": null,
+                "Typical Ingredients": null,
+                "Price of Ingredients/Level": null,
+                "Laboratory": null,
+                "Brewing Difficulty": null,
+                "Brewing Process": null,
+                "Trade Secret": null,
+                "The poison levels equals the QL.": null,
+                ".input {$value :number} {{{$value} applications every {$interval}}}": null,
+                "{$valueRange} on {$dice}": null,
+                "Side Effect": null,
+                "Overdose": null,
+                "Legality": null,
+                "legal": null,
+                "illegal": null,
+                "Addiction": null,
+                "Value/Cost": null,
+                "cannot be extracted": null,
+                ".input {$hiddenCount :number} {{Alternative Names}}": null,
+                // sex practices
+                "Failed": null,
+                // diseases
+                "Progress": null,
+                "Incubation Time": null,
+                "Damage": null,
+                "Causes": null,
+                "Treatment": null,
+                "Antidote": null,
+                ".input {$value :number} {{{$value}%}}": null,
+                "Animal Types": null,
+                "Communicability to Intelligent Creatures": null,
+                // personality traits
+                "Can be combined with": null,
             }, { allKeysAreRequired: true }),
         }),
     }),

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

@@ -43,7 +43,7 @@ export const Elixir = DB.Entity(import.meta.url, {
                 type: DB.String({ minLength: 1 }),
             }),
             special: DB.Optional({
-                comment: "The recipe’s description.",
+                comment: "Special information about the elixir.",
                 type: DB.String({ minLength: 1 }),
             }),
             alternative_names: DB.Optional({

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

@@ -98,17 +98,24 @@ export declare const Poison: DB.Entity<"Poison", {
                 }>, []>>, true>;
                 addiction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddiction", DB.Object<{
                     chance: DB.MemberDecl<DB.Integer, false>;
-                    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionInterval", {
-                        Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
-                            value: DB.MemberDecl<DB.Integer, true>;
-                        }>, []>>>;
-                        DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
-                            dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                                number: DB.MemberDecl<DB.Integer, true>;
-                                sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-                            }>, []>>, true>;
-                        }>, []>>>;
-                    }, []>>, true>;
+                    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionCheck", DB.Object<{
+                        interval: DB.MemberDecl<DB.Integer, true>;
+                        onlySameMonth: DB.MemberDecl<DB.Boolean, false>;
+                    }>, []>>, true>;
+                    withdrawalPrevention: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionWithdrawalPrevention", DB.Object<{
+                        amount: DB.MemberDecl<DB.Integer, true>;
+                        interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionWithdrawalPreventionInterval", {
+                            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
+                                value: DB.MemberDecl<DB.Integer, true>;
+                            }>, []>>>;
+                            DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
+                                dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
+                                    number: DB.MemberDecl<DB.Integer, true>;
+                                    sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+                                }>, []>>, true>;
+                            }>, []>>>;
+                        }, []>>, true>;
+                    }>, []>>, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"IntoxicantAddictionTranslation", {
                         chance: DB.MemberDecl<DB.String, true>;
                     }>, false>;
@@ -145,17 +152,24 @@ export declare const Poison: DB.Entity<"Poison", {
                 }>, []>>, true>;
                 addiction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddiction", DB.Object<{
                     chance: DB.MemberDecl<DB.Integer, false>;
-                    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionInterval", {
-                        Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
-                            value: DB.MemberDecl<DB.Integer, true>;
-                        }>, []>>>;
-                        DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
-                            dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                                number: DB.MemberDecl<DB.Integer, true>;
-                                sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-                            }>, []>>, true>;
-                        }>, []>>>;
-                    }, []>>, true>;
+                    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionCheck", DB.Object<{
+                        interval: DB.MemberDecl<DB.Integer, true>;
+                        onlySameMonth: DB.MemberDecl<DB.Boolean, false>;
+                    }>, []>>, true>;
+                    withdrawalPrevention: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionWithdrawalPrevention", DB.Object<{
+                        amount: DB.MemberDecl<DB.Integer, true>;
+                        interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionWithdrawalPreventionInterval", {
+                            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
+                                value: DB.MemberDecl<DB.Integer, true>;
+                            }>, []>>>;
+                            DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
+                                dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
+                                    number: DB.MemberDecl<DB.Integer, true>;
+                                    sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+                                }>, []>>, true>;
+                            }>, []>>>;
+                        }, []>>, true>;
+                    }>, []>>, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"IntoxicantAddictionTranslation", {
                         chance: DB.MemberDecl<DB.String, true>;
                     }>, false>;
@@ -440,17 +454,24 @@ export declare const AlchemicalPoison: DB.TypeAlias<"AlchemicalPoison", DB.Objec
         }>, []>>, true>;
         addiction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddiction", DB.Object<{
             chance: DB.MemberDecl<DB.Integer, false>;
-            interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionInterval", {
-                Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
-                    value: DB.MemberDecl<DB.Integer, true>;
-                }>, []>>>;
-                DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
-                    dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                        number: DB.MemberDecl<DB.Integer, true>;
-                        sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-                    }>, []>>, true>;
-                }>, []>>>;
-            }, []>>, true>;
+            check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionCheck", DB.Object<{
+                interval: DB.MemberDecl<DB.Integer, true>;
+                onlySameMonth: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            withdrawalPrevention: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionWithdrawalPrevention", DB.Object<{
+                amount: DB.MemberDecl<DB.Integer, true>;
+                interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionWithdrawalPreventionInterval", {
+                    Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>>;
+                    DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
+                        dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
+                            number: DB.MemberDecl<DB.Integer, true>;
+                            sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+                        }>, []>>, true>;
+                    }>, []>>>;
+                }, []>>, true>;
+            }>, []>>, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"IntoxicantAddictionTranslation", {
                 chance: DB.MemberDecl<DB.String, true>;
             }>, false>;
@@ -487,17 +508,24 @@ export declare const PlantPoison: DB.TypeAlias<"PlantPoison", DB.Object<{
         }>, []>>, true>;
         addiction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddiction", DB.Object<{
             chance: DB.MemberDecl<DB.Integer, false>;
-            interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionInterval", {
-                Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
-                    value: DB.MemberDecl<DB.Integer, true>;
-                }>, []>>>;
-                DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
-                    dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                        number: DB.MemberDecl<DB.Integer, true>;
-                        sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-                    }>, []>>, true>;
-                }>, []>>>;
-            }, []>>, true>;
+            check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionCheck", DB.Object<{
+                interval: DB.MemberDecl<DB.Integer, true>;
+                onlySameMonth: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            withdrawalPrevention: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionWithdrawalPrevention", DB.Object<{
+                amount: DB.MemberDecl<DB.Integer, true>;
+                interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionWithdrawalPreventionInterval", {
+                    Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>>;
+                    DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
+                        dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
+                            number: DB.MemberDecl<DB.Integer, true>;
+                            sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+                        }>, []>>, true>;
+                    }>, []>>>;
+                }, []>>, true>;
+            }>, []>>, true>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"IntoxicantAddictionTranslation", {
                 chance: DB.MemberDecl<DB.String, true>;
             }>, false>;
@@ -539,17 +567,24 @@ export declare const Intoxicant: DB.TypeAlias<"Intoxicant", DB.Object<{
     }>, []>>, true>;
     addiction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddiction", DB.Object<{
         chance: DB.MemberDecl<DB.Integer, false>;
-        interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionInterval", {
-            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
-                value: DB.MemberDecl<DB.Integer, true>;
-            }>, []>>>;
-            DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
-                dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                    number: DB.MemberDecl<DB.Integer, true>;
-                    sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-                }>, []>>, true>;
-            }>, []>>>;
-        }, []>>, true>;
+        check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionCheck", DB.Object<{
+            interval: DB.MemberDecl<DB.Integer, true>;
+            onlySameMonth: DB.MemberDecl<DB.Boolean, false>;
+        }>, []>>, true>;
+        withdrawalPrevention: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionWithdrawalPrevention", DB.Object<{
+            amount: DB.MemberDecl<DB.Integer, true>;
+            interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionWithdrawalPreventionInterval", {
+                Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+                DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
+                    dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
+                        number: DB.MemberDecl<DB.Integer, true>;
+                        sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+                    }>, []>>, true>;
+                }>, []>>>;
+            }, []>>, true>;
+        }>, []>>, true>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"IntoxicantAddictionTranslation", {
             chance: DB.MemberDecl<DB.String, true>;
         }>, false>;
@@ -566,17 +601,24 @@ export declare const IntoxicantLegality: DB.TypeAlias<"IntoxicantLegality", DB.O
 }>, []>;
 export declare const IntoxicantAddiction: DB.TypeAlias<"IntoxicantAddiction", DB.Object<{
     chance: DB.MemberDecl<DB.Integer, false>;
-    interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionInterval", {
-        Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
-            value: DB.MemberDecl<DB.Integer, true>;
-        }>, []>>>;
-        DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
-            dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
-                number: DB.MemberDecl<DB.Integer, true>;
-                sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
-            }>, []>>, true>;
-        }>, []>>>;
-    }, []>>, true>;
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionCheck", DB.Object<{
+        interval: DB.MemberDecl<DB.Integer, true>;
+        onlySameMonth: DB.MemberDecl<DB.Boolean, false>;
+    }>, []>>, true>;
+    withdrawalPrevention: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"IntoxicantAddictionWithdrawalPrevention", DB.Object<{
+        amount: DB.MemberDecl<DB.Integer, true>;
+        interval: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"IntoxicantAddictionWithdrawalPreventionInterval", {
+            Constant: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ConstantIntoxicantAddictionInterval", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            DiceBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DiceBasedIntoxicantAddictionInterval", DB.Object<{
+                dice: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Dice", DB.Object<{
+                    number: DB.MemberDecl<DB.Integer, true>;
+                    sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+                }>, []>>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+    }>, []>>, true>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"IntoxicantAddictionTranslation", {
         chance: DB.MemberDecl<DB.String, true>;
     }>, false>;

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

@@ -412,9 +412,13 @@ export const IntoxicantAddiction = DB.TypeAlias(import.meta.url, {
             comment: "The chance of getting addicted after an ingestion in percent. Some intoxicants do not have a contant chance of addiction.",
             type: DB.Integer({ minimum: 0, maximum: 100, multipleOf: 5 }),
         }),
-        interval: DB.Required({
+        check: DB.Required({
+            comment: "The interval at which to check for addiction after an ingestion. If set to one, every ingestion has to be checked for addiction. If set to two, every second ingestion has to be checked, and so on.",
+            type: DB.IncludeIdentifier(IntoxicantAddictionCheck),
+        }),
+        withdrawalPrevention: DB.Required({
             comment: "The maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.",
-            type: DB.IncludeIdentifier(IntoxicantAddictionInterval),
+            type: DB.IncludeIdentifier(IntoxicantAddictionWithdrawalPrevention),
         }),
         translations: NestedTranslationMap(DB.Optional, "IntoxicantAddiction", DB.Object({
             chance: DB.Required({
@@ -424,8 +428,34 @@ export const IntoxicantAddiction = DB.TypeAlias(import.meta.url, {
         })),
     }),
 });
-const IntoxicantAddictionInterval = DB.Enum(import.meta.url, {
-    name: "IntoxicantAddictionInterval",
+const IntoxicantAddictionCheck = DB.TypeAlias(import.meta.url, {
+    name: "IntoxicantAddictionCheck",
+    comment: "The interval at which to check for addiction after an ingestion. If set to one, every ingestion has to be checked for addiction. If set to two, every second ingestion has to be checked, and so on.",
+    type: () => DB.Object({
+        interval: DB.Required({
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        onlySameMonth: DB.Optional({
+            comment: "If true, only ingestions in the same month count for the check interval.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const IntoxicantAddictionWithdrawalPrevention = DB.TypeAlias(import.meta.url, {
+    name: "IntoxicantAddictionWithdrawalPrevention",
+    type: () => DB.Object({
+        amount: DB.Required({
+            comment: "The amount that must be ingested within the interval to prevent withdrawal symptoms.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        interval: DB.Required({
+            comment: "The maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.",
+            type: DB.IncludeIdentifier(IntoxicantAddictionWithdrawalPreventionInterval),
+        }),
+    }),
+});
+const IntoxicantAddictionWithdrawalPreventionInterval = DB.Enum(import.meta.url, {
+    name: "IntoxicantAddictionWithdrawalPreventionInterval",
     comment: "The maximum interval at which it, while addicted, must be ingested to not suffer from withdrawal symptoms.",
     values: () => ({
         Constant: DB.EnumCase({ type: DB.IncludeIdentifier(ConstantIntoxicantAddictionInterval) }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "optolith-database-schema",
-  "version": "0.31.0",
+  "version": "0.31.2",
   "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",