optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/magicalActions/Curse.d.ts

@@ -1,216 +1,217 @@
-import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
-export declare const Curse: Entity<"Curse", {
-    check: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SkillCheck", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, true>;
-    check_penalty: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SkillCheckPenalty", {
-        Spirit: EnumCase<null>;
-        HalfOfSpirit: EnumCase<null>;
-        Toughness: EnumCase<null>;
-        HigherOfSpiritAndToughness: EnumCase<null>;
-        SummoningDifficulty: EnumCase<null>;
-        CreationDifficulty: EnumCase<null>;
-        Object: EnumCase<null>;
+import * as DB from "tsondb/schema/dsl";
+export declare const Curse: DB.Entity<"Curse", {
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
+    check_penalty: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SkillCheckPenalty", {
+        Spirit: DB.EnumCase<null>;
+        HalfOfSpirit: DB.EnumCase<null>;
+        Toughness: DB.EnumCase<null>;
+        HigherOfSpiritAndToughness: DB.EnumCase<null>;
+        SummoningDifficulty: DB.EnumCase<null>;
+        CreationDifficulty: DB.EnumCase<null>;
+        Object: DB.EnumCase<null>;
     }, []>>, false>;
-    parameters: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CursePerformanceParameters", Object<{
-        cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CurseCost", {
-            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCurseCost", Object<{
-                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedCurseCostTranslation", {
-                    per: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", Object<{
-                        full: import("tsondb/schema/def").MemberDecl<String, true>;
-                        compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+    parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CursePerformanceParameters", DB.Object<{
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CurseCost", {
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCurseCost", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCurseCostTranslation", {
+                    per: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
                     }>, []>>, false>;
-                    note: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextOptional", Object<{
-                        full: import("tsondb/schema/def").MemberDecl<String, true>;
-                        compressed: import("tsondb/schema/def").MemberDecl<String, false>;
+                    note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
             }>, []>>>;
-            Indefinite: EnumCase<IncludeIdentifier<[], TypeAlias<"IndefiniteOneTimeCost", Object<{
-                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"IndefiniteOneTimeCostTranslation", {
-                    description: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", Object<{
-                        full: import("tsondb/schema/def").MemberDecl<String, true>;
-                        compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+            Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteOneTimeCost", DB.Object<{
+                translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteOneTimeCostTranslation", {
+                    description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
                     }>, []>>, true>;
                 }>, true>;
             }>, []>>>;
         }, []>>, true>;
-        duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CurseDuration", {
-            Immediate: EnumCase<null>;
-            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"DurationUnitValue", Object<{
-                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
-                    Seconds: EnumCase<null>;
-                    Minutes: EnumCase<null>;
-                    Hours: EnumCase<null>;
-                    Days: EnumCase<null>;
-                    Weeks: EnumCase<null>;
-                    Months: EnumCase<null>;
-                    Years: EnumCase<null>;
-                    Centuries: EnumCase<null>;
-                    Actions: EnumCase<null>;
-                    CombatRounds: EnumCase<null>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CurseDuration", {
+            Immediate: DB.EnumCase<null>;
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
+                unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                    Seconds: DB.EnumCase<null>;
+                    Minutes: DB.EnumCase<null>;
+                    Hours: DB.EnumCase<null>;
+                    Days: DB.EnumCase<null>;
+                    Weeks: DB.EnumCase<null>;
+                    Months: DB.EnumCase<null>;
+                    Years: DB.EnumCase<null>;
+                    Centuries: DB.EnumCase<null>;
+                    Actions: DB.EnumCase<null>;
+                    CombatRounds: DB.EnumCase<null>;
                 }, []>>, true>;
             }>, []>>>;
-            CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedDuration", Object<{
-                is_maximum: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, false>;
-                base: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultValue", {
-                    QualityLevels: EnumCase<null>;
-                    SkillPoints: EnumCase<null>;
+            CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedDuration", DB.Object<{
+                is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
+                    QualityLevels: DB.EnumCase<null>;
+                    SkillPoints: DB.EnumCase<null>;
                 }, []>>, true>;
