optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/SkillModificationLevel.js

@@ -1,28 +1,28 @@
 /**
  * @main SkillModificationLevel
  */
-import { Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, Optional, Required, String, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
-export const SkillModificationLevel = Entity(import.meta.url, {
+export const SkillModificationLevel = DB.Entity(import.meta.url, {
     name: "SkillModificationLevel",
     namePlural: "SkillModificationLevels",
-    type: () => Object({
-        fast: Required({
+    type: () => DB.Object({
+        fast: DB.Required({
             comment: "Configuration for this level for fast skills (spells, liturgical chants).",
-            type: IncludeIdentifier(FastSkillModificationLevelConfig),
+            type: DB.IncludeIdentifier(FastSkillModificationLevelConfig),
         }),
-        slow: Required({
+        slow: DB.Required({
             comment: "Configuration for this level for slow skills (rituals, ceremonies).",
-            type: IncludeIdentifier(SlowSkillModificationLevelConfig),
+            type: DB.IncludeIdentifier(SlowSkillModificationLevelConfig),
         }),
-        translations: NestedTranslationMap(Optional, "SkillModificationLevel", Object({
-            fast: Optional({
+        translations: NestedTranslationMap(DB.Optional, "SkillModificationLevel", DB.Object({
+            fast: DB.Optional({
                 comment: "Configuration for this level for fast skills (spells, liturgical chants). Values set here override the default generated text.",
-                type: IncludeIdentifier(LevelTypeConfigTranslation),
+                type: DB.IncludeIdentifier(LevelTypeConfigTranslation),
             }),
-            slow: Optional({
+            slow: DB.Optional({
                 comment: "Configuration for this level for slow skills (rituals, ceremonies). Values set here override the default generated text.",
-                type: IncludeIdentifier(LevelTypeConfigTranslation),
+                type: DB.IncludeIdentifier(LevelTypeConfigTranslation),
             }),
         }, { minProperties: 1 })),
     }),
@@ -51,66 +51,66 @@ export const SkillModificationLevel = Entity(import.meta.url, {
         { keyPath: ["slow", "cost"] },
     ],
 });
-const FastSkillModificationLevelConfig = TypeAlias(import.meta.url, {
+const FastSkillModificationLevelConfig = DB.TypeAlias(import.meta.url, {
     name: "FastSkillModificationLevelConfig",
-    type: () => Object({
-        casting_time: Required({
+    type: () => DB.Object({
+        casting_time: DB.Required({
             comment: "The casting time in actions.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        range: Required({
+        range: DB.Required({
             comment: "The range in meters.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        cost: Required({
+        cost: DB.Required({
             comment: "The cost in AE/KP.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const SlowSkillModificationLevelConfig = TypeAlias(import.meta.url, {
+const SlowSkillModificationLevelConfig = DB.TypeAlias(import.meta.url, {
     name: "SlowSkillModificationLevelConfig",
-    type: () => Object({
-        casting_time: Required({
+    type: () => DB.Object({
+        casting_time: DB.Required({
             comment: "The casting time.",
-            type: IncludeIdentifier(SlowSkillCastingTime),
+            type: DB.IncludeIdentifier(SlowSkillCastingTime),
         }),
-        range: Required({
+        range: DB.Required({
             comment: "The range in meters.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        cost: Required({
+        cost: DB.Required({
             comment: "The cost in AE/KP.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const SlowSkillCastingTime = TypeAlias(import.meta.url, {
+const SlowSkillCastingTime = DB.TypeAlias(import.meta.url, {
     name: "SlowSkillCastingTime",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "The (unitless) casting time.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        unit: Required({
+        unit: DB.Required({
             comment: "The unit for the `value`.",
-            type: IncludeIdentifier(SlowSkillCastingTimeUnit),
+            type: DB.IncludeIdentifier(SlowSkillCastingTimeUnit),
         }),
     }),
 });
-export const SlowSkillCastingTimeUnit = Enum(import.meta.url, {
+export const SlowSkillCastingTimeUnit = DB.Enum(import.meta.url, {
     name: "SlowSkillCastingTimeUnit",
     values: () => ({
-        Minutes: EnumCase({ type: null }),
-        Hours: EnumCase({ type: null }),
+        Minutes: DB.EnumCase({ type: null }),
+        Hours: DB.EnumCase({ type: null }),
     }),
 });
-const LevelTypeConfigTranslation = TypeAlias(import.meta.url, {
+const LevelTypeConfigTranslation = DB.TypeAlias(import.meta.url, {
     name: "LevelTypeConfigTranslation",
     comment: "Configuration translation of a type for a level. Values set here override the default generated text.",
-    type: () => Object({
-        range: Required({
-            type: String({ minLength: 1 }),
+    type: () => DB.Object({
+        range: DB.Required({
+            type: DB.String({ minLength: 1 }),
         }),
     }),
 });

package/lib/types/SocialStatus.d.ts

@@ -1,7 +1,7 @@
-import { Entity, Integer, String } from "tsondb/schema/def";
-export declare const SocialStatus: Entity<"SocialStatus", {
-    position: import("tsondb/schema/def").MemberDecl<Integer, true>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SocialStatusTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const SocialStatus: DB.Entity<"SocialStatus", {
+    position: DB.MemberDecl<DB.Integer, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SocialStatusTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }, undefined>;

package/lib/types/SocialStatus.js

@@ -1,17 +1,17 @@
-import { Entity, Integer, Object, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
-export const SocialStatus = Entity(import.meta.url, {
+export const SocialStatus = DB.Entity(import.meta.url, {
     name: "SocialStatus",
     namePlural: "SocialStatuses",
-    type: () => Object({
-        position: Required({
+    type: () => DB.Object({
+        position: DB.Required({
             comment: "The social status’ position. The higher the position, the more powerful the social status. This has to be a unique value.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
-        translations: NestedTranslationMap(Required, "SocialStatus", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "SocialStatus", DB.Object({
+            name: DB.Required({
                 comment: "The social status’ name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),