optolith-database-schema 0.17.2 → 0.18.1

package/lib/types/_AlternativeNames.d.ts

@@ -1,11 +1,5 @@
-import { NonEmptyString } from "./_NonEmptyString.js";
-export type AlternativeName = {
-    /**
-     * An alternative name of the disease.
-     */
-    name: NonEmptyString;
-    /**
-     * The region where this alternative name is used.
-     */
-    region?: NonEmptyString;
-};
+import { Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const AlternativeName: TypeAlias<"AlternativeName", Object<{
+    name: import("tsondb/schema/def").MemberDecl<String, true>;
+    region: import("tsondb/schema/def").MemberDecl<String, false>;
+}>, []>;

package/lib/types/_AlternativeNames.js

@@ -1 +1,14 @@
-export {};
+import { Object, Optional, Required, String, TypeAlias } from "tsondb/schema/def";
+export const AlternativeName = TypeAlias(import.meta.url, {
+    name: "AlternativeName",
+    type: () => Object({
+        name: Required({
+            comment: "An alternative name of the disease.",
+            type: String({ minLength: 1 }),
+        }),
+        region: Optional({
+            comment: "The region where this alternative name is used.",
+            type: String({ minLength: 1 }),
+        }),
+    }),
+});

package/lib/types/_ArcaneTradition.d.ts

@@ -1,28 +1,30 @@
-/**
- * @main ArcaneTradition
- */
-import { LocaleMap } from "./_LocaleMap.js";
-import { NonEmptyString } from "./_NonEmptyString.js";
-import { ArcaneTraditionPrerequisites } from "./_Prerequisite.js";
-/**
- * @title Arcane Tradition
- */
-export type ArcaneTradition = {
-    /**
-     * The arcane tradition's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    prerequisites: ArcaneTraditionPrerequisites;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<ArcaneTraditionTranslation>;
-};
-export type ArcaneTraditionTranslation = {
-    /**
-     * The arcane tradition's name.
-     */
-    name: NonEmptyString;
-};
+import { IncludeIdentifier, Object, String } from "tsondb/schema/def";
+export declare const ArcaneTraditionType: <TN extends string>(translationName: TN) => () => Object<{
+    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ArcaneTraditionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PlainPrerequisites", import("tsondb/schema/def").ArrayType<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"PrerequisitesElement", {
+        Single: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
+        Disjunction: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PrerequisitesDisjunction", Object<{
+            list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+            display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
+                Hide: import("tsondb/schema/def").EnumCaseDecl<null>;
+                ReplaceWith: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ReplacementDisplayOption", Object<{
+                    sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
+                        Standalone: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Connected: import("tsondb/schema/def").EnumCaseDecl<null>;
+                    }, []>>, false>;
+                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
+                        replacement: import("tsondb/schema/def").MemberDecl<String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+        Group: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PrerequisiteGroup", Object<{
+            list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
+                text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, true>;
+        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
+    }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<TN, {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}>;

package/lib/types/_ArcaneTradition.js

@@ -1,4 +1,14 @@
-/**
- * @main ArcaneTradition
- */
-export {};
+import { IncludeIdentifier, Object, Required, String } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+import { ArcaneTraditionPrerequisites } from "./_Prerequisite.js";
+export const ArcaneTraditionType = (translationName) => () => Object({
+    prerequisites: Required({
+        type: IncludeIdentifier(ArcaneTraditionPrerequisites),
+    }),
+    translations: NestedLocaleMap(Required, translationName, Object({
+        name: Required({
+            comment: "The arcane tradition’s name.",
+            type: String({ minLength: 1 }),
+        }),
+    })),
+});

package/lib/types/_Blessed.d.ts