-                modifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CheckResultBasedModifier", Object<{
-                    arithmetic: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultArithmetic", {
-                        Multiply: EnumCase<null>;
-                        Divide: EnumCase<null>;
+                modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
+                    arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
+                        Multiply: DB.EnumCase<null>;
+                        Divide: DB.EnumCase<null>;
                     }, []>>, true>;
-                    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                    value: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
-                unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
-                    Seconds: EnumCase<null>;
-                    Minutes: EnumCase<null>;
-                    Hours: EnumCase<null>;
-                    Days: EnumCase<null>;
-                    Weeks: EnumCase<null>;
-                    Months: EnumCase<null>;
-                    Years: EnumCase<null>;
-                    Centuries: EnumCase<null>;
-                    Actions: EnumCase<null>;
-                    CombatRounds: EnumCase<null>;
+                unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                    Seconds: DB.EnumCase<null>;
+                    Minutes: DB.EnumCase<null>;
+                    Hours: DB.EnumCase<null>;
+                    Days: DB.EnumCase<null>;
+                    Weeks: DB.EnumCase<null>;
+                    Months: DB.EnumCase<null>;
+                    Years: DB.EnumCase<null>;
+                    Centuries: DB.EnumCase<null>;
+                    Actions: DB.EnumCase<null>;
+                    CombatRounds: DB.EnumCase<null>;
                 }, []>>, true>;
-                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CheckResultBasedDurationTranslation", {
-                    replacement: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextReplace", Object<{
-                        full: import("tsondb/schema/def").MemberDecl<String, true>;
-                        compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"CheckResultBasedDurationTranslation", {
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
                     }>, []>>, false>;
                 }>, false>;
             }>, []>>>;
-            Indefinite: EnumCase<IncludeIdentifier<[], TypeAlias<"IndefiniteCurseDuration", Object<{
-                maximum: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"MaximumIndefiniteCurseDuration", {
-                    Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"DurationUnitValue", Object<{
-                        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
-                            Seconds: EnumCase<null>;
-                            Minutes: EnumCase<null>;
-                            Hours: EnumCase<null>;
-                            Days: EnumCase<null>;
-                            Weeks: EnumCase<null>;
-                            Months: EnumCase<null>;
-                            Years: EnumCase<null>;
-                            Centuries: EnumCase<null>;
-                            Actions: EnumCase<null>;
-                            CombatRounds: EnumCase<null>;
+            Indefinite: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"IndefiniteCurseDuration", DB.Object<{
+                maximum: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MaximumIndefiniteCurseDuration", {
+                    Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DurationUnitValue", DB.Object<{
+                        value: DB.MemberDecl<DB.Integer, true>;
+                        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                            Seconds: DB.EnumCase<null>;
+                            Minutes: DB.EnumCase<null>;
+                            Hours: DB.EnumCase<null>;
+                            Days: DB.EnumCase<null>;
+                            Weeks: DB.EnumCase<null>;
+                            Months: DB.EnumCase<null>;
+                            Years: DB.EnumCase<null>;
+                            Centuries: DB.EnumCase<null>;
+                            Actions: DB.EnumCase<null>;
+                            CombatRounds: DB.EnumCase<null>;
                         }, []>>, true>;
                     }>, []>>>;
-                    CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedDuration", Object<{
-                        is_maximum: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").BooleanType, false>;
-                        base: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultValue", {
-                            QualityLevels: EnumCase<null>;
-                            SkillPoints: EnumCase<null>;
+                    CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedDuration", DB.Object<{
+                        is_maximum: DB.MemberDecl<DB.Boolean, false>;
+                        base: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultValue", {
+                            QualityLevels: DB.EnumCase<null>;
+                            SkillPoints: DB.EnumCase<null>;
                         }, []>>, true>;
-                        modifier: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"CheckResultBasedModifier", Object<{
-                            arithmetic: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultArithmetic", {
-                                Multiply: EnumCase<null>;
-                                Divide: EnumCase<null>;
+                        modifier: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedModifier", DB.Object<{
+                            arithmetic: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CheckResultArithmetic", {
+                                Multiply: DB.EnumCase<null>;
+                                Divide: DB.EnumCase<null>;
                             }, []>>, true>;
-                            value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+                            value: DB.MemberDecl<DB.Integer, true>;
                         }>, []>>, false>;
