optolith-database-schema 0.17.0 → 0.18.1

package/lib/types/Patron.d.ts

@@ -1,197 +1,100 @@
-/**
- * @main Patron
- */
-import { TypeConfig } from "../typeConfig.js";
-import { AdvantageIdentifier, AttributeIdentifier, SkillIdentifier } from "./_Identifier.js";
-import { ImprovementCost } from "./_ImprovementCost.js";
-import { LocaleMap } from "./_LocaleMap.js";
-import { NonEmptyString } from "./_NonEmptyString.js";
-import { AdvantageReference, CultureReference, DisadvantageReference, PatronCategoryReference, SkillReference, SpellworkReference } from "./_SimpleReferences.js";
-/**
- * @title Patron
- */
-export type Patron = {
-    /**
-     * The patron's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    /**
-     * The patron's category.
-     */
-    category: PatronCategoryReference;
-    /**
-     * The patron-specific skills.
-     */
-    skills: [SkillReference, SkillReference, SkillReference];
-    /**
-     * The patron is only available to a certain set of cultures. It may be
-     * available to all, it may be available to only specific ones (intersection)
-     * and it may be available to all except specific ones to the listed cultures
-     * (difference).
-     */
-    culture: PatronCulture;
-    /**
-     * The list of cultures where patrons from this category can be the primary
-     * patron of.
-     * @uniqueItems
-     */
-    primary_patron_cultures?: CultureReference[];
-    /**
-     * The patron-specific powers. Used by animist power Animal Powers I–III and
-     * should only be present on animal patrons.
-     */
-    powers?: [AnimalPowersLevel1, AnimalPowersLevel2, AnimalPowersLevel3];
-    /**
-     * The patron-specific AE cost. Used by several animist forces for animal
-     * patrons.
-     * @integer
-     * @minimum 2
-     * @multipleOf 2
-     */
-    ae_cost?: number;
-    /**
-     * The patron-specific improvement cost. Used by several animist forces for
-     * animal patrons.
-     */
-    improvement_cost?: ImprovementCost;
-    /**
-     * The patron may grant common advantages that are taken into account during
-     * character creation.
-     *
-     * *Source:* Geisterwald & Knochenklippen, p. 6-7
-     * @minLength 1
-     */
-    common_advantages?: AdvantageReference[];
-    /**
-     * The patron may grant common disadvantages that are taken into account
-     * during character creation.
-     *
-     * *Source:* Geisterwald & Knochenklippen, p. 6-7
-     * @minLength 1
-     */
-    common_disadvantages?: DisadvantageReference[];
-    /**
-     * The animist may learn spellworks common for this patron.
-     *
-     * *Source:* Geisterwald & Knochenklippen, p. 6-7
-     * @minLength 1
-     */
-    common_spellworks?: SpellworkReference[];
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<PatronTranslation>;
-};
-export type PatronTranslation = {
-    /**
-     * The name of the patron.
-     */
-    name: NonEmptyString;
-};
-/**
- * The patron cultures the patron is or is not part of. If the patron is part of
- * all patron cultures, the set should be empty and the operation should be
- * difference.
- */
-export type PatronCulture = {
-    set: CultureReference[];
-    operation: PatronCultureOperation;
-};
-/**
- * The set operation to combine the set of all patron cultures with the
- * specified set of patron cultures: If they should intersect, the patron is
- * only part of the given cultures. If they should differ, the patron is only
- * part of the cultures that are not given.
- */
-export type PatronCultureOperation = "Intersection" | "Difference";
-export type AdvantageAnimalPower = {
-    /**
-     * The advantage's identifier.
-     * @integer
-     * @minimum 1
-     */
-    id: AdvantageIdentifier;
-    /**
-     * It grants a higher level of the advantage.
-     * @integer
-     * @minimum 2
-     */
-    level?: number;
-    /**
-     * It grants a specific general option of the advantage.
-     * @integer
-     * @minimum 1
-     */
-    option?: number;
-};
-export type SkillAnimalPower = {
-    /**
-     * The skill's identifier.
-     * @integer
-     * @minimum 1
-     */
-    id: SkillIdentifier;
-    /**
-     * The points that gets added to the skill's rating.
-     * @integer
-     * @minimum 1
-     */
-    points: number;
-};
-export type AnimalPowerLevel1 = {
-    tag: "Advantage";
-    advantage: AdvantageAnimalPower;
-} | {
-    tag: "Skill";
-    skill: SkillAnimalPower;
-};
-/**
- * @minItems 1
- */
-export type AnimalPowersLevel1 = AnimalPowerLevel1[];
-export type CombatAnimalPower = {
-    /**
-     * The combat value.
-     */
-    id: CombatAnimalPowerType;
-    /**
-     * The value that gets added to the combat value.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-};
-export type CombatAnimalPowerType = "Attack" | "Parry" | "RangedCombat" | "Dodge" | "DamagePoints" | "Protection";
-export type AnimalPowerLevel2 = {
-    tag: "Combat";
-    combat: CombatAnimalPower;
-};
-/**
- * @minItems 1
- */
-export type AnimalPowersLevel2 = AnimalPowerLevel2[];
-export type AttributeAnimalPower = {
-    /**
-     * The attribute's identifier.
-     * @integer
-     * @minimum 1
-     */
-    id: AttributeIdentifier;
-    /**
-     * The value that gets added to the attribute.
-     * @integer
-     * @minimum 1
-     */
-    value: number;
-};
-export type AnimalPowerLevel3 = {
-    tag: "Attribute";
-    attribute: AttributeAnimalPower;
-};
-/**
- * @minItems 1
- */
-export type AnimalPowersLevel3 = AnimalPowerLevel3[];
-export declare const config: TypeConfig<Patron, Patron["id"], "Patron">;
+import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
+export declare const Patron: Entity<"Patron", {
+    category: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+    skills: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    culture: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PatronCulture", Object<{
+        set: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        operation: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"PatronCultureOperation", {
+            Intersection: EnumCase<null>;
+            Difference: EnumCase<null>;
+        }, []>>, false>;
+    }>, []>>, true>;
+    powers: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AnimalPowers", Object<{
+        level1: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AnimalPowersLevel1", Array<IncludeIdentifier<[], Enum<"AnimalPowerLevel1", {
+            Advantage: EnumCase<IncludeIdentifier<[], TypeAlias<"AdvantageAnimalPower", Object<{
+                id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+                level: import("tsondb/schema/def").MemberDecl<Integer, false>;
+                option: import("tsondb/schema/def").MemberDecl<Integer, false>;
+            }>, []>>>;
+            Skill: EnumCase<IncludeIdentifier<[], TypeAlias<"SkillAnimalPower", Object<{
+                id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+                points: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            }>, []>>>;
+        }, []>>>, []>>, true>;
+        level2: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AnimalPowersLevel2", Array<IncludeIdentifier<[], Enum<"AnimalPowerLevel2", {
+            Combat: EnumCase<IncludeIdentifier<[], TypeAlias<"CombatAnimalPower", Object<{
+                id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CombatAnimalPowerType", {
+                    Attack: EnumCase<null>;
+                    Parry: EnumCase<null>;
+                    RangedCombat: EnumCase<null>;
+                    Dodge: EnumCase<null>;
+                    DamagePoints: EnumCase<null>;
+                    Protection: EnumCase<null>;
+                }, []>>, true>;
+                value: import("tsondb/schema/def").MemberDecl<Integer, false>;
+            }>, []>>>;
+        }, []>>>, []>>, true>;
+        level3: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AnimalPowersLevel3", Array<IncludeIdentifier<[], Enum<"AnimalPowerLevel3", {
+            Attribute: EnumCase<IncludeIdentifier<[], TypeAlias<"AttributeAnimalPower", Object<{
+                id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
+                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            }>, []>>>;
+        }, []>>>, []>>, true>;
+    }>, []>>, false>;
+    ae_cost: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ImprovementCost", {
+        A: EnumCase<null>;
+        B: EnumCase<null>;
+        C: EnumCase<null>;
+        D: EnumCase<null>;
+    }, []>>, false>;
+    common_advantages: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, false>;
+    common_disadvantages: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, false>;
+    common_spellworks: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"SpellworkIdentifier", {
+        Spell: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+        Ritual: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    }, []>>>, false>;
+    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<"PatronTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/Patron.js

