@optolith/database-schema 0.42.1

package/lib/types/FamiliarsTrick.js

@@ -0,0 +1,202 @@
+import * as DB from "tsondb/schema/dsl";
+import { OldParameter } from "./_ActivatableSkill.js";
+import { IndefiniteOneTimeCost, NonModifiableOneTimeCostPerCountable, } from "./_ActivatableSkillCost.js";
+import { DurationUnitValue, FixedDuration, IndefiniteDuration, } from "./_ActivatableSkillDuration.js";
+import { AnimalTypeIdentifier, MagicalTraditionIdentifier, PropertyIdentifier, } from "./_Identifier.js";
+import { ResponsiveText } from "./_ResponsiveText.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const FamiliarsTrick = DB.Entity(import.meta.url, {
+    name: "FamiliarsTrick",
+    namePlural: "FamiliarsTricks",
+    displayName: "Familiar’s Trick",
+    displayNamePlural: "Familiar’s Tricks",
+    type: () => DB.Object({
+        animal_types: DB.Required({
+            comment: `The animal types this trick is available to. Either it is available to all or only a list of specific animal types.
+
+If no animal types are given, the familiars trick applies to all animal types.`,
+            type: DB.Array(AnimalTypeIdentifier(), { uniqueItems: true }),
+        }),
+        traditions: DB.Optional({
+            comment: `The magical traditions whose familiars can use this trick. Either it is available to all or only a list of specific traditions.
+
+If no traditions are given, the familiars trick is not restricted by the magical tradition at all.`,
+            type: DB.Array(MagicalTraditionIdentifier(), { uniqueItems: true, minItems: 1 }),
+        }),
+        parameters: DB.Required({
+            comment: "Measurable parameters of a familiar’s trick.",
+            type: DB.IncludeIdentifier(FamiliarsTrickPerformanceParameters),
+        }),
+        property: DB.Required({
+            comment: "The associated property.",
+            type: DB.IncludeIdentifier(FamiliarsTrickProperty),
+        }),
+        ap_value: DB.Optional({
+            comment: "The AP value the familiar has to pay for. It may also be that a specific is known by all familiar by default. In the latter case the field is not set.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "FamiliarsTrick", DB.Object({
+            name: DB.Required({
+                comment: "The familiar’s trick’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            effect: DB.Required({
+                comment: "The effect description.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            cost: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            duration: DB.Optional({
+                isDeprecated: true,
+                type: DB.IncludeIdentifier(OldParameter),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const FamiliarsTrickProperty = DB.Enum(import.meta.url, {
+    name: "FamiliarsTrickProperty",
+    values: () => ({
+        Fixed: DB.EnumCase({ type: PropertyIdentifier() }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteFamiliarsTrickProperty) }),
+    }),
+});
+const IndefiniteFamiliarsTrickProperty = DB.TypeAlias(import.meta.url, {
+    name: "IndefiniteFamiliarsTrickProperty",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Optional, "IndefiniteFamiliarsTrickProperty", DB.Object({
+            description: DB.Required({
+                comment: "A description of the property.",
+                type: DB.IncludeIdentifier(ResponsiveText),
+            }),
+        })),
+    }),
+});
+const FamiliarsTrickPerformanceParameters = DB.Enum(import.meta.url, {
+    name: "FamiliarsTrickPerformanceParameters",
+    comment: "Measurable parameters of a familiar’s trick.",
+    values: () => ({
+        OneTime: DB.EnumCase({
+            type: DB.IncludeIdentifier(FamiliarsTrickOneTimePerformanceParameters),
+        }),
+        OneTimeInterval: DB.EnumCase({
+            type: DB.IncludeIdentifier(FamiliarsTrickOneTimeIntervalPerformanceParameters),
+        }),
+        Sustained: DB.EnumCase({
+            type: DB.IncludeIdentifier(FamiliarsTrickSustainedPerformanceParameters),
+        }),
+    }),
+});
+const FamiliarsTrickOneTimePerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickOneTimePerformanceParameters",
+    type: () => DB.Object({
+        cost: DB.Required({
+            type: DB.IncludeIdentifier(FamiliarsTrickOneTimeCost),
+        }),
+        duration: DB.Required({
+            type: DB.IncludeIdentifier(FamiliarsTrickOneTimeDuration),
+        }),
+    }),
+});
+const FamiliarsTrickOneTimeCost = DB.Enum(import.meta.url, {
+    name: "FamiliarsTrickOneTimeCost",
+    values: () => ({
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FamiliarsTrickFixedOneTimeCost) }),
+        All: DB.EnumCase({ type: DB.IncludeIdentifier(FamiliarsTrickAllOneTimeCost) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteOneTimeCost) }),
+    }),
+});
+const FamiliarsTrickFixedOneTimeCost = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickFixedOneTimeCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The AE cost value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        lp_value: DB.Optional({
+            comment: "The LP cost value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        interval: DB.Optional({
+            comment: "The interval in which you have to pay the AE cost again.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+        per: DB.Optional({
+            comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
+            type: DB.IncludeIdentifier(NonModifiableOneTimeCostPerCountable),
+        }),
+    }),
+});
+const FamiliarsTrickAllOneTimeCost = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickAllOneTimeCost",
+    type: () => DB.Object({
+        minimum: DB.Optional({
+            comment: "The minimum AE the familiar has to have/spend.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const FamiliarsTrickOneTimeDuration = DB.Enum(import.meta.url, {
+    name: "FamiliarsTrickOneTimeDuration",
+    values: () => ({
+        Immediate: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedDuration) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteDuration) }),
+    }),
+});
+const FamiliarsTrickOneTimeIntervalPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickOneTimeIntervalPerformanceParameters",
+    type: () => DB.Object({
+        cost: DB.Required({
+            type: DB.IncludeIdentifier(FamiliarsTrickOneTimeIntervalCost),
+        }),
+    }),
+});
+const FamiliarsTrickOneTimeIntervalCost = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickOneTimeIntervalCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The AE cost value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        interval: DB.Required({
+            comment: "The duration granted/added by paying the given AE cost.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});
+const FamiliarsTrickSustainedPerformanceParameters = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickSustainedPerformanceParameters",
+    type: () => DB.Object({
+        cost: DB.Required({
+            type: DB.IncludeIdentifier(FamiliarsTrickSustainedCost),
+        }),
+    }),
+});
+const FamiliarsTrickSustainedCost = DB.TypeAlias(import.meta.url, {
+    name: "FamiliarsTrickSustainedCost",
+    type: () => DB.Object({
+        value: DB.Required({
+            comment: "The AE cost value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        interval: DB.Optional({
+            comment: "The interval in which you have to pay the AE cost again.",
+            type: DB.IncludeIdentifier(DurationUnitValue),
+        }),
+    }),
+});