-                        unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DurationUnit", {
-                            Seconds: EnumCase<null>;
-                            Minutes: EnumCase<null>;
-                            Hours: EnumCase<null>;
-                            Days: EnumCase<null>;
-                            Weeks: EnumCase<null>;
-                            Months: EnumCase<null>;
-                            Years: EnumCase<null>;
-                            Centuries: EnumCase<null>;
-                            Actions: EnumCase<null>;
-                            CombatRounds: EnumCase<null>;
+                        unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DurationUnit", {
+                            Seconds: DB.EnumCase<null>;
+                            Minutes: DB.EnumCase<null>;
+                            Hours: DB.EnumCase<null>;
+                            Days: DB.EnumCase<null>;
+                            Weeks: DB.EnumCase<null>;
+                            Months: DB.EnumCase<null>;
+                            Years: DB.EnumCase<null>;
+                            Centuries: DB.EnumCase<null>;
+                            Actions: DB.EnumCase<null>;
+                            CombatRounds: DB.EnumCase<null>;
                         }, []>>, true>;
-                        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CheckResultBasedDurationTranslation", {
-                            replacement: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextReplace", Object<{
-                                full: import("tsondb/schema/def").MemberDecl<String, true>;
-                                compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                        translations: DB.MemberDecl<DB.NestedEntityMap<"CheckResultBasedDurationTranslation", {
+                            replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+                                full: DB.MemberDecl<DB.String, true>;
+                                compressed: DB.MemberDecl<DB.String, true>;
                             }>, []>>, false>;
                         }>, false>;
                     }>, []>>>;
                 }, []>>, false>;
-                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"IndefiniteCurseDurationTranslation", {
-                    description: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveText", Object<{
-                        full: import("tsondb/schema/def").MemberDecl<String, true>;
-                        compressed: import("tsondb/schema/def").MemberDecl<String, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"IndefiniteCurseDurationTranslation", {
+                    description: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveText", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, true>;
                     }>, []>>, true>;
                 }>, true>;
             }>, []>>>;
         }, []>>, true>;
     }>, []>>, true>;
-    property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<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<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                        InsideCoverFront: EnumCase<null>;
-                        InsideCoverBack: EnumCase<null>;
-                        Numbered: EnumCase<Integer>;
+    property: DB.MemberDecl<DB.ReferenceIdentifier, 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: 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<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], Enum<"Revision", {
-                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"Since", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                    pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<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<"CurseTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        effect: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ActivatableSkillEffect", {
-            Plain: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillPlainEffect", Object<{
-                text: import("tsondb/schema/def").MemberDecl<String, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CurseTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        effect: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableSkillEffect", {
+            Plain: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillPlainEffect", DB.Object<{
+                text: DB.MemberDecl<DB.String, true>;
             }>, []>>>;
-            ForEachQualityLevel: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillEffectForEachQualityLevel", Object<{
-                text_before: import("tsondb/schema/def").MemberDecl<String, true>;
-                quality_levels: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<String>, true>;
-                text_after: import("tsondb/schema/def").MemberDecl<String, false>;
+            ForEachQualityLevel: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillEffectForEachQualityLevel", DB.Object<{
+                text_before: DB.MemberDecl<DB.String, true>;
+                quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+                text_after: DB.MemberDecl<DB.String, false>;
             }>, []>>>;
