@optolith/database-schema 0.45.0 → 0.47.0

package/lib/types/_Identifier.js

@@ -32,6 +32,7 @@ import { Container } from "./equipment/item/Container.js";
 import { Elixir } from "./equipment/item/Elixir.js";
 import { EquipmentOfBlessedOnes } from "./equipment/item/EquipmentOfBlessedOnes.js";
 import { GemOrPreciousStone } from "./equipment/item/GemOrPreciousStone.js";
+import { HerbalAid } from "./equipment/item/HerbalAid.js";
 import { IlluminationLightSource } from "./equipment/item/IlluminationLightSource.js";
 import { IlluminationRefillOrSupply } from "./equipment/item/IlluminationRefillOrSupply.js";
 import { Jewelry } from "./equipment/item/Jewelry.js";
@@ -42,10 +43,12 @@ import { MagicalArtifact } from "./equipment/item/MagicalArtifact.js";
 import { MusicalInstrument } from "./equipment/item/MusicalInstrument.js";
 import { Newspaper } from "./equipment/item/Newspaper.js";
 import { OrienteeringAid } from "./equipment/item/OrienteeringAid.js";
+import { Plant } from "./equipment/item/Plant.js";
 import { Poison } from "./equipment/item/Poison.js";
 import { RopeOrChain } from "./equipment/item/RopeOrChain.js";
 import { Stationery } from "./equipment/item/Stationery.js";
 import { ArmorType } from "./equipment/item/sub/ArmorType.js";
+import { Biome } from "./equipment/item/sub/Biome.js";
 import { Reach } from "./equipment/item/sub/Reach.js";
 import { ThievesTool } from "./equipment/item/ThievesTool.js";
 import { ToolOfTheTrade } from "./equipment/item/ToolOfTheTrade.js";
@@ -180,6 +183,7 @@ export const AttributeIdentifier = () => R(Attribute);
 export const BandageOrRemedyIdentifier = () => R(BandageOrRemedy);
 export const BannzeichenIdentifier = () => R(Bannzeichen);
 export const BeutelzauberIdentifier = () => R(Beutelzauber);
+export const BiomeIdentifier = () => R(Biome);
 export const BlessedTraditionIdentifier = () => R(BlessedTradition);
 export const BlessingIdentifier = () => R(Blessing);
 export const BookIdentifier = () => R(Book);
@@ -231,6 +235,7 @@ export const GoblinRitualIdentifier = () => R(GoblinRitual);
 export const GuidelineIdentifier = () => R(Guideline);
 export const HairColorIdentifier = () => R(HairColor);
 export const HaubenzauberIdentifier = () => R(Haubenzauber);
+export const HerbalAidIdentifier = () => R(HerbalAid);
 export const IlluminationLightSourceIdentifier = () => R(IlluminationLightSource);
 export const IlluminationRefillOrSupplyIdentifier = () => R(IlluminationRefillOrSupply);
 export const InfluenceIdentifier = () => R(Influence);
@@ -270,6 +275,7 @@ export const PactTypeIdentifier = () => R(PactType);
 export const PatronCategoryIdentifier = () => R(PatronCategory);
 export const PatronIdentifier = () => R(Patron);
 export const PersonalityTraitIdentifier = () => R(PersonalityTrait);
+export const PlantIdentifier = () => R(Plant);
 export const PlayerTypeIdentifier = () => R(PlayerType);
 export const PoisonIdentifier = () => R(Poison);
 export const ProfessionIdentifier = () => R(Profession);

