optolith-database-schema 0.28.0 → 0.28.2

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

@@ -1,117 +1,118 @@
-import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
-export declare const MagicalMelody: Entity<"MagicalMelody", {
-    check: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"SkillCheck", Array<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 MagicalMelody: DB.Entity<"MagicalMelody", {
+    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>;
-    skill: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
-    parameters: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MagicalMelodyPerformanceParameters", Object<{
-        duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"MusicDuration", Object<{
-            length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"MusicLength", {
-                Long: EnumCase<null>;
-                Short: EnumCase<null>;
+    skill: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+    parameters: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"MagicalMelodyPerformanceParameters", DB.Object<{
+        duration: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"MusicDuration", DB.Object<{
+            length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MusicLength", {
+                Long: DB.EnumCase<null>;
+                Short: DB.EnumCase<null>;
             }, []>>, true>;
-            reusability: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"MusicReusability", {
-                OneTime: EnumCase<null>;
-                Sustainable: EnumCase<null>;
+            reusability: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MusicReusability", {
+                OneTime: DB.EnumCase<null>;
+                Sustainable: DB.EnumCase<null>;
             }, []>>, true>;
         }>, []>>, true>;
-        cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"MagicalMelodyCost", {
-            Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedMagicalMelodyCost", Object<{
-                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+        cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"MagicalMelodyCost", {
+            Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedMagicalMelodyCost", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            FirstPerson: EnumCase<IncludeIdentifier<[], TypeAlias<"FirstPersonMagicalMelodyCost", Object<{
-                value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+            FirstPerson: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FirstPersonMagicalMelodyCost", DB.Object<{
+                value: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
         }, []>>, true>;
     }>, []>>, true>;
-    property: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-    music_tradition: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<string, Object<{
-        id: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${string}Translation`, {
-            name: import("tsondb/schema/def").MemberDecl<String, true>;
+    property: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    music_tradition: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<string, DB.Object<{
+        id: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        translations: DB.MemberDecl<DB.NestedEntityMap<`${string}Translation`, {
+            name: DB.MemberDecl<DB.String, true>;
         }>, true>;
     }>, []>>>, true>;
-    improvement_cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ImprovementCost", {
-        A: EnumCase<null>;
-        B: EnumCase<null>;
-        C: EnumCase<null>;
-        D: EnumCase<null>;
+    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>;
     }, []>>, true>;
-    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<"MagicalMelodyTranslation", {
-        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<"MagicalMelodyTranslation", {
+        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<Array<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<Array<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>;
-        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>;
-        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>;
-        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<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/MagicalMelody.js

@@ -1,4 +1,4 @@
-import { Array, 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 { ActivatableSkillEffect } from "../_ActivatableSkillEffect.js";
 import { ArcaneBardTraditionIdentifier, PropertyIdentifier, SkillIdentifier, } from "../_Identifier.js";
@@ -8,64 +8,64 @@ import { NestedTranslationMap } from "../Locale.js";
 import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
 import { MusicDuration, MusicTraditionReference } from "./_MusicTradition.js";
-export const MagicalMelody = Entity(import.meta.url, {
+export const MagicalMelody = DB.Entity(import.meta.url, {
     name: "MagicalMelody",
     namePlural: "MagicalMelodies",
-    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),
         }),
-        skill: Required({
+        skill: DB.Required({
             comment: "To enhance their songs, elves can make a check on either *Singing (Two-Voiced Singing)* or *Music (appropriate application)* (or both) before making the check for the song.",
-            type: Array(SkillIdentifier(), {
+            type: DB.Array(SkillIdentifier(), {
                 minItems: 1,
                 maxItems: 2,
                 uniqueItems: true,
             }),
         }),
-        parameters: Required({
+        parameters: DB.Required({
             comment: "Measurable parameters of a magical melody.",
-            type: IncludeIdentifier(MagicalMelodyPerformanceParameters),
+            type: DB.IncludeIdentifier(MagicalMelodyPerformanceParameters),
         }),
-        property: Required({
+        property: DB.Required({
             comment: "The associated property.",
             type: PropertyIdentifier(),
         }),
-        music_tradition: Required({
+        music_tradition: DB.Required({
             comment: "The music tradition(s) the magical melody is available for. This also defines the different names in each music tradition.",
-            type: Array(IncludeIdentifier(MusicTraditionReference(ArcaneBardTraditionIdentifier())), {
+            type: DB.Array(DB.IncludeIdentifier(MusicTraditionReference(ArcaneBardTraditionIdentifier())), {
                 minItems: 1,
             }),
         }),
-        improvement_cost: Required({
+        improvement_cost: DB.Required({
             comment: "States which column is used to improve the skill.",
-            type: IncludeIdentifier(ImprovementCost),
+            type: DB.IncludeIdentifier(ImprovementCost),
         }),
         src,
-        translations: NestedTranslationMap(Required, "MagicalMelody", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "MagicalMelody", DB.Object({
+            name: DB.Required({
                 comment: "The magical melody’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),
             }),
-            duration: Optional({
+            duration: 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),
             }),
-            errata: Optional({
-                type: IncludeIdentifier(Errata),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
             }),
         })),
     }),
@@ -77,42 +77,42 @@ export const MagicalMelody = Entity(import.meta.url, {
         },
     ],
 });
-const MagicalMelodyPerformanceParameters = TypeAlias(import.meta.url, {
+const MagicalMelodyPerformanceParameters = DB.TypeAlias(import.meta.url, {
     name: "MagicalMelodyPerformanceParameters",
     comment: "Measurable parameters of a magical melody.",
-    type: () => Object({
-        duration: Required({
+    type: () => DB.Object({
+        duration: DB.Required({
             comment: "The duration.",
-            type: IncludeIdentifier(MusicDuration),
+            type: DB.IncludeIdentifier(MusicDuration),
         }),
-        cost: Required({
+        cost: DB.Required({
             comment: "The AE cost.",
-            type: IncludeIdentifier(MagicalMelodyCost),
+            type: DB.IncludeIdentifier(MagicalMelodyCost),
         }),
     }),
 });
-const MagicalMelodyCost = Enum(import.meta.url, {
+const MagicalMelodyCost = DB.Enum(import.meta.url, {
     name: "MagicalMelodyCost",
     values: () => ({
-        Fixed: EnumCase({ type: IncludeIdentifier(FixedMagicalMelodyCost) }),
-        FirstPerson: EnumCase({ type: IncludeIdentifier(FirstPersonMagicalMelodyCost) }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedMagicalMelodyCost) }),
+        FirstPerson: DB.EnumCase({ type: DB.IncludeIdentifier(FirstPersonMagicalMelodyCost) }),
     }),
 });
-const FixedMagicalMelodyCost = TypeAlias(import.meta.url, {
+const FixedMagicalMelodyCost = DB.TypeAlias(import.meta.url, {
     name: "FixedMagicalMelodyCost",
-    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 }),
         }),
     }),
 });
-const FirstPersonMagicalMelodyCost = TypeAlias(import.meta.url, {
+const FirstPersonMagicalMelodyCost = DB.TypeAlias(import.meta.url, {
     name: "FirstPersonMagicalMelodyCost",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "The (temporary) AE cost value for the first targeted person. The AE cost for each additional person is half this value.",
-            type: Integer({ minimum: 1, multipleOf: 2 }),
+            type: DB.Integer({ minimum: 1, multipleOf: 2 }),
         }),
     }),
 });