npm - @optolith/database-schema - Versions diffs - 0.47.2 → 0.47.4 - Mend

@optolith/database-schema 0.47.2 → 0.47.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

package/lib/types/Race.d.ts CHANGED Viewed

@@ -39,19 +39,59 @@ export declare const Race: DB.Entity<"Race", {
         common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
         automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+            level: DB.MemberDecl<DB.Integer, false>;
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+                General: DB.EnumCase<DB.ReferenceIdentifier>;
+                Race: DB.EnumCase<DB.ReferenceIdentifier>;
+                Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+                SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+                CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                Property: DB.EnumCase<DB.ReferenceIdentifier>;
+                Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+                Disease: DB.EnumCase<DB.ReferenceIdentifier>;
+                Poison: DB.EnumCase<DB.ReferenceIdentifier>;
+                Language: DB.EnumCase<DB.ReferenceIdentifier>;
+                AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+                LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+                ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                Element: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>>, false>;
         }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
         automatic_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+            level: DB.MemberDecl<DB.Integer, false>;
+            options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+                General: DB.EnumCase<DB.ReferenceIdentifier>;
+                Race: DB.EnumCase<DB.ReferenceIdentifier>;
+                Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+                SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+                CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+                Property: DB.EnumCase<DB.ReferenceIdentifier>;
+                Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+                Disease: DB.EnumCase<DB.ReferenceIdentifier>;
+                Poison: DB.EnumCase<DB.ReferenceIdentifier>;
+                Language: DB.EnumCase<DB.ReferenceIdentifier>;
+                AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+                LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+                Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+                Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+                TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+                ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                Element: DB.EnumCase<DB.ReferenceIdentifier>;
+            }, []>>>, false>;
         }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-        strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+        strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-            level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
-                Constant: DB.EnumCase<DB.Integer>;
-                Range: DB.EnumCase<DB.Object<{
-                    min: DB.MemberDecl<DB.Integer, true>;
-                    max: DB.MemberDecl<DB.Integer, true>;
-                }>>;
-            }, []>>, false>;
+            level: DB.MemberDecl<DB.Integer, false>;
             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -74,21 +114,10 @@ export declare const Race: DB.Entity<"Race", {
                 ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
                 Element: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>>, false>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
-                options: DB.MemberDecl<DB.String, false>;
-                note: DB.MemberDecl<DB.String, false>;
-                full: DB.MemberDecl<DB.String, false>;
-            }>, false>;
         }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-        strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+        strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-            level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
-                Constant: DB.EnumCase<DB.Integer>;
-                Range: DB.EnumCase<DB.Object<{
-                    min: DB.MemberDecl<DB.Integer, true>;
-                    max: DB.MemberDecl<DB.Integer, true>;
-                }>>;
-            }, []>>, false>;
+            level: DB.MemberDecl<DB.Integer, false>;
             options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
                 General: DB.EnumCase<DB.ReferenceIdentifier>;
                 Race: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -111,11 +140,6 @@ export declare const Race: DB.Entity<"Race", {
                 ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
                 Element: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>>, false>;
-            translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
-                options: DB.MemberDecl<DB.String, false>;
-                note: DB.MemberDecl<DB.String, false>;
-                full: DB.MemberDecl<DB.String, false>;
-            }>, false>;
         }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
         common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
             id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
@@ -352,19 +376,59 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
     common_cultures: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
     automatic_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        level: DB.MemberDecl<DB.Integer, false>;
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            General: DB.EnumCase<DB.ReferenceIdentifier>;
+            Race: DB.EnumCase<DB.ReferenceIdentifier>;
+            Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+            SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+            CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            Property: DB.EnumCase<DB.ReferenceIdentifier>;
+            Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+            Disease: DB.EnumCase<DB.ReferenceIdentifier>;
+            Poison: DB.EnumCase<DB.ReferenceIdentifier>;
+            Language: DB.EnumCase<DB.ReferenceIdentifier>;
+            AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+            LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+            Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+            Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+            Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+            ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            Element: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
     automatic_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
