optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/_CommonnessRatedAdvantageDisadvantage.d.ts

@@ -1,7 +1,7 @@
-import { Object, String, TypeArgument } from "tsondb/schema/def";
-export declare const CommonnessRatedAdvantageDisadvantage: import("tsondb/schema/def").TypeAliasDecl<"CommonnessRatedAdvantageDisadvantage", Object<{
-    id: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CommonnessRatedAdvantageDisadvantageTranslation", {
-        options: import("tsondb/schema/def").MemberDecl<String, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const CommonnessRatedAdvantageDisadvantage: DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+    id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
+        options: DB.MemberDecl<DB.String, true>;
     }>, false>;
-}>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", import("tsondb/schema/def").Type>]>;
+}>, [Identifier: DB.Param<"Identifier", DB.Type>]>;

package/lib/types/_CommonnessRatedAdvantageDisadvantage.js

@@ -1,18 +1,18 @@
-import { GenTypeAlias, Object, Optional, Param, Required, String, TypeArgument, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
-export const CommonnessRatedAdvantageDisadvantage = GenTypeAlias(import.meta.url, {
+export const CommonnessRatedAdvantageDisadvantage = DB.GenTypeAlias(import.meta.url, {
     name: "CommonnessRatedAdvantageDisadvantage",
     comment: "Reference to a commonness-rated advantage or disadvantage. Commonness-rating terms used in the source books are strongly recommended, common, uncommon, suggested and unsuitable.",
-    parameters: [Param("Identifier")],
-    type: Identifier => Object({
-        id: Required({
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        id: DB.Required({
             comment: "The advantage's or disadvantage's identifier.",
-            type: TypeArgument(Identifier),
+            type: DB.TypeArgument(Identifier),
         }),
-        translations: NestedTranslationMap(Optional, "CommonnessRatedAdvantageDisadvantage", Object({
-            options: Required({
+        translations: NestedTranslationMap(DB.Optional, "CommonnessRatedAdvantageDisadvantage", DB.Object({
+            options: DB.Required({
                 comment: "The options the commonness rating applies to.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),

package/lib/types/_Dice.d.ts

@@ -1,6 +1,6 @@
-import { IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
-export declare const Dice: TypeAlias<"Dice", Object<{
-    number: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    sides: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"DieType", Integer, []>>, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const Dice: DB.TypeAlias<"Dice", DB.Object<{
+    number: DB.MemberDecl<DB.Integer, true>;
+    sides: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"DieType", DB.Integer, []>>, true>;
 }>, []>;
-export declare const DieType: TypeAlias<"DieType", Integer, []>;
+export declare const DieType: DB.TypeAlias<"DieType", DB.Integer, []>;

package/lib/types/_Dice.js

@@ -1,23 +1,23 @@
-import { IncludeIdentifier, Integer, Object, Required, TypeAlias } from "tsondb/schema/def";
-export const Dice = TypeAlias(import.meta.url, {
+import * as DB from "tsondb/schema/dsl";
+export const Dice = DB.TypeAlias(import.meta.url, {
     name: "Dice",
-    type: () => Object({
-        number: Required({
+    type: () => DB.Object({
+        number: DB.Required({
             comment: "Number of dice of the same type. Example: 2 in 2D6.",
-            type: Integer({
+            type: DB.Integer({
                 minimum: 1,
             }),
         }),
-        sides: Required({
+        sides: DB.Required({
             comment: "Number of sides on every die. Example: 6 in 2D6.",
-            type: IncludeIdentifier(DieType),
+            type: DB.IncludeIdentifier(DieType),
         }),
     }),
 });
-export const DieType = TypeAlias(import.meta.url, {
+export const DieType = DB.TypeAlias(import.meta.url, {
     name: "DieType",
     comment: "Number of sides on every die. Example: 6 in 2D6.",
-    type: () => Integer({
+    type: () => DB.Integer({
         minimum: 2,
     }),
 });

package/lib/types/_DiseasePoison.d.ts

@@ -1,59 +1,59 @@
 /**
  * This file defines some shared types for different diseases and poisons.
  */
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias, TypeArgument } from "tsondb/schema/def";
-export declare const level: import("tsondb/schema/def").MemberDecl<Integer, true>;
-export declare const Resistance: Enum<"Resistance", {
-    Spirit: EnumCase<null>;
-    Toughness: EnumCase<null>;
-    LowerOfSpiritAndToughness: EnumCase<null>;
+import * as DB from "tsondb/schema/dsl";
+export declare const level: DB.MemberDecl<DB.Integer, true>;
+export declare const Resistance: DB.Enum<"Resistance", {
+    Spirit: DB.EnumCase<null>;
+    Toughness: DB.EnumCase<null>;
+    LowerOfSpiritAndToughness: DB.EnumCase<null>;
 }, []>;
-export declare const resistance: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Resistance", {
-    Spirit: EnumCase<null>;
-    Toughness: EnumCase<null>;
-    LowerOfSpiritAndToughness: EnumCase<null>;
+export declare const resistance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Resistance", {
+    Spirit: DB.EnumCase<null>;
+    Toughness: DB.EnumCase<null>;
+    LowerOfSpiritAndToughness: DB.EnumCase<null>;
 }, []>>, true>;
-export declare const Cause: TypeAlias<"Cause", Object<{
-    chance: import("tsondb/schema/def").MemberDecl<Integer, false>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CauseTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        chance: import("tsondb/schema/def").MemberDecl<String, false>;
-        note: import("tsondb/schema/def").MemberDecl<String, false>;
+export declare const Cause: DB.TypeAlias<"Cause", DB.Object<{
+    chance: DB.MemberDecl<DB.Integer, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CauseTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        chance: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
     }>, true>;
 }>, []>;
-export declare const cause: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"Cause", Object<{
-    chance: import("tsondb/schema/def").MemberDecl<Integer, false>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CauseTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        chance: import("tsondb/schema/def").MemberDecl<String, false>;
-        note: import("tsondb/schema/def").MemberDecl<String, false>;
+export declare const cause: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Cause", DB.Object<{
+    chance: DB.MemberDecl<DB.Integer, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"CauseTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        chance: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
     }>, true>;
 }>, []>>>, true>;
-export declare const Reduceable: TypeAlias<"Reduceable", Object<{
-    default: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, true>;
-    reduced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, false>;
-}>, [Content: import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>]>;
-export declare const DiseaseTranslation: Object<{
-    name: import("tsondb/schema/def").MemberDecl<String, true>;
-    alternative_names: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"AlternativeName", Object<{
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        region: import("tsondb/schema/def").MemberDecl<String, false>;
+export declare const Reduceable: DB.TypeAlias<"Reduceable", DB.Object<{
+    default: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, true>;
+    reduced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, false>;
+}>, [Content: DB.Param<"Content", DB.Type>]>;
+export declare const DiseaseTranslation: DB.Object<{
+    name: DB.MemberDecl<DB.String, true>;
+    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>;
-    progress: import("tsondb/schema/def").MemberDecl<String, true>;
-    incubation_time: import("tsondb/schema/def").MemberDecl<String, true>;
-    damage: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"Reduceable", Object<{
-        default: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, true>;
-        reduced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, false>;
-    }>, [Content: import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>]>>, true>;
-    duration: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"Reduceable", Object<{
-        default: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, true>;
-        reduced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>>, false>;
-    }>, [Content: import("tsondb/schema/def").TypeParameter<"Content", import("tsondb/schema/def").Type>]>>, true>;
-    special: import("tsondb/schema/def").MemberDecl<String, false>;
-    treatment: import("tsondb/schema/def").MemberDecl<String, true>;
-    cure: import("tsondb/schema/def").MemberDecl<String, true>;
-    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>;
+    progress: DB.MemberDecl<DB.String, true>;
+    incubation_time: DB.MemberDecl<DB.String, true>;
+    damage: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"Reduceable", DB.Object<{
+        default: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, true>;
+        reduced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, false>;
+    }>, [Content: DB.Param<"Content", DB.Type>]>>, true>;
+    duration: DB.MemberDecl<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"Reduceable", DB.Object<{
+        default: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, true>;
+        reduced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Content", DB.Type>>, false>;
+    }>, [Content: DB.Param<"Content", DB.Type>]>>, true>;
+    special: DB.MemberDecl<DB.String, false>;
+    treatment: DB.MemberDecl<DB.String, true>;
+    cure: DB.MemberDecl<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>;
 }>;

package/lib/types/_DiseasePoison.js

@@ -1,110 +1,110 @@
 /**
  * This file defines some shared types for different diseases and poisons.
  */
-import { Array, Enum, EnumCase, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, String, TypeAlias, TypeArgument, } 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";
-export const level = Required({
+export const level = DB.Required({
     comment: "The disease’s level.",
-    type: Integer({ minimum: 1 }),
+    type: DB.Integer({ minimum: 1 }),
 });
-export const Resistance = Enum(import.meta.url, {
+export const Resistance = DB.Enum(import.meta.url, {
     name: "Resistance",
     comment: "Depending on the disease, apply Spirit or Toughness as a penalty to the disease roll. It may also happen that the lower of both is applied as a penalty.",
     values: () => ({
-        Spirit: EnumCase({ type: null }),
-        Toughness: EnumCase({ type: null }),
-        LowerOfSpiritAndToughness: EnumCase({ type: null }),
+        Spirit: DB.EnumCase({ type: null }),
+        Toughness: DB.EnumCase({ type: null }),
+        LowerOfSpiritAndToughness: DB.EnumCase({ type: null }),
     }),
 });
-export const resistance = Required({
+export const resistance = DB.Required({
     comment: "Depending on the disease, apply Spirit or Toughness as a penalty to the disease roll. It may also happen that the lower of both is applied as a penalty.",
-    type: IncludeIdentifier(Resistance),
+    type: DB.IncludeIdentifier(Resistance),
 });
-export const Cause = TypeAlias(import.meta.url, {
+export const Cause = DB.TypeAlias(import.meta.url, {
     name: "Cause",
     comment: "What causes the disease? The GM rolls 1D20 to see if a character gets infected. If the infection check succeeds, the GM makes a disease check to determine the severity of the infection.",
-    type: () => Object({
-        chance: Optional({
+    type: () => DB.Object({
+        chance: DB.Optional({
             comment: "The chance to get infected by this cause, in percent. Some causes do not have a specific chance.",
-            type: Integer({ minimum: 5, multipleOf: 5, maximum: 100 }),
+            type: DB.Integer({ minimum: 5, multipleOf: 5, maximum: 100 }),
         }),
-        translations: NestedTranslationMap(Required, "Cause", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "Cause", DB.Object({
+            name: DB.Required({
                 comment: "The cause’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            chance: Optional({
+            chance: DB.Optional({
                 comment: "The chance to get infected by this cause. If present for this language, this overrides the universal `chance` field; they cannot be used at the same time.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            note: Optional({
+            note: DB.Optional({
                 comment: "An additional note about this cause.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),
 });
-export const cause = Required({
+export const cause = DB.Required({
     comment: "What causes the disease? The GM rolls 1D20 to see if a character gets infected. If the infection check succeeds, the GM makes a disease check to determine the severity of the infection.",
-    type: Array(IncludeIdentifier(Cause), { minItems: 1 }),
+    type: DB.Array(DB.IncludeIdentifier(Cause), { minItems: 1 }),
 });
-export const Reduceable = GenTypeAlias(import.meta.url, {
+export const Reduceable = DB.GenTypeAlias(import.meta.url, {
     name: "Reduceable",
     comment: `An effect or other parameter that may be reduced by a failed disease check for lessening or a degraded poison.
 
 This streamlines the wording for diseases and poison by using a unified wording for *lessened* (disease) and *degraded* (poison).`,
-    parameters: [Param("Content")],
-    type: Content => Object({
-        default: Required({
+    parameters: [DB.Param("Content")],
+    type: Content => DB.Object({
+        default: DB.Required({
             comment: "The default value. In the source, it's the text before the slash.",
-            type: TypeArgument(Content),
+            type: DB.TypeArgument(Content),
         }),
-        reduced: Optional({
+        reduced: DB.Optional({
             comment: "The reduced value. In the source, it's the text after the slash. Some entries may not have a reduced value.",
-            type: TypeArgument(Content),
+            type: DB.TypeArgument(Content),
         }),
     }),
 });
-export const DiseaseTranslation = Object({
-    name: Required({
+export const DiseaseTranslation = DB.Object({
+    name: DB.Required({
         comment: "The disease’s name.",
-        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 }),
     }),
-    progress: Required({
+    progress: DB.Required({
         comment: "The disease’s progress, in detail.",
-        type: String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, isMarkdown: true }),
     }),
-    incubation_time: Required({
+    incubation_time: DB.Required({
         comment: "After infection, how much time passes before symptoms appear?",
-        type: String({ minLength: 1 }),
+        type: DB.String({ minLength: 1 }),
     }),
-    damage: Required({
+    damage: DB.Required({
         comment: "The damage caused by the disease. If the disease check fails, apply the lessened effects.",
-        type: GenIncludeIdentifier(Reduceable, [String({ minLength: 1, isMarkdown: true })]),
+        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, isMarkdown: true })]),
     }),
-    duration: Required({
+    duration: DB.Required({
         comment: "The duration of the disease. If the disease check fails, use the lessened duration.",
-        type: GenIncludeIdentifier(Reduceable, [String({ minLength: 1, isMarkdown: true })]),
+        type: DB.GenIncludeIdentifier(Reduceable, [DB.String({ minLength: 1, isMarkdown: true })]),
     }),
-    special: Optional({
+    special: DB.Optional({
         comment: "Special information about the disease.",
-        type: String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, isMarkdown: true }),
     }),
-    treatment: Required({
+    treatment: DB.Required({
         comment: "Methods known to lessen the disease’s progress or relieve symptoms.",
-        type: String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, isMarkdown: true }),
     }),
-    cure: Required({
+    cure: DB.Required({
         comment: "Known remedies for the disease.",
-        type: String({ minLength: 1, isMarkdown: true }),
+        type: DB.String({ minLength: 1, isMarkdown: true }),
     }),
-    errata: Optional({
-        type: IncludeIdentifier(Errata),
+    errata: DB.Optional({
+        type: DB.IncludeIdentifier(Errata),
     }),
 });