package/lib/types/HairColor.d.ts

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

package/lib/types/HairColor.js

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

package/lib/types/HomunculusType.d.ts

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

package/lib/types/HomunculusType.js

@@ -0,0 +1,15 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+export const HomunculusType = DB.Entity(import.meta.url, {
+    name: "HomunculusType",
+    namePlural: "HomunculusTypes",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "HomunculusType", DB.Object({
+            name: DB.Required({
+                comment: "The homunculus type’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+});

package/lib/types/Influence.d.ts

@@ -0,0 +1,80 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Influence: DB.Entity<"Influence", {
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"InfluencePrerequisites", 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>;
+    }>, []>>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"InfluenceTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        rules: DB.MemberDecl<DB.String, false>;
+        effects: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"InfluenceEffect", DB.Object<{
+            label: DB.MemberDecl<DB.String, true>;
+            text: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, false>;
+        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/Influence.js

@@ -0,0 +1,52 @@
+import * as DB from "tsondb/schema/dsl";
+import { InfluencePrerequisites } from "./_Prerequisite.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Influence = DB.Entity(import.meta.url, {
+    name: "Influence",
+    namePlural: "Influences",
+    type: () => DB.Object({
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(InfluencePrerequisites),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Influence", DB.Object({
+            name: DB.Required({
+                comment: "The influence’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            rules: DB.Optional({
+                comment: "Some general rules for the influence. They will be prepended to the effects. This can be used for influences that do not have any effects and should contain the text mentioning this fact.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            effects: DB.Optional({
+                comment: "The effects of the influence. They should be sorted like they are in the book.",
+                type: DB.Array(DB.IncludeIdentifier(InfluenceEffect), { minItems: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const InfluenceEffect = DB.TypeAlias(import.meta.url, {
+    name: "InfluenceEffect",
+    type: () => DB.Object({
+        label: DB.Required({
+            comment: "An optional label that is displayed and placed before the actual text.",
+            type: DB.String({ minLength: 1 }),
+        }),
+        text: DB.Required({
+            comment: "The effect text.",
+            type: DB.String({ minLength: 1, markdown: "block" }),
+        }),
+    }),
+});

package/lib/types/Lessons.d.ts

@@ -0,0 +1,181 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Guideline: DB.Entity<"Guideline", {
+    spellwork_changes_allowed: DB.MemberDecl<DB.Integer, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"GuidelineTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;
+export declare const Curriculum: DB.Entity<"Curriculum", {
+    guideline: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    elective_spellworks: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ElectiveSpellworks", {
+        DefinedByGameMaster: DB.EnumCase<null>;
+        Specific: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificElectiveSpellworks", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ElectiveSpellwork", DB.Object<{
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                    Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, true>;
+                restriction: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ElectiveSpellworkRestriction", {
+                    Element: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
+            }>, []>>>, true>;
+        }>, []>>>;
+    }, []>>, false>;
+    restricted_spellworks: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedSpellworks", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RestrictedSpellwork", {
+        Property: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedProperty", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            exclude: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>>, false>;
+            maximum: DB.MemberDecl<DB.Integer, false>;
+        }>, []>>>;
+        Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+            Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+            Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>>;
+        DemonSummoning: DB.EnumCase<null>;
+        Borbaradian: DB.EnumCase<null>;
+        DamageIntelligent: DB.EnumCase<null>;
+    }, []>>>, []>>, false>;
+    lesson_packages: DB.MemberDecl<DB.ChildEntities<DB.Entity<"LessonPackage", {
+        curriculum: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        spellwork_changes: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkChange", DB.Object<{
+            base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                    Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, true>;
+                points: DB.MemberDecl<DB.Integer, true>;
+                tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            }>, []>>, true>;
+            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                    Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, true>;
+                points: DB.MemberDecl<DB.Integer, true>;
+                tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            }>, []>>, true>;
+        }>, []>>>, false>;
+        skills: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AbilityAdjustment", {
+            CombatTechnique: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CombatTechniqueAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatTechniqueIdentifier", {
+                    CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                    RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, true>;
+                points: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Skill: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                points: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+            Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                    Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, true>;
+                points: DB.MemberDecl<DB.Integer, true>;
+                tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+            }>, []>>>;
+        }, []>>>, false>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"LessonPackageTranslation", {
+            name: DB.MemberDecl<DB.String, true>;
+            spellwork_changes: DB.MemberDecl<DB.String, false>;
+        }>, true>;
+    }, "curriculum">>, 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<"CurriculumTranslation", {
+        name: 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>;
+export declare const LessonPackage: DB.Entity<"LessonPackage", {
+    curriculum: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    spellwork_changes: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkChange", DB.Object<{
+        base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, true>;
+            points: DB.MemberDecl<DB.Integer, true>;
+            tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        }>, []>>, true>;
+        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, true>;
+            points: DB.MemberDecl<DB.Integer, true>;
+            tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        }>, []>>, true>;
+    }>, []>>>, false>;
+    skills: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AbilityAdjustment", {
+        CombatTechnique: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CombatTechniqueAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatTechniqueIdentifier", {
+                CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, true>;
+            points: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Skill: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            points: DB.MemberDecl<DB.Integer, true>;
+        }>, []>>>;
+        Spellwork: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SpellworkAdjustment", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, true>;
+            points: DB.MemberDecl<DB.Integer, true>;
+            tradition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+        }>, []>>>;
+    }, []>>>, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"LessonPackageTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        spellwork_changes: DB.MemberDecl<DB.String, false>;
+    }>, true>;
+}, "curriculum">;