@optolith/database-schema 0.42.1

package/lib/types/rule/AlternativeRule.d.ts

@@ -0,0 +1,54 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const AlternativeRule: DB.Entity<"AlternativeRule", {
+    playerTypes: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    isMissingImplementation: DB.MemberDecl<DB.Boolean, 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<"AlternativeRuleTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: 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/rule/AlternativeRule.js

@@ -0,0 +1,40 @@
+import * as DB from "tsondb/schema/dsl";
+import { PlayerTypeIdentifier } from "../_Identifier.js";
+import { NestedTranslationMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const AlternativeRule = DB.Entity(import.meta.url, {
+    name: "AlternativeRule",
+    namePlural: "AlternativeRules",
+    type: () => DB.Object({
+        playerTypes: DB.Required({
+            comment: "The player types this alternative rule is suitable for.",
+            type: DB.Array(PlayerTypeIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        isMissingImplementation: DB.Required({
+            comment: "Has the alternative rule not been implemented in Optolith yet? This is also true if the alternative rule does not (currently) apply to any Optolith feature.",
+            type: DB.Boolean(),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "AlternativeRule", DB.Object({
+            name: DB.Required({
+                comment: "The alternative rule’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The description of the alternative rule.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/rule/AlternativeRule_PlayerType.d.ts

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

package/lib/types/rule/AlternativeRule_PlayerType.js

@@ -0,0 +1,16 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../Locale.js";
+export const PlayerType = DB.Entity(import.meta.url, {
+    name: "PlayerType",
+    namePlural: "PlayerTypes",
+    comment: "Player types describe different playing styles, expectations and wishes of players.",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "PlayerType", DB.Object({
+            name: DB.Required({
+                comment: "The player type.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+});

package/lib/types/rule/CoreRule.d.ts

@@ -0,0 +1,143 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const CoreRule: DB.Entity<"CoreRule", {
+    content: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ContentNode", {
+        Child: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ChildNode", DB.Object<{
+            id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            include: DB.MemberDecl<DB.Boolean, true>;
+        }>, []>>>;
+        Text: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"TextNode", DB.Object<{
+            translations: DB.MemberDecl<DB.NestedEntityMap<"TextNodeTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, true>;
+        }>, []>>>;
+        Reference: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReferenceNode", DB.Object<{
+            id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CoreRuleDerivableContentIdentifier", {
+                MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>, true>;
+        }>, []>>>;
+        ReferenceList: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReferenceListNode", DB.Object<{
+            source: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ReferenceListNodeSource", {
+                Attributes: DB.EnumCase<null>;
+                QualityLevels: DB.EnumCase<null>;
+                Conditions: DB.EnumCase<null>;
+                States: DB.EnumCase<null>;
+                ExperienceLevels: DB.EnumCase<null>;
+                Races: DB.EnumCase<null>;
+                Cultures: DB.EnumCase<null>;
+                Professions: DB.EnumCase<null>;
+                Advantages: DB.EnumCase<null>;
+                Disadvantages: DB.EnumCase<null>;
+                CombatTechniques: DB.EnumCase<null>;
+                SpecialAbilities: DB.EnumCase<null>;
+                PrimaryAttributes: DB.EnumCase<null>;
+                DerivedCharacteristics: DB.EnumCase<null>;
+                StartingAge: DB.EnumCase<null>;
+                Archetypes: DB.EnumCase<null>;
+                RequirementsForRoutineChecks: DB.EnumCase<null>;
+                GeneralSpecialAbilities: DB.EnumCase<null>;
+                FatePointSpecialAbilities: DB.EnumCase<null>;
+                LanguagesAndScripts: DB.EnumCase<null>;
+                CloseCombatBotch: DB.EnumCase<null>;
+                DefenseBotch: DB.EnumCase<null>;
+                MeleeCombatTechniques: DB.EnumCase<null>;
+                RangedCombatBotch: DB.EnumCase<null>;
+                RangedCombatDefenseBotch: DB.EnumCase<null>;
+                RangedCombatTechniques: DB.EnumCase<null>;
+                CombatSpecialAbilities: DB.EnumCase<null>;
+                Properties: DB.EnumCase<null>;
+                SpellBotch: DB.EnumCase<null>;
+                Services: DB.EnumCase<null>;
+                ProtectiveAndWardingCircles: DB.EnumCase<null>;
+                Elixirs: DB.EnumCase<null>;
+                StaffEnchantments: DB.EnumCase<null>;
+                FamiliarsTricks: DB.EnumCase<null>;
+                Curses: DB.EnumCase<null>;
+                ElvenMagicalSongs: DB.EnumCase<null>;
+                MagicalSpecialAbilities: DB.EnumCase<null>;
+                Cantrips: DB.EnumCase<null>;
+                Spells: DB.EnumCase<null>;
+                Rituals: DB.EnumCase<null>;
+                Aspects: DB.EnumCase<null>;
+                LiturgyBotch: DB.EnumCase<null>;
+                KarmaSpecialAbilities: DB.EnumCase<null>;
+                Blessings: DB.EnumCase<null>;
+                LiturgicalChants: DB.EnumCase<null>;
+                Ceremonies: DB.EnumCase<null>;
+                SocialStatuses: DB.EnumCase<null>;
+                Poisons: DB.EnumCase<null>;
+                Diseases: DB.EnumCase<null>;
+                HealingHerbs: DB.EnumCase<null>;
+                VisibilityModifier: DB.EnumCase<null>;
+                Demons: DB.EnumCase<null>;
+                Elementals: DB.EnumCase<null>;
+                Animals: DB.EnumCase<null>;
+                Familiars: DB.EnumCase<null>;
+                AnimalSpecialAbilities: DB.EnumCase<null>;
+                EquipmentPackages: DB.EnumCase<null>;
+                Items: DB.EnumCase<null>;
+                OptionalRules: DB.EnumCase<null>;
+                ImprovementCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReferenceListNodeImprovementCostSource", DB.Object<{
+                    target: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ReferenceListNodeImprovementCostSourceTarget", {
+                        Attributes: DB.EnumCase<null>;
+                        Skills: DB.EnumCase<null>;
+                    }, []>>, true>;
+                    maximum_rating: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"ReferenceListNodeTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
+            }>, 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<"CoreRuleTranslation", {
+        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>;

package/lib/types/rule/CoreRule.js

@@ -0,0 +1,181 @@
+import * as DB from "tsondb/schema/dsl";
+import { CoreRuleIdentifier } from "../_Identifier.js";
+import { CoreRuleDerivableContentIdentifier } from "../_IdentifierGroup.js";
+import { NestedTranslationMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const CoreRule = DB.Entity(import.meta.url, {
+    name: "CoreRule",
+    namePlural: "CoreRules",
+    type: () => DB.Object({
+        content: DB.Required({
+            type: DB.Array(DB.IncludeIdentifier(ContentNode), { minItems: 1 }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "CoreRule", DB.Object({
+            name: DB.Required({
+                comment: "The core rule’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const ContentNode = DB.Enum(import.meta.url, {
+    name: "ContentNode",
+    values: () => ({
+        Child: DB.EnumCase({ type: DB.IncludeIdentifier(ChildNode) }),
+        Text: DB.EnumCase({ type: DB.IncludeIdentifier(TextNode) }),
+        Reference: DB.EnumCase({ type: DB.IncludeIdentifier(ReferenceNode) }),
+        ReferenceList: DB.EnumCase({ type: DB.IncludeIdentifier(ReferenceListNode) }),
+    }),
+});
+const ChildNode = DB.TypeAlias(import.meta.url, {
+    name: "ChildNode",
+    comment: "A core rule nested inside this core rule. It may be displayed as a separate page or its content may be included in this rule's text, which will automatically generate a proper heading. No content node of a type other than `Child` should follow a child node, since then it may look like the the text may be part of the child node.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The nested core rule’s identifier.",
+            type: CoreRuleIdentifier(),
+        }),
+        include: DB.Required({
+            comment: "If the nested core rule's content should be integrated into this core rule and a proper heading should be added. Otherwise create a link to a separate view of that core rule.",
+            type: DB.Boolean(),
+        }),
+    }),
+});
+const TextNode = DB.TypeAlias(import.meta.url, {
+    name: "TextNode",
+    comment: "A simple text block, containing one or multiple paragraphs. Headings are not allowed, they should be handled as nested core rules instead.",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "TextNode", DB.Object({
+            text: DB.Required({
+                comment: "Markdown-formatted text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }),
+});
+const ReferenceListNode = DB.TypeAlias(import.meta.url, {
+    name: "ReferenceListNode",
+    comment: "Generate a list or table from a specific entity type.",
+    type: () => DB.Object({
+        source: DB.Required({
+            type: DB.IncludeIdentifier(ReferenceListNodeSource),
+        }),
+        translations: NestedTranslationMap(DB.Required, "ReferenceListNode", DB.Object({
+            text: DB.Required({
+                comment: "Markdown-formatted text.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+        })),
+    }),
+});
+const ReferenceListNodeSource = DB.Enum(import.meta.url, {
+    name: "ReferenceListNodeSource",
+    values: () => ({
+        Attributes: DB.EnumCase({ type: null }),
+        QualityLevels: DB.EnumCase({ type: null }),
+        Conditions: DB.EnumCase({ type: null }),
+        States: DB.EnumCase({ type: null }),
+        ExperienceLevels: DB.EnumCase({ type: null }),
+        Races: DB.EnumCase({ type: null }),
+        Cultures: DB.EnumCase({ type: null }),
+        Professions: DB.EnumCase({ type: null }),
+        Advantages: DB.EnumCase({ type: null }),
+        Disadvantages: DB.EnumCase({ type: null }),
+        CombatTechniques: DB.EnumCase({ type: null }),
+        SpecialAbilities: DB.EnumCase({ type: null }),
+        PrimaryAttributes: DB.EnumCase({ type: null }),
+        DerivedCharacteristics: DB.EnumCase({ type: null }),
+        StartingAge: DB.EnumCase({ type: null }),
+        Archetypes: DB.EnumCase({ type: null }),
+        RequirementsForRoutineChecks: DB.EnumCase({ type: null }),
+        GeneralSpecialAbilities: DB.EnumCase({ type: null }),
+        FatePointSpecialAbilities: DB.EnumCase({ type: null }),
+        LanguagesAndScripts: DB.EnumCase({ type: null }),
+        CloseCombatBotch: DB.EnumCase({ type: null }),
+        DefenseBotch: DB.EnumCase({ type: null }),
+        MeleeCombatTechniques: DB.EnumCase({ type: null }),
+        RangedCombatBotch: DB.EnumCase({ type: null }),
+        RangedCombatDefenseBotch: DB.EnumCase({ type: null }),
+        RangedCombatTechniques: DB.EnumCase({ type: null }),
+        CombatSpecialAbilities: DB.EnumCase({ type: null }),
+        Properties: DB.EnumCase({ type: null }),
+        SpellBotch: DB.EnumCase({ type: null }),
+        Services: DB.EnumCase({ type: null }),
+        ProtectiveAndWardingCircles: DB.EnumCase({ type: null }),
+        Elixirs: DB.EnumCase({ type: null }),
+        StaffEnchantments: DB.EnumCase({ type: null }),
+        FamiliarsTricks: DB.EnumCase({ type: null }),
+        Curses: DB.EnumCase({ type: null }),
+        ElvenMagicalSongs: DB.EnumCase({ type: null }),
+        MagicalSpecialAbilities: DB.EnumCase({ type: null }),
+        Cantrips: DB.EnumCase({ type: null }),
+        Spells: DB.EnumCase({ type: null }),
+        Rituals: DB.EnumCase({ type: null }),
+        Aspects: DB.EnumCase({ type: null }),
+        LiturgyBotch: DB.EnumCase({ type: null }),
+        KarmaSpecialAbilities: DB.EnumCase({ type: null }),
+        Blessings: DB.EnumCase({ type: null }),
+        LiturgicalChants: DB.EnumCase({ type: null }),
+        Ceremonies: DB.EnumCase({ type: null }),
+        SocialStatuses: DB.EnumCase({ type: null }),
+        Poisons: DB.EnumCase({ type: null }),
+        Diseases: DB.EnumCase({ type: null }),
+        HealingHerbs: DB.EnumCase({ type: null }),
+        VisibilityModifier: DB.EnumCase({ type: null }),
+        Demons: DB.EnumCase({ type: null }),
+        Elementals: DB.EnumCase({ type: null }),
+        Animals: DB.EnumCase({ type: null }),
+        Familiars: DB.EnumCase({ type: null }),
+        AnimalSpecialAbilities: DB.EnumCase({ type: null }),
+        EquipmentPackages: DB.EnumCase({ type: null }),
+        Items: DB.EnumCase({ type: null }),
+        OptionalRules: DB.EnumCase({ type: null }),
+        ImprovementCost: DB.EnumCase({
+            type: DB.IncludeIdentifier(ReferenceListNodeImprovementCostSource),
+        }),
+    }),
+});
+const ReferenceListNodeImprovementCostSource = DB.TypeAlias(import.meta.url, {
+    name: "ReferenceListNodeImprovementCostSource",
+    type: () => DB.Object({
+        target: DB.Required({
+            comment: "Define if the cost for attributes or skills should be defined. The cost for attributes start with value 9, while the cost for skills start with 1 in addition to possible activation cost.",
+            type: DB.IncludeIdentifier(ReferenceListNodeImprovementCostSourceTarget),
+        }),
+        maximum_rating: DB.Required({
+            comment: `The highest value the improvement cost are displayed for.
+
+The minimum maximum value should depend on what is the upper bound of the range of adventure point cost that are equal across multiple values (value increases for attributes are always 15 up to (and including) value 14, while value increases for skills are always 1 to 4, depending on the improvement cost, up to (and including) value 12), since those ranges should be combined into a single table row.`,
+            type: DB.Integer({ minimum: 12 }),
+        }),
+    }),
+});
+const ReferenceListNodeImprovementCostSourceTarget = DB.Enum(import.meta.url, {
+    name: "ReferenceListNodeImprovementCostSourceTarget",
+    values: () => ({
+        Attributes: DB.EnumCase({ type: null }),
+        Skills: DB.EnumCase({ type: null }),
+    }),
+});
+const ReferenceNode = DB.TypeAlias(import.meta.url, {
+    name: "ReferenceNode",
+    comment: "Generate the full text for a single entry as part of this core rule's text.",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The nested core rule’s identifier.",
+            type: DB.IncludeIdentifier(CoreRuleDerivableContentIdentifier),
+        }),
+    }),
+});

package/lib/types/rule/FocusRule.d.ts

@@ -0,0 +1,79 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const FocusRule: DB.Entity<"FocusRule", {
+    subject: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    level: DB.MemberDecl<DB.Integer, true>;
+    isMissingImplementation: DB.MemberDecl<DB.Boolean, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RulePrerequisites", 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<"FocusRuleTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: 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/rule/FocusRule.js

@@ -0,0 +1,48 @@
+import * as DB from "tsondb/schema/dsl";
+import { SubjectIdentifier } from "../_Identifier.js";
+import { RulePrerequisites } from "../_Prerequisite.js";
+import { NestedTranslationMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const FocusRule = DB.Entity(import.meta.url, {
+    name: "FocusRule",
+    namePlural: "FocusRules",
+    type: () => DB.Object({
+        subject: DB.Required({
+            comment: "The associated subject.",
+            type: SubjectIdentifier(),
+        }),
+        level: DB.Required({
+            comment: "The focus rule’s level.",
+            type: DB.Integer({ minimum: 1, maximum: 4 }),
+        }),
+        isMissingImplementation: DB.Required({
+            comment: "Has the focus rule not been implemented in Optolith yet? This is also true if the focus rule does not (currently) apply to any Optolith feature.",
+            type: DB.Boolean(),
+        }),
+        prerequisites: DB.Optional({
+            type: DB.IncludeIdentifier(RulePrerequisites),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "FocusRule", DB.Object({
+            name: DB.Required({
+                comment: "The focus rule’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            description: DB.Required({
+                comment: "The description of the focus rule.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/rule/FocusRule_Subject.d.ts

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

package/lib/types/rule/FocusRule_Subject.js

@@ -0,0 +1,22 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "../Locale.js";
+export const Subject = DB.Entity(import.meta.url, {
+    name: "Subject",
+    namePlural: "Subjects",
+    comment: "Subjects or Subject Areas are the categories of Focus Rules.",
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "Subject", DB.Object({
+            name: DB.Required({
+                comment: "The subject.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});