+        level: DB.MemberDecl<DB.Integer, false>;
+        options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
+            General: DB.EnumCase<DB.ReferenceIdentifier>;
+            Race: DB.EnumCase<DB.ReferenceIdentifier>;
+            Skill: DB.EnumCase<DB.ReferenceIdentifier>;
+            SkillApplication: DB.EnumCase<DB.ReferenceIdentifier>;
+            CloseCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            RangedCombatTechnique: DB.EnumCase<DB.ReferenceIdentifier>;
+            Property: DB.EnumCase<DB.ReferenceIdentifier>;
+            Aspect: DB.EnumCase<DB.ReferenceIdentifier>;
+            Disease: DB.EnumCase<DB.ReferenceIdentifier>;
+            Poison: DB.EnumCase<DB.ReferenceIdentifier>;
+            Language: DB.EnumCase<DB.ReferenceIdentifier>;
+            AnimalShape: DB.EnumCase<DB.ReferenceIdentifier>;
+            LiturgicalChant: DB.EnumCase<DB.ReferenceIdentifier>;
+            Ceremony: DB.EnumCase<DB.ReferenceIdentifier>;
+            Spell: DB.EnumCase<DB.ReferenceIdentifier>;
+            Ritual: DB.EnumCase<DB.ReferenceIdentifier>;
+            TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+            ArcaneBardTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+            Element: DB.EnumCase<DB.ReferenceIdentifier>;
+        }, []>>>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-    strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+    strongly_recommended_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-        level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
-            Constant: DB.EnumCase<DB.Integer>;
-            Range: DB.EnumCase<DB.Object<{
-                min: DB.MemberDecl<DB.Integer, true>;
-                max: DB.MemberDecl<DB.Integer, true>;
-            }>>;
-        }, []>>, false>;
+        level: DB.MemberDecl<DB.Integer, false>;
         options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -387,21 +451,10 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
             ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
             Element: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>>, false>;
