@optolith/database-schema 0.42.1

package/lib/types/_ArcaneTradition.d.ts

@@ -0,0 +1,30 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ArcaneTraditionType: <TN extends string>(translationName: TN) => () => DB.Object<{
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneTraditionPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<`${TN}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}>;

package/lib/types/_ArcaneTradition.js

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

package/lib/types/_Blessed.d.ts

@@ -0,0 +1,8 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const LiturgyTradition: DB.Enum<"LiturgyTradition", {
+    GeneralAspect: DB.EnumCase<DB.ReferenceIdentifier>;
+    Tradition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgyTraditionWithAspects", DB.Object<{
+        tradition: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        aspects: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    }>, []>>>;
+}, []>;

package/lib/types/_Blessed.js

@@ -0,0 +1,22 @@
+import * as DB from "tsondb/schema/dsl";
+import { AspectIdentifier, BlessedTraditionIdentifier } from "./_Identifier.js";
+export const LiturgyTradition = DB.Enum(import.meta.url, {
+    name: "LiturgyTradition",
+    values: () => ({
+        GeneralAspect: DB.EnumCase({ type: AspectIdentifier() }),
+        Tradition: DB.EnumCase({ type: DB.IncludeIdentifier(LiturgyTraditionWithAspects) }),
+    }),
+});
+const LiturgyTraditionWithAspects = DB.TypeAlias(import.meta.url, {
+    name: "LiturgyTraditionWithAspects",
+    type: () => DB.Object({
+        tradition: DB.Required({
+            comment: "The blessed tradition.",
+            type: BlessedTraditionIdentifier(),
+        }),
+        aspects: DB.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: DB.Array(AspectIdentifier(), { minItems: 1, maxItems: 2 }),
+        }),
+    }),
+});

package/lib/types/_Color.d.ts

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AttributeColor: DB.Enum<"AttributeColor", {
+    Black: DB.EnumCase<null>;
+    Blue: DB.EnumCase<null>;
+    Green: DB.EnumCase<null>;
+    Orange: DB.EnumCase<null>;
+    Purple: DB.EnumCase<null>;
+    Red: DB.EnumCase<null>;
+    White: DB.EnumCase<null>;
+    Yellow: DB.EnumCase<null>;
+}, []>;
+export declare const GradientColor: DB.Enum<"GradientColor", {
+    Gaia: DB.EnumCase<null>;
+    LightHarvestGold: DB.EnumCase<null>;
+    OldRed: DB.EnumCase<null>;
+    SanMarino: DB.EnumCase<null>;
+    TribalTeal: DB.EnumCase<null>;
+    Verdigris: DB.EnumCase<null>;
+}, []>;

package/lib/types/_Color.js

@@ -0,0 +1,27 @@
+import * as DB from "tsondb/schema/dsl";
+export const AttributeColor = DB.Enum(import.meta.url, {
+    name: "AttributeColor",
+    comment: "A display color for an attribute.",
+    values: () => ({
+        Black: DB.EnumCase({ type: null }),
+        Blue: DB.EnumCase({ type: null }),
+        Green: DB.EnumCase({ type: null }),
+        Orange: DB.EnumCase({ type: null }),
+        Purple: DB.EnumCase({ type: null }),
+        Red: DB.EnumCase({ type: null }),
+        White: DB.EnumCase({ type: null }),
+        Yellow: DB.EnumCase({ type: null }),
+    }),
+});
+export const GradientColor = DB.Enum(import.meta.url, {
+    name: "GradientColor",
+    comment: "A display color for entries that have a certain color as a gradient in the header of their box in the official publications.",
+    values: () => ({
+        Gaia: DB.EnumCase({ type: null }), // HEX #62934b / CMYK 64 17 82 13
+        LightHarvestGold: DB.EnumCase({ type: null }), // HEX #dbb578 / CMYK 9 26 56 9
+        OldRed: DB.EnumCase({ type: null }), // HEX #8c3537 / CMYK 51 91 81 6
+        SanMarino: DB.EnumCase({ type: null }), // HEX #4f70a8 / CMYK 75 53 10 2
+        TribalTeal: DB.EnumCase({ type: null }), // HEX #507471 / CMYK 55 13 33 48
+        Verdigris: DB.EnumCase({ type: null }), // HEX #5b6235 / CMYK 70 53 91 17
+    }),
+});

package/lib/types/_CommonnessRatedAdvantageDisadvantage.d.ts

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CommonnessRatedAdvantageDisadvantage: DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+    id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+        options: DB.MemberDecl<DB.String, true>;
+    }>, false>;
+}>, [Identifier: DB.Param<"Identifier", DB.Type>]>;

package/lib/types/_CommonnessRatedAdvantageDisadvantage.js

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+export const CommonnessRatedAdvantageDisadvantage = DB.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: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        id: DB.Required({
+            comment: "The advantage's or disadvantage's identifier.",
+            type: DB.TypeArgument(Identifier),
+        }),
+        translations: NestedTranslationMap(DB.Optional, "CommonnessRatedAdvantageDisadvantage", DB.Object({
+            options: DB.Required({
+                comment: "The options the commonness rating applies to.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});

package/lib/types/_Dice.d.ts

@@ -0,0 +1,6 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Dice: DB.TypeAlias<"Dice", DB.Object<{
+    number: DB.MemberDecl<DB.Integer, true>;
+    sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
+}>, []>;
+export declare const DieType: DB.TypeAlias<"DieType", DB.Integer, []>;

package/lib/types/_Dice.js

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

package/lib/types/_DiseasePoison.d.ts

@@ -0,0 +1,59 @@
+/**
+ * This file defines some shared types for different diseases and poisons.
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const level: DB.MemberDecl<DB.Integer, true>;
+export declare const Resistance: DB.Enum<"Resistance", {
+    Spirit: DB.EnumCase<null>;
+    Toughness: DB.EnumCase<null>;
+    LowerOfSpiritAndToughness: DB.EnumCase<null>;
+}, []>;
+export declare const resistance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Resistance", {
+    Spirit: DB.EnumCase<null>;
+    Toughness: DB.EnumCase<null>;
+    LowerOfSpiritAndToughness: DB.EnumCase<null>;
+}, []>>, true>;
+export declare const Cause: DB.TypeAlias<"Cause", DB.Object<{
+    chance: DB.MemberDecl<DB.Integer, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CauseTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        chance: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+    }>, true>;
+}>, []>;
+export declare const cause: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Cause", DB.Object<{
+    chance: DB.MemberDecl<DB.Integer, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CauseTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        chance: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+    }>, true>;
+}>, []>>>, true>;
+export declare const Reduceable: DB.TypeAlias<"Reduceable", DB.Object<{
+    default: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, true>;
+    reduced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, false>;
+}>, [Content: DB.Param<"Content", DB.Type>]>;
+export declare const DiseaseTranslation: DB.Object<{
+    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>;
+    }>, []>>>, false>;
+    progress: DB.MemberDecl<DB.String, true>;
+    incubation_time: DB.MemberDecl<DB.String, true>;
+    damage: 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>;
+        reduced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, false>;
+    }>, [Content: DB.Param<"Content", DB.Type>]>>, true>;
+    duration: 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>;
+        reduced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, false>;
+    }>, [Content: DB.Param<"Content", DB.Type>]>>, true>;
+    special: DB.MemberDecl<DB.String, false>;
+    treatment: DB.MemberDecl<DB.String, true>;
+    cure: DB.MemberDecl<DB.String, true>;
+    errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+        date: DB.MemberDecl<DB.Date, true>;
+        description: DB.MemberDecl<DB.String, true>;
+    }>, []>>>, []>>, false>;
+}>;

package/lib/types/_DiseasePoison.js

@@ -0,0 +1,110 @@
+/**
+ * This file defines some shared types for different diseases and poisons.
+ */
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { AlternativeName } from "./_AlternativeNames.js";
+import { Errata } from "./source/_Erratum.js";
+export const level = DB.Required({
+    comment: "The disease’s level.",
+    type: DB.Integer({ minimum: 1 }),
+});
+export const Resistance = DB.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: DB.EnumCase({ type: null }),
+        Toughness: DB.EnumCase({ type: null }),
+        LowerOfSpiritAndToughness: DB.EnumCase({ type: null }),
+    }),
+});
+export const resistance = DB.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: DB.IncludeIdentifier(Resistance),
+});
+export const Cause = DB.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: () => DB.Object({
+        chance: DB.Optional({
+            comment: "The chance to get infected by this cause, in percent. Some causes do not have a specific chance.",
+            type: DB.Integer({ minimum: 5, multipleOf: 5, maximum: 100 }),
+        }),
+        translations: NestedTranslationMap(DB.Required, "Cause", DB.Object({
+            name: DB.Required({
+                comment: "The cause’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            chance: DB.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: DB.String({ minLength: 1 }),
+            }),
+            note: DB.Optional({
+                comment: "An additional note about this cause.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});
+export const cause = DB.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: DB.Array(DB.IncludeIdentifier(Cause), { minItems: 1 }),
+});
+export const Reduceable = DB.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: [DB.Param("Content")],
+    type: Content => DB.Object({
+        default: DB.Required({
+            comment: "The default value. In the source, it's the text before the slash.",
+            type: DB.TypeArgument(Content),
+        }),
+        reduced: DB.Optional({
+            comment: "The reduced value. In the source, it's the text after the slash. Some entries may not have a reduced value, i.e. there is no slash with text after it. If the text after the slash is a dash, include it here as well.",
+            type: DB.TypeArgument(Content),
+        }),
+    }),
+});
+export const DiseaseTranslation = DB.Object({
+    name: DB.Required({
+        comment: "The disease’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 }),
+    }),
+    progress: DB.Required({
+        comment: "The disease’s progress, in detail.",
+        type: DB.String({ minLength: 1, markdown: "block" }),
+    }),
+    incubation_time: DB.Required({
+        comment: "After infection, how much time passes before symptoms appear?",
+        type: DB.String({ minLength: 1 }),
+    }),
+    damage: DB.Required({
+        comment: "The damage caused by the disease. If the disease check fails, apply the lessened effects.",
+        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, markdown: "block" })]),
+    }),
+    duration: DB.Required({
+        comment: "The duration of the disease. If the disease check fails, use the lessened duration.",
+        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, markdown: "block" })]),
+    }),
+    special: DB.Optional({
+        comment: "Special information about the disease.",
+        type: DB.String({ minLength: 1, markdown: "block" }),
+    }),
+    treatment: DB.Required({
+        comment: "Methods known to lessen the disease’s progress or relieve symptoms.",
+        type: DB.String({ minLength: 1, markdown: "block" }),
+    }),
+    cure: DB.Required({
+        comment: "Known remedies for the disease.",
+        type: DB.String({ minLength: 1, markdown: "block" }),
+    }),
+    errata: DB.Optional({
+        type: DB.IncludeIdentifier(Errata),
+    }),
+});

package/lib/types/_Enhancements.d.ts

@@ -0,0 +1,170 @@
+/**
+ * @title Enhancements
+ */
+import * as DB from "tsondb/schema/dsl";
+export declare const Enhancements: DB.TypeAlias<"Enhancements", DB.ChildEntities<DB.Entity<"Enhancement", {
+    parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillWithEnhancementsIdentifier", {
+        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    skill_rating: DB.MemberDecl<DB.Integer, true>;
+    adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, 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>;
+    }>, []>>>, []>>, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        effect: DB.MemberDecl<DB.String, true>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, "parent">>, []>;
+export declare const Enhancement: DB.Entity<"Enhancement", {
+    parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillWithEnhancementsIdentifier", {
+        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+        LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>, true>;
+    skill_rating: DB.MemberDecl<DB.Integer, true>;
+    adventure_points_modifier: DB.MemberDecl<DB.Integer, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"EnhancementPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
+                    }, []>>, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
+                    }>, true>;
+                }>, []>>>;
+            }, []>>, false>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, 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>;
+    }>, []>>>, []>>, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"EnhancementTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        effect: DB.MemberDecl<DB.String, true>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, "parent">;

package/lib/types/_Enhancements.js

@@ -0,0 +1,80 @@
+/**
+ * @title Enhancements
+ */
+import * as DB from "tsondb/schema/dsl";
+import { SkillWithEnhancementsIdentifier } from "./_IdentifierGroup.js";
+import { EnhancementPrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { PublicationRefs } from "./source/_PublicationRef.js";
+export const Enhancements = DB.TypeAlias(import.meta.url, {
+    name: "Enhancements",
+    comment: "A list of enhancements.",
+    type: () => DB.ChildEntities(Enhancement),
+});
+export const Enhancement = DB.Entity(import.meta.url, {
+    name: "Enhancement",
+    namePlural: "Enhancements",
+    type: () => DB.Object({
+        parent: DB.Required({
+            comment: "The spellwork or liturgy this enhancement belongs to",
+            type: DB.IncludeIdentifier(SkillWithEnhancementsIdentifier),
+        }),
+        skill_rating: DB.Required({
+            comment: "The skill rating required to learn this enhancement.",
+            type: DB.Integer({
+                minimum: 8,
+                maximum: 16,
+                multipleOf: 2,
+            }),
+        }),
+        adventure_points_modifier: DB.Required({
+            comment: "The value to multiply with the numeric representation of the associated skill's improvement cost to form the final AP cost of this enhancement.",
+            type: DB.Integer({
+                minimum: 1,
+            }),
+        }),
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(EnhancementPrerequisites),
+        }),
+        src: DB.Optional({
+            comment: "Only defined if different than the associated skill.",
+            type: DB.IncludeIdentifier(PublicationRefs),
+        }),
+        translations: NestedTranslationMap(DB.Required, "Enhancement", DB.Object({
+            name: DB.Required({
+                comment: "The name of the enhancement.",
+                type: DB.String({
+                    minLength: 1,
+                }),
+            }),
+            effect: DB.Required({
+                comment: "The effect description.",
+                type: DB.String({
+                    minLength: 1,
+                    markdown: "block",
+                }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    instanceDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: `${getDisplayNameForInstanceId(instance.parent)?.name ?? ""} — ${instanceDisplayName}`,
+        localeId: instanceDisplayNameLocaleId,
+    }),
+    uniqueConstraints: [
+        [
+            {
+                keyPath: "parent",
+            },
+            {
+                entityMapKeyPath: "translations",
+                keyPathInEntityMap: "name",
+            },
+        ],
+    ],
+});