optolith-database-schema 0.28.0 → 0.28.2

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

@@ -1,86 +1,87 @@
-import { Entity, Enum, EnumCase, IncludeIdentifier, Object, TypeAlias } from "tsondb/schema/def";
-export declare const AnimalCare: Entity<"AnimalCare", {
-    type: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AnimalCareType", {
-        General: EnumCase<IncludeIdentifier<[], TypeAlias<"GeneralAnimalCare", Object<{
-            cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Cost", {
-                Free: EnumCase<null>;
-                Various: EnumCase<null>;
-                Invaluable: EnumCase<null>;
-                Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
-                    value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedCostTranslation", {
-                        wrap_in_text: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const AnimalCare: DB.Entity<"AnimalCare", {
+    type: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnimalCareType", {
+        General: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"GeneralAnimalCare", DB.Object<{
+            cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+                Free: DB.EnumCase<null>;
+                Various: DB.EnumCase<null>;
+                Invaluable: DB.EnumCase<null>;
+                Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+                    value: DB.MemberDecl<DB.Float, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                        wrap_in_text: DB.MemberDecl<DB.String, true>;
                     }>, false>;
                 }>, []>>>;
-                Range: EnumCase<IncludeIdentifier<[], TypeAlias<"CostRange", Object<{
-                    from: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-                    to: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CostRangeTranslation", {
-                        wrap_in_text: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+                Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+                    from: DB.MemberDecl<DB.Float, true>;
+                    to: DB.MemberDecl<DB.Float, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                        wrap_in_text: DB.MemberDecl<DB.String, true>;
                     }>, false>;
                 }>, []>>>;
             }, []>>, true>;
-            weight: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Weight", import("tsondb/schema/def").FloatType, []>>, true>;
+            weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
         }>, []>>>;
-        Feed: EnumCase<IncludeIdentifier<[], TypeAlias<"AnimalFeed", Object<{
-            cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"AnimalFeedCost", {
-                PerWeek: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
-                    value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-                    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedCostTranslation", {
-                        wrap_in_text: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+        Feed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AnimalFeed", DB.Object<{
+            cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"AnimalFeedCost", {
+                PerWeek: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+                    value: DB.MemberDecl<DB.Float, true>;
+                    translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                        wrap_in_text: DB.MemberDecl<DB.String, true>;
                     }>, false>;
                 }>, []>>>;
             }, []>>, true>;
         }>, []>>>;
     }, []>>, true>;
-    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"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<[], TypeAlias<"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<IncludeIdentifier<[], TypeAlias<"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<import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], Enum<"Revision", {
-                Since: EnumCase<IncludeIdentifier<[], TypeAlias<"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<IncludeIdentifier<[], TypeAlias<"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<[], TypeAlias<"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<`${string}Translation`, {
-        name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
-        secondary_name: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
-        note: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
-        rules: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, false>;
-        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", import("tsondb/schema/def").ArrayType<IncludeIdentifier<[], TypeAlias<"Erratum", Object<{
-            date: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").DateType, true>;
-            description: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").StringType, true>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<`${string}Translation`, {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.String, false>;
+        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/equipment/item/AnimalCare.js

@@ -1,13 +1,13 @@
-import { Entity, Enum, EnumCase, IncludeIdentifier, Object, Required, TypeAlias, } from "tsondb/schema/def";
+import * as DB from "tsondb/schema/dsl";
 import { src } from "../../source/_PublicationRef.js";
 import { Cost, DefaultItemTranslations, FixedCost, Weight } from "./_Item.js";