-        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
-            options: DB.MemberDecl<DB.String, false>;
-            note: DB.MemberDecl<DB.String, false>;
-            full: DB.MemberDecl<DB.String, false>;
-        }>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
-    strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
+    strongly_recommended_disadvantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"AutomaticAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;
-        level: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"CommonnessRatedAdvantageDisadvantageLevel", {
-            Constant: DB.EnumCase<DB.Integer>;
-            Range: DB.EnumCase<DB.Object<{
-                min: DB.MemberDecl<DB.Integer, true>;
-                max: DB.MemberDecl<DB.Integer, true>;
-            }>>;
-        }, []>>, false>;
+        level: DB.MemberDecl<DB.Integer, false>;
         options: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"RequirableSelectOptionIdentifier", {
             General: DB.EnumCase<DB.ReferenceIdentifier>;
             Race: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -424,11 +477,6 @@ export declare const RaceVariant: DB.Entity<"RaceVariant", {
             ArcaneDancerTradition: DB.EnumCase<DB.ReferenceIdentifier>;
             Element: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>>, false>;
-        translations: DB.MemberDecl<DB.NestedEntityMap<"CommonnessRatedAdvantageDisadvantageTranslation", {
-            options: DB.MemberDecl<DB.String, false>;
-            note: DB.MemberDecl<DB.String, false>;
-            full: DB.MemberDecl<DB.String, false>;
-        }>, false>;
     }>, [Identifier: DB.Param<"Identifier", DB.Type>]>>>, false>;
     common_advantages: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<DB.Param<string, DB.Type>[], DB.TypeAlias<"CommonnessRatedAdvantageDisadvantage", DB.Object<{
         id: DB.MemberDecl<DB.TypeArgument<DB.Param<"Identifier", DB.Type>>, true>;

package/lib/types/Race.js CHANGED Viewed

@@ -3,6 +3,7 @@ import * as DB from "tsondb/schema/dsl";
 import { CommonnessRatedAdvantageDisadvantage } from "./_CommonnessRatedAdvantageDisadvantage.js";
 import { Dice, DieType } from "./_Dice.js";
 import { AdvantageIdentifier, AttributeIdentifier, CultureIdentifier, DisadvantageIdentifier, EyeColorIdentifier, HairColorIdentifier, RaceIdentifier, } from "./_Identifier.js";
+import { RequirableSelectOptionIdentifier } from "./_IdentifierGroup.js";
 import { calculationContainsRaceBase, DerivedCharacteristic } from "./DerivedCharacteristic.js";
 import { ExperienceLevel } from "./ExperienceLevel.js";
 import { NestedTranslationMap } from "./Locale.js";
@@ -155,6 +156,14 @@ const AutomaticAdvantageDisadvantage = DB.GenTypeAlias(import.meta.url, {
             comment: "The automatic advantage or disadvantage.",
             type: DB.TypeArgument(Identifier),
         }),
+        level: DB.Optional({
+            comment: "The level of the entry.",
+            type: DB.Integer({ minimum: 1 }),
+        }),
+        options: DB.Optional({
+            comment: "Required select options. Order is important. Typically, you only need the first array index, though.",
+            type: DB.Array(DB.IncludeIdentifier(RequirableSelectOptionIdentifier), { minItems: 1 }),
+        }),
     }),
 });
 const RandomWeightGeneration = DB.TypeAlias(import.meta.url, {
@@ -214,22 +223,22 @@ export const RaceVariant = DB.Entity(import.meta.url, {
             type: DB.Array(CultureIdentifier(), { minItems: 1 }),
         }),
         automatic_advantages: DB.Optional({
-            comment: "A list of automatically applied advantages. This does only work for advantages with no further configuration such as level or special selection.",
+            comment: "A list of automatically applied advantages.",
             type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]), {
                 minItems: 1,
             }),
         }),
         automatic_disadvantages: DB.Optional({
-            comment: "A list of automatically applied disadvantages. This does only work for disadvantages with no further configuration such as level or special selection.",
+            comment: "A list of automatically applied disadvantages.",
             type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
         }),
         strongly_recommended_advantages: DB.Optional({
             comment: "A list of strongly recommended advantages.",
-            type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [AdvantageIdentifier()]), { minItems: 1 }),
+            type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [AdvantageIdentifier()]), { minItems: 1 }),
         }),
         strongly_recommended_disadvantages: DB.Optional({
             comment: "A list of strongly recommended disadvantages.",
-            type: DB.Array(DB.GenIncludeIdentifier(CommonnessRatedAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
+            type: DB.Array(DB.GenIncludeIdentifier(AutomaticAdvantageDisadvantage, [DisadvantageIdentifier()]), { minItems: 1 }),
         }),
         common_advantages: DB.Optional({
             comment: "A list of common advantages.",

package/lib/types/Skill.d.ts CHANGED Viewed

@@ -12,6 +12,47 @@ export declare const Skill: DB.Entity<"Skill", {
         }, []>>, false>;
         explicit: DB.MemberDecl<DB.ChildEntities<DB.Entity<"SkillApplication", {
             parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+            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: 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>;
+                    }>, []>>, true>;
+                    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: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                    InsideCoverFront: DB.EnumCase<null>;
+                                    InsideCoverBack: DB.EnumCase<null>;
+                                    Numbered: DB.EnumCase<DB.Integer>;
+                                }, []>>, false>;
+                            }>, []>>>, true>;
+                        }>, []>>>;
+                        Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                            printing: DB.MemberDecl<DB.Integer, true>;
+                        }>, []>>>;
+                    }, []>>>, false>;
+                }>, true>;
+            }>, []>>>, []>>, false>;
             translations: DB.MemberDecl<DB.NestedEntityMap<"SkillApplicationTranslation", {
                 name: DB.MemberDecl<DB.String, true>;
             }>, true>;
