optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/TargetCategory.d.ts

@@ -1,7 +1,7 @@
-import { Entity, String } from "tsondb/schema/def";
-export declare const TargetCategory: Entity<"TargetCategory", {
-    parent: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"TargetCategoryTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const TargetCategory: DB.Entity<"TargetCategory", {
+    parent: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"TargetCategoryTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
     }>, true>;
 }, undefined>;

package/lib/types/TargetCategory.js

@@ -1,18 +1,18 @@
-import { Entity, ObjectType, Optional, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "./Locale.js";
 import { TargetCategoryIdentifier } from "./_Identifier.js";
-export const TargetCategory = Entity(import.meta.url, {
+export const TargetCategory = DB.Entity(import.meta.url, {
     name: "TargetCategory",
     namePlural: "TargetCategories",
-    type: () => ObjectType({
-        parent: Optional({
+    type: () => DB.Object({
+        parent: DB.Optional({
             comment: "A superordinate target category, if present.",
             type: TargetCategoryIdentifier(),
         }),
-        translations: NestedTranslationMap(Required, "TargetCategory", ObjectType({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "TargetCategory", DB.Object({
+            name: DB.Required({
                 comment: "The target category’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),

package/lib/types/_Activatable.d.ts

@@ -1,12 +1,12 @@
 /**
  * General type specifications used by multiple activatable entries.
  */
-import { Integer, String } from "tsondb/schema/def";
-export declare const name: import("tsondb/schema/def").MemberDecl<String, true>;
-export declare const name_in_library: import("tsondb/schema/def").MemberDecl<String, false>;
-export declare const levels: import("tsondb/schema/def").MemberDecl<Integer, false>;
-export declare const maximum: import("tsondb/schema/def").MemberDecl<Integer, false>;
-export declare const rules: import("tsondb/schema/def").MemberDecl<String, true>;
-export declare const effect: import("tsondb/schema/def").MemberDecl<String, true>;
-export declare const range_l10n: import("tsondb/schema/def").MemberDecl<String, false>;
-export declare const input: import("tsondb/schema/def").MemberDecl<String, false>;
+import * as DB from "tsondb/schema/dsl";
+export declare const name: DB.MemberDecl<DB.String, true>;
+export declare const name_in_library: DB.MemberDecl<DB.String, false>;
+export declare const levels: DB.MemberDecl<DB.Integer, false>;
+export declare const maximum: DB.MemberDecl<DB.Integer, false>;
+export declare const rules: DB.MemberDecl<DB.String, true>;
+export declare const effect: DB.MemberDecl<DB.String, true>;
+export declare const range_l10n: DB.MemberDecl<DB.String, false>;
+export declare const input: DB.MemberDecl<DB.String, false>;

package/lib/types/_Activatable.js

@@ -1,20 +1,20 @@
 /**
  * General type specifications used by multiple activatable entries.
  */
-import { Integer, Optional, Required, String } from "tsondb/schema/def";
-export const name = Required({
+import * as DB from "tsondb/schema/dsl";
+export const name = DB.Required({
     comment: "Name of the activatable entry.",
-    type: String({ minLength: 1 }),
+    type: DB.String({ minLength: 1 }),
 });
-export const name_in_library = Optional({
+export const name_in_library = DB.Optional({
     comment: "The full name of the entry as stated in the sources. Only use when `name` needs to be different from full name for text generation purposes.",
-    type: String({ minLength: 1 }),
+    type: DB.String({ minLength: 1 }),
 });
-export const levels = Optional({
+export const levels = DB.Optional({
     comment: "Number of available levels.",
-    type: Integer({ minimum: 2 }),
+    type: DB.Integer({ minimum: 2 }),
 });
-export const maximum = Optional({
+export const maximum = DB.Optional({
     comment: `The number stating how often you can buy the entry. The **default** depends on the entry type:
 
 - **Advantage:** \`1\` in all cases (as specified in the **Core Rules**)
@@ -22,22 +22,22 @@ export const maximum = Optional({
 - **Special Abilities:** \`1\` if no options can be selected, otherwise the number of possible options
 
 The maximum is only set if it differs from the defaults specified above.`,
-    type: Integer({ minimum: 1 }),
+    type: DB.Integer({ minimum: 1 }),
 });
-export const rules = Required({
+export const rules = DB.Required({
     comment: "The rule text.",
-    type: String({ minLength: 1, isMarkdown: true }),
+    type: DB.String({ minLength: 1, isMarkdown: true }),
 });
-export const effect = Required({
+export const effect = DB.Required({
     comment: "The effect description.",
-    type: String({ minLength: 1, isMarkdown: true }),
+    type: DB.String({ minLength: 1, isMarkdown: true }),
 });
-export const range_l10n = Optional({
+export const range_l10n = DB.Optional({
     comment: "The range of the advantage.",
     isDeprecated: true,
-    type: String({ minLength: 1 }),
+    type: DB.String({ minLength: 1 }),
 });
-export const input = Optional({
+export const input = DB.Optional({
     comment: "A string that is used as a label for an input field.",
-    type: String({ minLength: 1 }),
+    type: DB.String({ minLength: 1 }),
 });

package/lib/types/_ActivatableAdvanced.d.ts

@@ -1,50 +1,50 @@
-import { Array, Boolean, EnumCase, IncludeIdentifier, Object, type Type, TypeArgument } from "tsondb/schema/def";
-export declare const advanced: (identifier: Type) => import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").EnumDecl<"AdvancedSpecialAbility", {
-    General: EnumCase<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>>;
-    RestrictOptions: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"RestrictAdvancedSpecialAbilityOptions", Object<{
-        id: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>, true>;
-        option: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"AdvancedSpecialAbilityRestrictedOptionIdentifier", {
-            General: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-            Skill: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-            CloseCombatTechnique: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-            RangedCombatTechnique: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-            Element: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
-            Aspect: EnumCase<import("tsondb/schema/def").ReferenceIdentifierType>;
+import * as DB from "tsondb/schema/dsl";
+export declare const advanced: (identifier: DB.Type) => DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.Enum<"AdvancedSpecialAbility", {
+    General: DB.EnumCase<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>>;
+    RestrictOptions: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"RestrictAdvancedSpecialAbilityOptions", DB.Object<{
+        id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        option: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"AdvancedSpecialAbilityRestrictedOptionIdentifier", {
+            General: DB.EnumCase<DB.ReferenceIdentifier>;
+            Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+            CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            Element: DB.EnumCase<DB.ReferenceIdentifier>;
+            Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>>, true>;
-    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>;
-    OneOf: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"OneOfAdvancedSpecialAbilityOptions", Object<{
-        options: import("tsondb/schema/def").MemberDecl<Array<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>>, true>;
-        is_selection_required_on_purchase: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
-            Hide: EnumCase<null>;
-            ReplaceWith: EnumCase<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ReplacementDisplayOption", Object<{
-                sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
-                    Standalone: EnumCase<null>;
-                    Connected: EnumCase<null>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+    OneOf: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"OneOfAdvancedSpecialAbilityOptions", DB.Object<{
+        options: DB.MemberDecl<DB.Array<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>>, true>;
+        is_selection_required_on_purchase: DB.MemberDecl<DB.Boolean, 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<import("tsondb/schema/def").StringType, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                    replacement: DB.MemberDecl<DB.String, true>;
                 }>, true>;
             }>, []>>>;
         }, []>>, false>;
-    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>;
-    DeriveFromExternalOption: EnumCase<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"AdvancedSpecialAbilityDerivedFromExternalOption", Object<{
-        external_entry: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-        map: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, Type>[], import("tsondb/schema/def").TypeAliasDecl<"AdvancedSpecialAbilityDerivedFromExternalOptionMapping", Object<{
-            from_option: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-            to_advanced: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Identifier", Type>>, true>;
-        }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>, true>;
-        display_option: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"DisplayOption", {
-            Hide: EnumCase<null>;
-            ReplaceWith: EnumCase<IncludeIdentifier<[], import("tsondb/schema/def").TypeAliasDecl<"ReplacementDisplayOption", Object<{
-                sentence_type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], import("tsondb/schema/def").EnumDecl<"SentenceType", {
-                    Standalone: EnumCase<null>;
-                    Connected: EnumCase<null>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+    DeriveFromExternalOption: DB.EnumCase<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AdvancedSpecialAbilityDerivedFromExternalOption", DB.Object<{
+        external_entry: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        map: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AdvancedSpecialAbilityDerivedFromExternalOptionMapping", DB.Object<{
+            from_option: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            to_advanced: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        }>, [Identifier: DB.Param<"Identifier", 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<import("tsondb/schema/def").StringType, true>;
+                translations: DB.MemberDecl<DB.NestedEntityMap<"ReplacementDisplayOptionTranslation", {
+                    replacement: DB.MemberDecl<DB.String, true>;
                 }>, true>;
             }>, []>>>;
         }, []>>, false>;
-    }>, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>;
-}, [Identifier: import("tsondb/schema/def").TypeParameter<"Identifier", Type>]>>>, true>;
+    }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>;
+}, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, true>;

package/lib/types/_ActivatableAdvanced.js

@@ -1,96 +1,100 @@
-import { Array, Boolean, EnumCase, GenEnum, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Object, Optional, Param, Required, TypeArgument, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { MagicalTraditionIdentifier, PatronIdentifier } from "./_Identifier.js";
 import { AdvancedSpecialAbilityRestrictedOptionIdentifier } from "./_IdentifierGroup.js";
 import { DisplayOption } from "./prerequisites/DisplayOption.js";
-const AdvancedSpecialAbility = GenEnum(import.meta.url, {
+const AdvancedSpecialAbility = DB.GenEnum(import.meta.url, {
     name: "AdvancedSpecialAbility",
     comment: "A reference to an advanced special ability.",
-    parameters: [Param("Identifier")],
+    parameters: [DB.Param("Identifier")],
     values: Identifier => ({
-        General: EnumCase({ type: TypeArgument(Identifier) }),
-        RestrictOptions: EnumCase({
-            type: GenIncludeIdentifier(RestrictAdvancedSpecialAbilityOptions, [TypeArgument(Identifier)]),
+        General: DB.EnumCase({ type: DB.TypeArgument(Identifier) }),
+        RestrictOptions: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(RestrictAdvancedSpecialAbilityOptions, [
+                DB.TypeArgument(Identifier),
+            ]),
         }),
-        OneOf: EnumCase({
-            type: GenIncludeIdentifier(OneOfAdvancedSpecialAbilityOptions, [TypeArgument(Identifier)]),
+        OneOf: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(OneOfAdvancedSpecialAbilityOptions, [
+                DB.TypeArgument(Identifier),
+            ]),
         }),
-        DeriveFromExternalOption: EnumCase({
-            type: GenIncludeIdentifier(AdvancedSpecialAbilityDerivedFromExternalOption, [
-                TypeArgument(Identifier),
+        DeriveFromExternalOption: DB.EnumCase({
+            type: DB.GenIncludeIdentifier(AdvancedSpecialAbilityDerivedFromExternalOption, [
+                DB.TypeArgument(Identifier),
             ]),
         }),
     }),
 });
-const RestrictAdvancedSpecialAbilityOptions = GenTypeAlias(import.meta.url, {
+const RestrictAdvancedSpecialAbilityOptions = DB.GenTypeAlias(import.meta.url, {
     name: "RestrictAdvancedSpecialAbilityOptions",
-    parameters: [Param("Identifier")],
-    type: Identifier => Object({
-        id: Required({
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        id: DB.Required({
             comment: "The advanced special ability’s identifier.",
-            type: TypeArgument(Identifier),
+            type: DB.TypeArgument(Identifier),
         }),
-        option: Required({
+        option: DB.Required({
             comment: "Specify the select option(s) that only are allowed for the referenced advanced special ability; others are disallowed.",
-            type: Array(IncludeIdentifier(AdvancedSpecialAbilityRestrictedOptionIdentifier), {
+            type: DB.Array(DB.IncludeIdentifier(AdvancedSpecialAbilityRestrictedOptionIdentifier), {
                 minItems: 1,
             }),
         }),
     }),
 });
-const OneOfAdvancedSpecialAbilityOptions = GenTypeAlias(import.meta.url, {
+const OneOfAdvancedSpecialAbilityOptions = DB.GenTypeAlias(import.meta.url, {
     name: "OneOfAdvancedSpecialAbilityOptions",
-    parameters: [Param("Identifier")],
-    type: Identifier => Object({
-        options: Required({
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        options: DB.Required({
             comment: "The possible advanced special abilities.",
-            type: Array(TypeArgument(Identifier), { minItems: 2 }),
+            type: DB.Array(DB.TypeArgument(Identifier), { minItems: 2 }),
         }),
-        is_selection_required_on_purchase: Required({
+        is_selection_required_on_purchase: DB.Required({
             comment: "Do have to choose the advanced special ability when buying the style special ability? Otherwise the decision can be made later.",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
-        display_option: Optional({
-            type: IncludeIdentifier(DisplayOption),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
         }),
     }),
 });
-const AdvancedSpecialAbilityDerivedFromExternalOption = GenTypeAlias(import.meta.url, {
+const AdvancedSpecialAbilityDerivedFromExternalOption = DB.GenTypeAlias(import.meta.url, {
     name: "AdvancedSpecialAbilityDerivedFromExternalOption",
-    parameters: [Param("Identifier")],
-    type: Identifier => Object({
-        external_entry: Required({
+    parameters: [DB.Param("Identifier")],
+    type: Identifier => DB.Object({
+        external_entry: DB.Required({
             comment: "The possible advanced special abilities.",
             type: MagicalTraditionIdentifier(),
         }),
-        map: Required({
+        map: DB.Required({
             comment: "Map options from the external entry to allowed advanced special abilities.",
-            type: Array(GenIncludeIdentifier(AdvancedSpecialAbilityDerivedFromExternalOptionMapping, [
-                TypeArgument(Identifier),
+            type: DB.Array(DB.GenIncludeIdentifier(AdvancedSpecialAbilityDerivedFromExternalOptionMapping, [
+                DB.TypeArgument(Identifier),
             ]), { minItems: 1 }),
         }),
-        display_option: Optional({
-            type: IncludeIdentifier(DisplayOption),
+        display_option: DB.Optional({
+            type: DB.IncludeIdentifier(DisplayOption),
         }),
     }),
 });
-const AdvancedSpecialAbilityDerivedFromExternalOptionMapping = GenTypeAlias(import.meta.url, {
+const AdvancedSpecialAbilityDerivedFromExternalOptionMapping = DB.GenTypeAlias(import.meta.url, {
     name: "AdvancedSpecialAbilityDerivedFromExternalOptionMapping",
-    parameters: [Param("Identifier")],
+    parameters: [DB.Param("Identifier")],
     comment: "Mapping from an option of the external entry to an allowed advanced special ability.",
-    type: Identifier => Object({
-        from_option: Required({
+    type: Identifier => DB.Object({
+        from_option: DB.Required({
             comment: "The select option’s identifier.",
             type: PatronIdentifier(),
         }),
-        to_advanced: Required({
+        to_advanced: DB.Required({
             comment: "The advanced special ability’s identifier.",
-            type: TypeArgument(Identifier),
+            type: DB.TypeArgument(Identifier),
         }),
     }),
 });
-export const advanced = (identifier) => Required({
+export const advanced = (identifier) => DB.Required({
     comment: "The Advanced Special Abilities for the respective Style Special Ability. Sometimes, only a specific select option or a set of select options of an entry is allowed, which can be modelled by the option property. It can also be that you can choose from a set of special abilities, but then you can’t specify an option.",
-    type: Array(GenIncludeIdentifier(AdvancedSpecialAbility, [identifier]), {
+    type: DB.Array(DB.GenIncludeIdentifier(AdvancedSpecialAbility, [identifier]), {
         minItems: 3,
         maxItems: 3,
     }),