optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/Patron.d.ts

@@ -1,100 +1,101 @@
-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>;
+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: 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>;
+    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: 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>;
+            Skill: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillAnimalPower", DB.Object<{
+                id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+                points: DB.MemberDecl<DB.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>;
+        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: import("tsondb/schema/def").MemberDecl<Integer, false>;
+                value: DB.MemberDecl<DB.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>;
+        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: 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>;
+    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: 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>;
+    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: 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<string, {
-            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>;
+    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: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                        InsideCoverFront: EnumCase<null>;
-                        InsideCoverBack: EnumCase<null>;
-                        Numbered: EnumCase<Integer>;
+                    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>;
             }>, []>>, false>;
-            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>;
+            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: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                            InsideCoverFront: EnumCase<null>;
-                            InsideCoverBack: EnumCase<null>;
-                            Numbered: EnumCase<Integer>;
+                        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: EnumCase<IncludeIdentifier<[], TypeAlias<"Deprecation", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.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>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"PatronTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }, undefined>;

package/lib/types/Patron.js

@@ -1,60 +1,63 @@
-import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+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 = Entity(import.meta.url, {
+export const Patron = DB.Entity(import.meta.url, {
     name: "Patron",
     namePlural: "Patrons",
-    type: () => Object({
-        category: Required({
+    type: () => DB.Object({
+        category: DB.Required({
             comment: "The patron’s category.",
             type: PatronCategoryIdentifier(),
         }),
-        skills: Required({
+        skills: DB.Required({
             comment: "The patron-specific skills.",
-            type: Array(SkillIdentifier(), { minItems: 3, maxItems: 3 }),
+            type: DB.Array(SkillIdentifier(), { minItems: 3, maxItems: 3 }),
         }),
-        culture: Required({
+        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: IncludeIdentifier(PatronCulture),
+            type: DB.IncludeIdentifier(PatronCulture),
         }),
-        powers: Optional({
+        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: IncludeIdentifier(AnimalPowers),
+            type: DB.IncludeIdentifier(AnimalPowers),
         }),
-        ae_cost: Optional({
+        ae_cost: DB.Optional({
             comment: "The patron-specific AE cost. Used by several animist forces for animal patrons.",
-            type: Integer({ minimum: 2, multipleOf: 2 }),
+            type: DB.Integer({ minimum: 2, multipleOf: 2 }),
         }),
-        improvement_cost: Optional({
+        improvement_cost: DB.Optional({
             comment: "The patron-specific improvement cost. Used by several animist forces for animal patrons.",
-            type: IncludeIdentifier(ImprovementCost),
+            type: DB.IncludeIdentifier(ImprovementCost),
         }),
-        common_advantages: Optional({
+        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: Array(AdvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+            type: DB.Array(AdvantageIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
-        common_disadvantages: Optional({
+        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: Array(DisadvantageIdentifier(), { minItems: 1, uniqueItems: true }),
+            type: DB.Array(DisadvantageIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
-        common_spellworks: Optional({
+        common_spellworks: DB.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 }),
+            type: DB.Array(DB.IncludeIdentifier(SpellworkIdentifier), {
+                minItems: 1,
+                uniqueItems: true,
+            }),
         }),
         src,
-        translations: NestedTranslationMap(Required, "Patron", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "Patron", DB.Object({
+            name: DB.Required({
                 comment: "The patron’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),
@@ -66,135 +69,135 @@ export const Patron = Entity(import.meta.url, {
         },
     ],
 });
-const PatronCulture = TypeAlias(import.meta.url, {
+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: () => Object({
-        set: Required({
-            type: Array(TribeIdentifier(), { uniqueItems: true }),
+    type: () => DB.Object({
+        set: DB.Required({
+            type: DB.Array(TribeIdentifier(), { uniqueItems: true }),
         }),
-        operation: Optional({
-            type: IncludeIdentifier(PatronCultureOperation),
+        operation: DB.Optional({
+            type: DB.IncludeIdentifier(PatronCultureOperation),
         }),
     }),
 });
-const PatronCultureOperation = Enum(import.meta.url, {
+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: EnumCase({ type: null }),
-        Difference: EnumCase({ type: null }),
+        Intersection: DB.EnumCase({ type: null }),
+        Difference: DB.EnumCase({ type: null }),
     }),
 });
-const AnimalPowers = TypeAlias(import.meta.url, {
+const AnimalPowers = DB.TypeAlias(import.meta.url, {
     name: "AnimalPowers",
-    type: () => Object({
-        level1: Required({
-            type: IncludeIdentifier(AnimalPowersLevel1),
+    type: () => DB.Object({
+        level1: DB.Required({
+            type: DB.IncludeIdentifier(AnimalPowersLevel1),
         }),
-        level2: Required({
-            type: IncludeIdentifier(AnimalPowersLevel2),
+        level2: DB.Required({
+            type: DB.IncludeIdentifier(AnimalPowersLevel2),
         }),
-        level3: Required({
-            type: IncludeIdentifier(AnimalPowersLevel3),
+        level3: DB.Required({
+            type: DB.IncludeIdentifier(AnimalPowersLevel3),
         }),
     }),
 });
-const AdvantageAnimalPower = TypeAlias(import.meta.url, {
+const AdvantageAnimalPower = DB.TypeAlias(import.meta.url, {
     name: "AdvantageAnimalPower",
-    type: () => Object({
-        id: Required({
+    type: () => DB.Object({
+        id: DB.Required({
             comment: "The advantage’s identifier.",
             type: AdvantageIdentifier(),
         }),
-        level: Optional({
+        level: DB.Optional({
             comment: "It grants a higher level of the advantage.",
-            type: Integer({ minimum: 2 }),
+            type: DB.Integer({ minimum: 2 }),
         }),
-        option: Optional({
+        option: DB.Optional({
             comment: "It grants a specific general option of the advantage.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const SkillAnimalPower = TypeAlias(import.meta.url, {
+const SkillAnimalPower = DB.TypeAlias(import.meta.url, {
     name: "SkillAnimalPower",
-    type: () => Object({
-        id: Required({
+    type: () => DB.Object({
+        id: DB.Required({
             comment: "The skill’s identifier.",
             type: SkillIdentifier(),
         }),
-        points: Required({
+        points: DB.Required({
             comment: "The points that gets added to the skill’s rating.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const AnimalPowerLevel1 = Enum(import.meta.url, {
+const AnimalPowerLevel1 = DB.Enum(import.meta.url, {
     name: "AnimalPowerLevel1",
     values: () => ({
-        Advantage: EnumCase({ type: IncludeIdentifier(AdvantageAnimalPower) }),
-        Skill: EnumCase({ type: IncludeIdentifier(SkillAnimalPower) }),
+        Advantage: DB.EnumCase({ type: DB.IncludeIdentifier(AdvantageAnimalPower) }),
+        Skill: DB.EnumCase({ type: DB.IncludeIdentifier(SkillAnimalPower) }),
     }),
 });
-const AnimalPowersLevel1 = TypeAlias(import.meta.url, {
+const AnimalPowersLevel1 = DB.TypeAlias(import.meta.url, {
     name: "AnimalPowersLevel1",
-    type: () => Array(IncludeIdentifier(AnimalPowerLevel1), { minItems: 1, uniqueItems: true }),
+    type: () => DB.Array(DB.IncludeIdentifier(AnimalPowerLevel1), { minItems: 1, uniqueItems: true }),
 });
-const CombatAnimalPower = TypeAlias(import.meta.url, {
+const CombatAnimalPower = DB.TypeAlias(import.meta.url, {
     name: "CombatAnimalPower",
-    type: () => Object({
-        id: Required({
+    type: () => DB.Object({
+        id: DB.Required({
             comment: "The combat value.",
-            type: IncludeIdentifier(CombatAnimalPowerType),
+            type: DB.IncludeIdentifier(CombatAnimalPowerType),
         }),
-        value: Optional({
+        value: DB.Optional({
             comment: "The value that gets added to the combat value.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const CombatAnimalPowerType = Enum(import.meta.url, {
+const CombatAnimalPowerType = DB.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 }),
+        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 = Enum(import.meta.url, {
+const AnimalPowerLevel2 = DB.Enum(import.meta.url, {
     name: "AnimalPowerLevel2",
     values: () => ({
-        Combat: EnumCase({ type: IncludeIdentifier(CombatAnimalPower) }),
+        Combat: DB.EnumCase({ type: DB.IncludeIdentifier(CombatAnimalPower) }),
     }),
 });
-const AnimalPowersLevel2 = TypeAlias(import.meta.url, {
+const AnimalPowersLevel2 = DB.TypeAlias(import.meta.url, {
     name: "AnimalPowersLevel2",
-    type: () => Array(IncludeIdentifier(AnimalPowerLevel2), { minItems: 1, uniqueItems: true }),
+    type: () => DB.Array(DB.IncludeIdentifier(AnimalPowerLevel2), { minItems: 1, uniqueItems: true }),
 });
-const AttributeAnimalPower = TypeAlias(import.meta.url, {
+const AttributeAnimalPower = DB.TypeAlias(import.meta.url, {
     name: "AttributeAnimalPower",
-    type: () => Object({
-        id: Required({
+    type: () => DB.Object({
+        id: DB.Required({
             comment: "The attribute’s identifier.",
             type: AttributeIdentifier(),
         }),
-        value: Required({
+        value: DB.Required({
             comment: "The value that gets added to the attribute.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const AnimalPowerLevel3 = Enum(import.meta.url, {
+const AnimalPowerLevel3 = DB.Enum(import.meta.url, {
     name: "AnimalPowerLevel3",
     values: () => ({
-        Attribute: EnumCase({ type: IncludeIdentifier(AttributeAnimalPower) }),
+        Attribute: DB.EnumCase({ type: DB.IncludeIdentifier(AttributeAnimalPower) }),
     }),
 });
-const AnimalPowersLevel3 = TypeAlias(import.meta.url, {
+const AnimalPowersLevel3 = DB.TypeAlias(import.meta.url, {
     name: "AnimalPowersLevel3",
-    type: () => Array(IncludeIdentifier(AnimalPowerLevel3), { minItems: 1, uniqueItems: true }),
+    type: () => DB.Array(DB.IncludeIdentifier(AnimalPowerLevel3), { minItems: 1, uniqueItems: true }),
 });

package/lib/types/PatronCategory.d.ts

@@ -1,7 +1,7 @@
-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>;
+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

@@ -1,18 +1,18 @@
-import { Array, Entity, Object, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { CultureIdentifier } from "./_Identifier.js";
-export const PatronCategory = Entity(import.meta.url, {
+export const PatronCategory = DB.Entity(import.meta.url, {
     name: "PatronCategory",
     namePlural: "PatronCategories",
-    type: () => Object({
-        primary_patron_cultures: Required({
+    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: Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
+            type: DB.Array(CultureIdentifier(), { minItems: 1, uniqueItems: true }),
         }),
-        translations: NestedTranslationMap(Required, "PatronCategory", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "PatronCategory", DB.Object({
+            name: DB.Required({
                 comment: "The patron category’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),