-            ForEachTwoQualityLevels: EnumCase<IncludeIdentifier<[], TypeAlias<"ActivatableSkillEffectForEachTwoQualityLevels", Object<{
-                text_before: import("tsondb/schema/def").MemberDecl<String, true>;
-                quality_levels: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<String>, true>;
-                text_after: import("tsondb/schema/def").MemberDecl<String, false>;
+            ForEachTwoQualityLevels: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableSkillEffectForEachTwoQualityLevels", DB.Object<{
+                text_before: DB.MemberDecl<DB.String, true>;
+                quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+                text_after: DB.MemberDecl<DB.String, false>;
             }>, []>>>;
         }, []>>, true>;
-        cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"OldParameter", Object<{
-            full: import("tsondb/schema/def").MemberDecl<String, true>;
-            abbr: import("tsondb/schema/def").MemberDecl<String, true>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
         }>, []>>, false>;
-        duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"OldParameter", Object<{
-            full: import("tsondb/schema/def").MemberDecl<String, true>;
-            abbr: import("tsondb/schema/def").MemberDecl<String, true>;
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
         }>, []>>, false>;
-        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
-            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
-            description: import("tsondb/schema/def").MemberDecl<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/magicalActions/Curse.js

@@ -1,4 +1,4 @@
-import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { OldParameter } from "../_ActivatableSkill.js";
 import { IndefiniteOneTimeCost } from "../_ActivatableSkillCost.js";
 import { CheckResultBasedDuration, DurationUnitValue } from "../_ActivatableSkillDuration.js";