-export const AnimalCare = Entity(import.meta.url, {
+export const AnimalCare = DB.Entity(import.meta.url, {
     name: "AnimalCare",
     namePlural: "AnimalCare",
-    type: () => Object({
-        type: Required({
+    type: () => DB.Object({
+        type: DB.Required({
             comment: "Values depending on whether the animal care is feed.",
-            type: IncludeIdentifier(AnimalCareType),
+            type: DB.IncludeIdentifier(AnimalCareType),
         }),
         src,
         translations: DefaultItemTranslations("AnimalCare"),
@@ -20,39 +20,39 @@ export const AnimalCare = Entity(import.meta.url, {
         },
     ],
 });
-const AnimalCareType = Enum(import.meta.url, {
+const AnimalCareType = DB.Enum(import.meta.url, {
     name: "AnimalCareType",
     comment: "Values depending on whether the animal care is feed.",
     values: () => ({
-        General: EnumCase({ type: IncludeIdentifier(GeneralAnimalCare) }),
-        Feed: EnumCase({ type: IncludeIdentifier(AnimalFeed) }),
+        General: DB.EnumCase({ type: DB.IncludeIdentifier(GeneralAnimalCare) }),
+        Feed: DB.EnumCase({ type: DB.IncludeIdentifier(AnimalFeed) }),
     }),
 });
-const GeneralAnimalCare = TypeAlias(import.meta.url, {
+const GeneralAnimalCare = DB.TypeAlias(import.meta.url, {
     name: "GeneralAnimalCare",
-    type: () => Object({
-        cost: Required({
+    type: () => DB.Object({
+        cost: DB.Required({
             comment: "The cost in silverthalers.",
-            type: IncludeIdentifier(Cost),
+            type: DB.IncludeIdentifier(Cost),
         }),
-        weight: Required({
+        weight: DB.Required({
             comment: "The weight in kg.",
-            type: IncludeIdentifier(Weight),
+            type: DB.IncludeIdentifier(Weight),
         }),
     }),
 });
-const AnimalFeed = TypeAlias(import.meta.url, {
+const AnimalFeed = DB.TypeAlias(import.meta.url, {
     name: "AnimalFeed",
-    type: () => Object({
-        cost: Required({
+    type: () => DB.Object({
+        cost: DB.Required({
             comment: "The cost in silverthalers.",
-            type: IncludeIdentifier(AnimalFeedCost),
+            type: DB.IncludeIdentifier(AnimalFeedCost),
         }),
     }),
 });
-const AnimalFeedCost = Enum(import.meta.url, {
+const AnimalFeedCost = DB.Enum(import.meta.url, {
     name: "AnimalFeedCost",
     values: () => ({
-        PerWeek: EnumCase({ type: IncludeIdentifier(FixedCost) }),
+        PerWeek: DB.EnumCase({ type: DB.IncludeIdentifier(FixedCost) }),
     }),
 });

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

@@ -1,165 +1,166 @@
-import { Array, Boolean, Entity, Enum, EnumCase, IncludeIdentifier, Integer, Object, String, TypeAlias } from "tsondb/schema/def";
-export declare const Armor: Entity<"Armor", {
-    cost: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Cost", {
-        Free: EnumCase<null>;
-        Various: EnumCase<null>;
-        Invaluable: EnumCase<null>;
-        Fixed: EnumCase<IncludeIdentifier<[], TypeAlias<"FixedCost", Object<{
-            value: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"FixedCostTranslation", {
-                wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+import * as DB from "tsondb/schema/dsl";
+export declare const Armor: DB.Entity<"Armor", {
+    cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Cost", {
+        Free: DB.EnumCase<null>;
+        Various: DB.EnumCase<null>;
+        Invaluable: DB.EnumCase<null>;
+        Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedCost", DB.Object<{
+            value: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"FixedCostTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
             }>, false>;
         }>, []>>>;
-        Range: EnumCase<IncludeIdentifier<[], TypeAlias<"CostRange", Object<{
-            from: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-            to: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").FloatType, true>;
-            translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"CostRangeTranslation", {
-                wrap_in_text: import("tsondb/schema/def").MemberDecl<String, true>;
+        Range: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"CostRange", DB.Object<{
+            from: DB.MemberDecl<DB.Float, true>;
+            to: DB.MemberDecl<DB.Float, true>;
+            translations: DB.MemberDecl<DB.NestedEntityMap<"CostRangeTranslation", {
+                wrap_in_text: DB.MemberDecl<DB.String, true>;
             }>, false>;
         }>, []>>>;
     }, []>>, true>;
-    weight: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Weight", import("tsondb/schema/def").FloatType, []>>, true>;
-    complexity: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"ArmorComplexity", {
-        Primitive: EnumCase<null>;
-        Simple: EnumCase<null>;
-        Complex: EnumCase<IncludeIdentifier<[], TypeAlias<"ComplexComplexity", Object<{
-            ap_value: import("tsondb/schema/def").MemberDecl<Integer, true>;
+    weight: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Weight", DB.Float, []>>, true>;
+    complexity: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ArmorComplexity", {
+        Primitive: DB.EnumCase<null>;
+        Simple: DB.EnumCase<null>;
+        Complex: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ComplexComplexity", DB.Object<{
+            ap_value: DB.MemberDecl<DB.Integer, true>;
         }>, []>>>;
-        Various: EnumCase<null>;
+        Various: DB.EnumCase<null>;
     }, []>>, false>;
-    protection: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Protection", Integer, []>>, true>;
-    encumbrance: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Encumbrance", Integer, []>>, true>;
-    has_additional_penalties: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HasAdditionalPenalties", Boolean, []>>, true>;
-    armor_type: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-    hit_zone: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"HitZone", {
-        Head: EnumCase<IncludeIdentifier<[], TypeAlias<"HeadHitZone", Object<{
-            combination_possibilities: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HeadHitZoneCombinationPossibilities", Object<{
-                armors: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
-                protection: import("tsondb/schema/def").MemberDecl<Integer, false>;
+    protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
+    encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
+    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+    armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
+        Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
+            combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{
+                armors: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                protection: DB.MemberDecl<DB.Integer, false>;
             }>, []>>, false>;
         }>, []>>>;
-        Torso: EnumCase<null>;
-        Arms: EnumCase<null>;
-        Legs: EnumCase<null>;
+        Torso: DB.EnumCase<null>;
+        Arms: DB.EnumCase<null>;
+        Legs: DB.EnumCase<null>;
     }, []>>, false>;
-    restrictedTo: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedTo", Object<{
-        races: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToRaces", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+        races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToCultures", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        professions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToProfessions", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        magicalTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToMagicalTraditions", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        blessedTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToBlessedTraditions", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RestrictedToBlessedTraditionsScope", {
-                Specific: EnumCase<Array<import("tsondb/schema/def").ReferenceIdentifierType>>;
-                Church: EnumCase<null>;
-                Shamanistic: EnumCase<null>;
+        blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+            scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                Church: DB.EnumCase<null>;
+                Shamanistic: DB.EnumCase<null>;
             }, []>>, true>;
-            isSanctifiedBy: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+            isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
         }>, []>>, false>;
     }>, []>>, false>;
-    src: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"PublicationRefs", Array<IncludeIdentifier<[], TypeAlias<"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<[], TypeAlias<"InitialOccurrence", Object<{
-                printing: import("tsondb/schema/def").MemberDecl<Integer, false>;
-                pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                    first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                        InsideCoverFront: EnumCase<null>;
-                        InsideCoverBack: EnumCase<null>;
-                        Numbered: EnumCase<Integer>;
+    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<Integer>;
+                    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<[], TypeAlias<"Since", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<Integer, true>;
-                    pages: import("tsondb/schema/def").MemberDecl<Array<IncludeIdentifier<[], TypeAlias<"PageRange", Object<{
-                        first_page: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"Page", {
-                            InsideCoverFront: EnumCase<null>;
-                            InsideCoverBack: EnumCase<null>;
-                            Numbered: EnumCase<Integer>;
+            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<Integer>;
+                        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<[], TypeAlias<"Deprecation", Object<{
-                    printing: import("tsondb/schema/def").MemberDecl<Integer, 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<"ArmorTranslation", {
-        name: import("tsondb/schema/def").MemberDecl<String, true>;
-        secondary_name: import("tsondb/schema/def").MemberDecl<String, false>;
-        note: import("tsondb/schema/def").MemberDecl<String, false>;
-        rules: import("tsondb/schema/def").MemberDecl<String, false>;
-        advantage: import("tsondb/schema/def").MemberDecl<String, false>;
-        disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
-        errata: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Errata", Array<IncludeIdentifier<[], TypeAlias<"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<"ArmorTranslation", {
+        name: DB.MemberDecl<DB.String, true>;
+        secondary_name: DB.MemberDecl<DB.String, false>;
+        note: DB.MemberDecl<DB.String, false>;
+        rules: DB.MemberDecl<DB.String, false>;
+        advantage: DB.MemberDecl<DB.String, false>;
+        disadvantage: DB.MemberDecl<DB.String, false>;
+        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>;
-export declare const SecondaryArmor: TypeAlias<"SecondaryArmor", Object<{
-    protection: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Protection", Integer, []>>, true>;
-    encumbrance: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"Encumbrance", Integer, []>>, true>;
-    has_additional_penalties: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HasAdditionalPenalties", Boolean, []>>, true>;
-    armor_type: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").ReferenceIdentifierType, true>;
-    hit_zone: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"HitZone", {
-        Head: EnumCase<IncludeIdentifier<[], TypeAlias<"HeadHitZone", Object<{
-            combination_possibilities: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"HeadHitZoneCombinationPossibilities", Object<{
-                armors: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
-                protection: import("tsondb/schema/def").MemberDecl<Integer, false>;
+export declare const SecondaryArmor: DB.TypeAlias<"SecondaryArmor", DB.Object<{
+    protection: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Protection", DB.Integer, []>>, true>;
+    encumbrance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"Encumbrance", DB.Integer, []>>, true>;
+    has_additional_penalties: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>>, true>;
+    armor_type: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    hit_zone: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"HitZone", {
+        Head: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZone", DB.Object<{
+            combination_possibilities: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"HeadHitZoneCombinationPossibilities", DB.Object<{
+                armors: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+                protection: DB.MemberDecl<DB.Integer, false>;
             }>, []>>, false>;
         }>, []>>>;
-        Torso: EnumCase<null>;
-        Arms: EnumCase<null>;
-        Legs: EnumCase<null>;
+        Torso: DB.EnumCase<null>;
+        Arms: DB.EnumCase<null>;
+        Legs: DB.EnumCase<null>;
     }, []>>, false>;
-    restrictedTo: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedTo", Object<{
-        races: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToRaces", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+    restrictedTo: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedTo", DB.Object<{
+        races: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToRaces", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        cultures: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToCultures", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        cultures: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToCultures", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        professions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToProfessions", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        professions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToProfessions", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        magicalTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToMagicalTraditions", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<Array<import("tsondb/schema/def").ReferenceIdentifierType>, true>;
+        magicalTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToMagicalTraditions", DB.Object<{
+            scope: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
         }>, []>>, false>;
-        blessedTraditions: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], TypeAlias<"RestrictedToBlessedTraditions", Object<{
-            scope: import("tsondb/schema/def").MemberDecl<IncludeIdentifier<[], Enum<"RestrictedToBlessedTraditionsScope", {
-                Specific: EnumCase<Array<import("tsondb/schema/def").ReferenceIdentifierType>>;
-                Church: EnumCase<null>;
-                Shamanistic: EnumCase<null>;
+        blessedTraditions: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RestrictedToBlessedTraditions", DB.Object<{
+            scope: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"RestrictedToBlessedTraditionsScope", {
+                Specific: DB.EnumCase<DB.Array<DB.ReferenceIdentifier>>;
+                Church: DB.EnumCase<null>;
+                Shamanistic: DB.EnumCase<null>;
             }, []>>, true>;
-            isSanctifiedBy: import("tsondb/schema/def").MemberDecl<Boolean, true>;
+            isSanctifiedBy: DB.MemberDecl<DB.Boolean, true>;
         }>, []>>, false>;
     }>, []>>, false>;
-    translations: import("tsondb/schema/def").MemberDecl<import("tsondb/schema/def").NestedEntityMapType<"SecondaryArmorTranslation", {
-        advantage: import("tsondb/schema/def").MemberDecl<String, false>;
-        disadvantage: import("tsondb/schema/def").MemberDecl<String, false>;
+    translations: DB.MemberDecl<DB.NestedEntityMap<"SecondaryArmorTranslation", {
+        advantage: DB.MemberDecl<DB.String, false>;
+        disadvantage: DB.MemberDecl<DB.String, false>;
     }>, false>;
 }>, []>;
-export declare const Protection: TypeAlias<"Protection", Integer, []>;
-export declare const Encumbrance: TypeAlias<"Encumbrance", Integer, []>;
-export declare const HasAdditionalPenalties: TypeAlias<"HasAdditionalPenalties", Boolean, []>;
+export declare const Protection: DB.TypeAlias<"Protection", DB.Integer, []>;
+export declare const Encumbrance: DB.TypeAlias<"Encumbrance", DB.Integer, []>;
+export declare const HasAdditionalPenalties: DB.TypeAlias<"HasAdditionalPenalties", DB.Boolean, []>;