optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/_ActivatableSkillEffect.js

@@ -1,65 +1,65 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
-export const ActivatableSkillEffect = Enum(import.meta.url, {
+import * as DB from "tsondb/schema/dsl";
+export const ActivatableSkillEffect = DB.Enum(import.meta.url, {
     name: "ActivatableSkillEffect",
     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.",
     values: () => ({
-        Plain: EnumCase({
-            type: IncludeIdentifier(ActivatableSkillPlainEffect),
+        Plain: DB.EnumCase({
+            type: DB.IncludeIdentifier(ActivatableSkillPlainEffect),
         }),
-        ForEachQualityLevel: EnumCase({
-            type: IncludeIdentifier(ActivatableSkillEffectForEachQualityLevel),
+        ForEachQualityLevel: DB.EnumCase({
+            type: DB.IncludeIdentifier(ActivatableSkillEffectForEachQualityLevel),
         }),
-        ForEachTwoQualityLevels: EnumCase({
-            type: IncludeIdentifier(ActivatableSkillEffectForEachTwoQualityLevels),
+        ForEachTwoQualityLevels: DB.EnumCase({
+            type: DB.IncludeIdentifier(ActivatableSkillEffectForEachTwoQualityLevels),
         }),
     }),
 });
-const ActivatableSkillPlainEffect = TypeAlias(import.meta.url, {
+const ActivatableSkillPlainEffect = DB.TypeAlias(import.meta.url, {
     name: "ActivatableSkillPlainEffect",
-    type: () => Object({
-        text: Required({
+    type: () => DB.Object({
+        text: DB.Required({
             comment: "The effect description.",
-            type: String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, isMarkdown: true }),
         }),
     }),
 });
-const ActivatableSkillEffectForEachQualityLevel = TypeAlias(import.meta.url, {
+const ActivatableSkillEffectForEachQualityLevel = DB.TypeAlias(import.meta.url, {
     name: "ActivatableSkillEffectForEachQualityLevel",
-    type: () => Object({
-        text_before: Required({
+    type: () => DB.Object({
+        text_before: DB.Required({
             comment: "The effect description before the list of effects for each quality level.",
-            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 }), {
+            type: DB.Array(DB.String({ minLength: 1, isMarkdown: true }), {
                 minItems: 6,
                 maxItems: 6,
             }),
         }),
-        text_after: Optional({
+        text_after: DB.Optional({
             comment: "The effect description after the list of effects for each quality level.",
-            type: String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, isMarkdown: true }),
         }),
     }),
 });
-const ActivatableSkillEffectForEachTwoQualityLevels = TypeAlias(import.meta.url, {
+const ActivatableSkillEffectForEachTwoQualityLevels = DB.TypeAlias(import.meta.url, {
     name: "ActivatableSkillEffectForEachTwoQualityLevels",
-    type: () => Object({
-        text_before: Required({
+    type: () => DB.Object({
+        text_before: DB.Required({
             comment: "The effect description before the list of effects for each quality level.",
-            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 two quality levels. The first element represents QL 1–2, the second element QL 3–4 and the third element QL 5–6.",
-            type: Array(String({ minLength: 1, isMarkdown: true }), {
+            type: DB.Array(DB.String({ minLength: 1, isMarkdown: true }), {
                 minItems: 3,
                 maxItems: 3,
             }),
         }),
-        text_after: Optional({
+        text_after: DB.Optional({
             comment: "The effect description after the list of effects for each quality level.",
-            type: String({ minLength: 1, isMarkdown: true }),
+            type: DB.String({ minLength: 1, isMarkdown: true }),
         }),
     }),
 });

package/lib/types/_ActivatableSkillRange.d.ts

@@ -1,61 +1,61 @@
-import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, TypeAlias } from "tsondb/schema/def";
-export declare const Range: TypeAlias<"Range", Object<{
-    value: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeValue", {
-        Modifiable: EnumCase<IncludeIdentifier<[], TypeAlias<"ModifiableRange", Object<{
-            is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
-            initial_modification_level: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-            is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+import * as DB from "tsondb/schema/dsl";
+export declare const Range: DB.TypeAlias<"Range", DB.Object<{
+    value: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeValue", {
+        Modifiable: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ModifiableRange", DB.Object<{
+            is_maximum: DB.MemberDecl<DB.Boolean, false>;
+            initial_modification_level: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            is_radius: DB.MemberDecl<DB.Boolean, false>;
         }>, []>>>;
-        Sight: EnumCase<null>;
-        Self: EnumCase<null>;
-        Global: EnumCase<null>;
-        Touch: EnumCase<null>;
-        Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedRange", Object<{
-            is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
-            value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-            unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeUnit", {
-                Steps: EnumCase<null>;
-                Miles: EnumCase<null>;
+        Sight: DB.EnumCase<null>;
+        Self: DB.EnumCase<null>;
+        Global: DB.EnumCase<null>;
+        Touch: DB.EnumCase<null>;
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedRange", DB.Object<{
+            is_maximum: DB.MemberDecl<DB.Boolean, false>;
+            value: DB.MemberDecl<DB.Integer, true>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+                Steps: DB.EnumCase<null>;
+                Miles: DB.EnumCase<null>;
             }, []>>, true>;
-            is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+            is_radius: DB.MemberDecl<DB.Boolean, false>;
         }>, []>>>;
-        CheckResultBased: EnumCase<IncludeIdentifier<[], TypeAlias<"CheckResultBasedRange", Object<{
-            is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
-            base: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"CheckResultValue", {
-                QualityLevels: EnumCase<null>;
-                SkillPoints: EnumCase<null>;
+        CheckResultBased: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CheckResultBasedRange", 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<"RangeUnit", {
-                Steps: EnumCase<null>;
-                Miles: EnumCase<null>;
+            unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+                Steps: DB.EnumCase<null>;
+                Miles: DB.EnumCase<null>;
             }, []>>, true>;
-            is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+            is_radius: DB.MemberDecl<DB.Boolean, false>;
         }>, []>>>;
     }, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"RangeTranslation", {
-        note: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"ResponsiveTextOptional", Object<{
-            full: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
-            compressed: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"RangeTranslation", {
+        note: 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<"ResponsiveTextReplace", Object<{
-            full: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
-            compressed: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+        replacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextReplace", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, true>;
         }>, []>>, false>;
     }>, false>;
 }>, []>;
-export declare const FixedRange: TypeAlias<"FixedRange", Object<{
-    is_maximum: import("tsondb/schema/def").MemberDecl<Boolean, false>;
-    value: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    unit: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RangeUnit", {
-        Steps: EnumCase<null>;
-        Miles: EnumCase<null>;
+export declare const FixedRange: DB.TypeAlias<"FixedRange", DB.Object<{
+    is_maximum: DB.MemberDecl<DB.Boolean, false>;
+    value: DB.MemberDecl<DB.Integer, true>;
+    unit: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RangeUnit", {
+        Steps: DB.EnumCase<null>;
+        Miles: DB.EnumCase<null>;
     }, []>>, true>;
-    is_radius: import("tsondb/schema/def").MemberDecl<Boolean, false>;
+    is_radius: DB.MemberDecl<DB.Boolean, false>;
 }>, []>;

package/lib/types/_ActivatableSkillRange.js

@@ -1,106 +1,106 @@
-import { Boolean, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { CheckResultBasedModifier, CheckResultValue } from "./_ActivatableSkillCheckResultBased.js";
 import { SkillModificationLevelIdentifier } from "./_Identifier.js";
 import { ResponsiveTextOptional, ResponsiveTextReplace } from "./_ResponsiveText.js";
 import { NestedTranslationMap } from "./Locale.js";
-export const Range = TypeAlias(import.meta.url, {
+export const Range = DB.TypeAlias(import.meta.url, {
     name: "Range",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "The range value.",
-            type: IncludeIdentifier(RangeValue),
+            type: DB.IncludeIdentifier(RangeValue),
         }),
-        translations: NestedTranslationMap(Optional, "Range", Object({
-            note: Optional({
+        translations: NestedTranslationMap(DB.Optional, "Range", DB.Object({
+            note: DB.Optional({
                 comment: "A note, appended to the generated string in parenthesis. If the generated is modified using `replacement`, the note is appended to the modifier string.",
-                type: IncludeIdentifier(ResponsiveTextOptional),
+                type: DB.IncludeIdentifier(ResponsiveTextOptional),
             }),
-            replacement: Optional({
+            replacement: DB.Optional({
                 comment: "A replacement string. If `note` is provided, it is appended to the replaced string.",
-                type: IncludeIdentifier(ResponsiveTextReplace),
+                type: DB.IncludeIdentifier(ResponsiveTextReplace),
             }),
         }, { minProperties: 1 })),
     }),
 });
-const RangeValue = Enum(import.meta.url, {
+const RangeValue = DB.Enum(import.meta.url, {
     name: "RangeValue",
     values: () => ({
-        Modifiable: EnumCase({ type: IncludeIdentifier(ModifiableRange) }),
-        Sight: EnumCase({ type: null }),
-        Self: EnumCase({ type: null }),
-        Global: EnumCase({ comment: "German: *dereumfassend*", type: null }),
-        Touch: EnumCase({ type: null }),
-        Fixed: EnumCase({ type: IncludeIdentifier(FixedRange) }),
-        CheckResultBased: EnumCase({ type: IncludeIdentifier(CheckResultBasedRange) }),
+        Modifiable: DB.EnumCase({ type: DB.IncludeIdentifier(ModifiableRange) }),
+        Sight: DB.EnumCase({ type: null }),
+        Self: DB.EnumCase({ type: null }),
+        Global: DB.EnumCase({ comment: "German: *dereumfassend*", type: null }),
+        Touch: DB.EnumCase({ type: null }),
+        Fixed: DB.EnumCase({ type: DB.IncludeIdentifier(FixedRange) }),
+        CheckResultBased: DB.EnumCase({ type: DB.IncludeIdentifier(CheckResultBasedRange) }),
     }),
 });
-const ModifiableRange = TypeAlias(import.meta.url, {
+const ModifiableRange = DB.TypeAlias(import.meta.url, {
     name: "ModifiableRange",
-    type: () => Object({
-        is_maximum: Optional({
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
             comment: "If `true`, the range is a maximum range.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
-        initial_modification_level: Required({
+        initial_modification_level: DB.Required({
             comment: "The initial skill modification identifier/level.",
             type: SkillModificationLevelIdentifier(),
         }),
-        is_radius: Optional({
+        is_radius: DB.Optional({
             comment: "If `true`, the range is a radius.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
     }),
 });
-export const FixedRange = TypeAlias(import.meta.url, {
+export const FixedRange = DB.TypeAlias(import.meta.url, {
     name: "FixedRange",
-    type: () => Object({
-        is_maximum: Optional({
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
             comment: "If `true`, the range is a maximum range.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
-        value: Required({
+        value: DB.Required({
             comment: "The (unitless) range value.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        unit: Required({
+        unit: DB.Required({
             comment: "The unit of the `value`.",
-            type: IncludeIdentifier(RangeUnit),
+            type: DB.IncludeIdentifier(RangeUnit),
         }),
-        is_radius: Optional({
+        is_radius: DB.Optional({
             comment: "If `true`, the range is a radius.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
     }),
 });
-const CheckResultBasedRange = TypeAlias(import.meta.url, {
+const CheckResultBasedRange = DB.TypeAlias(import.meta.url, {
     name: "CheckResultBasedRange",
-    type: () => Object({
-        is_maximum: Optional({
+    type: () => DB.Object({
+        is_maximum: DB.Optional({
             comment: "If the range is the maximum range.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
-        base: Required({
+        base: DB.Required({
             comment: "The base value that is derived from the check result.",
-            type: IncludeIdentifier(CheckResultValue),
+            type: DB.IncludeIdentifier(CheckResultValue),
         }),
-        modifier: Optional({
+        modifier: DB.Optional({
             comment: "If defined, it modifies the base value.",
-            type: IncludeIdentifier(CheckResultBasedModifier),
+            type: DB.IncludeIdentifier(CheckResultBasedModifier),
         }),
-        unit: Required({
+        unit: DB.Required({
             comment: "The duration unit.",
-            type: IncludeIdentifier(RangeUnit),
+            type: DB.IncludeIdentifier(RangeUnit),
         }),
-        is_radius: Optional({
+        is_radius: DB.Optional({
             comment: "If `true`, the range is a radius.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
     }),
 });
-const RangeUnit = Enum(import.meta.url, {
+const RangeUnit = DB.Enum(import.meta.url, {
     name: "RangeUnit",
     values: () => ({
-        Steps: EnumCase({ type: null }),
-        Miles: EnumCase({ type: null }),
+        Steps: DB.EnumCase({ type: null }),
+        Miles: DB.EnumCase({ type: null }),
     }),
 });

package/lib/types/_ActivatableSkillTargetCategory.d.ts

@@ -1,14 +1,14 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Object, String, TypeAlias } from "tsondb/schema/def";
-export declare const AffectedTargetCategories: TypeAlias<"AffectedTargetCategories", Array<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>;
+import * as DB from "tsondb/schema/dsl";
+export declare const AffectedTargetCategories: 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>;
 }>, []>>>, []>;

package/lib/types/_ActivatableSkillTargetCategory.js

@@ -1,30 +1,30 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { TargetCategoryIdentifier } from "./_Identifier.js";
-export const AffectedTargetCategories = TypeAlias(import.meta.url, {
+export const AffectedTargetCategories = DB.TypeAlias(import.meta.url, {
     name: "AffectedTargetCategories",
     comment: `The target category – the kind of creature or object – the skill affects.
 
 If no target categories are given, the skill applies to all target categories.`,
-    type: () => Array(IncludeIdentifier(SpecificAffectedTargetCategory)),
+    type: () => DB.Array(DB.IncludeIdentifier(SpecificAffectedTargetCategory)),
 });
-const SpecificAffectedTargetCategory = TypeAlias(import.meta.url, {
+const SpecificAffectedTargetCategory = DB.TypeAlias(import.meta.url, {
     name: "SpecificAffectedTargetCategory",
-    type: () => Object({
-        id: Required({ type: IncludeIdentifier(SpecificAffectedTargetCategoryIdentifier) }),
-        translations: NestedTranslationMap(Optional, "SpecificAffectedTargetCategory", Object({
-            note: Required({ type: String({ minLength: 1 }) }),
+    type: () => DB.Object({
+        id: DB.Required({ type: DB.IncludeIdentifier(SpecificAffectedTargetCategoryIdentifier) }),
+        translations: NestedTranslationMap(DB.Optional, "SpecificAffectedTargetCategory", DB.Object({
+            note: DB.Required({ type: DB.String({ minLength: 1 }) }),
         })),
     }),
 });
-const SpecificAffectedTargetCategoryIdentifier = Enum(import.meta.url, {
+const SpecificAffectedTargetCategoryIdentifier = DB.Enum(import.meta.url, {
     name: "SpecificAffectedTargetCategoryIdentifier",
     values: () => ({
-        Self: EnumCase({ type: null }),
-        Zone: EnumCase({ type: null }),
-        LiturgicalChantsAndCeremonies: EnumCase({ type: null }),
-        Cantrips: EnumCase({ type: null }),
-        Spellworks: EnumCase({ type: null }),
-        Predefined: EnumCase({ type: TargetCategoryIdentifier() }),
+        Self: DB.EnumCase({ type: null }),
+        Zone: DB.EnumCase({ type: null }),
+        LiturgicalChantsAndCeremonies: DB.EnumCase({ type: null }),
+        Cantrips: DB.EnumCase({ type: null }),
+        Spellworks: DB.EnumCase({ type: null }),
+        Predefined: DB.EnumCase({ type: TargetCategoryIdentifier() }),
     }),
 });

package/lib/types/_AlternativeNames.d.ts

@@ -1,5 +1,5 @@
-import { Object, String, TypeAlias } from "tsondb/schema/def";
-export declare const AlternativeName: TypeAlias<"AlternativeName", Object<{
-    name: import("tsondb/schema/def").MemberDecl<String, true>;
-    region: import("tsondb/schema/def").MemberDecl<String, false>;
+import * as DB from "tsondb/schema/dsl";
+export declare const AlternativeName: DB.TypeAlias<"AlternativeName", DB.Object<{
+    name: DB.MemberDecl<DB.String, true>;
+    region: DB.MemberDecl<DB.String, false>;
 }>, []>;

package/lib/types/_AlternativeNames.js

@@ -1,14 +1,14 @@
-import { Object, Optional, Required, String, TypeAlias } from "tsondb/schema/def";
-export const AlternativeName = TypeAlias(import.meta.url, {
+import * as DB from "tsondb/schema/dsl";
+export const AlternativeName = DB.TypeAlias(import.meta.url, {
     name: "AlternativeName",
-    type: () => Object({
-        name: Required({
+    type: () => DB.Object({
+        name: DB.Required({
             comment: "An alternative name of the disease.",
-            type: String({ minLength: 1 }),
+            type: DB.String({ minLength: 1 }),
         }),
-        region: Optional({
+        region: DB.Optional({
             comment: "The region where this alternative name is used.",
-            type: String({ minLength: 1 }),
+            type: DB.String({ minLength: 1 }),
         }),
     }),
 });

package/lib/types/_ArcaneTradition.d.ts

@@ -1,30 +1,30 @@
-import { IncludeIdentifier, Object, String } from "tsondb/schema/def";
-export declare const ArcaneTraditionType: <TN extends string>(translationName: TN) => () => Object<{
-    prerequisites: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ArcaneTraditionPrerequisites", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], import("tsondb/schema/def").TypeAliasDecl<"PlainPrerequisites", import("tsondb/schema/def").ArrayType<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<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<[], 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>;
+import * as DB from "tsondb/schema/dsl";
+export declare const ArcaneTraditionType: <TN extends string>(translationName: TN) => () => DB.Object<{
+    prerequisites: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ArcaneTraditionPrerequisites", 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<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>]>>, []>>, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<`${TN}Translation`, {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
+        }>, [T: DB.Param<"T", DB.Type>]>>>;
+    }, [T: DB.Param<"T", DB.Type>]>>>, [T: DB.Param<"T", DB.Type>]>>, []>>, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<`${TN}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }>;

package/lib/types/_ArcaneTradition.js

@@ -1,14 +1,14 @@
-import { IncludeIdentifier, Object, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { ArcaneTraditionPrerequisites } from "./_Prerequisite.js";
-export const ArcaneTraditionType = (translationName) => () => Object({
-    prerequisites: Required({
-        type: IncludeIdentifier(ArcaneTraditionPrerequisites),
+export const ArcaneTraditionType = (translationName) => () => DB.Object({
+    prerequisites: DB.Required({
+        type: DB.IncludeIdentifier(ArcaneTraditionPrerequisites),
     }),
-    translations: NestedTranslationMap(Required, translationName, Object({
-        name: Required({
+    translations: NestedTranslationMap(DB.Required, translationName, DB.Object({
+        name: DB.Required({
             comment: "The arcane tradition’s name.",
-            type: String({ minLength: 1 }),
+            type: DB.String({ minLength: 1 }),
         }),
     })),
 });

package/lib/types/_Blessed.d.ts

@@ -1,8 +1,8 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
-export declare const LiturgyTradition: Enum<"LiturgyTradition", {
-    GeneralAspect: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-    Tradition: EnumCase<IncludeIdentifier<[], TypeAlias<"LiturgyTraditionWithAspects", Object<{
-        tradition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        aspects: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, false>;
+import * as DB from "tsondb/schema/dsl";
+export declare const LiturgyTradition: DB.Enum<"LiturgyTradition", {
+    GeneralAspect: DB.EnumCase<DB.ReferenceIdentifier>;
+    Tradition: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"LiturgyTraditionWithAspects", DB.Object<{
+        tradition: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        aspects: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     }>, []>>>;
 }, []>;

package/lib/types/_Blessed.js

@@ -1,22 +1,22 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { AspectIdentifier, BlessedTraditionIdentifier } from "./_Identifier.js";
-export const LiturgyTradition = Enum(import.meta.url, {
+export const LiturgyTradition = DB.Enum(import.meta.url, {
     name: "LiturgyTradition",
     values: () => ({
-        GeneralAspect: EnumCase({ type: AspectIdentifier() }),
-        Tradition: EnumCase({ type: IncludeIdentifier(LiturgyTraditionWithAspects) }),
+        GeneralAspect: DB.EnumCase({ type: AspectIdentifier() }),
+        Tradition: DB.EnumCase({ type: DB.IncludeIdentifier(LiturgyTraditionWithAspects) }),
     }),
 });
-const LiturgyTraditionWithAspects = TypeAlias(import.meta.url, {
+const LiturgyTraditionWithAspects = DB.TypeAlias(import.meta.url, {
     name: "LiturgyTraditionWithAspects",
-    type: () => Object({
-        tradition: Required({
+    type: () => DB.Object({
+        tradition: DB.Required({
             comment: "The blessed tradition.",
             type: BlessedTraditionIdentifier(),
         }),
-        aspects: Optional({
+        aspects: DB.Optional({
             comment: "The aspect(s) from the tradition the ceremony belongs to. Note that not all traditions have aspects. Traditions with aspects must have at least one aspect specified.",
-            type: Array(AspectIdentifier(), { minItems: 1, maxItems: 2 }),
+            type: DB.Array(AspectIdentifier(), { minItems: 1, maxItems: 2 }),
         }),
     }),
 });