optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/equipment/item/Elixir.d.ts

@@ -1,103 +1,104 @@
-import { Array, Entity, IncludeIdentifier, Integer, Object, String } from "tsondb/schema/def";
-export declare const Elixir: Entity<"Elixir", {
-    effect_types: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"EffectType", {
-        Healing: import("tsondb/schema/def").EnumCaseDecl<null>;
-        Poison: import("tsondb/schema/def").EnumCaseDecl<null>;
-        PhysicalEffect: import("tsondb/schema/def").EnumCaseDecl<null>;
-        PsychicEffect: import("tsondb/schema/def").EnumCaseDecl<null>;
-        Beneficial: import("tsondb/schema/def").EnumCaseDecl<null>;
-        Defensive: import("tsondb/schema/def").EnumCaseDecl<null>;
-        Supernatural: import("tsondb/schema/def").EnumCaseDecl<null>;
+import * as DB from "tsondb/schema/dsl";
+export declare const Elixir: DB.Entity<"Elixir", {
+    effect_types: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"EffectType", {
+        Healing: DB.EnumCase<null>;
+        Poison: DB.EnumCase<null>;
+        PhysicalEffect: DB.EnumCase<null>;
+        PsychicEffect: DB.EnumCase<null>;
+        Beneficial: DB.EnumCase<null>;
+        Defensive: DB.EnumCase<null>;
+        Supernatural: DB.EnumCase<null>;
     }, []>>>, false>;
-    value: import("tsondb/schema/def").MemberDecl<Integer, false>;
-    cost_per_ingredient_level: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    laboratory: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"LaboratoryLevel", {
-        ArchaicLaboratory: import("tsondb/schema/def").EnumCaseDecl<null>;
-        WitchKitchen: import("tsondb/schema/def").EnumCaseDecl<null>;
-        AlchemistsLaboratory: import("tsondb/schema/def").EnumCaseDecl<null>;
+    value: DB.MemberDecl<DB.Integer, false>;
+    cost_per_ingredient_level: DB.MemberDecl<DB.Integer, true>;
+    laboratory: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"LaboratoryLevel", {
+        ArchaicLaboratory: DB.EnumCase<null>;
+        WitchKitchen: DB.EnumCase<null>;
+        AlchemistsLaboratory: DB.EnumCase<null>;
     }, []>>, true>;
-    brewing_difficulty: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    trade_secret: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"RecipeTradeSecret", Object<{
-        ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-        prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PlainGeneralPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PlainPrerequisites", Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").EnumDecl<"PrerequisitesElement", {
-            Single: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").TypeArgumentType<import("tsondb/schema/def").TypeParameter<"T", import("tsondb/schema/def").Type>>>;
-            Disjunction: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PrerequisitesDisjunction", Object<{
-                list: import("tsondb/schema/def").MemberDecl<Array<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<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
-                    Hide: import("tsondb/schema/def").EnumCaseDecl<null>;
-                    ReplaceWith: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ReplacementDisplayOption", Object<{
-                        sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
-                            Standalone: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Connected: import("tsondb/schema/def").EnumCaseDecl<null>;
+    brewing_difficulty: DB.MemberDecl<DB.Integer, true>;
+    trade_secret: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RecipeTradeSecret", DB.Object<{
+        ap_value: DB.MemberDecl<DB.Integer, true>;
+        prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"PlainGeneralPrerequisites", 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: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PrerequisiteGroup", Object<{
-                list: import("tsondb/schema/def").MemberDecl<Array<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>;
+            }>, [T: DB.Param<"T", DB.Type>]>>>;
+        }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, false>;
     }>, []>>, true>;
-    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"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<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", Object<{
-                printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
-                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        Numbered: import("tsondb/schema/def").EnumCaseDecl<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<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                        InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                        Numbered: import("tsondb/schema/def").EnumCaseDecl<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<[], import("tsondb/schema/def").EnumDecl<"Revision", {
-                Since: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Since", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
-                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Numbered: import("tsondb/schema/def").EnumCaseDecl<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<[], import("tsondb/schema/def").EnumDecl<"Page", {
-                            InsideCoverFront: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            InsideCoverBack: import("tsondb/schema/def").EnumCaseDecl<null>;
-                            Numbered: import("tsondb/schema/def").EnumCaseDecl<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: import("tsondb/schema/def").EnumCaseDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"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<"ElixirTranslationTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        description: import("tsondb/schema/def").MemberDecl<String, false>;
-        special: import("tsondb/schema/def").MemberDecl<String, false>;
-        alternative_names: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"AlternativeName", Object<{
-            name: import("tsondb/schema/def").MemberDecl<String, true>;
-            region: import("tsondb/schema/def").MemberDecl<String, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ElixirTranslationTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: DB.MemberDecl<DB.String, false>;
+        special: DB.MemberDecl<DB.String, false>;
+        alternative_names: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"AlternativeName", DB.Object<{
+            name: DB.MemberDecl<DB.String, true>;
+            region: DB.MemberDecl<DB.String, false>;
         }>, []>>>, false>;
-        typical_ingredients: import("tsondb/schema/def").MemberDecl<Array<String>, true>;
-        brewing_process_prerequisites: import("tsondb/schema/def").MemberDecl<String, false>;
-        quality_levels: import("tsondb/schema/def").MemberDecl<Array<String>, true>;
-        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Errata", Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"Erratum", Object<{
-            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
-            description: import("tsondb/schema/def").MemberDecl<String, true>;
+        typical_ingredients: DB.MemberDecl<DB.Array<DB.String>, true>;
+        brewing_process_prerequisites: DB.MemberDecl<DB.String, false>;
+        quality_levels: DB.MemberDecl<DB.Array<DB.String>, true>;
+        errata: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Errata", DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Erratum", DB.Object<{
+            date: DB.MemberDecl<DB.Date, true>;
+            description: DB.MemberDecl<DB.String, true>;
         }>, []>>>, []>>, false>;
     }>, true>;
 }, undefined>;

package/lib/types/equipment/item/Elixir.js

@@ -1,69 +1,72 @@
-import { Array, Entity, IncludeIdentifier, Integer, Object, Optional, Required, String, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "../../Locale.js";
 import { AlternativeName } from "../../_AlternativeNames.js";
 import { Errata } from "../../source/_Erratum.js";
 import { src } from "../../source/_PublicationRef.js";
 import { EffectType, LaboratoryLevel, RecipeTradeSecret } from "./_Herbary.js";
-export const Elixir = Entity(import.meta.url, {
+export const Elixir = DB.Entity(import.meta.url, {
     name: "Elixir",
     namePlural: "Elixirs",
-    type: () => Object({
-        effect_types: Optional({
+    type: () => DB.Object({
+        effect_types: DB.Optional({
             comment: "Effect type(s) of an alchemical poison.",
-            type: Array(IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
+            type: DB.Array(DB.IncludeIdentifier(EffectType), { minItems: 1, uniqueItems: true }),
         }),
-        value: Optional({
+        value: DB.Optional({
             comment: "The raw (ingredients) value per level, in silverthalers.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        cost_per_ingredient_level: Required({
+        cost_per_ingredient_level: DB.Required({
             comment: "The cost per ingredient level in silverthalers.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        laboratory: Required({
+        laboratory: DB.Required({
             comment: "The laboratory level needed to brew the elixir.",
-            type: IncludeIdentifier(LaboratoryLevel),
+            type: DB.IncludeIdentifier(LaboratoryLevel),
         }),
-        brewing_difficulty: Required({
+        brewing_difficulty: DB.Required({
             comment: "The brewing difficulty, which represents the challenge of creating an elixir.",
-            type: Integer(),
+            type: DB.Integer(),
         }),
-        trade_secret: Required({
+        trade_secret: DB.Required({
             comment: "AP value and prerequisites of the elixir recipe’s trade secret.",
-            type: IncludeIdentifier(RecipeTradeSecret),
+            type: DB.IncludeIdentifier(RecipeTradeSecret),
         }),
         src,
-        translations: NestedTranslationMap(Required, "ElixirTranslation", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "ElixirTranslation", DB.Object({
+            name: DB.Required({
                 comment: "The item’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            description: Optional({
+            description: DB.Optional({
                 comment: "The recipe’s description.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            special: Optional({
+            special: DB.Optional({
                 comment: "The recipe’s description.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            alternative_names: Optional({
+            alternative_names: DB.Optional({
                 comment: "A list of alternative names.",
-                type: Array(IncludeIdentifier(AlternativeName), { minItems: 1 }),
+                type: DB.Array(DB.IncludeIdentifier(AlternativeName), { minItems: 1 }),
             }),
-            typical_ingredients: Required({
+            typical_ingredients: DB.Required({
                 comment: "A list of typical ingredients.",
-                type: Array(String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
+                type: DB.Array(DB.String({ minLength: 1 }), { minItems: 1, uniqueItems: true }),
             }),
-            brewing_process_prerequisites: Optional({
+            brewing_process_prerequisites: DB.Optional({
                 comment: "Prerequsites for the brewing process, if any.",
-                type: String({ minLength: 1, isMarkdown: true }),
+                type: DB.String({ minLength: 1, isMarkdown: true }),
             }),
-            quality_levels: Required({
+            quality_levels: DB.Required({
                 comment: "The list of effects for each quality level. The first element represents QL 1, the second element QL 2, and so on.",
-                type: Array(String({ minLength: 1, isMarkdown: true }), { minItems: 6, maxItems: 6 }),
+                type: DB.Array(DB.String({ minLength: 1, isMarkdown: true }), {
+                    minItems: 6,
+                    maxItems: 6,
+                }),
             }),
-            errata: Optional({
-                type: IncludeIdentifier(Errata),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
             }),
         })),
     }),