@optolith/database-schema 0.44.1 → 0.46.0

package/lib/main.js

@@ -28,6 +28,7 @@ export const schema = new Schema([
     Types.BandageOrRemedy,
     Types.Bannzeichen,
     Types.Beutelzauber,
+    Types.Biome,
     Types.BlessedTradition,
     Types.Blessing,
     Types.Book,
@@ -78,6 +79,7 @@ export const schema = new Schema([
     Types.Guideline,
     Types.HairColor,
     Types.Haubenzauber,
+    Types.HerbalAid,
     Types.HomunculusType,
     Types.IlluminationLightSource,
     Types.IlluminationRefillOrSupply,
@@ -114,6 +116,7 @@ export const schema = new Schema([
     Types.PatronCategory,
     Types.PersonalityTrait,
     Types.PlayerType,
+    Types.Plant,
     Types.Poison,
     Types.Profession,
     Types.Property,

package/lib/types/Advantage.js

@@ -2,7 +2,7 @@ import * as DB from "tsondb/schema/dsl";
 import { input, levels, maximum, name, name_in_library, range_l10n, rules } from "./_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventurePointsValue.js";
 import { automatic_entries } from "./_ActivatableAutomatic.js";
-import { nameBuilderRules } from "./_ActivatableNames.js";
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "./_ActivatableNames.js";
 import { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
@@ -48,6 +48,7 @@ export const Advantage = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
+    instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
     uniqueConstraints: [
         {
             entityMapKeyPath: "translations",

package/lib/types/AnimalDisease.d.ts

@@ -69,6 +69,7 @@ export declare const AnimalDisease: DB.Entity<"AnimalDisease", {
         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>;
         progress: DB.MemberDecl<DB.String, true>;
         incubation_time: DB.MemberDecl<DB.String, true>;

package/lib/types/Culture.js

@@ -247,6 +247,7 @@ const BlessedCommonProfessionConstraint = DB.Enum(import.meta.url, {
     name: "BlessedCommonProfessionConstraint",
     values: () => ({
         Tradition: DB.EnumCase({ type: DB.IncludeIdentifier(BlessedTraditionConstraint) }),
+        Profession: DB.EnumCase({ type: DB.IncludeIdentifier(ProfessionConstraint) }),
     }),
 });
 const PlainCommonProfessions = DB.TypeAlias(import.meta.url, {

package/lib/types/Disadvantage.js

@@ -1,7 +1,7 @@
 import * as DB from "tsondb/schema/dsl";
 import { input, levels, maximum, name, name_in_library, rules } from "./_Activatable.js";
 import { ap_value, ap_value_append, ap_value_l10n } from "./_ActivatableAdventurePointsValue.js";
-import { nameBuilderRules } from "./_ActivatableNames.js";
+import { activatableDisplayNameCustomizer, nameBuilderRules } from "./_ActivatableNames.js";
 import { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js";
 import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
 import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
@@ -49,6 +49,7 @@ export const Disadvantage = DB.Entity(import.meta.url, {
         })),
     }),
     instanceDisplayName: {},
+    instanceDisplayNameCustomizer: activatableDisplayNameCustomizer,
     uniqueConstraints: [
         {
             entityMapKeyPath: "translations",

package/lib/types/Disease.d.ts

@@ -89,6 +89,7 @@ export declare const Disease: DB.Entity<"Disease", {
         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>;
         progress: DB.MemberDecl<DB.String, true>;
         incubation_time: DB.MemberDecl<DB.String, true>;

package/lib/types/Locale.d.ts

@@ -1590,6 +1590,7 @@ export declare const Locale: DB.Entity<"Locale", {
         "no Liturgies totaling {$apValue} AP": null;
         "{$apValue} AP to improve other {$skillsOfGroup}": null;
         "{$apValue} AP to distribute among the following skills: {$list}": null;
+        "maximum SR per skill: {$maxSR}": null;
         "no AP to improve other {$skillsOfGroup}": null;
         ".input {$count :number} {{{$count} cantrips}}": null;
         "{$count} from the following list": null;

package/lib/types/Locale.js

@@ -1640,6 +1640,7 @@ export const Locale = DB.Entity(import.meta.url, {
                 "no Liturgies totaling {$apValue} AP": null,
                 "{$apValue} AP to improve other {$skillsOfGroup}": null,
                 "{$apValue} AP to distribute among the following skills: {$list}": null,
+                "maximum SR per skill: {$maxSR}": null,
                 "no AP to improve other {$skillsOfGroup}": null,
                 ".input {$count :number} {{{$count} cantrips}}": null,
                 "{$count} from the following list": null,

package/lib/types/_ActivatableNames.d.ts

@@ -13,3 +13,17 @@ export declare const nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB
     }, []>>, false>;
     useParenthesis: DB.MemberDecl<DB.Boolean, false>;
 }>, []>>, false>;
+export declare const activatableDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, locales, }: {
+    instance: {
+        translations: Record<string, {
+            name: string;
+            name_in_library?: string;
+        }>;
+    };
+    instanceDisplayName: string;
+    instanceDisplayNameLocaleId: string | undefined;
+    locales: string[];
+}) => {
+    name: string;
+    localeId: string | undefined;
+};

package/lib/types/_ActivatableNames.js

@@ -24,3 +24,15 @@ const ActivatableNameLevelPlacement = DB.Enum(import.meta.url, {
         AfterOptions: DB.EnumCase({ type: null }),
     }),
 });
+export const activatableDisplayNameCustomizer = ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, locales, }) => {
+    for (const locale of locales) {
+        const translation = instance.translations[locale];
+        if (translation) {
+            return {
+                name: translation.name_in_library ?? translation.name,
+                localeId: locale,
+            };
+        }
+    }
+    return { name: instanceDisplayName, localeId: instanceDisplayNameLocaleId };
+};

package/lib/types/_AlternativeNames.d.ts

@@ -2,4 +2,5 @@ import * as DB from "tsondb/schema/dsl";
 export declare const AlternativeName: DB.TypeAlias<"AlternativeName", DB.Object<{
     name: DB.MemberDecl<DB.String, true>;
     region: DB.MemberDecl<DB.String, false>;
+    language: DB.MemberDecl<DB.ReferenceIdentifier, false>;
 }>, []>;

package/lib/types/_AlternativeNames.js

@@ -1,4 +1,5 @@
 import * as DB from "tsondb/schema/dsl";
+import { LanguageIdentifier } from "./_Identifier.js";
 export const AlternativeName = DB.TypeAlias(import.meta.url, {
     name: "AlternativeName",
     type: () => DB.Object({
@@ -10,5 +11,9 @@ export const AlternativeName = DB.TypeAlias(import.meta.url, {
             comment: "The region where this alternative name is used.",
             type: DB.String({ minLength: 1 }),
         }),
+        language: DB.Optional({
+            comment: "The language of that alternative name if any.",
+            type: LanguageIdentifier(),
+        }),
     }),
 });

package/lib/types/_DiseasePoison.d.ts

@@ -38,6 +38,7 @@ export declare const DiseaseTranslation: DB.Object<{
     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>;
     progress: DB.MemberDecl<DB.String, true>;
     incubation_time: DB.MemberDecl<DB.String, true>;

package/lib/types/_Identifier.d.ts

@@ -25,6 +25,7 @@ export declare const AttributeIdentifier: () => R;
 export declare const BandageOrRemedyIdentifier: () => R;
 export declare const BannzeichenIdentifier: () => R;
 export declare const BeutelzauberIdentifier: () => R;
+export declare const BiomeIdentifier: () => R;
 export declare const BlessedTraditionIdentifier: () => R;
 export declare const BlessingIdentifier: () => R;
 export declare const BookIdentifier: () => R;
@@ -76,6 +77,7 @@ export declare const GoblinRitualIdentifier: () => R;
 export declare const GuidelineIdentifier: () => R;
 export declare const HairColorIdentifier: () => R;
 export declare const HaubenzauberIdentifier: () => R;
+export declare const HerbalAidIdentifier: () => R;
 export declare const IlluminationLightSourceIdentifier: () => R;
 export declare const IlluminationRefillOrSupplyIdentifier: () => R;
 export declare const InfluenceIdentifier: () => R;
@@ -115,6 +117,7 @@ export declare const PactTypeIdentifier: () => R;
 export declare const PatronCategoryIdentifier: () => R;
 export declare const PatronIdentifier: () => R;
 export declare const PersonalityTraitIdentifier: () => R;
+export declare const PlantIdentifier: () => R;
 export declare const PlayerTypeIdentifier: () => R;
 export declare const PoisonIdentifier: () => R;
 export declare const ProfessionIdentifier: () => R;

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>;