@@ -9,46 +9,46 @@ import { SkillCheck, SkillCheckPenalty } from "../_SkillCheck.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
-export const Curse = Entity(import.meta.url, {
+export const Curse = DB.Entity(import.meta.url, {
     name: "Curse",
     namePlural: "Curses",
-    type: () => Object({
-        check: Required({
+    type: () => DB.Object({
+        check: DB.Required({
             comment: "Lists the linked three attributes used to make a skill check.",
-            type: IncludeIdentifier(SkillCheck),
+            type: DB.IncludeIdentifier(SkillCheck),
         }),
-        check_penalty: Optional({
+        check_penalty: DB.Optional({
             comment: "In some cases, the target's Spirit or Toughness is applied as a penalty.",
-            type: IncludeIdentifier(SkillCheckPenalty),
+            type: DB.IncludeIdentifier(SkillCheckPenalty),
         }),
-        parameters: Required({
+        parameters: DB.Required({
             comment: "Measurable parameters of a curse.",
-            type: IncludeIdentifier(CursePerformanceParameters),
+            type: DB.IncludeIdentifier(CursePerformanceParameters),
         }),
-        property: Required({
+        property: DB.Required({
             comment: "The associated property.",
             type: PropertyIdentifier(),
         }),
         src,
-        translations: NestedTranslationMap(Required, "Curse", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "Curse", DB.Object({
+            name: DB.Required({
                 comment: "The curse’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            effect: Required({
+            effect: DB.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),
+                type: DB.IncludeIdentifier(ActivatableSkillEffect),
             }),
-            cost: Optional({
+            cost: DB.Optional({
                 isDeprecated: true,
-                type: IncludeIdentifier(OldParameter),
+                type: DB.IncludeIdentifier(OldParameter),
             }),
-            duration: Optional({
+            duration: DB.Optional({
                 isDeprecated: true,
-                type: IncludeIdentifier(OldParameter),
+                type: DB.IncludeIdentifier(OldParameter),
             }),
-            errata: Optional({
-                type: IncludeIdentifier(Errata),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
             }),
         })),
     }),
@@ -60,74 +60,74 @@ export const Curse = Entity(import.meta.url, {
         },
     ],
 });
-const CursePerformanceParameters = TypeAlias(import.meta.url, {
+const CursePerformanceParameters = DB.TypeAlias(import.meta.url, {
     name: "CursePerformanceParameters",
     comment: "Measurable parameters of a curse.",
-    type: () => Object({
-        cost: Required({
+    type: () => DB.Object({
+        cost: DB.Required({
             comment: "The AE cost.",
-            type: IncludeIdentifier(CurseCost),
+            type: DB.IncludeIdentifier(CurseCost),
         }),
-        duration: Required({
+        duration: DB.Required({
             comment: "The duration.",
-            type: IncludeIdentifier(CurseDuration),
+            type: DB.IncludeIdentifier(CurseDuration),
         }),
     }),
 });
-const CurseCost = Enum(import.meta.url, {
+const CurseCost = DB.Enum(import.meta.url, {
     name: "CurseCost",
     values: () => ({
-        Fixed: EnumCase({ type: IncludeIdentifier(FixedCurseCost) }),
-        Indefinite: EnumCase({ type: IncludeIdentifier(IndefiniteOneTimeCost) }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedCurseCost) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteOneTimeCost) }),
     }),
 });
-const FixedCurseCost = TypeAlias(import.meta.url, {
+const FixedCurseCost = DB.TypeAlias(import.meta.url, {
     name: "FixedCurseCost",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "The (temporary) AE cost value.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        translations: NestedTranslationMap(Optional, "FixedCurseCost", Object({
-            per: Optional({
+        translations: NestedTranslationMap(DB.Optional, "FixedCurseCost", DB.Object({
+            per: DB.Optional({
                 comment: "The cost have to be per a specific countable entity, e.g. `8 KP per person`.",
-                type: IncludeIdentifier(ResponsiveText),
+                type: DB.IncludeIdentifier(ResponsiveText),
             }),
-            note: Optional({
+            note: DB.Optional({
                 comment: "A note, appended to the generated string in parenthesis.",
-                type: IncludeIdentifier(ResponsiveTextOptional),
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
             }),
         }, { minProperties: 1 })),
     }),
 });
-const CurseDuration = Enum(import.meta.url, {
+const CurseDuration = DB.Enum(import.meta.url, {
     name: "CurseDuration",
     values: () => ({
-        Immediate: EnumCase({ type: null }),
-        Fixed: EnumCase({ type: IncludeIdentifier(DurationUnitValue) }),
-        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedDuration) }),
-        Indefinite: EnumCase({ type: IncludeIdentifier(IndefiniteCurseDuration) }),
+        Immediate: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
+        Indefinite: DB.EnumCase({ type: DB.IncludeIdentifier(IndefiniteCurseDuration) }),
     }),
 });
-const IndefiniteCurseDuration = TypeAlias(import.meta.url, {
+const IndefiniteCurseDuration = DB.TypeAlias(import.meta.url, {
     name: "IndefiniteCurseDuration",
-    type: () => Object({
-        maximum: Optional({
+    type: () => DB.Object({
+        maximum: DB.Optional({
             comment: "Specified if the duration has a maximum time span.",
-            type: IncludeIdentifier(MaximumIndefiniteCurseDuration),
+            type: DB.IncludeIdentifier(MaximumIndefiniteCurseDuration),
         }),
-        translations: NestedTranslationMap(Required, "IndefiniteCurseDuration", Object({
-            description: Required({
+        translations: NestedTranslationMap(DB.Required, "IndefiniteCurseDuration", DB.Object({
+            description: DB.Required({
                 comment: "A description of the duration.",
-                type: IncludeIdentifier(ResponsiveText),
+                type: DB.IncludeIdentifier(ResponsiveText),
             }),
         })),
     }),
 });
-const MaximumIndefiniteCurseDuration = Enum(import.meta.url, {
+const MaximumIndefiniteCurseDuration = DB.Enum(import.meta.url, {
     name: "MaximumIndefiniteCurseDuration",
     values: () => ({
-        Fixed: EnumCase({ type: IncludeIdentifier(DurationUnitValue) }),
-        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedDuration) }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
     }),
 });