optolith-database-schema 0.31.1 → 0.31.3

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.3](https://github.com/elyukai/optolith-database-schema/compare/v0.31.2...v0.31.3) (2026-02-16)
+
+
+### Bug Fixes
+
+* interpretation and display of poisons/elixirs ([30a6a3c](https://github.com/elyukai/optolith-database-schema/commit/30a6a3c4262e2920f9100605faee8c426cd37491))
+
+## [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)
 
 

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
@@ -2331,6 +2333,58 @@ export interface Locale {
     "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 (poison)": string
+    "Ingestion (poison)": string
+    "Inhalation (poison)": string
+    "Contact (poison)": 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 } }
+    "Ingestion": string
+    "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 } }
+    ".input {$count :number} {{check required every {$count}. application}}": string & { __params: { "count": number } }
+    ".input {$count :number} {{check required every {$count}. application in the same month}}": string & { __params: { "count": 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
   }
 }
 
@@ -20602,7 +20656,7 @@ export interface ElixirTranslationTranslation {
   description?: string
 
   /**
-   * The recipe’s description.
+   * Special information about the elixir.
    */
   special?: string
 
@@ -21931,10 +21985,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).
@@ -21951,10 +22010,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

@@ -1414,6 +1414,58 @@ export declare const Locale: DB.Entity<"Locale", {
         "Structure Points": null;
         ".input {$value :number} {{{$value} Structure Points}}": null;
         "{$value} Structure Points": null;
+        "{$types} poison": null;
+        "Weapon (poison)": null;
+        "Ingestion (poison)": null;
+        "Inhalation (poison)": null;
+        "Contact (poison)": 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;
+        Ingestion: 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;
+        ".input {$count :number} {{check required every {$count}. application}}": null;
+        ".input {$count :number} {{check required every {$count}. application in the same month}}": 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

@@ -1453,6 +1453,62 @@ export const Locale = DB.Entity(import.meta.url, {
                 "Structure Points": null,
                 ".input {$value :number} {{{$value} Structure Points}}": null,
                 "{$value} Structure Points": null,
+                // poisons/elixirs
+                "{$types} poison": null,
+                "Weapon (poison)": null,
+                "Ingestion (poison)": null,
+                "Inhalation (poison)": null,
+                "Contact (poison)": 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,
+                "Ingestion": 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,
+                ".input {$count :number} {{check required every {$count}. application}}": null,
+                ".input {$count :number} {{check required every {$count}. application in the same month}}": 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>;
+                    }>, []>>, false>;
+                    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>;
+                    }>, []>>, false>;
+                    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>;
+            }>, []>>, false>;
+            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>;
+            }>, []>>, false>;
+            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>;
+        }>, []>>, false>;
+        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>;
+    }>, []>>, false>;
+    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.Optional({
+            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.1",
+  "version": "0.31.3",
   "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",