@@ -93,6 +134,47 @@ export declare const Applications: DB.TypeAlias<"Applications", DB.Object<{
     }, []>>, false>;
     explicit: DB.MemberDecl<DB.ChildEntities<DB.Entity<"SkillApplication", {
         parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        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: 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>;
+                }>, []>>, true>;
+                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: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                                InsideCoverFront: DB.EnumCase<null>;
+                                InsideCoverBack: DB.EnumCase<null>;
+                                Numbered: DB.EnumCase<DB.Integer>;
+                            }, []>>, false>;
+                        }>, []>>>, true>;
+                    }>, []>>>;
+                    Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                        printing: DB.MemberDecl<DB.Integer, true>;
+                    }>, []>>>;
+                }, []>>>, false>;
+            }>, true>;
+        }>, []>>>, []>>, false>;
         translations: DB.MemberDecl<DB.NestedEntityMap<"SkillApplicationTranslation", {
             name: DB.MemberDecl<DB.String, true>;
         }>, true>;
@@ -105,6 +187,47 @@ export declare const ApplicationCategory: DB.Enum<"ApplicationCategory", {
 }, []>;
 export declare const SkillApplication: DB.Entity<"SkillApplication", {
     parent: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+    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: 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>;
+            }>, []>>, true>;
+            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: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Page", {
+                            InsideCoverFront: DB.EnumCase<null>;
+                            InsideCoverBack: DB.EnumCase<null>;
+                            Numbered: DB.EnumCase<DB.Integer>;
+                        }, []>>, false>;
+                    }>, []>>>, true>;
+                }>, []>>>;
+                Deprecated: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"Deprecation", DB.Object<{
+                    printing: DB.MemberDecl<DB.Integer, true>;
+                }>, []>>>;
+            }, []>>>, false>;
+        }>, true>;
+    }>, []>>>, []>>, false>;
     translations: DB.MemberDecl<DB.NestedEntityMap<"SkillApplicationTranslation", {
         name: DB.MemberDecl<DB.String, true>;
     }>, true>;

package/lib/types/Skill.js CHANGED Viewed

@@ -7,7 +7,7 @@ import { ImprovementCost } from "./_ImprovementCost.js";
 import { SkillCheck } from "./_SkillCheck.js";
 import { NestedTranslationMap } from "./Locale.js";
 import { Errata } from "./source/_Erratum.js";
