optolith-database-schema 0.17.2 → 0.18.1

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

@@ -1,310 +1,142 @@
-/**
- * @main CoreRule
- */
-import { TypeConfig } from "../../typeConfig.js";
-import { CoreRuleIdentifier } from "../_Identifier.js";
-import { CoreRuleDerivableContentIdentifier } from "../_IdentifierGroup.js";
-import { LocaleMap } from "../_LocaleMap.js";
-import { NonEmptyMarkdown, NonEmptyString } from "../_NonEmptyString.js";
-import { Errata } from "../source/_Erratum.js";
-import { PublicationRefs } from "../source/_PublicationRef.js";
-/**
- * @title Core Rule
- */
-export type CoreRule = {
-    /**
-     * The core rule's identifier. An unique, increasing integer.
-     * @integer
-     */
-    id: number;
-    /**
-     * @minItems 1
-     */
-    content: ContentNode[];
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<CoreRuleTranslation>;
-};
-export type CoreRuleTranslation = {
-    /**
-     * The name of the optional rule.
-     */
-    name: NonEmptyString;
-    errata?: Errata;
-};
-export type ContentNode = {
-    tag: "Child";
-    child: ChildNode;
-} | {
-    tag: "Text";
-    text: TextNode;
-} | {
-    tag: "Reference";
-    reference: ReferenceNode;
-} | {
-    tag: "ReferenceList";
-    reference_list: ReferenceListNode;
-};
-/**
- * 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.
- */
-export type ChildNode = {
-    /**
-     * The nested core rule's identifier.
-     */
-    id: CoreRuleIdentifier;
-    /**
-     * 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.
-     */
-    include: boolean;
-};
-/**
- * A simple text block, containing one or multiple paragraphs. Headings are not
- * allowed, they should be handled as nested core rules instead.
- */
-export type TextNode = {
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<TextNodeTranslation>;
-};
-export type TextNodeTranslation = {
-    /**
-     * Markdown-formatted text.
-     */
-    text: NonEmptyMarkdown;
-};
-/**
- * Generate a list or table from a specific entity type.
- */
-export type ReferenceListNode = {
-    source: ReferenceListNodeSource;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<ReferenceListNodeTranslation>;
-};
-export type ReferenceListNodeSource = {
-    tag: "Attributes";
-    attributes: {};
-} | {
-    tag: "QualityLevels";
-    quality_levels: {};
-} | {
-    tag: "Conditions";
-    conditions: {};
-} | {
-    tag: "States";
-    states: {};
-} | {
-    tag: "ExperienceLevels";
-    experience_levels: {};
-} | {
-    tag: "Races";
-    races: {};
-} | {
-    tag: "Cultures";
-    cultures: {};
-} | {
-    tag: "Professions";
-    professions: {};
-} | {
-    tag: "Advantages";
-    advantages: {};
-} | {
-    tag: "Disadvantages";
-    disadvantages: {};
-} | {
-    tag: "CombatTechniques";
-    combat_techniques: {};
-} | {
-    tag: "SpecialAbilities";
-    special_abilities: {};
-} | {
-    tag: "PrimaryAttributes";
-    primary_attributes: {};
-} | {
-    tag: "DerivedCharacteristics";
-    derived_characteristics: {};
-} | {
-    tag: "StartingAge";
-    starting_age: {};
-} | {
-    tag: "Archetypes";
-    archetypes: {};
-} | {
-    tag: "RequirementsForRoutineChecks";
-    requirements_for_routine_checks: {};
-} | {
-    tag: "GeneralSpecialAbilities";
-    general_special_abilities: {};
-} | {
-    tag: "FatePointSpecialAbilities";
-    fate_point_special_abilities: {};
-} | {
-    tag: "LanguagesAndScripts";
-    languages_and_scripts: {};
-} | {
-    tag: "CloseCombatBotch";
-    close_combat_botch: {};
-} | {
-    tag: "DefenseBotch";
-    defense_botch: {};
-} | {
-    tag: "MeleeCombatTechniques";
-    melee_combat_techniques: {};
-} | {
-    tag: "RangedCombatBotch";
-    ranged_combat_botch: {};
-} | {
-    tag: "RangedCombatDefenseBotch";
-    ranged_combat_defense_botch: {};
-} | {
-    tag: "RangedCombatTechniques";
-    ranged_combat_techniques: {};
-} | {
-    tag: "CombatSpecialAbilities";
-    combat_special_abilities: {};
-} | {
-    tag: "Properties";
-    properties: {};
-} | {
-    tag: "SpellBotch";
-    spell_botch: {};
-} | {
-    tag: "Services";
-    services: {};
-} | {
-    tag: "ProtectiveAndWardingCircles";
-    protective_and_warding_circles: {};
-} | {
-    tag: "Elixirs";
-    elixirs: {};
-} | {
-    tag: "StaffEnchantments";
-    staff_enchantments: {};
-} | {
-    tag: "FamiliarsTricks";
-    familiars_tricks: {};
-} | {
-    tag: "Curses";
-    curses: {};
-} | {
-    tag: "ElvenMagicalSongs";
-    elven_magical_songs: {};
-} | {
-    tag: "MagicalSpecialAbilities";
-    magical_special_abilities: {};
-} | {
-    tag: "Cantrips";
-    cantrips: {};
-} | {
-    tag: "Spells";
-    spells: {};
-} | {
-    tag: "Rituals";
-    rituals: {};
-} | {
-    tag: "Aspects";
-    aspects: {};
-} | {
-    tag: "LiturgyBotch";
-    liturgy_botch: {};
-} | {
-    tag: "KarmaSpecialAbilities";
-    karma_special_abilities: {};
-} | {
-    tag: "Blessings";
-    blessings: {};
-} | {
-    tag: "LiturgicalChants";
-    liturgical_chants: {};
-} | {
-    tag: "Ceremonies";
-    ceremonies: {};
-} | {
-    tag: "SocialStatuses";
-    social_statuses: {};
-} | {
-    tag: "Poisons";
-    poisons: {};
-} | {
-    tag: "Diseases";
-    diseases: {};
-} | {
-    tag: "HealingHerbs";
-    healing_herbs: {};
-} | {
-    tag: "VisibilityModifier";
-    visibility_modifier: {};
-} | {
-    tag: "Demons";
-    demons: {};
-} | {
-    tag: "Elementals";
-    elementals: {};
-} | {
-    tag: "Animals";
-    animals: {};
-} | {
-    tag: "Familiars";
-    familiars: {};
-} | {
-    tag: "AnimalSpecialAbilities";
-    animal_special_abilities: {};
-} | {
-    tag: "EquipmentPackages";
-    equipment_packages: {};
-} | {
-    tag: "Items";
-    items: {};
-} | {
-    tag: "OptionalRules";
-    optional_rules: {};
-} | {
-    tag: "ImprovementCost";
-    improvement_cost: ReferenceListNodeImprovementCostSource;
-};
-export type ReferenceListNodeImprovementCostSource = {
-    /**
-     * 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.
-     */
-    target: ReferenceListNodeImprovementCostSourceTarget;
-    /**
-     * 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.
-     * @integer
-     * @minimum 12
-     */
-    maximum_rating: number;
-};
-export type ReferenceListNodeImprovementCostSourceTarget = "Attributes" | "Skills";
-export type ReferenceListNodeTranslation = {
-    /**
-     * Markdown-formatted text.
-     */
-    text: NonEmptyMarkdown;
-};
-/**
- * Generate the full text for a single entry as part of this core rule's text.
- */
-export type ReferenceNode = {
-    id: CoreRuleDerivableContentIdentifier;
-};
-export declare const config: TypeConfig<CoreRule, CoreRule["id"], "CoreRule">;
+import { Array, Boolean, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const CoreRule: Entity<"CoreRule", {
+    content: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"ContentNode", {
+        Child: EnumCase<IncludeIdentifier<[], TypeAlias<"ChildNode", Object<{
+            id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+            include: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        }>, []>>>;
+        Text: EnumCase<IncludeIdentifier<[], TypeAlias<"TextNode", Object<{
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"TextNodeTranslation", {
+                text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, true>;
+        }>, []>>>;
+        Reference: EnumCase<IncludeIdentifier<[], TypeAlias<"ReferenceNode", Object<{
+            id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CoreRuleDerivableContentIdentifier", {
+                MagicalTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                FamiliarSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                MagicalSpecialAbility: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+                BlessedTradition: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+            }, []>>, true>;
+        }>, []>>>;
+        ReferenceList: EnumCase<IncludeIdentifier<[], TypeAlias<"ReferenceListNode", Object<{
+            source: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ReferenceListNodeSource", {
+                Attributes: EnumCase<null>;
+                QualityLevels: EnumCase<null>;
+                Conditions: EnumCase<null>;
+                States: EnumCase<null>;
+                ExperienceLevels: EnumCase<null>;
+                Races: EnumCase<null>;
+                Cultures: EnumCase<null>;
+                Professions: EnumCase<null>;
+                Advantages: EnumCase<null>;
+                Disadvantages: EnumCase<null>;
+                CombatTechniques: EnumCase<null>;
+                SpecialAbilities: EnumCase<null>;
+                PrimaryAttributes: EnumCase<null>;
+                DerivedCharacteristics: EnumCase<null>;
+                StartingAge: EnumCase<null>;
+                Archetypes: EnumCase<null>;
+                RequirementsForRoutineChecks: EnumCase<null>;
+                GeneralSpecialAbilities: EnumCase<null>;
+                FatePointSpecialAbilities: EnumCase<null>;
+                LanguagesAndScripts: EnumCase<null>;
+                CloseCombatBotch: EnumCase<null>;
+                DefenseBotch: EnumCase<null>;
+                MeleeCombatTechniques: EnumCase<null>;
+                RangedCombatBotch: EnumCase<null>;
+                RangedCombatDefenseBotch: EnumCase<null>;
+                RangedCombatTechniques: EnumCase<null>;
+                CombatSpecialAbilities: EnumCase<null>;
+                Properties: EnumCase<null>;
+                SpellBotch: EnumCase<null>;
+                Services: EnumCase<null>;
+                ProtectiveAndWardingCircles: EnumCase<null>;
+                Elixirs: EnumCase<null>;
+                StaffEnchantments: EnumCase<null>;
+                FamiliarsTricks: EnumCase<null>;
+                Curses: EnumCase<null>;
+                ElvenMagicalSongs: EnumCase<null>;
+                MagicalSpecialAbilities: EnumCase<null>;
+                Cantrips: EnumCase<null>;
+                Spells: EnumCase<null>;
+                Rituals: EnumCase<null>;
+                Aspects: EnumCase<null>;
+                LiturgyBotch: EnumCase<null>;
+                KarmaSpecialAbilities: EnumCase<null>;
+                Blessings: EnumCase<null>;
+                LiturgicalChants: EnumCase<null>;
+                Ceremonies: EnumCase<null>;
+                SocialStatuses: EnumCase<null>;
+                Poisons: EnumCase<null>;
+                Diseases: EnumCase<null>;
+                HealingHerbs: EnumCase<null>;
+                VisibilityModifier: EnumCase<null>;
+                Demons: EnumCase<null>;
+                Elementals: EnumCase<null>;
+                Animals: EnumCase<null>;
+                Familiars: EnumCase<null>;
+                AnimalSpecialAbilities: EnumCase<null>;
+                EquipmentPackages: EnumCase<null>;
+                Items: EnumCase<null>;
+                OptionalRules: EnumCase<null>;
+                ImprovementCost: EnumCase<IncludeIdentifier<[], TypeAlias<"ReferenceListNodeImprovementCostSource", Object<{
+                    target: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ReferenceListNodeImprovementCostSourceTarget", {
+                        Attributes: EnumCase<null>;
+                        Skills: EnumCase<null>;
+                    }, []>>, true>;
+                    maximum_rating: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>>;
+            }, []>>, true>;
+            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReferenceListNodeTranslation", {
+                text: import("tsondb/schema/def").MemberDecl<String, true>;
+            }>, true>;
+        }>, []>>>;
+    }, []>>>, true>;
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"PublicationRef", Object<{
+        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+        occurrences: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"Occurrence", {
+            initial: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
+                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                        InsideCoverFront: EnumCase<null>;
+                        InsideCoverBack: EnumCase<null>;
+                        Numbered: EnumCase<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"Revision", {
+                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
+                            InsideCoverFront: EnumCase<null>;
+                            InsideCoverBack: EnumCase<null>;
+                            Numbered: EnumCase<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CoreRuleTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
+            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
+            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;

package/lib/types/rule/CoreRule.js

@@ -1,14 +1,173 @@
-/**
- * @main CoreRule
- */
-import { todo } from "../../validation/builders/integrity.js";
-import { validateEntityFileName } from "../../validation/builders/naming.js";
-import { createSchemaValidator } from "../../validation/builders/schema.js";
-import { getFilenamePrefixAsNumericId } from "../../validation/filename.js";
-export const config = {
+import { Array, Boolean, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { CoreRuleIdentifier } from "../_Identifier.js";
+import { CoreRuleDerivableContentIdentifier } from "../_IdentifierGroup.js";
+import { NestedLocaleMap } from "../Locale.js";
+import { Errata } from "../source/_Erratum.js";
+import { src } from "../source/_PublicationRef.js";
+export const CoreRule = Entity(import.meta.url, {
     name: "CoreRule",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("CoreRule"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "CoreRules",
+    type: () => Object({
+        content: Required({
+            type: Array(IncludeIdentifier(ContentNode), { minItems: 1 }),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "CoreRuleTranslation", Object({
+            name: Required({
+                comment: "The core rule’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const ContentNode = Enum(import.meta.url, {
+    name: "ContentNode",
+    values: () => ({
+        Child: EnumCase({ type: IncludeIdentifier(ChildNode) }),
+        Text: EnumCase({ type: IncludeIdentifier(TextNode) }),
+        Reference: EnumCase({ type: IncludeIdentifier(ReferenceNode) }),
+        ReferenceList: EnumCase({ type: IncludeIdentifier(ReferenceListNode) }),
+    }),
+});
+const ChildNode = 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: () => Object({
+        id: Required({
+            comment: "The nested core rule’s identifier.",
+            type: CoreRuleIdentifier(),
+        }),
+        include: 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: Boolean(),
+        }),
+    }),
+});
+const TextNode = 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: () => Object({
+        translations: NestedLocaleMap(Required, "TextNodeTranslation", Object({
+            text: Required({
+                comment: "Markdown-formatted text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        })),
+    }),
+});
+const ReferenceListNode = TypeAlias(import.meta.url, {
+    name: "ReferenceListNode",
+    comment: "Generate a list or table from a specific entity type.",
+    type: () => Object({
+        source: Required({
+            type: IncludeIdentifier(ReferenceListNodeSource),
+        }),
+        translations: NestedLocaleMap(Required, "ReferenceListNodeTranslation", Object({
+            text: Required({
+                comment: "Markdown-formatted text.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+        })),
+    }),
+});
+const ReferenceListNodeSource = Enum(import.meta.url, {
+    name: "ReferenceListNodeSource",
+    values: () => ({
+        Attributes: EnumCase({ type: null }),
+        QualityLevels: EnumCase({ type: null }),
+        Conditions: EnumCase({ type: null }),
+        States: EnumCase({ type: null }),
+        ExperienceLevels: EnumCase({ type: null }),
+        Races: EnumCase({ type: null }),
+        Cultures: EnumCase({ type: null }),
+        Professions: EnumCase({ type: null }),
+        Advantages: EnumCase({ type: null }),
+        Disadvantages: EnumCase({ type: null }),
+        CombatTechniques: EnumCase({ type: null }),
+        SpecialAbilities: EnumCase({ type: null }),
+        PrimaryAttributes: EnumCase({ type: null }),
+        DerivedCharacteristics: EnumCase({ type: null }),
+        StartingAge: EnumCase({ type: null }),
+        Archetypes: EnumCase({ type: null }),
+        RequirementsForRoutineChecks: EnumCase({ type: null }),
+        GeneralSpecialAbilities: EnumCase({ type: null }),
+        FatePointSpecialAbilities: EnumCase({ type: null }),
+        LanguagesAndScripts: EnumCase({ type: null }),
+        CloseCombatBotch: EnumCase({ type: null }),
+        DefenseBotch: EnumCase({ type: null }),
+        MeleeCombatTechniques: EnumCase({ type: null }),
+        RangedCombatBotch: EnumCase({ type: null }),
+        RangedCombatDefenseBotch: EnumCase({ type: null }),
+        RangedCombatTechniques: EnumCase({ type: null }),
+        CombatSpecialAbilities: EnumCase({ type: null }),
+        Properties: EnumCase({ type: null }),
+        SpellBotch: EnumCase({ type: null }),
+        Services: EnumCase({ type: null }),
+        ProtectiveAndWardingCircles: EnumCase({ type: null }),
+        Elixirs: EnumCase({ type: null }),
+        StaffEnchantments: EnumCase({ type: null }),
+        FamiliarsTricks: EnumCase({ type: null }),
+        Curses: EnumCase({ type: null }),
+        ElvenMagicalSongs: EnumCase({ type: null }),
+        MagicalSpecialAbilities: EnumCase({ type: null }),
+        Cantrips: EnumCase({ type: null }),
+        Spells: EnumCase({ type: null }),
+        Rituals: EnumCase({ type: null }),
+        Aspects: EnumCase({ type: null }),
+        LiturgyBotch: EnumCase({ type: null }),
+        KarmaSpecialAbilities: EnumCase({ type: null }),
+        Blessings: EnumCase({ type: null }),
+        LiturgicalChants: EnumCase({ type: null }),
+        Ceremonies: EnumCase({ type: null }),
+        SocialStatuses: EnumCase({ type: null }),
+        Poisons: EnumCase({ type: null }),
+        Diseases: EnumCase({ type: null }),
+        HealingHerbs: EnumCase({ type: null }),
+        VisibilityModifier: EnumCase({ type: null }),
+        Demons: EnumCase({ type: null }),
+        Elementals: EnumCase({ type: null }),
+        Animals: EnumCase({ type: null }),
+        Familiars: EnumCase({ type: null }),
+        AnimalSpecialAbilities: EnumCase({ type: null }),
+        EquipmentPackages: EnumCase({ type: null }),
+        Items: EnumCase({ type: null }),
+        OptionalRules: EnumCase({ type: null }),
+        ImprovementCost: EnumCase({ type: IncludeIdentifier(ReferenceListNodeImprovementCostSource) }),
+    }),
+});
+const ReferenceListNodeImprovementCostSource = TypeAlias(import.meta.url, {
+    name: "ReferenceListNodeImprovementCostSource",
+    type: () => Object({
+        target: 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: IncludeIdentifier(ReferenceListNodeImprovementCostSourceTarget),
+        }),
+        maximum_rating: 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: Integer({ minimum: 12 }),
+        }),
+    }),
+});
+const ReferenceListNodeImprovementCostSourceTarget = Enum(import.meta.url, {
+    name: "ReferenceListNodeImprovementCostSourceTarget",
+    values: () => ({
+        Attributes: EnumCase({ type: null }),
+        Skills: EnumCase({ type: null }),
+    }),
+});
+const ReferenceNode = TypeAlias(import.meta.url, {
+    name: "ReferenceNode",
+    comment: "Generate the full text for a single entry as part of this core rule's text.",
+    type: () => Object({
+        id: Required({
+            comment: "The nested core rule’s identifier.",
+            type: IncludeIdentifier(CoreRuleDerivableContentIdentifier),
+        }),
+    }),
+});