optolith-database-schema 0.28.0 → 0.28.2

package/lib/types/equipment/item/_RangedWeapon.d.ts

@@ -1,32 +1,32 @@
 /**
  * Auxiliary types for ranged weapons.
  */
-import { Array, Boolean, IncludeIdentifier, Integer, Object, TypeAlias, TypeArgument } from "tsondb/schema/def";
-export declare const RangedWeapon: TypeAlias<"RangedWeapon", IncludeIdentifier<import("tsondb/schema/def").TypeParameter<string, import("tsondb/schema/def").Type>[], TypeAlias<"GenRangedWeapon", Object<{
-    damage: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Damage", import("tsondb/schema/def").Type>>, true>;
-    reload_time: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
-        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const RangedWeapon: DB.TypeAlias<"RangedWeapon", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"GenRangedWeapon", DB.Object<{
+    damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+    reload_time: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ReloadTime", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
     }>, []>>>, true>;
-    range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
-        close: import("tsondb/schema/def").MemberDecl<Integer, true>;
-        medium: import("tsondb/schema/def").MemberDecl<Integer, true>;
-        far: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RangeBrackets", DB.Object<{
+        close: DB.MemberDecl<DB.Integer, true>;
+        medium: DB.MemberDecl<DB.Integer, true>;
+        far: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
-    ammunition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
-    length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", Integer, []>>, false>;
-    is_improvised_weapon: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-}>, [Damage: import("tsondb/schema/def").TypeParameter<"Damage", import("tsondb/schema/def").Type>]>>, []>;
-export declare const GenRangedWeapon: TypeAlias<"GenRangedWeapon", Object<{
-    damage: import("tsondb/schema/def").MemberDecl<TypeArgument<import("tsondb/schema/def").TypeParameter<"Damage", import("tsondb/schema/def").Type>>, true>;
-    reload_time: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"ReloadTime", Object<{
-        value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
+    is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+}>, [Damage: DB.Param<"Damage", DB.Type>]>>, []>;
+export declare const GenRangedWeapon: DB.TypeAlias<"GenRangedWeapon", DB.Object<{
+    damage: DB.MemberDecl<DB.TypeArgument<DB.Param<"Damage", DB.Type>>, true>;
+    reload_time: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"ReloadTime", DB.Object<{
+        value: DB.MemberDecl<DB.Integer, true>;
     }>, []>>>, true>;
-    range: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RangeBrackets", Object<{
-        close: import("tsondb/schema/def").MemberDecl<Integer, true>;
-        medium: import("tsondb/schema/def").MemberDecl<Integer, true>;
-        far: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    range: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RangeBrackets", DB.Object<{
+        close: DB.MemberDecl<DB.Integer, true>;
+        medium: DB.MemberDecl<DB.Integer, true>;
+        far: DB.MemberDecl<DB.Integer, true>;
     }>, []>>, true>;
-    ammunition: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, false>;
-    length: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Length", Integer, []>>, false>;
-    is_improvised_weapon: import("tsondb/schema/def").MemberDecl<Boolean, true>;
-}>, [Damage: import("tsondb/schema/def").TypeParameter<"Damage", import("tsondb/schema/def").Type>]>;
+    ammunition: DB.MemberDecl<DB.ReferenceIdentifier, false>;
+    length: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Length", DB.Integer, []>>, false>;
+    is_improvised_weapon: DB.MemberDecl<DB.Boolean, true>;
+}>, [Damage: DB.Param<"Damage", DB.Type>]>;

package/lib/types/equipment/item/_RangedWeapon.js

@@ -1,93 +1,93 @@
 /**
  * Auxiliary types for ranged weapons.
  */