@@ -1,22 +1,8 @@
-import { AspectReference, BlessedTraditionReference } from "./_SimpleReferences.js";
-export type SkillTradition = {
-    tag: "GeneralAspect";
-    general_aspect: AspectReference;
-} | {
-    tag: "Tradition";
-    tradition: SkillTraditionWithAspects;
-};
-export type SkillTraditionWithAspects = {
-    /**
-     * The blessed tradition.
-     */
-    tradition: BlessedTraditionReference;
-    /**
-     * The aspect(s) from the tradition the ceremony belongs to. Note that not
-     * all traditions have aspects. Traditions with aspects must have at least one
-     * aspect specified.
-     * @minItems 1
-     * @maxItems 2
-     */
-    aspects?: AspectReference[];
-};
+import { Array, Enum, EnumCase, IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
+export declare const LiturgyTradition: Enum<"LiturgyTradition", {
+    GeneralAspect: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    Tradition: EnumCase<IncludeIdentifier<[], TypeAlias<"LiturgyTraditionWithAspects", Object<{
+        tradition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        aspects: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, false>;
+    }>, []>>>;
+}, []>;

package/lib/types/_Blessed.js

@@ -1 +1,22 @@
-export {};
+import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import { AspectIdentifier, BlessedTraditionIdentifier } from "./_Identifier.js";
+export const LiturgyTradition = Enum(import.meta.url, {
+    name: "LiturgyTradition",
+    values: () => ({
+        GeneralAspect: EnumCase({ type: AspectIdentifier() }),
+        Tradition: EnumCase({ type: IncludeIdentifier(LiturgyTraditionWithAspects) }),
+    }),
+});
+const LiturgyTraditionWithAspects = TypeAlias(import.meta.url, {
+    name: "LiturgyTraditionWithAspects",
+    type: () => Object({
+        tradition: Required({
+            comment: "The blessed tradition.",
+            type: BlessedTraditionIdentifier(),
+        }),
+        aspects: Optional({
+            comment: "The aspect(s) from the tradition the ceremony belongs to. Note that not all traditions have aspects. Traditions with aspects must have at least one aspect specified.",
+            type: Array(AspectIdentifier(), { minItems: 1, maxItems: 2 }),
+        }),
+    }),
+});

package/lib/types/_CommonnessRatedAdvantageDisadvantage.d.ts

@@ -1,10 +1,4 @@
-/**
- * Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.
- * @title Commonness-rated Advantage/Disadvantage
- */
-export type CommonnessRatedAdvantageDisadvantage<Identifier> = {
-    /**
-     * The advantage's or disadvantage's identifier.
-     */
-    id: Identifier;
-};
+import { Object, TypeArgument } from "tsondb/schema/def";
+export declare const CommonnessRatedAdvantageDisadvantage: import("tsondb/schema/def").TypeAliasDecl<"CommonnessRatedAdvantageDisadvantage", Object<{
+    id: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>>, true>;
+}>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>;

package/lib/types/_CommonnessRatedAdvantageDisadvantage.js

@@ -1 +1,12 @@
-export {};
+import { GenTypeAlias, Object, Param, Required, TypeArgument } from "tsondb/schema/def";
+export const CommonnessRatedAdvantageDisadvantage = GenTypeAlias(import.meta.url, {
+    name: "CommonnessRatedAdvantageDisadvantage",
+    comment: "Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.",
+    parameters: [Param("Identifier")],
+    type: Identifier => Object({
+        id: Required({
+            comment: "The advantage's or disadvantage's identifier.",
+            type: TypeArgument(Identifier),
+        }),
+    }),
+});

package/lib/types/_Dice.d.ts

@@ -1,19 +1,6 @@
-/**
- * @title Dice
- */
-export type Dice = {
-    /**
-     * Number of dice of the same type. Example: 2 in 2D6.
-     * @integer
-     * @minimum 1
-     */
-    number: number;
-    /**
-     * Number of sides on every die. Example: 6 in 2D6.
-     */
-    sides: DieType;
-};
-/**
- * Number of sides on every dice. Example: 6 in 2D6.
- */
-export type DieType = 3 | 6 | 20;
+import { IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
+export declare const Dice: TypeAlias<"Dice", Object<{
+    number: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", Integer, []>>, true>;
+}>, []>;
+export declare const DieType: TypeAlias<"DieType", Integer, []>;

package/lib/types/_Dice.js

@@ -1 +1,23 @@
-export {};
+import { IncludeIdentifier, Integer, Object, Required, TypeAlias } from "tsondb/schema/def";
+export const Dice = TypeAlias(import.meta.url, {
+    name: "Dice",
+    type: () => Object({
+        number: Required({
+            comment: "Number of dice of the same type. Example: 2 in 2D6.",
+            type: Integer({
+                minimum: 1,
+            }),
+        }),
+        sides: Required({
+            comment: "Number of sides on every die. Example: 6 in 2D6.",
+            type: IncludeIdentifier(DieType),
+        }),
+    }),
+});
+export const DieType = TypeAlias(import.meta.url, {
+    name: "DieType",
+    comment: "Number of sides on every die. Example: 6 in 2D6.",
+    type: () => Integer({
+        minimum: 2,
+    }),
+});

package/lib/types/_DiseasePoison.d.ts

@@ -1,110 +1,59 @@
 /**
  * This file defines some shared types for different diseases and poisons.
- * @title Disease (shared)
  */
-import { AlternativeName } from "./_AlternativeNames.js";
-import { LocaleMap } from "./_LocaleMap.js";
-import { NonEmptyMarkdown, NonEmptyString } from "./_NonEmptyString.js";
-import { Errata } from "./source/_Erratum.js";
-/**
- * Depending on the disease, apply Spirit or Toughness as a penalty to the
- * disease roll. It may also happen that the lower of both is applied as a
- * penalty.
- */
-export type Resistance = "Spirit" | "Toughness" | "LowerOfSpiritAndToughness";
-/**
- * What causes the disease? The GM rolls 1D20 to see if a character gets
- * infected. If the infection check succeeds, the GM makes a disease check to
- * determine the severity of the infection.
- */
-export type Cause = {
-    /**
-     * The chance to get infected by this cause, in percent.
-     * @integer
-     * @minimum 5
-     * @multipleOf 5
-     * @maximum 100
-     */
-    chance?: number;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<CauseTranslation>;
-};
-export type CauseTranslation = {
-    /**
-     * The name of the cause.
-     * @minLength 1
-     */
-    name: string;
-    /**
-     * The chance to get infected by this cause. If present for this
-     * language, this overrides the universal `chance` field; they cannot be
-     * used at the same time.
-     */
-    chance?: NonEmptyString;
-    /**
-     * An additional note about this cause.
-     */
-    note?: NonEmptyString;
-};
-export type DiseaseTranslation = {
-    /**
-     * The name of the disease.
-     */
-    name: NonEmptyString;
-    /**
-     * A list of alternative names.
-     * @minItems 1
-     */
-    alternative_names?: AlternativeName[];
-    /**
-     * The disease’s progress, in detail.
-     */
-    progress: NonEmptyMarkdown;
-    /**
-     * After infection, how much time passes before symptoms appear?
-     */
-    incubation_time: NonEmptyString;
-    /**
-     * The damage caused by the disease. If the disease check fails, apply the
-     * lessened effects.
-     */
-    damage: Reduceable;
-    /**
-     * The duration of the disease. If the disease check fails, use the
-     * lessened duration.
-     */
-    duration: Reduceable;
-    /**
-     * Special information about the disease.
-     */
-    special?: NonEmptyMarkdown;
-    /**
-     * Methods known to lessen the disease’s progress or relieve symptoms.
-     */
-    treatment: NonEmptyMarkdown;
-    /**
-     * Known remedies for the disease.
-     */
-    cure: NonEmptyMarkdown;
-    errata?: Errata;
-};
-/**
- * An effect or other parameter that may be reduced by a failed disease check
- * for lessening or a degraded poison.
- *
- * This streamlines the wording for diseases and poison by using a unified
- * wording for *lessened* (disease) and *degraded* (poison).
- */
-export type Reduceable<Content = NonEmptyMarkdown> = {
-    /**
-     * The default value. In the source, it's the text before the slash.
-     */
-    default: Content;
-    /**
-     * The reduced value. In the source, it's the text after the slash. Some
-     * entries may not have a reduced value.
-     */
-    reduced?: Content;
-};
+import { Array, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias, TypeArgument } from "tsondb/schema/def";
+export declare const level: import("tsondb/schema/def").MemberDecl<Integer, true>;
+export declare const Resistance: Enum<"Resistance", {
+    Spirit: EnumCase<null>;
+    Toughness: EnumCase<null>;
+    LowerOfSpiritAndToughness: EnumCase<null>;
+}, []>;
+export declare const resistance: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Resistance", {
+    Spirit: EnumCase<null>;
+    Toughness: EnumCase<null>;
+    LowerOfSpiritAndToughness: EnumCase<null>;
+}, []>>, true>;
+export declare const Cause: TypeAlias<"Cause", Object<{
+    chance: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CauseTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        chance: import("tsondb/schema/def").MemberDecl<String, false>;
+        note: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, true>;
+}>, []>;
+export declare const cause: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"Cause", Object<{
+    chance: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CauseTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        chance: import("tsondb/schema/def").MemberDecl<String, false>;
+        note: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, true>;
+}>, []>>>, true>;
+export declare const Reduceable: TypeAlias<"Reduceable", Object<{
+    default: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, true>;
+    reduced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, false>;
+}>, [Content: import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>]>;
+export declare const DiseaseTranslation: Object<{
+    name: import("tsondb/schema/def").MemberDecl<String, true>;
+    alternative_names: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"AlternativeName", Object<{
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        region: import("tsondb/schema/def").MemberDecl<String, false>;
+    }>, []>>>, false>;
+    progress: import("tsondb/schema/def").MemberDecl<String, true>;
+    incubation_time: import("tsondb/schema/def").MemberDecl<String, true>;
+    damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"Reduceable", Object<{
+        default: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, true>;
+        reduced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, false>;
+    }>, [Content: import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>]>>, true>;
+    duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"Reduceable", Object<{
+        default: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, true>;
+        reduced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, false>;
+    }>, [Content: import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>]>>, true>;
+    special: import("tsondb/schema/def").MemberDecl<String, false>;
+    treatment: import("tsondb/schema/def").MemberDecl<String, true>;
+    cure: import("tsondb/schema/def").MemberDecl<String, true>;
+    errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+        date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+        description: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, []>>>, []>>, false>;
+}>;

package/lib/types/_DiseasePoison.js

@@ -1,5 +1,110 @@
 /**
  * This file defines some shared types for different diseases and poisons.
- * @title Disease (shared)
  */
-export {};
+import { Array, Enum, EnumCase, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+import { AlternativeName } from "./_AlternativeNames.js";
+import { Errata } from "./source/_Erratum.js";
+export const level = Required({
+    comment: "The disease’s level.",
+    type: Integer({ minimum: 1 }),
+});
+export const Resistance = Enum(import.meta.url, {
+    name: "Resistance",
+    comment: "Depending on the disease, apply Spirit or Toughness as a penalty to the disease roll. It may also happen that the lower of both is applied as a penalty.",
+    values: () => ({
+        Spirit: EnumCase({ type: null }),
+        Toughness: EnumCase({ type: null }),
+        LowerOfSpiritAndToughness: EnumCase({ type: null }),
+    }),
+});
+export const resistance = Required({
+    comment: "Depending on the disease, apply Spirit or Toughness as a penalty to the disease roll. It may also happen that the lower of both is applied as a penalty.",
+    type: IncludeIdentifier(Resistance),
+});
+export const Cause = TypeAlias(import.meta.url, {
+    name: "Cause",
+    comment: "What causes the disease? The GM rolls 1D20 to see if a character gets infected. If the infection check succeeds, the GM makes a disease check to determine the severity of the infection.",
+    type: () => Object({
+        chance: Required({
+            comment: "The chance to get infected by this cause, in percent.",
+            type: Integer({ minimum: 5, multipleOf: 5, maximum: 100 }),
+        }),
+        translations: NestedLocaleMap(Required, "CauseTranslation", Object({
+            name: Required({
+                comment: "The cause’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            chance: Optional({
+                comment: "The chance to get infected by this cause. If present for this language, this overrides the universal `chance` field; they cannot be used at the same time.",
+                type: String({ minLength: 1 }),
+            }),
+            note: Optional({
+                comment: "An additional note about this cause.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+export const cause = Required({
+    comment: "What causes the disease? The GM rolls 1D20 to see if a character gets infected. If the infection check succeeds, the GM makes a disease check to determine the severity of the infection.",
+    type: Array(IncludeIdentifier(Cause), { minItems: 1 }),
+});
+export const Reduceable = GenTypeAlias(import.meta.url, {
+    name: "Reduceable",
+    comment: `An effect or other parameter that may be reduced by a failed disease check for lessening or a degraded poison.
+
+This streamlines the wording for diseases and poison by using a unified wording for *lessened* (disease) and *degraded* (poison).`,
+    parameters: [Param("Content")],
+    type: Content => Object({
+        default: Required({
+            comment: "The default value. In the source, it's the text before the slash.",
+            type: TypeArgument(Content),
+        }),
+        reduced: Optional({
+            comment: "The reduced value. In the source, it's the text after the slash. Some entries may not have a reduced value.",
+            type: TypeArgument(Content),
+        }),
+    }),
+});
+export const DiseaseTranslation = Object({
+    name: Required({
+        comment: "The disease’s name.",
+        type: String({ minLength: 1 }),
+    }),
+    alternative_names: Optional({
+        comment: "A list of alternative names.",
+        type: Array(IncludeIdentifier(AlternativeName), { minItems: 1 }),
+    }),
+    progress: Required({
+        comment: "The disease’s progress, in detail.",
+        type: String({ minLength: 1, isMarkdown: true }),
+    }),
+    incubation_time: Required({
+        comment: "After infection, how much time passes before symptoms appear?",
+        type: String({ minLength: 1 }),
+    }),
+    damage: Required({
+        comment: "The damage caused by the disease. If the disease check fails, apply the lessened effects.",
+        type: GenIncludeIdentifier(Reduceable, [String({ minLength: 1, isMarkdown: true })]),
+    }),
+    duration: Required({
+        comment: "The duration of the disease. If the disease check fails, use the lessened duration.",
+        type: GenIncludeIdentifier(Reduceable, [String({ minLength: 1, isMarkdown: true })]),
+    }),
+    special: Optional({
+        comment: "Special information about the disease.",
+        type: String({ minLength: 1, isMarkdown: true }),
+    }),
+    treatment: Required({
+        comment: "Methods known to lessen the disease’s progress or relieve symptoms.",
+        type: String({ minLength: 1, isMarkdown: true }),
+    }),
+    cure: Required({
+        comment: "Known remedies for the disease.",
+        type: String({ minLength: 1, isMarkdown: true }),
+    }),
+    errata: Optional({
+        type: IncludeIdentifier(Errata),
+    }),
+});