optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/Ritual.js

@@ -1,4 +1,4 @@
-import { ChildEntities, Entity, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { OldParameter, SlowPerformanceParameters } from "./_ActivatableSkill.js";
 import { ActivatableSkillEffect } from "./_ActivatableSkillEffect.js";
 import { AffectedTargetCategories } from "./_ActivatableSkillTargetCategory.js";
@@ -11,79 +11,79 @@ import { reversalis, SpellworkTraditions } from "./_Spellwork.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
-export const Ritual = Entity(import.meta.url, {
+export const Ritual = DB.Entity(import.meta.url, {
     name: "Ritual",
     namePlural: "Rituals",
-    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),
         }),
-        parameters: Required({
+        parameters: DB.Required({
             comment: "Measurable parameters of a ritual.",
-            type: IncludeIdentifier(SlowPerformanceParameters),
+            type: DB.IncludeIdentifier(SlowPerformanceParameters),
         }),
-        target: Required({
+        target: DB.Required({
             comment: "The target category – the kind of creature or object – the skill affects.",
-            type: IncludeIdentifier(AffectedTargetCategories),
+            type: DB.IncludeIdentifier(AffectedTargetCategories),
         }),
-        property: Required({
+        property: DB.Required({
             comment: "The associated property.",
             type: PropertyIdentifier(),
         }),
-        traditions: Required({
+        traditions: DB.Required({
             comment: "The tradition(s) the ritual is available for. It may be *generally* available to all traditions or it may be only familiar in specific traditions.",
-            type: IncludeIdentifier(SpellworkTraditions),
+            type: DB.IncludeIdentifier(SpellworkTraditions),
         }),
-        improvement_cost: Required({
+        improvement_cost: DB.Required({
             comment: "States which column is used to improve the skill.",
-            type: IncludeIdentifier(ImprovementCost),
+            type: DB.IncludeIdentifier(ImprovementCost),
         }),
-        prerequisites: Optional({
+        prerequisites: DB.Optional({
             comment: "The prerequisites for the ritual.",
-            type: IncludeIdentifier(SpellworkPrerequisites),
+            type: DB.IncludeIdentifier(SpellworkPrerequisites),
         }),
         reversalis,
         src,
-        translations: NestedTranslationMap(Required, "Ritual", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "Ritual", DB.Object({
+            name: DB.Required({
                 comment: "The ritual’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),
             }),
-            casting_time: Optional({
+            casting_time: 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),
             }),
-            range: Optional({
+            range: DB.Optional({
                 isDeprecated: true,
-                type: IncludeIdentifier(OldParameter),
+                type: DB.IncludeIdentifier(OldParameter),
             }),
-            duration: Optional({
+            duration: DB.Optional({
                 isDeprecated: true,
-                type: IncludeIdentifier(OldParameter),
+                type: DB.IncludeIdentifier(OldParameter),
             }),
-            target: Optional({
+            target: DB.Optional({
                 isDeprecated: true,
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            errata: Optional({
-                type: IncludeIdentifier(Errata),
+            errata: DB.Optional({
+                type: DB.IncludeIdentifier(Errata),
             }),
         })),
-        enhancements: Required({
-            type: ChildEntities(Enhancement),
+        enhancements: DB.Required({
+            type: DB.ChildEntities(Enhancement),
         }),
     }),
     instanceDisplayName: {},

package/lib/types/Service.d.ts

@@ -1,55 +1,56 @@
-import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Object, String } from "tsondb/schema/def";
-export declare const Service: Entity<"Service", {
-    availability: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], Enum<"ServiceAvailability", {
-        SummonedCreatures: EnumCase<null>;
-        Monstrosities: EnumCase<null>;
+import * as DB from "tsondb/schema/dsl";
+export declare const Service: DB.Entity<"Service", {
+    availability: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"ServiceAvailability", {
+        SummonedCreatures: DB.EnumCase<null>;
+        Monstrosities: DB.EnumCase<null>;
     }, []>>>, 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<import("tsondb/schema/def").IntegerType, false>;
-                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                        InsideCoverFront: EnumCase<null>;
-                        InsideCoverBack: EnumCase<null>;
-                        Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
+    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<import("tsondb/schema/def").IntegerType>;
+                    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<[], import("tsondb/schema/def").TypeAliasDecl<"Since", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
-                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
-                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                            InsideCoverFront: EnumCase<null>;
-                            InsideCoverBack: EnumCase<null>;
-                            Numbered: EnumCase<import("tsondb/schema/def").IntegerType>;
+            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<import("tsondb/schema/def").IntegerType>;
+                        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<[], import("tsondb/schema/def").TypeAliasDecl<"Deprecation", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, 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<"ServiceTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        description: import("tsondb/schema/def").MemberDecl<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>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"ServiceTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        description: 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>;
     }>, true>;
 }, undefined>;

package/lib/types/Service.js

@@ -1,30 +1,30 @@
-import { Array, Entity, Enum, EnumCase, IncludeIdentifier, Object, Optional, Required, String, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
 import { src } from "./source/_PublicationRef.js";
-export const Service = Entity(import.meta.url, {
+export const Service = DB.Entity(import.meta.url, {
     name: "Service",
     namePlural: "Services",
-    type: () => Object({
-        availability: Required({
+    type: () => DB.Object({
+        availability: DB.Required({
             comment: "Defines for which creature type(s) the service is available.",
-            type: Array(IncludeIdentifier(ServiceAvailability), {
+            type: DB.Array(DB.IncludeIdentifier(ServiceAvailability), {
                 minItems: 1,
                 uniqueItems: true,
             }),
         }),
         src,
-        translations: NestedTranslationMap(Required, "Service", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "Service", DB.Object({
+            name: DB.Required({
                 comment: "The service’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            description: Required({
+            description: DB.Required({
                 comment: "The service’s description.",
-                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),
             }),
         })),
     }),
@@ -36,10 +36,10 @@ export const Service = Entity(import.meta.url, {
         },
     ],
 });
-const ServiceAvailability = Enum(import.meta.url, {
+const ServiceAvailability = DB.Enum(import.meta.url, {
     name: "ServiceAvailability",
     values: () => ({
-        SummonedCreatures: EnumCase({ type: null }),
-        Monstrosities: EnumCase({ type: null }),
+        SummonedCreatures: DB.EnumCase({ type: null }),
+        Monstrosities: DB.EnumCase({ type: null }),
     }),
 });

package/lib/types/SexPractice.d.ts

@@ -1,50 +1,51 @@
-import { Entity, Object, String } from "tsondb/schema/def";
-export declare const SexPractice: Entity<"SexPractice", {
-    src: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PublicationRefs", import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], 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<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"InitialOccurrence", Object<{
-                printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, false>;
-                pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IncludeIdentifierType<[], 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<import("tsondb/schema/def").IntegerType>;
+import * as DB from "tsondb/schema/dsl";
+export declare const SexPractice: DB.Entity<"SexPractice", {
+    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<import("tsondb/schema/def").IncludeIdentifierType<[], 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<import("tsondb/schema/def").IntegerType>;
+                    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<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").EnumDecl<"Revision", {
-                Since: import("tsondb/schema/def").EnumCaseDecl<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"Since", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, true>;
-                    pages: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ArrayType<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"PageRange", Object<{
-                        first_page: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IncludeIdentifierType<[], 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<import("tsondb/schema/def").IntegerType>;
+            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<import("tsondb/schema/def").IncludeIdentifierType<[], 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<import("tsondb/schema/def").IntegerType>;
+                        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<import("tsondb/schema/def").IncludeIdentifierType<[], import("tsondb/schema/def").TypeAliasDecl<"Deprecation", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").IntegerType, 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<"SexPracticeTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        rules: import("tsondb/schema/def").MemberDecl<String, true>;
-        duration: import("tsondb/schema/def").MemberDecl<String, true>;
-        prerequisites: import("tsondb/schema/def").MemberDecl<String, false>;
-        failed: import("tsondb/schema/def").MemberDecl<String, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SexPracticeTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        rules: DB.MemberDecl<DB.String, true>;
+        duration: DB.MemberDecl<DB.String, true>;
+        prerequisites: DB.MemberDecl<DB.String, false>;
+        failed: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }, undefined>;

package/lib/types/SexPractice.js

@@ -1,31 +1,31 @@
-import { Entity, Object, Optional, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { src } from "./source/_PublicationRef.js";
-export const SexPractice = Entity(import.meta.url, {
+export const SexPractice = DB.Entity(import.meta.url, {
     name: "SexPractice",
     namePlural: "SexPractices",
-    type: () => Object({
+    type: () => DB.Object({
         src,
-        translations: NestedTranslationMap(Required, "SexPractice", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "SexPractice", DB.Object({
+            name: DB.Required({
                 comment: "The sex practice’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            rules: Required({
+            rules: DB.Required({
                 comment: "The rules of the sex practice.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            duration: Required({
+            duration: DB.Required({
                 comment: "How long a round of this sex practice takes.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            prerequisites: Optional({
+            prerequisites: DB.Optional({
                 comment: "Prerequisites of participants and environment. Do not specify if the sex practice has no prerequisites.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
-            failed: Required({
+            failed: DB.Required({
                 comment: "Effects of a failed *Seduction* check.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),