package/lib/types/_ResponsiveText.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Originally, this type was created to represent the text of a spell, which can
+ * be displayed in full on the spell card, but also in a compressed version on
+ * the character sheet. However, it can be used for any text that has a similar
+ * requirement.
+ *
+ * The `ResponsiveTextReplace` type is a special case where the full and
+ * compressed versions are not standalone texts, but rather templates that
+ * include a placeholder (`$1`) for a generated string. The generated string is
+ * expected to adapt to different size contexts as well.
+ *
+ * The `ResponsiveTextOptional` type allows for the possibility that a
+ * compressed version may not be provided. In such cases, the full text should
+ * be used in all contexts, and the absence of a compressed version indicates
+ * that no special formatting is needed for smaller areas.
+ * @module
+ */
 import * as DB from "tsondb/schema/dsl";
 export declare const ResponsiveText: DB.TypeAlias<"ResponsiveText", DB.Object<{
     full: DB.MemberDecl<DB.String, true>;

package/lib/types/_ResponsiveText.js

@@ -1,3 +1,20 @@
+/**
+ * Originally, this type was created to represent the text of a spell, which can
+ * be displayed in full on the spell card, but also in a compressed version on
+ * the character sheet. However, it can be used for any text that has a similar
+ * requirement.
+ *
+ * The `ResponsiveTextReplace` type is a special case where the full and
+ * compressed versions are not standalone texts, but rather templates that
+ * include a placeholder (`$1`) for a generated string. The generated string is
+ * expected to adapt to different size contexts as well.
+ *
+ * The `ResponsiveTextOptional` type allows for the possibility that a
+ * compressed version may not be provided. In such cases, the full text should
+ * be used in all contexts, and the absence of a compressed version indicates
+ * that no special formatting is needed for smaller areas.
+ * @module
+ */
 import * as DB from "tsondb/schema/dsl";
 export const ResponsiveText = DB.TypeAlias(import.meta.url, {
     name: "ResponsiveText",

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

@@ -92,6 +92,7 @@ export declare const Elixir: DB.Entity<"Elixir", {
         alternative_names: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"AlternativeName", DB.Object<{
             name: DB.MemberDecl<DB.String, true>;
             region: DB.MemberDecl<DB.String, false>;
+            language: DB.MemberDecl<DB.ReferenceIdentifier, false>;
         }>, []>>>, false>;
         typical_ingredients: DB.MemberDecl<DB.Array<DB.String>, true>;
         brewing_process_prerequisites: DB.MemberDecl<DB.String, false>;

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

@@ -0,0 +1,64 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const HerbalAid: DB.Entity<"HerbalAid", {
+    types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
+        Healing: DB.EnumCase<null>;
+        Poison: DB.EnumCase<null>;
+        PhysicalEffect: DB.EnumCase<null>;
+        PsychicEffect: DB.EnumCase<null>;
+        Beneficial: DB.EnumCase<null>;
+        Defensive: DB.EnumCase<null>;
+        Supernatural: DB.EnumCase<null>;
+    }, []>>>, true>;
+    crafting_difficulty: DB.MemberDecl<DB.Integer, true>;
+    combatUse: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HerbalAidCombatUse", {
+        Weapon: DB.EnumCase<DB.ReferenceIdentifier>;
+        Armor: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, false>;
+    src: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRefs", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PublicationRef", DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        occurrences: DB.MemberDecl<DB.NestedEntityMap<string, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"HerbalAidTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, true>;
+        ingredients: DB.MemberDecl<DB.Array<DB.String>, true>;
+        typical_tools: DB.MemberDecl<DB.Array<DB.String>, false>;
+    }>, true>;
+}, undefined>;

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

@@ -0,0 +1,56 @@
+import * as DB from "tsondb/schema/dsl";
+import { src } from "../../source/_PublicationRef.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { WeaponIdentifier, ArmorIdentifier } from "../../_Identifier.js";
+import { EffectType } from "./_Herbary.js";
+export const HerbalAid = DB.Entity(import.meta.url, {
+    name: "HerbalAid",
+    namePlural: "HerbalAids",
+    type: () => DB.Object({
+        types: DB.Required({
+            comment: "The plant types this aid belongs to.",
+            type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+        }),
+        crafting_difficulty: DB.Required({
+            comment: "The difficulty for this aid to craft.",
+            type: DB.Integer(),
+        }),
+        combatUse: DB.Optional({
+            comment: "The armor or weapon this herbal aid represents.",
+            type: DB.IncludeIdentifier(HerbalAidCombatUse),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "HerbalAid", DB.Object({
+            name: DB.Required({
+                comment: "The herbal aid's name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The herbal aid's description.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            ingredients: DB.Required({
+                comment: "The ingredients used to craft this herbal aid.",
+                type: DB.Array(DB.String({ minLength: 1, markdown: "inline" }), { minItems: 1 }),
+            }),
+            typical_tools: DB.Optional({
+                comment: "The typical tools used to craft this.",
+                type: DB.Array(DB.String({ minLength: 1, markdown: "inline" }), { minItems: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const HerbalAidCombatUse = DB.Enum(import.meta.url, {
+    name: "HerbalAidCombatUse",
+    values: () => ({
+        Weapon: DB.EnumCase({ type: WeaponIdentifier() }),
+        Armor: DB.EnumCase({ type: ArmorIdentifier() }),
+    }),
+});

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

@@ -0,0 +1,183 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Plant: DB.Entity<"Plant", {
+    types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
+        Healing: DB.EnumCase<null>;
+        Poison: DB.EnumCase<null>;
+        PhysicalEffect: DB.EnumCase<null>;
+        PsychicEffect: DB.EnumCase<null>;
+        Beneficial: DB.EnumCase<null>;
+        Defensive: DB.EnumCase<null>;
+        Supernatural: DB.EnumCase<null>;
+    }, []>>>, true>;
+    occurences: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlantOccurences", DB.Object<{
+        items: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PlantOccurrence", DB.Object<{
+            biome: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            rarity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PlantRarity", {
+                Common: DB.EnumCase<null>;
+                Occasional: DB.EnumCase<null>;
+                RatherRare: DB.EnumCase<null>;
+                Rare: DB.EnumCase<null>;
+                VeryRare: DB.EnumCase<null>;
+            }, []>>, true>;
+            translation: DB.MemberDecl<DB.NestedEntityMap<"PlantOccurrenceTranslation", {
+                note: DB.MemberDecl<DB.String, true>;
+            }>, false>;
+        }>, []>>>, false>;
+        translation: DB.MemberDecl<DB.NestedEntityMap<"PlantOccurrencesTranslation", {
+            note: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, []>>, true>;
+    search_difficulty: DB.MemberDecl<DB.Integer, true>;
+    identification_difficulty: DB.MemberDecl<DB.Integer, true>;
+    applications: DB.MemberDecl<DB.Array<DB.Integer>, true>;
+    touch: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlantEffect", DB.Object<{
+        types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
+            Healing: DB.EnumCase<null>;
+            Poison: DB.EnumCase<null>;
+            PhysicalEffect: DB.EnumCase<null>;
+            PsychicEffect: DB.EnumCase<null>;
+            Beneficial: DB.EnumCase<null>;
+            Defensive: DB.EnumCase<null>;
+            Supernatural: DB.EnumCase<null>;
+        }, []>>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PlantEffectTranslationTranslation", {
+            description: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }>, []>>, false>;
+    inhalation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlantEffect", DB.Object<{
+        types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
+            Healing: DB.EnumCase<null>;
+            Poison: DB.EnumCase<null>;
+            PhysicalEffect: DB.EnumCase<null>;
+            PsychicEffect: DB.EnumCase<null>;
+            Beneficial: DB.EnumCase<null>;
+            Defensive: DB.EnumCase<null>;
+            Supernatural: DB.EnumCase<null>;
+        }, []>>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PlantEffectTranslationTranslation", {
+            description: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }>, []>>, false>;
+    ingestion: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlantEffect", DB.Object<{
+        types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
+            Healing: DB.EnumCase<null>;
+            Poison: DB.EnumCase<null>;
+            PhysicalEffect: DB.EnumCase<null>;
+            PsychicEffect: DB.EnumCase<null>;
+            Beneficial: DB.EnumCase<null>;
+            Defensive: DB.EnumCase<null>;
+            Supernatural: DB.EnumCase<null>;
+        }, []>>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PlantEffectTranslationTranslation", {
+            description: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }>, []>>, false>;
+    price: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PlantPrice", {
+        Constant: DB.EnumCase<DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            cost: DB.MemberDecl<DB.Float, true>;
+        }>>;
+        Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefinitePlantPrice", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"IndefinitePlantPriceTranslation", {
+                description: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>, true>;
+    recipes: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"PlantRecipe", {
+        HerbalAid: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HerbalAidRecipe", DB.Object<{
+            herbal_aid: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            translation: DB.MemberDecl<DB.NestedEntityMap<"HerbalAidRecipeTranslation", {
+                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>;
+        }>, []>>>;
+        Elixir: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ElixirRecipe", DB.Object<{
+            elixir: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            translation: DB.MemberDecl<DB.NestedEntityMap<"ElixirRecipeTranslation", {
+                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>;
+        }>, []>>>;
+        Poison: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PoisonRecipe", DB.Object<{
+            poison: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            translation: DB.MemberDecl<DB.NestedEntityMap<"PoisonRecipeTranslation", {
+                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>;
+        }>, []>>>;
+        Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteRecipe", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteRecipeTranslation", {
+                description: DB.MemberDecl<DB.String, true>;
+            }>, 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, {
+            initial: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InitialOccurrence", DB.Object<{
+                printing: DB.MemberDecl<DB.Integer, false>;
+                pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                    first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, true>;
+                    last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                        InsideCoverFront: DB.EnumCase<null>;
+                        InsideCoverBack: DB.EnumCase<null>;
+                        Numbered: DB.EnumCase<DB.Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+                isRemoved: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>, true>;
+            revisions: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"Revision", {
+                Since: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Since", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                    pages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"PageRange", DB.Object<{
+                        first_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, true>;
+                        last_page: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PlantTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        alternative_names: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"AlternativeName", DB.Object<{
+            name: DB.MemberDecl<DB.String, true>;
+            region: DB.MemberDecl<DB.String, false>;
+            language: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        }>, []>>>, false>;
+        remedies_and_traditions: DB.MemberDecl<DB.String, true>;
+        knowledge: DB.MemberDecl<DB.Array<DB.String>, true>;
+    }>, true>;
+}, undefined>;

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

@@ -0,0 +1,222 @@
+import * as DB from "tsondb/schema/dsl";
+import { src } from "../../source/_PublicationRef.js";
+import { NestedTranslationMap } from "../../Locale.js";
+import { AlternativeName } from "../../_AlternativeNames.js";
+import { BiomeIdentifier, HerbalAidIdentifier, ElixirIdentifier, PoisonIdentifier, } from "../../_Identifier.js";
+import { ResponsiveTextOptional, ResponsiveTextReplace } from "../../_ResponsiveText.js";
+import { EffectType, PlantRarity } from "./_Herbary.js";
+export const Plant = DB.Entity(import.meta.url, {
+    name: "Plant",
+    namePlural: "Plants",
+    type: () => DB.Object({
+        types: DB.Required({
+            comment: "The plant types of this plant.",
+            type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+        }),
+        occurences: DB.Required({
+            comment: "The biomes this plant occurs in and its rarity in those biomes.",
+            type: DB.IncludeIdentifier(PlantOccurences),
+        }),
+        search_difficulty: DB.Required({
+            comment: "The search difficulty for this plant.",
+            type: DB.Integer(),
+        }),
+        identification_difficulty: DB.Required({
+            comment: "The identification difficulty for this plant.",
+            type: DB.Integer(),
+        }),
+        applications: DB.Required({
+            comment: "The applications of this plant per quality level.",
+            type: DB.Array(DB.Integer(), { minItems: 6, maxItems: 6 }),
+        }),
+        touch: DB.Optional({
+            comment: "The plant's touch effect.",
+            type: DB.IncludeIdentifier(PlantEffect),
+        }),
+        inhalation: DB.Optional({
+            comment: "The plant's inhalation effect.",
+            type: DB.IncludeIdentifier(PlantEffect),
+        }),
+        ingestion: DB.Optional({
+            comment: "The plant's ingestion effect.",
+            type: DB.IncludeIdentifier(PlantEffect),
+        }),
+        price: DB.Required({
+            comment: "The price of the plant.",
+            type: DB.IncludeIdentifier(PlantPrice),
+        }),
+        recipes: DB.Optional({
+            comment: "The herbal aids and elixirs that can be crafted with this plant.",
+            type: DB.Array(DB.IncludeIdentifier(PlantRecipe), { minItems: 1 }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Plant", DB.Object({
+            name: DB.Required({
+                comment: "The plant's name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            alternative_names: DB.Optional({
+                comment: "A list of alternative names.",
+                type: DB.Array(DB.IncludeIdentifier(AlternativeName), { minItems: 1 }),
+            }),
+            remedies_and_traditions: DB.Required({
+                comment: "How this plant is used as a household remedy and in folk traditions.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            knowledge: DB.Required({
+                comment: "What one knows about this plant for each quality level. The first element represents QL 1, the second element QL 2, and so on.",
+                type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
+                    minItems: 3,
+                    maxItems: 6,
+                }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const PlantOccurences = DB.TypeAlias(import.meta.url, {
+    name: "PlantOccurences",
+    type: () => DB.Object({
+        items: DB.Optional({
+            comment: "The biomes this plant occurs in and its rarity in those biomes.",
+            type: DB.Array(DB.IncludeIdentifier(PlantOccurrence), { minItems: 1 }),
+        }),
+        translation: NestedTranslationMap(DB.Optional, "PlantOccurrences", DB.Object({
+            note: DB.Required({
+                comment: "A note to all occurences of this plant",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }, {
+        minProperties: 1,
+    }),
+});
+const PlantOccurrence = DB.TypeAlias(import.meta.url, {
+    name: "PlantOccurrence",
+    type: () => DB.Object({
+        biome: DB.Required({
+            comment: "The biome this plant occurs in.",
+            type: BiomeIdentifier(),
+        }),
+        rarity: DB.Required({
+            comment: "The rarity of this plant in the biome.",
+            type: DB.IncludeIdentifier(PlantRarity),
+        }),
+        translation: NestedTranslationMap(DB.Optional, "PlantOccurrence", DB.Object({
+            note: DB.Required({
+                comment: "A note added to this occurrence",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+        })),
+    }),
+});
+const PlantEffect = DB.TypeAlias(import.meta.url, {
+    name: "PlantEffect",
+    type: () => DB.Object({
+        types: DB.Optional({
+            comment: "The effect type of this plant effect.",
+            type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+        }),
+        translations: NestedTranslationMap(DB.Required, "PlantEffectTranslation", DB.Object({
+            description: DB.Required({
+                comment: "The effect of the plant.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }),
+});
+const PlantPrice = DB.Enum(import.meta.url, {
+    name: "PlantPrice",
+    values: () => ({
+        Constant: DB.EnumCase({
+            type: DB.Object({
+                value: DB.Required({
+                    comment: "The value of the plant in silver coins.",
+                    type: DB.Float({ minimum: 0 }),
+                }),
+                cost: DB.Required({
+                    comment: "The cost of the plant in silver coins.",
+                    type: DB.Float({ minimum: 0 }),
+                }),
+            }),
+        }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefinitePlantPrice) }),
+    }),
+});
+const IndefinitePlantPrice = DB.TypeAlias(import.meta.url, {
+    name: "IndefinitePlantPrice",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "IndefinitePlantPrice", DB.Object({
+            description: DB.Required({
+                comment: "A description of the price.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }),
+});
+const PlantRecipe = DB.Enum(import.meta.url, {
+    name: "PlantRecipe",
+    values: () => ({
+        HerbalAid: DB.EnumCase({ type: DB.IncludeIdentifier(HerbalAidRecipe) }),
+        Elixir: DB.EnumCase({ type: DB.IncludeIdentifier(ElixirRecipe) }),
+        Poison: DB.EnumCase({ type: DB.IncludeIdentifier(PoisonRecipe) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteRecipe) }),
+    }),
+});
+const PlantProductTranslation = DB.Object({
+    note: DB.Optional({
+        comment: "A note, appended to the generated string in parenthesis. If the generated is modified using `replacement`, the note is appended to the modifier string.",
+        type: DB.IncludeIdentifier(ResponsiveTextOptional),
+    }),
+    replacement: DB.Optional({
+        comment: "A replacement string. If `note` is provided, it is appended to the replaced string.",
+        type: DB.IncludeIdentifier(ResponsiveTextReplace),
+    }),
+}, { minProperties: 1 });
+const HerbalAidRecipe = DB.TypeAlias(import.meta.url, {
+    name: "HerbalAidRecipe",
+    type: () => DB.Object({
+        herbal_aid: DB.Required({
+            comment: "The herbal aid this recipe results in.",
+            type: HerbalAidIdentifier(),
+        }),
+        translation: NestedTranslationMap(DB.Optional, "HerbalAidRecipe", PlantProductTranslation),
+    }),
+});
+const ElixirRecipe = DB.TypeAlias(import.meta.url, {
+    name: "ElixirRecipe",
+    type: () => DB.Object({
+        elixir: DB.Required({
+            comment: "The elixir this recipe results in.",
+            type: ElixirIdentifier(),
+        }),
+        translation: NestedTranslationMap(DB.Optional, "ElixirRecipe", PlantProductTranslation),
+    }),
+});
+const PoisonRecipe = DB.TypeAlias(import.meta.url, {
+    name: "PoisonRecipe",
+    type: () => DB.Object({
+        poison: DB.Required({
+            comment: "The poison this recipe results in.",
+            type: PoisonIdentifier(),
+        }),
+        translation: NestedTranslationMap(DB.Optional, "PoisonRecipe", PlantProductTranslation),
+    }),
+});
+const IndefiniteRecipe = DB.TypeAlias(import.meta.url, {
+    name: "IndefiniteRecipe",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "IndefiniteRecipe", DB.Object({
+            description: DB.Required({
+                comment: "A description of the recipe.",
+                type: DB.String({ minLength: 1, markdown: "inline" }),
+            }),
+        })),
+    }),
+});

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

@@ -297,6 +297,7 @@ export declare const Poison: DB.Entity<"Poison", {
         alternative_names: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"AlternativeName", DB.Object<{
             name: DB.MemberDecl<DB.String, true>;
             region: DB.MemberDecl<DB.String, false>;
+            language: DB.MemberDecl<DB.ReferenceIdentifier, false>;
         }>, []>>>, false>;
         effect: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"Reduceable", DB.Object<{
             default: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, true>;

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

@@ -11,6 +11,13 @@ export declare const EffectType: DB.Enum<"EffectType", {
     Defensive: DB.EnumCase<null>;
     Supernatural: DB.EnumCase<null>;
 }, []>;
+export declare const PlantRarity: DB.Enum<"PlantRarity", {
+    Common: DB.EnumCase<null>;
+    Occasional: DB.EnumCase<null>;
+    RatherRare: DB.EnumCase<null>;
+    Rare: DB.EnumCase<null>;
+    VeryRare: DB.EnumCase<null>;
+}, []>;
 export declare const LaboratoryLevel: DB.Enum<"LaboratoryLevel", {
     ArchaicLaboratory: DB.EnumCase<null>;
     WitchKitchen: DB.EnumCase<null>;