optolith-database-schema 0.28.0 → 0.28.2

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

@@ -1,221 +1,222 @@
-import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
-export declare const GeodeRitual: Entity<"GeodeRitual", {
-    check: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SkillCheck", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").ReferenceIdentifierType>, []>>, true>;
-    parameters: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"GeodeRitualPerformanceParameters", Object<{
-        casting_time: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SlowSkillNonModifiableCastingTime", Object<{
-            value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-            unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SlowSkillCastingTimeUnit", {
-                Minutes: EnumCase<null>;
-                Hours: EnumCase<null>;
+import * as DB from "tsondb/schema/dsl";
+export declare const GeodeRitual: DB.Entity<"GeodeRitual", {
+    check: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SkillCheck", DB.Array<DB.ReferenceIdentifier>, []>>, true>;
+    parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"GeodeRitualPerformanceParameters", DB.Object<{
+        casting_time: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"SlowSkillNonModifiableCastingTime", DB.Object<{
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SlowSkillCastingTimeUnit", {
+                Minutes: DB.EnumCase<null>;
+                Hours: DB.EnumCase<null>;
             }, []>>, true>;
         }>, []>>, true>;
-        cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"GeodeRitualCost", {
-            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedGeodeRitualCost", Object<{
-                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"GeodeRitualCost", {
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedGeodeRitualCost", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Map: EnumCase<IncludeIdentifier<[], TypeAlias<"OneTimeCostMap", Object<{
-                options: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"OneTimeCostMapOption", Object<{
-                    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                    permanent_value: import("tsondb/schema/def").MemberDecl<Integer, false>;
-                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"OneTimeCostMapOptionTranslation", {
-                        label: 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>;
+            Map: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMap", DB.Object<{
+                options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"OneTimeCostMapOption", DB.Object<{
+                    value: DB.MemberDecl<DB.Integer, true>;
+                    permanent_value: DB.MemberDecl<DB.Integer, false>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapOptionTranslation", {
+                        label: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
                         }>, []>>, true>;
-                        label_standalone: 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>;
+                        label_standalone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                            full: DB.MemberDecl<DB.String, true>;
+                            compressed: DB.MemberDecl<DB.String, false>;
                         }>, []>>, false>;
                     }>, false>;
                 }>, []>>>, true>;
-                translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"OneTimeCostMapTranslation", {
-                    list_prepend: 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>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"OneTimeCostMapTranslation", {
+                    list_prepend: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
-                    list_append: 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>;
+                    list_append: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
-                    replacement: 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>;
+                    replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+                        full: DB.MemberDecl<DB.String, true>;
+                        compressed: DB.MemberDecl<DB.String, false>;
                     }>, []>>, false>;
                 }>, false>;
             }>, []>>>;
         }, []>>, true>;
-        range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"GeodeRitualRange", {
-            Self: EnumCase<null>;
-            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedGeodeRitualRange", Object<{
-                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"GeodeRitualRange", {
+            Self: DB.EnumCase<null>;
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedGeodeRitualRange", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
         }, []>>, true>;
-        duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"GeodeRitualDuration", {
-            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<"GeodeRitualDuration", {
+            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>;
             }>, []>>>;
         }, []>>, true>;
     }>, []>>, true>;
-    target: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"AffectedTargetCategories", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"SpecificAffectedTargetCategory", Object<{
-        id: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SpecificAffectedTargetCategoryIdentifier", {
-            Self: EnumCase<null>;
-            Zone: EnumCase<null>;
-            LiturgicalChantsAndCeremonies: EnumCase<null>;
-            Cantrips: EnumCase<null>;
-            Spellworks: EnumCase<null>;
-            Predefined: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+    target: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AffectedTargetCategories", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SpecificAffectedTargetCategory", DB.Object<{
+        id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SpecificAffectedTargetCategoryIdentifier", {
+            Self: DB.EnumCase<null>;
+            Zone: DB.EnumCase<null>;
+            LiturgicalChantsAndCeremonies: DB.EnumCase<null>;
+            Cantrips: DB.EnumCase<null>;
+            Spellworks: DB.EnumCase<null>;
+            Predefined: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
-        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SpecificAffectedTargetCategoryTranslation", {
-            note: import("tsondb/schema/def").MemberDecl<String, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<"SpecificAffectedTargetCategoryTranslation", {
+            note: DB.MemberDecl<DB.String, true>;
         }>, false>;
     }>, []>>>, []>>, true>;
-    property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"GeodeRitualPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PlainPrerequisites", import("tsondb/schema/def").ArrayType<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], Enum<"PrerequisitesElement", {
-        Single: EnumCase<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
-        Disjunction: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisitesDisjunction", Object<{
-            list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
-            display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"DisplayOption", {
-                Hide: EnumCase<null>;
-                ReplaceWith: EnumCase<IncludeIdentifier<[], TypeAlias<"ReplacementDisplayOption", Object<{
-                    sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"SentenceType", {
-                        Standalone: EnumCase<null>;
-                        Connected: EnumCase<null>;
+    property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"GeodeRitualPrerequisites", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PlainPrerequisites", DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"PrerequisitesElement", {
+        Single: DB.EnumCase<DB.TypeArgument<DB.Param<"T", DB.Type>>>;
+        Disjunction: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisitesDisjunction", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            display_option: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"DisplayOption", {
+                Hide: DB.EnumCase<null>;
+                ReplaceWith: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ReplacementDisplayOption", DB.Object<{
+                    sentence_type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SentenceType", {
+                        Standalone: DB.EnumCase<null>;
+                        Connected: DB.EnumCase<null>;
                     }, []>>, false>;
-                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"ReplacementDisplayOptionTranslation", {
-                        replacement: import("tsondb/schema/def").MemberDecl<String, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                        replacement: DB.MemberDecl<DB.String, true>;
                     }>, true>;
                 }>, []>>>;
             }, []>>, false>;
-        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
-        Group: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"PrerequisiteGroup", Object<{
-            list: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>, true>;
-            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"PrerequisiteGroupTranslation", {
-                text: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+        Group: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"PrerequisiteGroup", DB.Object<{
+            list: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"T", DB.Type>>>, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"PrerequisiteGroupTranslation", {
+                text: DB.MemberDecl<DB.String, true>;
             }>, true>;
-        }>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>;
-    }, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>>, [T: import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>]>>, []>>, false>;
-    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>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, 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: 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<"GeodeRitualTranslation", {
-        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<"GeodeRitualTranslation", {
+        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>;
-        casting_time: 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>;
+        casting_time: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"OldParameter", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            abbr: DB.MemberDecl<DB.String, true>;
         }>, []>>, false>;
-        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>;
-        range: 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>;
+        range: 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>;
-        target: import("tsondb/schema/def").MemberDecl<String, 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>;
+        target: DB.MemberDecl<DB.String, false>;
+        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/GeodeRitual.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 { SlowSkillNonModifiableCastingTime } from "../_ActivatableSkillCastingTime.js";
 import { OneTimeCostMap } from "../_ActivatableSkillCost.js";
@@ -11,62 +11,62 @@ import { SkillCheck } from "../_SkillCheck.js";
 import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
-export const GeodeRitual = Entity(import.meta.url, {
+export const GeodeRitual = DB.Entity(import.meta.url, {
     name: "GeodeRitual",
     namePlural: "GeodeRituals",
-    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),
         }),
-        parameters: Required({
+        parameters: DB.Required({
             comment: "Measurable parameters of a geode ritual.",
-            type: IncludeIdentifier(GeodeRitualPerformanceParameters),
+            type: DB.IncludeIdentifier(GeodeRitualPerformanceParameters),
         }),
-        target: Required({
+        target: DB.Required({
             comment: "The target category – the kind of creature or object – the skill affects.",
-            type: IncludeIdentifier(AffectedTargetCategories),
+            type: DB.IncludeIdentifier(AffectedTargetCategories),
         }),
-        property: Required({
+        property: DB.Required({
             comment: "The associated property.",
             type: PropertyIdentifier(),
         }),
-        prerequisites: Optional({
+        prerequisites: DB.Optional({
             comment: "The prerequisites for the geode ritual.",
-            type: IncludeIdentifier(GeodeRitualPrerequisites),
+            type: DB.IncludeIdentifier(GeodeRitualPrerequisites),
         }),
         src,
-        translations: NestedTranslationMap(Required, "GeodeRitual", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "GeodeRitual", DB.Object({
+            name: DB.Required({
                 comment: "The geode ritual’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),
             }),
-            casting_time: Optional({
+            casting_time: DB.Optional({
                 isDeprecated: true,
-                type: IncludeIdentifier(OldParameter),
+                type: DB.IncludeIdentifier(OldParameter),
             }),
-            cost: Optional({
+            cost: DB.Optional({
                 isDeprecated: true,
-                type: IncludeIdentifier(OldParameter),
+                type: DB.IncludeIdentifier(OldParameter),
             }),
-            range: Optional({
+            range: 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),
             }),
-            target: Optional({
+            target: DB.Optional({
                 isDeprecated: true,
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            errata: Optional({
-                type: IncludeIdentifier(Errata),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
             }),
         })),
     }),
@@ -78,65 +78,65 @@ export const GeodeRitual = Entity(import.meta.url, {
         },
     ],
 });
-const GeodeRitualPerformanceParameters = TypeAlias(import.meta.url, {
+const GeodeRitualPerformanceParameters = DB.TypeAlias(import.meta.url, {
     name: "GeodeRitualPerformanceParameters",
     comment: "Measurable parameters of a geode ritual.",
-    type: () => Object({
-        casting_time: Required({
+    type: () => DB.Object({
+        casting_time: DB.Required({
             comment: "The casting time.",
-            type: IncludeIdentifier(SlowSkillNonModifiableCastingTime),
+            type: DB.IncludeIdentifier(SlowSkillNonModifiableCastingTime),
         }),
-        cost: Required({
+        cost: DB.Required({
             comment: "The AE cost.",
-            type: IncludeIdentifier(GeodeRitualCost),
+            type: DB.IncludeIdentifier(GeodeRitualCost),
         }),
-        range: Required({
+        range: DB.Required({
             comment: "The range.",
-            type: IncludeIdentifier(GeodeRitualRange),
+            type: DB.IncludeIdentifier(GeodeRitualRange),
         }),
-        duration: Required({
+        duration: DB.Required({
             comment: "The duration.",
-            type: IncludeIdentifier(GeodeRitualDuration),
+            type: DB.IncludeIdentifier(GeodeRitualDuration),
         }),
     }),
 });
-const GeodeRitualCost = Enum(import.meta.url, {
+const GeodeRitualCost = DB.Enum(import.meta.url, {
     name: "GeodeRitualCost",
     values: () => ({
-        Fixed: EnumCase({ type: IncludeIdentifier(FixedGeodeRitualCost) }),
-        Map: EnumCase({ type: IncludeIdentifier(OneTimeCostMap) }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedGeodeRitualCost) }),
+        Map: DB.EnumCase({ type: DB.IncludeIdentifier(OneTimeCostMap) }),
     }),
 });
-const FixedGeodeRitualCost = TypeAlias(import.meta.url, {
+const FixedGeodeRitualCost = DB.TypeAlias(import.meta.url, {
     name: "FixedGeodeRitualCost",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "The AE cost value.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const GeodeRitualRange = Enum(import.meta.url, {
+const GeodeRitualRange = DB.Enum(import.meta.url, {
     name: "GeodeRitualRange",
     values: () => ({
-        Self: EnumCase({ type: null }),
-        Fixed: EnumCase({ type: IncludeIdentifier(FixedGeodeRitualRange) }),
+        Self: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedGeodeRitualRange) }),
     }),
 });
-const FixedGeodeRitualRange = TypeAlias(import.meta.url, {
+const FixedGeodeRitualRange = DB.TypeAlias(import.meta.url, {
     name: "FixedGeodeRitualRange",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "The range in steps/m.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const GeodeRitualDuration = Enum(import.meta.url, {
+const GeodeRitualDuration = DB.Enum(import.meta.url, {
     name: "GeodeRitualDuration",
     values: () => ({
-        Immediate: EnumCase({ type: null }),
-        Fixed: EnumCase({ type: IncludeIdentifier(DurationUnitValue) }),
-        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedDuration) }),
+        Immediate: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(DurationUnitValue) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedDuration) }),
     }),
 });