-import { src } from "./source/_PublicationRef.js";
+import { optionalSrc, src } from "./source/_PublicationRef.js";
 export const Skill = DB.Entity(import.meta.url, {
     name: "Skill",
     namePlural: "Skills",
@@ -109,6 +109,7 @@ export const SkillApplication = DB.Entity(import.meta.url, {
             comment: "The skill this application belongs to.",
             type: SkillIdentifier(),
         }),
+        src: optionalSrc,
         translations: NestedTranslationMap(DB.Required, "SkillApplication", DB.Object({
             name: DB.Required({
                 comment: "The skill application’s name.",

package/lib/types/_ActivatableNonMundane.d.ts CHANGED Viewed

@@ -1,4 +1,8 @@
 import * as DB from "tsondb/schema/dsl";
+export declare const cost_note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+    full: DB.MemberDecl<DB.String, true>;
+    compressed: DB.MemberDecl<DB.String, false>;
+}>, []>>, false>;
 export declare const cost: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"EnchantmentCost", {
     ArcaneEnergyCost: DB.EnumCase<DB.IncludeIdentifier<[], DB.Enum<"ArcaneEnergyCost", {
         Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedArcaneEnergyCost", DB.Object<{

package/lib/types/_ActivatableNonMundane.js CHANGED Viewed

@@ -11,6 +11,10 @@ const EnchantmentCost = DB.Enum(import.meta.url, {
         BindingCost: DB.EnumCase({ type: DB.IncludeIdentifier(BindingCost) }),
     }),
 });
+export const cost_note = DB.Optional({
+    comment: "A note, appended to the generated cost string in parenthesis.",
+    type: DB.IncludeIdentifier(ResponsiveTextOptional),
+});
 export const cost = DB.Optional({
     comment: "The cost when casting the entry.",
     type: DB.IncludeIdentifier(EnchantmentCost),

package/lib/types/traditionArtifacts/ArcaneOrbEnchantment.d.ts CHANGED Viewed

@@ -1269,6 +1269,10 @@ export declare const ArcaneOrbEnchantment: DB.Entity<"ArcaneOrbEnchantment", {
         name: DB.MemberDecl<DB.String, true>;
         name_in_library: DB.MemberDecl<DB.String, false>;
         effect: DB.MemberDecl<DB.String, true>;
+        cost_note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
         bindingCost: DB.MemberDecl<DB.String, false>;
         aeCost: DB.MemberDecl<DB.String, false>;
         volume: DB.MemberDecl<DB.String, false>;

package/lib/types/traditionArtifacts/ArcaneOrbEnchantment.js CHANGED Viewed

@@ -1,13 +1,12 @@
 import * as DB from "tsondb/schema/dsl";
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js";
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
+import { levels, maximum } from "../_Activatable.js";
+import { ap_value } from "../_ActivatableAdventurePointsValue.js";
 import { nameBuilderRules } from "../_ActivatableNames.js";
-import { aeCost, bindingCost, cost, property, volume, volume_l10n, } from "../_ActivatableNonMundane.js";
+import { cost, property, volume } from "../_ActivatableNonMundane.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
-import { NestedTranslationMap } from "../Locale.js";
-import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
+import { translations } from "./_shared.js";
 export const ArcaneOrbEnchantment = DB.Entity(import.meta.url, {
     name: "ArcaneOrbEnchantment",
     namePlural: "ArcaneOrbEnchantments",
@@ -25,19 +24,7 @@ export const ArcaneOrbEnchantment = DB.Entity(import.meta.url, {
         property: property(),
         ap_value,
         src,
-        translations: NestedTranslationMap(DB.Required, "ArcaneOrbEnchantment", DB.Object({
-            name,
-            name_in_library,
-            effect,
-            bindingCost,
-            aeCost,
-            volume: volume_l10n,
-            ap_value_append,
-            ap_value: ap_value_l10n,
-            errata: DB.Optional({
-                type: DB.IncludeIdentifier(Errata),
-            }),
-        })),
+        translations: translations("ArcaneOrbEnchantment"),
     }),
     instanceDisplayName: {},
     uniqueConstraints: [

package/lib/types/traditionArtifacts/AttireEnchantment.d.ts CHANGED Viewed

@@ -1269,6 +1269,10 @@ export declare const AttireEnchantment: DB.Entity<"AttireEnchantment", {
         name: DB.MemberDecl<DB.String, true>;
         name_in_library: DB.MemberDecl<DB.String, false>;
         effect: DB.MemberDecl<DB.String, true>;
+        cost_note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
         bindingCost: DB.MemberDecl<DB.String, false>;
         aeCost: DB.MemberDecl<DB.String, false>;
         volume: DB.MemberDecl<DB.String, false>;

package/lib/types/traditionArtifacts/AttireEnchantment.js CHANGED Viewed

@@ -1,13 +1,12 @@
 import * as DB from "tsondb/schema/dsl";
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js";
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
+import { levels, maximum } from "../_Activatable.js";
+import { ap_value } from "../_ActivatableAdventurePointsValue.js";
 import { nameBuilderRules } from "../_ActivatableNames.js";
-import { aeCost, bindingCost, cost, property, volume, volume_l10n, } from "../_ActivatableNonMundane.js";
+import { cost, property, volume } from "../_ActivatableNonMundane.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
-import { NestedTranslationMap } from "../Locale.js";
-import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
+import { translations } from "./_shared.js";
 export const AttireEnchantment = DB.Entity(import.meta.url, {
     name: "AttireEnchantment",
     namePlural: "AttireEnchantments",
@@ -25,19 +24,7 @@ export const AttireEnchantment = DB.Entity(import.meta.url, {
         property: property(),
         ap_value,
         src,
-        translations: NestedTranslationMap(DB.Required, "AttireEnchantment", DB.Object({
-            name,
-            name_in_library,
-            effect,
-            bindingCost,
-            aeCost,
-            volume: volume_l10n,
-            ap_value_append,
-            ap_value: ap_value_l10n,
-            errata: DB.Optional({
-                type: DB.IncludeIdentifier(Errata),
-            }),
-        })),
+        translations: translations("AttireEnchantment"),
     }),
     instanceDisplayName: {},
     uniqueConstraints: [

package/lib/types/traditionArtifacts/Beutelzauber.d.ts CHANGED Viewed

@@ -1269,6 +1269,10 @@ export declare const Beutelzauber: DB.Entity<"Beutelzauber", {
         name: DB.MemberDecl<DB.String, true>;
         name_in_library: DB.MemberDecl<DB.String, false>;
         effect: DB.MemberDecl<DB.String, true>;
+        cost_note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
         bindingCost: DB.MemberDecl<DB.String, false>;
         aeCost: DB.MemberDecl<DB.String, false>;
         volume: DB.MemberDecl<DB.String, false>;

package/lib/types/traditionArtifacts/Beutelzauber.js CHANGED Viewed

@@ -1,13 +1,12 @@
 import * as DB from "tsondb/schema/dsl";
-import { effect, levels, maximum, name, name_in_library } from "../_Activatable.js";
-import { ap_value, ap_value_append, ap_value_l10n } from "../_ActivatableAdventurePointsValue.js";
+import { levels, maximum } from "../_Activatable.js";
+import { ap_value } from "../_ActivatableAdventurePointsValue.js";
 import { nameBuilderRules } from "../_ActivatableNames.js";
-import { aeCost, bindingCost, cost, property, volume, volume_l10n, } from "../_ActivatableNonMundane.js";
+import { cost, property, volume } from "../_ActivatableNonMundane.js";
 import { explicit_select_options, select_options } from "../_ActivatableSelectOptions.js";
 import { GeneralPrerequisites } from "../_Prerequisite.js";
-import { NestedTranslationMap } from "../Locale.js";
-import { Errata } from "../source/_Erratum.js";
 import { src } from "../source/_PublicationRef.js";
+import { translations } from "./_shared.js";
 export const Beutelzauber = DB.Entity(import.meta.url, {
     name: "Beutelzauber",
     namePlural: "Beutelzauber",
@@ -25,19 +24,7 @@ export const Beutelzauber = DB.Entity(import.meta.url, {
         property: property(),
         ap_value,
         src,
-        translations: NestedTranslationMap(DB.Required, "Beutelzauber", DB.Object({
-            name,
-            name_in_library,
-            effect,
-            bindingCost,
-            aeCost,
-            volume: volume_l10n,
-            ap_value_append,
-            ap_value: ap_value_l10n,
-            errata: DB.Optional({
-                type: DB.IncludeIdentifier(Errata),
-            }),
-        })),
+        translations: translations("Beutelzauber"),
     }),
     instanceDisplayName: {},
     uniqueConstraints: [

package/lib/types/traditionArtifacts/BowlEnchantment.d.ts CHANGED Viewed

@@ -1269,6 +1269,10 @@ export declare const BowlEnchantment: DB.Entity<"BowlEnchantment", {
         name: DB.MemberDecl<DB.String, true>;
         name_in_library: DB.MemberDecl<DB.String, false>;
         effect: DB.MemberDecl<DB.String, true>;
+        cost_note: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{
+            full: DB.MemberDecl<DB.String, true>;
+            compressed: DB.MemberDecl<DB.String, false>;
+        }>, []>>, false>;
         bindingCost: DB.MemberDecl<DB.String, false>;
         aeCost: DB.MemberDecl<DB.String, false>;
         volume: DB.MemberDecl<DB.String, false>;