@optolith/database-schema 0.42.1

package/lib/types/MetaCondition.d.ts

@@ -0,0 +1,53 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const MetaCondition: DB.Entity<"MetaCondition", {
+    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<"MetaConditionTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        rules: DB.MemberDecl<DB.String, false>;
+        effects: DB.MemberDecl<DB.Array<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/MetaCondition.js

@@ -0,0 +1,39 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const MetaCondition = DB.Entity(import.meta.url, {
+    name: "MetaCondition",
+    namePlural: "MetaConditions",
+    comment: "Meta Conditions are rule elements that work like conditions in the sense that they have four levels with different effects, but which are not explicitly listed as conditions.",
+    type: () => DB.Object({
+        src,
+        translations: NestedTranslationMap(DB.Required, "MetaCondition", DB.Object({
+            name: DB.Required({
+                comment: "The meta condition’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            rules: DB.Optional({
+                comment: "Additional rules for the meta condition, if applicable.",
+                type: DB.String({ minLength: 1, markdown: "block" }),
+            }),
+            effects: DB.Required({
+                comment: "The effects for level 1 to 4.",
+                type: DB.Array(DB.String({ minLength: 1, markdown: "block" }), {
+                    minItems: 4,
+                    maxItems: 4,
+                }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});

package/lib/types/PactCategory.d.ts

@@ -0,0 +1,75 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PactCategory: DB.Entity<"PactCategory", {
+    types: DB.MemberDecl<DB.ChildEntities<DB.Entity<"PactType", {
+        parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PactTypeTranslation", {
+            name: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }, "parent">>, true>;
+    domains: DB.MemberDecl<DB.ChildEntities<DB.Entity<"PactDomain", {
+        parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"PactDomainTranslation", {
+            name: DB.MemberDecl<DB.String, true>;
+        }>, true>;
+    }, "parent">>, 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<"PactCategoryTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
+        }>, []>>>, []>>, false>;
+    }>, true>;
+}, undefined>;
+export declare const PactType: DB.Entity<"PactType", {
+    parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PactTypeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, "parent">;
+export declare const PactDomain: DB.Entity<"PactDomain", {
+    parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PactDomainTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, "parent">;

package/lib/types/PactCategory.js

@@ -0,0 +1,102 @@
+import * as DB from "tsondb/schema/dsl";
+import { PactCategoryIdentifier } from "./_Identifier.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { Errata } from "./source/_Erratum.js";
+import { src } from "./source/_PublicationRef.js";
+export const PactCategory = DB.Entity(import.meta.url, {
+    name: "PactCategory",
+    namePlural: "PactCategories",
+    type: () => DB.Object({
+        types: DB.Required({
+            comment: "Types of creatures in this category.",
+            type: DB.ChildEntities(PactType),
+        }),
+        domains: DB.Required({
+            comment: "Domains in this category.",
+            type: DB.ChildEntities(PactDomain),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "PactCategory", DB.Object({
+            name: DB.Required({
+                comment: "The pact category’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+export const PactType = DB.Entity(import.meta.url, {
+    name: "PactType",
+    namePlural: "PactTypes",
+    type: () => DB.Object({
+        parent: DB.Required({
+            comment: "The pact category this type belongs to.",
+            type: PactCategoryIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Required, "PactType", DB.Object({
+            name: DB.Required({
+                comment: "The type’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    instanceDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: `${getDisplayNameForInstanceId("PactCategory", instance.parent)?.name ?? ""} — ${instanceDisplayName}`,
+        localeId: instanceDisplayNameLocaleId,
+    }),
+    uniqueConstraints: [
+        [
+            {
+                keyPath: "parent",
+            },
+            {
+                entityMapKeyPath: "translations",
+                keyPathInEntityMap: "name",
+            },
+        ],
+    ],
+});
+export const PactDomain = DB.Entity(import.meta.url, {
+    name: "PactDomain",
+    namePlural: "PactDomains",
+    type: () => DB.Object({
+        parent: DB.Required({
+            comment: "The pact category this domain belongs to.",
+            type: PactCategoryIdentifier(),
+        }),
+        translations: NestedTranslationMap(DB.Required, "PactDomain", DB.Object({
+            name: DB.Required({
+                comment: "The domain’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    parentReferenceKey: "parent",
+    instanceDisplayName: {},
+    instanceDisplayNameCustomizer: ({ instance, instanceDisplayName, instanceDisplayNameLocaleId, getDisplayNameForInstanceId, }) => ({
+        name: `${getDisplayNameForInstanceId("PactCategory", instance.parent)?.name ?? ""} — ${instanceDisplayName}`,
+        localeId: instanceDisplayNameLocaleId,
+    }),
+    uniqueConstraints: [
+        [
+            {
+                keyPath: "parent",
+            },
+            {
+                entityMapKeyPath: "translations",
+                keyPathInEntityMap: "name",
+            },
+        ],
+    ],
+});

package/lib/types/Patron.d.ts

@@ -0,0 +1,101 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const Patron: DB.Entity<"Patron", {
+    category: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    skills: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    culture: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PatronCulture", DB.Object<{
+        set: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        operation: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"PatronCultureOperation", {
+            Intersection: DB.EnumCase<null>;
+            Difference: DB.EnumCase<null>;
+        }, []>>, false>;
+    }>, []>>, true>;
+    powers: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimalPowers", DB.Object<{
+        level1: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimalPowersLevel1", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AnimalPowerLevel1", {
+            Advantage: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdvantageAnimalPower", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                level: DB.MemberDecl<DB.Integer, false>;
+                option: DB.MemberDecl<DB.Integer, false>;
+            }>, []>>>;
+            Skill: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillAnimalPower", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                points: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>>, []>>, true>;
+        level2: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimalPowersLevel2", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AnimalPowerLevel2", {
+            Combat: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CombatAnimalPower", DB.Object<{
+                id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CombatAnimalPowerType", {
+                    Attack: DB.EnumCase<null>;
+                    Parry: DB.EnumCase<null>;
+                    RangedCombat: DB.EnumCase<null>;
+                    Dodge: DB.EnumCase<null>;
+                    DamagePoints: DB.EnumCase<null>;
+                    Protection: DB.EnumCase<null>;
+                }, []>>, true>;
+                value: DB.MemberDecl<DB.Integer, false>;
+            }>, []>>>;
+        }, []>>>, []>>, true>;
+        level3: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimalPowersLevel3", DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AnimalPowerLevel3", {
+            Attribute: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AttributeAnimalPower", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                value: DB.MemberDecl<DB.Integer, true>;
+            }>, []>>>;
+        }, []>>>, []>>, true>;
+    }>, []>>, false>;
+    ae_cost: DB.MemberDecl<DB.Integer, false>;
+    improvement_cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ImprovementCost", {
+        A: DB.EnumCase<null>;
+        B: DB.EnumCase<null>;
+        C: DB.EnumCase<null>;
+        D: DB.EnumCase<null>;
+    }, []>>, false>;
+    common_advantages: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    common_disadvantages: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
+    common_spellworks: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"SpellworkIdentifier", {
+        Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+        Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+    }, []>>>, 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<"PatronTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/Patron.js

@@ -0,0 +1,203 @@
+import * as DB from "tsondb/schema/dsl";
+import { AdvantageIdentifier, AttributeIdentifier, DisadvantageIdentifier, PatronCategoryIdentifier, SkillIdentifier, TribeIdentifier, } from "./_Identifier.js";
+import { SpellworkIdentifier } from "./_IdentifierGroup.js";
+import { ImprovementCost } from "./_ImprovementCost.js";
+import { NestedTranslationMap } from "./Locale.js";
+import { src } from "./source/_PublicationRef.js";
+export const Patron = DB.Entity(import.meta.url, {
+    name: "Patron",
+    namePlural: "Patrons",
+    type: () => DB.Object({
+        category: DB.Required({
+            comment: "The patron’s category.",
+            type: PatronCategoryIdentifier(),
+        }),
+        skills: DB.Required({
+            comment: "The patron-specific skills.",
+            type: DB.Array(SkillIdentifier(), { minItems: 3, maxItems: 3 }),
+        }),
+        culture: DB.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: DB.IncludeIdentifier(PatronCulture),
+        }),
+        powers: DB.Optional({
+            comment: "The patron-specific powers. Used by animist power Animal Powers I–III and should only be present on animal patrons.",
+            type: DB.IncludeIdentifier(AnimalPowers),
+        }),
+        ae_cost: DB.Optional({
+            comment: "The patron-specific AE cost. Used by several animist forces for animal patrons.",
+            type: DB.Integer({ minimum: 2, multipleOf: 2 }),
+        }),
+        improvement_cost: DB.Optional({
+            comment: "The patron-specific improvement cost. Used by several animist forces for animal patrons.",
+            type: DB.IncludeIdentifier(ImprovementCost),
+        }),
+        common_advantages: DB.Optional({
+            comment: `The patron may grant common advantages that are taken into account during character creation.
+
+*Source:* Geisterwald & Knochenklippen, p. 6-7`,
+            type: DB.Array(AdvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        common_disadvantages: DB.Optional({
+            comment: `The patron may grant common disadvantages that are taken into account during character creation.
+
+*Source:* Geisterwald & Knochenklippen, p. 6-7`,
+            type: DB.Array(DisadvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        common_spellworks: DB.Optional({
+            comment: `The animist may learn spellworks common for this patron.
+
+*Source:* Geisterwald & Knochenklippen, p. 6-7`,
+            type: DB.Array(DB.IncludeIdentifier(SpellworkIdentifier), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
+        }),
+        src,
+        translations: NestedTranslationMap(DB.Required, "Patron", DB.Object({
+            name: DB.Required({
+                comment: "The patron’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});
+const PatronCulture = DB.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: () => DB.Object({
+        set: DB.Required({
+            type: DB.Array(TribeIdentifier(), { uniqueItems: true }),
+        }),
+        operation: DB.Optional({
+            type: DB.IncludeIdentifier(PatronCultureOperation),
+        }),
+    }),
+});
+const PatronCultureOperation = DB.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: DB.EnumCase({ type: null }),
+        Difference: DB.EnumCase({ type: null }),
+    }),
+});
+const AnimalPowers = DB.TypeAlias(import.meta.url, {
+    name: "AnimalPowers",
+    type: () => DB.Object({
+        level1: DB.Required({
+            type: DB.IncludeIdentifier(AnimalPowersLevel1),
+        }),
+        level2: DB.Required({
+            type: DB.IncludeIdentifier(AnimalPowersLevel2),
+        }),
+        level3: DB.Required({
+            type: DB.IncludeIdentifier(AnimalPowersLevel3),
+        }),
+    }),
+});
+const AdvantageAnimalPower = DB.TypeAlias(import.meta.url, {
+    name: "AdvantageAnimalPower",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The advantage’s identifier.",
+            type: AdvantageIdentifier(),
+        }),
+        level: DB.Optional({
+            comment: "It grants a higher level of the advantage.",
+            type: DB.Integer({ minimum: 2 }),
+        }),
+        option: DB.Optional({
+            comment: "It grants a specific general option of the advantage.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const SkillAnimalPower = DB.TypeAlias(import.meta.url, {
+    name: "SkillAnimalPower",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The skill’s identifier.",
+            type: SkillIdentifier(),
+        }),
+        points: DB.Required({
+            comment: "The points that gets added to the skill’s rating.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const AnimalPowerLevel1 = DB.Enum(import.meta.url, {
+    name: "AnimalPowerLevel1",
+    values: () => ({
+        Advantage: DB.EnumCase({ type: DB.IncludeIdentifier(AdvantageAnimalPower) }),
+        Skill: DB.EnumCase({ type: DB.IncludeIdentifier(SkillAnimalPower) }),
+    }),
+});
+const AnimalPowersLevel1 = DB.TypeAlias(import.meta.url, {
+    name: "AnimalPowersLevel1",
+    type: () => DB.Array(DB.IncludeIdentifier(AnimalPowerLevel1), { minItems: 1, uniqueItems: true }),
+});
+const CombatAnimalPower = DB.TypeAlias(import.meta.url, {
+    name: "CombatAnimalPower",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The combat value.",
+            type: DB.IncludeIdentifier(CombatAnimalPowerType),
+        }),
+        value: DB.Optional({
+            comment: "The value that gets added to the combat value.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const CombatAnimalPowerType = DB.Enum(import.meta.url, {
+    name: "CombatAnimalPowerType",
+    values: () => ({
+        Attack: DB.EnumCase({ type: null }),
+        Parry: DB.EnumCase({ type: null }),
+        RangedCombat: DB.EnumCase({ type: null }),
+        Dodge: DB.EnumCase({ type: null }),
+        DamagePoints: DB.EnumCase({ type: null }),
+        Protection: DB.EnumCase({ type: null }),
+    }),
+});
+const AnimalPowerLevel2 = DB.Enum(import.meta.url, {
+    name: "AnimalPowerLevel2",
+    values: () => ({
+        Combat: DB.EnumCase({ type: DB.IncludeIdentifier(CombatAnimalPower) }),
+    }),
+});
+const AnimalPowersLevel2 = DB.TypeAlias(import.meta.url, {
+    name: "AnimalPowersLevel2",
+    type: () => DB.Array(DB.IncludeIdentifier(AnimalPowerLevel2), { minItems: 1, uniqueItems: true }),
+});
+const AttributeAnimalPower = DB.TypeAlias(import.meta.url, {
+    name: "AttributeAnimalPower",
+    type: () => DB.Object({
+        id: DB.Required({
+            comment: "The attribute’s identifier.",
+            type: AttributeIdentifier(),
+        }),
+        value: DB.Required({
+            comment: "The value that gets added to the attribute.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+    }),
+});
+const AnimalPowerLevel3 = DB.Enum(import.meta.url, {
+    name: "AnimalPowerLevel3",
+    values: () => ({
+        Attribute: DB.EnumCase({ type: DB.IncludeIdentifier(AttributeAnimalPower) }),
+    }),
+});
+const AnimalPowersLevel3 = DB.TypeAlias(import.meta.url, {
+    name: "AnimalPowersLevel3",
+    type: () => DB.Array(DB.IncludeIdentifier(AnimalPowerLevel3), { minItems: 1, uniqueItems: true }),
+});

package/lib/types/PatronCategory.d.ts

@@ -0,0 +1,7 @@
+import * as DB from "tsondb/schema/dsl";
+export declare const PatronCategory: DB.Entity<"PatronCategory", {
+    primary_patron_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PatronCategoryTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+    }>, true>;
+}, undefined>;

package/lib/types/PatronCategory.js

@@ -0,0 +1,26 @@
+import * as DB from "tsondb/schema/dsl";
+import { NestedTranslationMap } from "./Locale.js";
+import { CultureIdentifier } from "./_Identifier.js";
+export const PatronCategory = DB.Entity(import.meta.url, {
+    name: "PatronCategory",
+    namePlural: "PatronCategories",
+    type: () => DB.Object({
+        primary_patron_cultures: DB.Required({
+            comment: "The list of cultures where patrons from this category can be the primary patron of.",
+            type: DB.Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
+        }),
+        translations: NestedTranslationMap(DB.Required, "PatronCategory", DB.Object({
+            name: DB.Required({
+                comment: "The patron category’s name.",
+                type: DB.String({ minLength: 1 }),
+            }),
+        })),
+    }),
+    instanceDisplayName: {},
+    uniqueConstraints: [
+        {
+            entityMapKeyPath: "translations",
+            keyPathInEntityMap: "name",
+        },
+    ],
+});