@optolith/database-schema 0.42.1

package/lib/types/Advantage.js

@@ -0,0 +1,58 @@
+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 { explicit_select_options, select_options } from "./_ActivatableSelectOptions.js";
+import { skill_applications, skill_uses } from "./_ActivatableSkillApplicationsAndUses.js";
+import { AdvantageDisadvantagePrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Advantage = DB.Entity(import.meta.url, {
+    name: "Advantage",
+    namePlural: "Advantages",
+    type: () => DB.Object({
+        levels,
+        nameBuilderRules,
+        select_options,
+        explicit_select_options,
+        skill_applications,
+        skill_uses,
+        maximum,
+        automatic_entries,
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(AdvantageDisadvantagePrerequisites),
+        }),
+        ap_value,
+        has_maximum_spent_influence: DB.Required({
+            comment: "Does this advantage count towards the maximum of AP to be spent on advantages?",
+            type: DB.Boolean(),
+        }),
+        is_exclusive_to_arcane_spellworks: DB.Required({
+            comment: "Does this advantage exclusively applies to arcane spellworks and not to magical actions and magical applications?",
+            type: DB.Boolean(),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Advantage", DB.Object({
+            name,
+            name_in_library,
+            input,
+            rules,
+            range: range_l10n,
+            ap_value_append,
+            ap_value: ap_value_l10n,
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name_in_library",
+            keyPathInEntityMapFallback: "name",
+        },
+    ],
+});

package/lib/types/AnimalDisease.d.ts

@@ -0,0 +1,91 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AnimalDisease: DB.Entity<"AnimalDisease", {
+    level: DB.MemberDecl<DB.Integer, true>;
+    resistance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Resistance", {
+        Spirit: DB.EnumCase<null>;
+        Toughness: DB.EnumCase<null>;
+        LowerOfSpiritAndToughness: DB.EnumCase<null>;
+    }, []>>, true>;
+    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>;
+    animal_types: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    communicability_to_intelligent_creatures: 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>;
+    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<"AnimalDiseaseTranslation", {
+        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>;
+    }>, true>;
+}, undefined>;

package/lib/types/AnimalDisease.js