@@ -1,14 +1,196 @@
-/**
- * @main Patron
- */
-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, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, PatronCategoryIdentifier, SkillIdentifier, } from "./_Identifier.js";
+import { SpellworkIdentifier } from "./_IdentifierGroup.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { NestedLocaleMap } from "./Locale.js";
+import { src } from "./source/_PublicationRef.js";
+export const Patron = Entity(import.meta.url, {
     name: "Patron",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("Patron"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "Patrons",
+    type: () => Object({
+        category: Required({
+            comment: "The patron’s category.",
+            type: PatronCategoryIdentifier(),
+        }),
+        skills: Required({
+            comment: "The patron-specific skills.",
+            type: Array(SkillIdentifier(), { minItems: 3, maxItems: 3 }),
+        }),
+        culture: Required({
+            comment: "The patron is only available to a certain set of cultures. It may be available to all, it may be available to only specific ones (intersection) and it may be available to all except specific ones to the listed cultures (difference).",
+            type: IncludeIdentifier(PatronCulture),
+        }),
+        powers: Optional({
+            comment: "The patron-specific powers. Used by animist power Animal Powers I–III and should only be present on animal patrons.",
+            type: IncludeIdentifier(AnimalPowers),
+        }),
+        ae_cost: Optional({
+            comment: "The patron-specific AE cost. Used by several animist forces for animal patrons.",
+            type: Integer({ minimum: 2, multipleOf: 2 }),
+        }),
+        improvement_cost: Optional({
+            comment: "The patron-specific improvement cost. Used by several animist forces for animal patrons.",
+            type: IncludeIdentifier(ImprovementCost),
+        }),
+        common_advantages: Optional({
+            comment: `The patron may grant common advantages that are taken into account during character creation.
+
+*Source:* Geisterwald & Knochenklippen, p. 6-7`,
+            type: Array(AdvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        common_disadvantages: Optional({
+            comment: `The patron may grant common disadvantages that are taken into account during character creation.
+
+*Source:* Geisterwald & Knochenklippen, p. 6-7`,
+            type: Array(DisadvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        common_spellworks: Optional({
+            comment: `The animist may learn spellworks common for this patron.
+
+*Source:* Geisterwald & Knochenklippen, p. 6-7`,
+            type: Array(IncludeIdentifier(SpellworkIdentifier), { minItems: 1, uniqueItems: true }),
+        }),
+        src,
+        translations: NestedLocaleMap(Required, "PatronTranslation", Object({
+            name: Required({
+                comment: "The patron’s name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    displayName: {},
+});
+const PatronCulture = TypeAlias(import.meta.url, {
+    name: "PatronCulture",
+    comment: "The patron cultures the patron is or is not part of. If the patron is part of all patron cultures, the set should be empty and the operation should be difference.",
+    type: () => Object({
+        set: Required({
+            comment: "The AE cost value.",
+            type: Array(CultureIdentifier(), { uniqueItems: true }),
+        }),
+        operation: Optional({
+            comment: "The interval in which you have to pay the AE cost again.",
+            type: IncludeIdentifier(PatronCultureOperation),
+        }),
+    }),
+});
+const PatronCultureOperation = Enum(import.meta.url, {
+    name: "PatronCultureOperation",
+    comment: "The set operation to combine the set of all patron cultures with the specified set of patron cultures: If they should intersect, the patron is only part of the given cultures. If they should differ, the patron is only part of the cultures that are not given.",
+    values: () => ({
+        Intersection: EnumCase({ type: null }),
+        Difference: EnumCase({ type: null }),
+    }),
+});
+const AnimalPowers = TypeAlias(import.meta.url, {
+    name: "AnimalPowers",
+    type: () => Object({
+        level1: Required({
+            type: IncludeIdentifier(AnimalPowersLevel1),
+        }),
+        level2: Required({
+            type: IncludeIdentifier(AnimalPowersLevel2),
+        }),
+        level3: Required({
+            type: IncludeIdentifier(AnimalPowersLevel3),
+        }),
+    }),
+});
+const AdvantageAnimalPower = TypeAlias(import.meta.url, {
+    name: "AdvantageAnimalPower",
+    type: () => Object({
+        id: Required({
+            comment: "The advantage’s identifier.",
+            type: AdvantageIdentifier(),
+        }),
+        level: Optional({
+            comment: "It grants a higher level of the advantage.",
+            type: Integer({ minimum: 2 }),
+        }),
+        option: Optional({
+            comment: "It grants a specific general option of the advantage.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const SkillAnimalPower = TypeAlias(import.meta.url, {
+    name: "SkillAnimalPower",
+    type: () => Object({
+        id: Required({
+            comment: "The skill’s identifier.",
+            type: SkillIdentifier(),
+        }),
+        points: Required({
+            comment: "The points that gets added to the skill’s rating.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const AnimalPowerLevel1 = Enum(import.meta.url, {
+    name: "AnimalPowerLevel1",
+    values: () => ({
+        Advantage: EnumCase({ type: IncludeIdentifier(AdvantageAnimalPower) }),
+        Skill: EnumCase({ type: IncludeIdentifier(SkillAnimalPower) }),
+    }),
+});
+const AnimalPowersLevel1 = TypeAlias(import.meta.url, {
+    name: "AnimalPowersLevel1",
+    type: () => Array(IncludeIdentifier(AnimalPowerLevel1), { minItems: 1, uniqueItems: true }),
+});
+const CombatAnimalPower = TypeAlias(import.meta.url, {
+    name: "CombatAnimalPower",
+    type: () => Object({
+        id: Required({
+            comment: "The combat value.",
+            type: IncludeIdentifier(CombatAnimalPowerType),
+        }),
+        value: Optional({
+            comment: "The value that gets added to the combat value.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const CombatAnimalPowerType = Enum(import.meta.url, {
+    name: "CombatAnimalPowerType",
+    values: () => ({
+        Attack: EnumCase({ type: null }),
+        Parry: EnumCase({ type: null }),
+        RangedCombat: EnumCase({ type: null }),
+        Dodge: EnumCase({ type: null }),
+        DamagePoints: EnumCase({ type: null }),
+        Protection: EnumCase({ type: null }),
+    }),
+});
+const AnimalPowerLevel2 = Enum(import.meta.url, {
+    name: "AnimalPowerLevel2",
+    values: () => ({
+        Combat: EnumCase({ type: IncludeIdentifier(CombatAnimalPower) }),
+    }),
+});
+const AnimalPowersLevel2 = TypeAlias(import.meta.url, {
+    name: "AnimalPowersLevel2",
+    type: () => Array(IncludeIdentifier(AnimalPowerLevel2), { minItems: 1, uniqueItems: true }),
+});
+const AttributeAnimalPower = TypeAlias(import.meta.url, {
+    name: "AttributeAnimalPower",
+    type: () => Object({
+        id: Required({
+            comment: "The attribute’s identifier.",
+            type: AttributeIdentifier(),
+        }),
+        value: Required({
+            comment: "The value that gets added to the attribute.",
+            type: Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const AnimalPowerLevel3 = Enum(import.meta.url, {
+    name: "AnimalPowerLevel3",
+    values: () => ({
+        Attribute: EnumCase({ type: IncludeIdentifier(AttributeAnimalPower) }),
+    }),
+});
+const AnimalPowersLevel3 = TypeAlias(import.meta.url, {
+    name: "AnimalPowersLevel3",
+    type: () => Array(IncludeIdentifier(AnimalPowerLevel3), { minItems: 1, uniqueItems: true }),
+});

package/lib/types/PatronCategory.d.ts

@@ -1,36 +1,7 @@
-/**
- * @main PatronCategory
- */
-import { TypeConfig } from "../typeConfig.js";
-import { LocaleMap } from "./_LocaleMap.js";
-import { NonEmptyString } from "./_NonEmptyString.js";
-import { CultureReference } from "./_SimpleReferences.js";
-/**
- * @title Patron Category
- */
-export type PatronCategory = {
-    /**
-     * The patron category's identifier. An unique, increasing integer.
-     * @integer
-     * @minimum 1
-     */
-    id: number;
-    /**
-     * The list of cultures where patrons from this category can be the primary
-     * patron of.
-     * @minItems 1
-     * @uniqueItems
-     */
-    primary_patron_cultures: CultureReference[];
-    /**
-     * All translations for the entry, identified by IETF language tag (BCP47).
-     */
-    translations: LocaleMap<PatronCategoryTranslation>;
-};
-export type PatronCategoryTranslation = {
-    /**
-     * The name of the patron category.
-     */
-    name: NonEmptyString;
-};
-export declare const config: TypeConfig<PatronCategory, PatronCategory["id"], "PatronCategory">;
+import { Array, Entity, String } from "tsondb/schema/def";
+export declare const PatronCategory: Entity<"PatronCategory", {
+    primary_patron_cultures: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PatronCategoryTranslation", {
+        name: import("tsondb/schema/def").MemberDecl<String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/PatronCategory.js

@@ -1,14 +1,20 @@
-/**
- * @main PatronCategory
- */
-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, Object, Required, String } from "tsondb/schema/def";
+import { NestedLocaleMap } from "./Locale.js";
+import { CultureIdentifier } from "./_Identifier.js";
+export const PatronCategory = Entity(import.meta.url, {
     name: "PatronCategory",
-    id: getFilenamePrefixAsNumericId,
-    integrityValidator: todo("PatronCategory"),
-    schemaValidator: createSchemaValidator(import.meta.url),
-    fileNameValidator: validateEntityFileName,
-};
+    namePlural: "PatronCategories",
+    type: () => Object({
+        primary_patron_cultures: Required({
+            comment: "The list of cultures where patrons from this category can be the primary patron of.",
+            type: Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        translations: NestedLocaleMap(Required, "PatronCategoryTranslation", Object({
+            name: Required({
+                comment: "The patron category’s name.",
+                type: String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    displayName: {},
+});