-import { Array, Boolean, Enum, EnumCase, GenIncludeIdentifier, GenTypeAlias, IncludeIdentifier, Integer, Object, Optional, Param, Required, TypeAlias, TypeArgument, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { Dice } from "../../_Dice.js";
 import { AmmunitionIdentifier } from "../../_Identifier.js";
 import { Length } from "./_Weapon.js";
-const RangedDamage = Enum(import.meta.url, {
+const RangedDamage = DB.Enum(import.meta.url, {
     name: "RangedDamage",
     comment: "The damage of a ranged weapon. It consists of a random part using dice and an optional flat part ny default. Some ranged weapons may work different so that damage is either not applicable at all or it is outlined as *Special* and further defined in a description.",
     values: () => ({
-        Default: EnumCase({ type: IncludeIdentifier(DefaultRangedDamage) }),
-        NotApplicable: EnumCase({ type: null }),
-        Special: EnumCase({ type: null }),
+        Default: DB.EnumCase({ type: DB.IncludeIdentifier(DefaultRangedDamage) }),
+        NotApplicable: DB.EnumCase({ type: null }),
+        Special: DB.EnumCase({ type: null }),
     }),
 });
-const DefaultRangedDamage = TypeAlias(import.meta.url, {
+const DefaultRangedDamage = DB.TypeAlias(import.meta.url, {
     name: "DefaultRangedDamage",
     comment: "The damage of a weapon consists of a random part using dice and an optional flat part.",
-    type: () => Object({
-        dice: Required({
+    type: () => DB.Object({
+        dice: DB.Required({
             comment: "How many dice of which type are rolled to get the damage.",
-            type: IncludeIdentifier(Dice),
+            type: DB.IncludeIdentifier(Dice),
         }),
-        flat: Optional({
+        flat: DB.Optional({
             comment: "Flat damage, if any. It gets added to the result of the dice rolls.",
-            type: Integer(),
+            type: DB.Integer(),
         }),
     }),
 });
-export const RangedWeapon = TypeAlias(import.meta.url, {
+export const RangedWeapon = DB.TypeAlias(import.meta.url, {
     name: "RangedWeapon",
-    type: () => GenIncludeIdentifier(GenRangedWeapon, [IncludeIdentifier(RangedDamage)]),
+    type: () => DB.GenIncludeIdentifier(GenRangedWeapon, [DB.IncludeIdentifier(RangedDamage)]),
 });
-export const GenRangedWeapon = GenTypeAlias(import.meta.url, {
+export const GenRangedWeapon = DB.GenTypeAlias(import.meta.url, {
     name: "GenRangedWeapon",
-    parameters: [Param("Damage")],
-    type: Damage => Object({
-        damage: Required({
+    parameters: [DB.Param("Damage")],
+    type: Damage => DB.Object({
+        damage: DB.Required({
             comment: "The damage of a weapon can consist of random dice rolls and flat damage.",
-            type: TypeArgument(Damage),
+            type: DB.TypeArgument(Damage),
         }),
-        reload_time: Required({
+        reload_time: DB.Required({
             comment: "One or multiple reload times.",
-            type: Array(IncludeIdentifier(ReloadTime), {
+            type: DB.Array(DB.IncludeIdentifier(ReloadTime), {
                 minItems: 1,
                 uniqueItems: true,
             }),
         }),
-        range: Required({
+        range: DB.Required({
             comment: "The range brackets for the weapon: close, medium, far. Distances in m.",
-            type: IncludeIdentifier(RangeBrackets),
+            type: DB.IncludeIdentifier(RangeBrackets),
         }),
-        ammunition: Optional({
+        ammunition: DB.Optional({
             comment: "The needed ammunition.",
             type: AmmunitionIdentifier(),
         }),
-        length: Optional({
+        length: DB.Optional({
             comment: "The length of the weapon in cm/halffingers.",
-            type: IncludeIdentifier(Length),
+            type: DB.IncludeIdentifier(Length),
         }),
-        is_improvised_weapon: Required({
+        is_improvised_weapon: DB.Required({
             comment: "Is the weapon an improvised weapon?",
-            type: Boolean(),
+            type: DB.Boolean(),
         }),
     }),
 });
-const RangeBrackets = TypeAlias(import.meta.url, {
+const RangeBrackets = DB.TypeAlias(import.meta.url, {
     name: "RangeBrackets",
-    type: () => Object({
-        close: Required({
+    type: () => DB.Object({
+        close: DB.Required({
             comment: "The close range bracket for the weapon. Distance in m.",
-            type: Integer({ minimum: 0 }),
+            type: DB.Integer({ minimum: 0 }),
         }),
-        medium: Required({
+        medium: DB.Required({
             comment: "The medium range bracket for the weapon. Distance in m.",
-            type: Integer({ minimum: 0 }),
+            type: DB.Integer({ minimum: 0 }),
         }),
-        far: Required({
+        far: DB.Required({
             comment: "The far range bracket for the weapon. Distance in m.",
-            type: Integer({ minimum: 0 }),
+            type: DB.Integer({ minimum: 0 }),
         }),
     }),
 });
-const ReloadTime = TypeAlias(import.meta.url, {
+const ReloadTime = DB.TypeAlias(import.meta.url, {
     name: "ReloadTime",
-    type: () => Object({
-        value: Required({
+    type: () => DB.Object({
+        value: DB.Required({
             comment: "A reload time value in actions.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });

package/lib/types/equipment/item/_Weapon.d.ts

@@ -1,17 +1,18 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, ObjectType, TypeAlias, type GetDisplayNameAndId, type GetInstanceById } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
+import type { GetDisplayNameAndId, GetInstanceById } from "tsondb/schema/gen";
 import type { GenMeleeWeapon, GenRangedWeapon } from "../../../../gen/types.js";
-export declare const PrimaryAttributeDamageThreshold: Enum<"PrimaryAttributeDamageThreshold", {
-    Default: EnumCase<IncludeIdentifier<[], TypeAlias<"DefaultPrimaryAttributeDamageThreshold", ObjectType<{
-        threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
+export declare const PrimaryAttributeDamageThreshold: DB.Enum<"PrimaryAttributeDamageThreshold", {
+    Default: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"DefaultPrimaryAttributeDamageThreshold", DB.Object<{
+        threshold: DB.MemberDecl<DB.Integer, true>;
     }>, []>>>;
-    List: EnumCase<IncludeIdentifier<[], TypeAlias<"PrimaryAttributeDamageThresholdList", ObjectType<{
-        list: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"SinglePrimaryAttributeDamageThreshold", ObjectType<{
-            attribute: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-            threshold: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    List: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PrimaryAttributeDamageThresholdList", DB.Object<{
+        list: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"SinglePrimaryAttributeDamageThreshold", DB.Object<{
+            attribute: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            threshold: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>, true>;
     }>, []>>>;
 }, []>;
-export declare const Length: TypeAlias<"Length", Integer, []>;
+export declare const Length: DB.TypeAlias<"Length", DB.Integer, []>;
 export declare const checkWeaponCombatTechniqueIntegrity: ({ instanceContent, getInstanceById, getDisplayNameAndId, }: {
     instanceContent: {
         melee_uses?: Record<string, GenMeleeWeapon<unknown>>;

package/lib/types/equipment/item/_Weapon.js

@@ -1,51 +1,51 @@
-import { Array, Enum, EnumCase, IncludeIdentifier, Integer, ObjectType, Required, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { AttributeIdentifier } from "../../_Identifier.js";
-export const PrimaryAttributeDamageThreshold = Enum(import.meta.url, {
+export const PrimaryAttributeDamageThreshold = DB.Enum(import.meta.url, {
     name: "PrimaryAttributeDamageThreshold",
     comment: "The primary attribute damage and threshold value. You can either use an integer, an object or a pair. Use an integer if you just have to define a single threshold value for the default primary attribute of the combat technique. Use an object if you need to define the value only or if you need to define the value as well as a single different primary attribute than which the combat technique uses. Use the pair if you need to set the primary attributes to AGI and STR (the combat technique has AGI but this item has AGI/STR) and/or if you need to set different thresholds for AGI and STR (e.g. AGI 14/STR 15). If the same values are in the pair, they will be merged (AGI 14/STR 14 will be AGI/STR 14).",
     values: () => ({
-        Default: EnumCase({ type: IncludeIdentifier(DefaultPrimaryAttributeDamageThreshold) }),
-        List: EnumCase({ type: IncludeIdentifier(PrimaryAttributeDamageThresholdList) }),
+        Default: DB.EnumCase({ type: DB.IncludeIdentifier(DefaultPrimaryAttributeDamageThreshold) }),
+        List: DB.EnumCase({ type: DB.IncludeIdentifier(PrimaryAttributeDamageThresholdList) }),
     }),
 });
-const DefaultPrimaryAttributeDamageThreshold = TypeAlias(import.meta.url, {
+const DefaultPrimaryAttributeDamageThreshold = DB.TypeAlias(import.meta.url, {
     name: "DefaultPrimaryAttributeDamageThreshold",
-    type: () => ObjectType({
-        threshold: Required({
+    type: () => DB.Object({
+        threshold: DB.Required({
             comment: "The attribute value representing the damage threshold for the primary attribute of the item's combat technique.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-const PrimaryAttributeDamageThresholdList = TypeAlias(import.meta.url, {
+const PrimaryAttributeDamageThresholdList = DB.TypeAlias(import.meta.url, {
     name: "PrimaryAttributeDamageThresholdList",
-    type: () => ObjectType({
-        list: Required({
+    type: () => DB.Object({
+        list: DB.Required({
             comment: "A list of primary attributes with their associated threshold.",
-            type: Array(IncludeIdentifier(SinglePrimaryAttributeDamageThreshold), {
+            type: DB.Array(DB.IncludeIdentifier(SinglePrimaryAttributeDamageThreshold), {
                 minItems: 1,
                 uniqueItems: true,
             }),
         }),
     }),
 });
-const SinglePrimaryAttributeDamageThreshold = TypeAlias(import.meta.url, {
+const SinglePrimaryAttributeDamageThreshold = DB.TypeAlias(import.meta.url, {
     name: "SinglePrimaryAttributeDamageThreshold",
-    type: () => ObjectType({
-        attribute: Required({
+    type: () => DB.Object({
+        attribute: DB.Required({
             comment: "The primary attribute.",
             type: AttributeIdentifier(),
         }),
-        threshold: Required({
+        threshold: DB.Required({
             comment: "The attribute value representing the damage threshold.",
-            type: Integer({ minimum: 1 }),
+            type: DB.Integer({ minimum: 1 }),
         }),
     }),
 });
-export const Length = TypeAlias(import.meta.url, {
+export const Length = DB.TypeAlias(import.meta.url, {
     name: "Length",
     comment: "The length of the weapon in cm/halffingers.",
-    type: () => Integer({ minimum: 1 }),
+    type: () => DB.Integer({ minimum: 1 }),
 });
 export const checkWeaponCombatTechniqueIntegrity = ({ instanceContent, getInstanceById, getDisplayNameAndId, }, { secondary: _secondary }) => {
     const checkPart = (rule, value, name, type, id) => (rule.kind === "Prohibited") === (value === undefined) || rule.kind === "Optional"

package/lib/types/equipment/item/sub/ArmorType.d.ts

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

package/lib/types/equipment/item/sub/ArmorType.js

@@ -1,17 +1,17 @@
-import { Entity, Integer, Object, Optional, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "../../../Locale.js";
-export const ArmorType = Entity(import.meta.url, {
+export const ArmorType = DB.Entity(import.meta.url, {
     name: "ArmorType",
     namePlural: "ArmorTypes",
-    type: () => Object({
-        sturdiness_rating: Optional({
+    type: () => DB.Object({
+        sturdiness_rating: DB.Optional({
             comment: "An armor type can have a *sturdiness rating*. The higher the rating, the more durable the armor. Rolling higher than this rating during a sturdiness check means the armor receives one level of the new condition *Wear*.",
-            type: Integer({ minimum: 1, maximum: 20 }),
+            type: DB.Integer({ minimum: 1, maximum: 20 }),
         }),
-        translations: NestedTranslationMap(Required, "ArmorType", Object({
-            name: Required({
+        translations: NestedTranslationMap(DB.Required, "ArmorType", DB.Object({
+            name: DB.Required({
                 comment: "The armor type’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),

package/lib/types/equipment/item/sub/Reach.d.ts

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

package/lib/types/equipment/item/sub/Reach.js

@@ -1,13 +1,13 @@
-import { Entity, Object, Required, String } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { NestedTranslationMap } from "../../../Locale.js";
-export const Reach = Entity(import.meta.url, {
+export const Reach = DB.Entity(import.meta.url, {
     name: "Reach",
     namePlural: "Reaches",
-    type: () => Object({
-        translations: NestedTranslationMap(Required, "Reach", Object({
-            name: Required({
+    type: () => DB.Object({
+        translations: NestedTranslationMap(DB.Required, "Reach", DB.Object({
+            name: DB.Required({
                 comment: "The reach’s name.",
-                type: String({ minLength: 1 }),
+                type: DB.String({ minLength: 1 }),
             }),
         })),
     }),