@@ -0,0 +1,35 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { cause, Cause, DiseaseTranslation, level, resistance } from "./_DiseasePoison.js";
+import { AnimalTypeIdentifier } from "./_Identifier.js";
+import { src } from "./source/_PublicationRef.js";
+export const AnimalDisease = DB.Entity(import.meta.url, {
+    name: "AnimalDisease",
+    namePlural: "AnimalDiseases",
+    type: () => DB.Object({
+        level,
+        resistance,
+        cause,
+        animal_types: DB.Required({
+            comment: `The animal types this disease applies to.
+
+If no animal types are given, the animal disease applies to all animal types.`,
+            type: DB.Array(AnimalTypeIdentifier()),
+        }),
+        communicability_to_intelligent_creatures: DB.Required({
+            comment: `If and at which chance the disease can be communicated to intelligent creatures.
+
+If no causes are given, the disease is not communicable to intelligent creatures.`,
+            type: DB.Array(DB.IncludeIdentifier(Cause)),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "AnimalDisease", DiseaseTranslation),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/AnimalType.d.ts

@@ -0,0 +1,6 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AnimalType: DB.Entity<"AnimalType", {
+    translations: DB.MemberDecl<DB.NestedEntityMap<"AnimalTypeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/AnimalType.js

@@ -0,0 +1,21 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+export const AnimalType = DB.Entity(import.meta.url, {
+    name: "AnimalType",
+    namePlural: "AnimalTypes",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "AnimalType", DB.Object({
+            name: DB.Required({
+                comment: "The animal type’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/ArcaneBardTradition.d.ts

@@ -0,0 +1,30 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ArcaneBardTradition: DB.Entity<"ArcaneBardTradition", {
+    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<"ArcaneBardTraditionTranslationTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/ArcaneBardTradition.js

@@ -0,0 +1,14 @@
+import * as DB from "tsondb/schema/dsl";
+import { ArcaneTraditionType } from "./_ArcaneTradition.js";
+export const ArcaneBardTradition = DB.Entity(import.meta.url, {
+    name: "ArcaneBardTradition",
+    namePlural: "ArcaneBardTraditions",
+    type: ArcaneTraditionType("ArcaneBardTraditionTranslation"),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/ArcaneDancerTradition.d.ts

@@ -0,0 +1,30 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const ArcaneDancerTradition: DB.Entity<"ArcaneDancerTradition", {
+    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<"ArcaneDancerTraditionTranslationTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/ArcaneDancerTradition.js

@@ -0,0 +1,14 @@
+import * as DB from "tsondb/schema/dsl";
+import { ArcaneTraditionType } from "./_ArcaneTradition.js";
+export const ArcaneDancerTradition = DB.Entity(import.meta.url, {
+    name: "ArcaneDancerTradition",
+    namePlural: "ArcaneDancerTraditions",
+    type: ArcaneTraditionType("ArcaneDancerTraditionTranslation"),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/Aspect.d.ts

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Aspect: DB.Entity<"Aspect", {
+    translations: DB.MemberDecl<DB.NestedEntityMap<"AspectTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        master_of_aspect_suffix: DB.MemberDecl<DB.String, false>;
+    }>, true>;
+}, undefined>;

package/lib/types/Aspect.js

@@ -0,0 +1,27 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+export const Aspect = DB.Entity(import.meta.url, {
+    name: "Aspect",
+    namePlural: "Aspects",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "Aspect", DB.Object({
+            name: DB.Required({
+                comment: "The aspect’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            master_of_aspect_suffix: DB.Optional({
+                comment: "In some languages, the aspect’s grammatical gender influences the full name of a *Master of (Aspect)* instance. To make this possible, the *name* (**not** the *name in library*) is joined with what is contained in this field.",
+                type: DB.String({
+                    minLength: 1,
+                }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/Attribute.d.ts

@@ -0,0 +1,19 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Attribute: DB.Entity<"Attribute", {
+    position: DB.MemberDecl<DB.Integer, true>;
+    color: DB.MemberDecl<DB.IncludeIdentifier<[], 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>;
+    }, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"AttributeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        abbreviation: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/Attribute.js

@@ -0,0 +1,49 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { AttributeColor } from "./_Color.js";
+export const Attribute = DB.Entity(import.meta.url, {
+    name: "Attribute",
+    namePlural: "Attributes",
+    comment: "A base attribute of a character.",
+    type: () => DB.Object({
+        position: DB.Required({
+            comment: "The position of the attribute in lists. This has to be a unique value.",
+            type: DB.Integer({ minimum: 0 }),
+        }),
+        color: DB.Required({
+            comment: "The display color of the attribute.",
+            type: DB.IncludeIdentifier(AttributeColor),
+        }),
+        translations: NestedTranslationMap(DB.Required, "Attribute", DB.Object({
+            name: DB.Required({
+                comment: "The attribute’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            abbreviation: DB.Required({
+                comment: "The abbreviation of the attribute’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The description of the attribute.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    sortOrder: {
+        keyPath: "position",
+    },
+    uniqueConstraints: [
+        {
+            keyPath: "position",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "abbreviation",
+        },
+    ],
+});

package/lib/types/Blessing.d.ts

@@ -0,0 +1,106 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Blessing: DB.Entity<"Blessing", {
+    parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"BlessingPerformanceParameters", DB.Object<{
+        range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BlessingRange", {
+            Self: DB.EnumCase<null>;
+            Touch: DB.EnumCase<null>;
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedRange", DB.Object<{
+                is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                value: DB.MemberDecl<DB.Integer, true>;
+                unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+                    Steps: DB.EnumCase<null>;
+                    Miles: DB.EnumCase<null>;
+                }, []>>, true>;
+                is_radius: DB.MemberDecl<DB.Boolean, false>;
+            }>, []>>>;
+        }, []>>, true>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BlessingDuration", {
+            Immediate: DB.EnumCase<null>;
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedBlessingDuration", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
+                unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                    Seconds: DB.EnumCase<null>;
+                    Minutes: DB.EnumCase<null>;
+                    Hours: DB.EnumCase<null>;
+                    Days: DB.EnumCase<null>;
+                    Weeks: DB.EnumCase<null>;
+                    Months: DB.EnumCase<null>;
+                    Years: DB.EnumCase<null>;
+                    Centuries: DB.EnumCase<null>;
+                    Actions: DB.EnumCase<null>;
+                    CombatRounds: DB.EnumCase<null>;
+                }, []>>, true>;
+            }>, []>>>;
+            Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteBlessingDuration", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteBlessingDurationTranslation", {
+                    description: DB.MemberDecl<DB.String, true>;
+                }>, true>;
+            }>, []>>>;
+        }, []>>, true>;
+    }>, []>>, true>;
+    target: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AffectedTargetCategories", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificAffectedTargetCategory", DB.Object<{
+        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecificAffectedTargetCategoryIdentifier", {
+            Self: DB.EnumCase<null>;
+            Zone: DB.EnumCase<null>;
+            LiturgicalChantsAndCeremonies: DB.EnumCase<null>;
+            Cantrips: DB.EnumCase<null>;
+            Spellworks: DB.EnumCase<null>;
+            Predefined: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificAffectedTargetCategoryTranslation", {
+            note: DB.MemberDecl<DB.String, true>;
+        }>, false>;
+    }>, []>>>, []>>, true>;
+    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<"BlessingTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        effect: DB.MemberDecl<DB.String, true>;
+        range: DB.MemberDecl<DB.String, true>;
+        duration: DB.MemberDecl<DB.String, true>;
+        target: 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>;
+}, undefined>;

package/lib/types/Blessing.js

@@ -0,0 +1,102 @@
+import * as DB from "tsondb/schema/dsl";
+import { DurationUnit } from "./_ActivatableSkillDuration.js";
+import { FixedRange } from "./_ActivatableSkillRange.js";
+import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Blessing = DB.Entity(import.meta.url, {
+    name: "Blessing",
+    namePlural: "Blessings",
+    type: () => DB.Object({
+        parameters: DB.Required({
+            comment: "Measurable parameters of a blessing.",
+            type: DB.IncludeIdentifier(BlessingPerformanceParameters),
+        }),
+        target: DB.Required({
+            comment: "The target category – the kind of creature or object – the skill affects.",
+            type: DB.IncludeIdentifier(AffectedTargetCategories),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Blessing", DB.Object({
+            name: DB.Required({
+                comment: "The blessing’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            effect: DB.Required({
+                comment: "The effect description.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            range: DB.Required({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            duration: DB.Required({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            target: DB.Required({
+                isDeprecated: true,
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const BlessingPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "BlessingPerformanceParameters",
+    comment: "Measurable parameters of a blessing.",
+    type: () => DB.Object({
+        range: DB.Required({ type: DB.IncludeIdentifier(BlessingRange) }),
+        duration: DB.Required({ type: DB.IncludeIdentifier(BlessingDuration) }),
+    }),
+});
+const BlessingRange = DB.Enum(import.meta.url, {
+    name: "BlessingRange",
+    values: () => ({
+        Self: DB.EnumCase({ type: null }),
+        Touch: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
+    }),
+});
+const BlessingDuration = DB.Enum(import.meta.url, {
+    name: "BlessingDuration",
+    values: () => ({
+        Immediate: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedBlessingDuration) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteBlessingDuration) }),
+    }),
+});
+const FixedBlessingDuration = DB.TypeAlias(import.meta.url, {
+    name: "FixedBlessingDuration",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The (unitless) duration.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        unit: DB.Required({
+            comment: "The duration unit.",
+            type: DB.IncludeIdentifier(DurationUnit),
+        }),
+    }),
+});
+const IndefiniteBlessingDuration = DB.TypeAlias(import.meta.url, {
+    name: "IndefiniteBlessingDuration",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "IndefiniteBlessingDuration", DB.Object({
+            description: DB.Required({
+                comment: "A description of the duration.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+});