optolith-database-schema 0.17.2 → 0.18.1

package/lib/types/Ceremony.js

@@ -1,14 +1,88 @@
-/**
- * @main Ceremony
- */
-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, ChildEntities, Entity, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
+import { OldParameter, SlowPerformanceParameters } from "./_ActivatableSkill.js";
+import { ActivatableSkillEffect } from "./_ActivatableSkillEffect.js";
+import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
+import { LiturgyTradition } from "./_Blessed.js";
+import { Enhancement } from "./_Enhancements.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { LiturgyPrerequisites } from "./_Prerequisite.js";
+import { SkillCheck, SkillCheckPenalty } from "./_SkillCheck.js";
+import { NestedLocaleMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Ceremony = Entity(import.meta.url, {
     name: "Ceremony",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("Ceremony"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "Ceremonies",
+    type: () => Object({
+        check: Required({
+            comment: "Lists the linked three attributes used to make a skill check.",
+            type: IncludeIdentifier(SkillCheck),
+        }),
+        check_penalty: Optional({
+            comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
+            type: IncludeIdentifier(SkillCheckPenalty),
+        }),
+        parameters: Required({
+            comment: "Measurable parameters of a ceremony.",
+            type: IncludeIdentifier(SlowPerformanceParameters),
+        }),
+        target: Required({
+            comment: "The target category – the kind of creature or object – the skill affects.",
+            type: IncludeIdentifier(AffectedTargetCategories),
+        }),
+        traditions: Required({
+            comment: "The tradition(s) the ceremony is available for. Note that general aspects do not have an associated tradition and thus need to be defined in a special way.",
+            type: Array(IncludeIdentifier(LiturgyTradition), { minItems: 1 }),
+        }),
+        improvement_cost: Required({
+            comment: "States which column is used to improve the skill.",
+            type: IncludeIdentifier(ImprovementCost),
+        }),
+        prerequisites: Optional({
+            comment: "The prerequisites for the ceremony.",
+            type: IncludeIdentifier(LiturgyPrerequisites),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "LiturgicalChantTranslation", Object({
+            name: Required({
+                comment: "The ceremony’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            name_compressed: Optional({
+                comment: "A compressed name of the ceremony for use in small areas (e.g. on character sheet). Should only be defined if the `name` does not fit on character sheet.",
+                type: String({ minLength: 1 }),
+            }),
+            effect: Required({
+                comment: "The effect description may be either a plain text or a text that is divided by a list of effects for each quality level. It may also be a list for each two quality levels.",
+                type: IncludeIdentifier(ActivatableSkillEffect),
+            }),
+            casting_time: Optional({
+                isDeprecated: true,
+                type: IncludeIdentifier(OldParameter),
+            }),
+            cost: Optional({
+                isDeprecated: true,
+                type: IncludeIdentifier(OldParameter),
+            }),
+            range: Optional({
+                isDeprecated: true,
+                type: IncludeIdentifier(OldParameter),
+            }),
+            duration: Optional({
+                isDeprecated: true,
+                type: IncludeIdentifier(OldParameter),
+            }),
+            target: Optional({
+                isDeprecated: true,
+                type: String({ minLength: 1 }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+        enhancements: Required({
+            type: ChildEntities(Enhancement),
+        }),
+    }),
+    displayName: {},
+});

package/lib/types/CombatTechnique.d.ts

@@ -0,0 +1,127 @@
+import { Array, Boolean, Entity, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const CloseCombatTechnique: Entity<"CloseCombatTechnique", {
+    special: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CloseCombatTechniqueSpecialRules", Object<{
+        can_parry: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        has_damage_threshold: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        has_reach: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        has_length: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+        has_shield_size: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+    }>, []>>, true>;
+    primary_attribute: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    breaking_point_rating: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ImprovementCost", {
+        A: import("tsondb/schema/def").EnumCaseDecl<null>;
+        B: import("tsondb/schema/def").EnumCaseDecl<null>;
+        C: import("tsondb/schema/def").EnumCaseDecl<null>;
+        D: import("tsondb/schema/def").EnumCaseDecl<null>;
+    }, []>>, 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<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
+                Since: import("tsondb/schema/def").EnumCaseDecl<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<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: import("tsondb/schema/def").EnumCaseDecl<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<"CloseCombatTechniqueTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        special: import("tsondb/schema/def").MemberDecl<String, false>;
+        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>;
+export declare const RangedCombatTechnique: Entity<"RangedCombatTechnique", {
+    special: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangedCombatTechniqueSpecialRules", Object<{
+        has_ammunition: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+    }>, []>>, true>;
+    primary_attribute: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    breaking_point_rating: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"ImprovementCost", {
+        A: import("tsondb/schema/def").EnumCaseDecl<null>;
+        B: import("tsondb/schema/def").EnumCaseDecl<null>;
+        C: import("tsondb/schema/def").EnumCaseDecl<null>;
+        D: import("tsondb/schema/def").EnumCaseDecl<null>;
+    }, []>>, 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<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
+                Since: import("tsondb/schema/def").EnumCaseDecl<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<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: import("tsondb/schema/def").EnumCaseDecl<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<"RangedCombatTechniqueTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        special: import("tsondb/schema/def").MemberDecl<String, false>;
+        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/CombatTechnique.js

@@ -0,0 +1,101 @@
+import { Array, Boolean, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { AttributeIdentifier } from "./_Identifier.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { NestedLocaleMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const CloseCombatTechnique = Entity(import.meta.url, {
+    name: "CloseCombatTechnique",
+    namePlural: "CloseCombatTechniques",
+    type: () => Object({
+        special: Required({
+            comment: "Special rules for the combat technique that apply to all weapons in this category.",
+            type: IncludeIdentifier(CloseCombatTechniqueSpecialRules),
+        }),
+        primary_attribute: Required({
+            comment: "The primary attribute(s).",
+            type: Array(AttributeIdentifier(), { minItems: 1, maxItems: 2, uniqueItems: true }),
+        }),
+        breaking_point_rating: Required({
+            comment: "The *Breaking Point Rating* of the respective combat technique.",
+            type: Integer({ minimum: 1 }),
+        }),
+        improvement_cost: Required({
+            comment: "States which column is used to improve the combat technique.",
+            type: IncludeIdentifier(ImprovementCost),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "CloseCombatTechniqueTranslation", Object({
+            name: Required({
+                comment: "The combat technique’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            special: Optional({
+                comment: "Additional rules for the combat technique, if applicable.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const CloseCombatTechniqueSpecialRules = TypeAlias(import.meta.url, {
+    name: "CloseCombatTechniqueSpecialRules",
+    comment: "Special rules for the combat technique that apply to all weapons in this category.",
+    type: () => Object({
+        can_parry: Required({
+            comment: "Is parrying possible with this combat technique?",
+            type: Boolean(),
+        }),
+        has_damage_threshold: Required({ type: Boolean() }),
+        has_reach: Required({ type: Boolean() }),
+        has_length: Required({ type: Boolean() }),
+        has_shield_size: Required({ type: Boolean() }),
+    }),
+});
+export const RangedCombatTechnique = Entity(import.meta.url, {
+    name: "RangedCombatTechnique",
+    namePlural: "RangedCombatTechniques",
+    type: () => Object({
+        special: Required({
+            comment: "Special rules for the combat technique that apply to all weapons in this category.",
+            type: IncludeIdentifier(RangedCombatTechniqueSpecialRules),
+        }),
+        primary_attribute: Required({
+            comment: "The primary attribute(s).",
+            type: Array(AttributeIdentifier(), { minItems: 1, maxItems: 2, uniqueItems: true }),
+        }),
+        breaking_point_rating: Required({
+            comment: "The *Breaking Point Rating* of the respective combat technique.",
+            type: Integer({ minimum: 1 }),
+        }),
+        improvement_cost: Required({
+            comment: "States which column is used to improve the combat technique.",
+            type: IncludeIdentifier(ImprovementCost),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "RangedCombatTechniqueTranslation", Object({
+            name: Required({
+                comment: "The combat technique’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            special: Optional({
+                comment: "Additional rules for the combat technique, if applicable.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const RangedCombatTechniqueSpecialRules = TypeAlias(import.meta.url, {
+    name: "RangedCombatTechniqueSpecialRules",
+    comment: "Special rules for the combat technique that apply to all weapons in this category.",
+    type: () => Object({
+        has_ammunition: Required({ type: Boolean() }),
+    }),
+});

package/lib/types/Condition.d.ts

@@ -1,40 +1,52 @@
-/**
- * @main Condition
- */
-import { TypeConfig } from "../typeConfig.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 Condition
- */
-export type Condition = {
-    /**
-     * The condition's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    src: PublicationRefs;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<ConditionTranslation>;
-};
-export type ConditionTranslation = {
-    /**
-     * The condition's name.
-     */
-    name: NonEmptyString;
-    /**
-     * Additional rules for the condition, if applicable.
-     */
-    rules?: NonEmptyMarkdown;
-    /**
-     * The effects for level 1 to 4.
-     */
-    effects: [NonEmptyMarkdown, NonEmptyMarkdown, NonEmptyMarkdown, NonEmptyMarkdown];
-    errata?: Errata;
-};
-export declare const config: TypeConfig<Condition, Condition["id"], "Condition">;
+import { Array, Entity, IncludeIdentifier, Object, String } from "tsondb/schema/def";
+export declare const Condition: Entity<"Condition", {
+    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"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<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", Object<{
+                printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
+                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
+                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                    }, []>>, true>;
+                    last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                        Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                    }, []>>, false>;
+                }>, []>>>, true>;
+            }>, []>>, true>;
+            revisions: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Revision", {
+                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Since", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
+                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                        }, []>>, true>;
+                        last_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
+                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
+                            Numbered: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IntegerType>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Deprecation", Object<{
+                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ConditionTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        rules: import("tsondb/schema/def").MemberDecl<String, false>;
+        effects: import("tsondb/schema/def").MemberDecl<Array<String>, true>;
+        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Errata", Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"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/Condition.js

@@ -1,14 +1,32 @@
-/**
- * @main Condition
- */
-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, Entity, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const Condition = Entity(import.meta.url, {
     name: "Condition",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("Condition"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "Conditions",
+    type: () => Object({
+        src,
+        translations: NestedLocaleMap(Required, "ConditionTranslation", Object({
+            name: Required({
+                comment: "The condition’s name.",
+                type: String({ minLength: 1 }),
+            }),
+            rules: Optional({
+                comment: "Additional rules for the condition, if applicable.",
+                type: String({ minLength: 1, isMarkdown: true }),
+            }),
+            effects: Required({
+                comment: "The effects for level 1 to 4.",
+                type: Array(String({ minLength: 1, isMarkdown: true }), {
+                    minItems: 4,
+                    maxItems: 4,
+                }),
+            }),
+            errata: Optional({
+                type: IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    displayName: {},
+});

package/lib/types/Continent.d.ts

@@ -1,30 +1,6 @@
-/**
- * @main Continent
- */
-import { TypeConfig } from "../typeConfig.js";
-import { LocaleMap } from "./_LocaleMap.js";
-/**
- * Continents are mostly referenced to in languages and scripts that occur on a
- * specific continent.
- * @title Continent
- */
-export type Continent = {
-    /**
-     * The continent's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<ContinentTranslation>;
-};
-export type ContinentTranslation = {
-    /**
-     * The continent name.
-     * @minLength 1
-     */
-    name: string;
-};
-export declare const config: TypeConfig<Continent, Continent["id"], "Continent">;
+import { Entity, String } from "tsondb/schema/def";
+export declare const Continent: Entity<"Continent", {
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ContinentTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/Continent.js

@@ -1,14 +1,16 @@
-/**
- * @main Continent
- */
-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 { Entity, Object, Required, String } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+export const Continent = Entity(import.meta.url, {
     name: "Continent",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("Continent"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "Continents",
+    comment: "Continents are mostly referenced to in languages and scripts that occur on a specific continent.",
+    type: () => Object({
+        translations: NestedLocaleMap(Required, "ContinentTranslation", Object({
+            name: Required({
+                comment: "The continent name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    displayName: {},
+});