@optolith/database-schema 0.74.0 → 0.76.0

package/lib/cache/activatableSelectOptions.js

@@ -1,4 +1,4 @@
-import { on } from "@elyukai/utils/function";
+import { constant, on } from "@elyukai/utils/function";
 import { isNotNullish } from "@elyukai/utils/nullable";
 import { mapObject } from "@elyukai/utils/object";
 import { compareNullish, compareNumber } from "@elyukai/utils/ordering";
@@ -155,10 +155,12 @@ const getDerivedSkillishSelectOptions = (database, entryId, entity, category, op
         };
     });
 };
-const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap) => {
+const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
     switch (selectOptionCategory.kind) {
         case "Blessings":
-            return database.getAllInstanceContainersOfEntity("Blessing").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Blessing")
+                .map(({ id, content }) => ({
                 id: Case("Blessing", id),
                 content: {
                     parent: entryId,
@@ -169,7 +171,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "Cantrips":
-            return database.getAllInstanceContainersOfEntity("Cantrip").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Cantrip")
+                .map(({ id, content }) => ({
                 id: Case("Cantrip", id),
                 content: {
                     parent: entryId,
@@ -180,7 +184,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "TradeSecrets":
-            return database.getAllInstanceContainersOfEntity("TradeSecret").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("TradeSecret")
+                .map(({ id, content }) => ({
                 id: Case("TradeSecret", id),
                 content: {
                     parent: entryId,
@@ -196,7 +202,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "Scripts":
-            return database.getAllInstanceContainersOfEntity("Script").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Script")
+                .map(({ id, content }) => ({
                 id: Case("Script", id),
                 content: {
                     parent: entryId,
@@ -268,7 +276,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
             });
         }
         case "ArcaneBardTraditions":
-            return database.getAllInstanceContainersOfEntity("ArcaneBardTradition").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("ArcaneBardTradition")
+                .map(({ id, content }) => ({
                 id: Case("ArcaneBardTradition", id),
                 content: {
                     parent: entryId,
@@ -284,7 +294,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "ArcaneDancerTraditions":
-            return database.getAllInstanceContainersOfEntity("ArcaneDancerTradition").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("ArcaneDancerTradition")
+                .map(({ id, content }) => ({
                 id: Case("ArcaneDancerTradition", id),
                 content: {
                     parent: entryId,
@@ -300,7 +312,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "SexPractices":
-            return database.getAllInstanceContainersOfEntity("SexPractice").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("SexPractice")
+                .map(({ id, content }) => ({
                 id: Case("SexPractice", id),
                 content: {
                     parent: entryId,
@@ -313,7 +327,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "Races":
-            return database.getAllInstanceContainersOfEntity("Race").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Race")
+                .map(({ id, content }) => ({
                 id: Case("Race", id),
                 content: {
                     parent: entryId,
@@ -326,7 +342,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 uses: [],
             }));
         case "Cultures":
-            return database.getAllInstanceContainersOfEntity("Culture").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Culture")
+                .map(({ id, content }) => ({
                 id: Case("Culture", id),
                 content: {
                     parent: entryId,
@@ -340,7 +358,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
             }));
         case "RacesAndCultures":
             return [
-                ...database.getAllInstanceContainersOfEntity("Race").map(({ id, content }) => ({
+                ...database
+                    .getAllInstanceContainersOfEntity("Race")
+                    .map(({ id, content }) => ({
                     id: Case("Race", id),
                     content: {
                         parent: entryId,
@@ -352,7 +372,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                     newApplications: [],
                     uses: [],
                 })),
-                ...database.getAllInstanceContainersOfEntity("Culture").map(({ id, content }) => ({
+                ...database
+                    .getAllInstanceContainersOfEntity("Culture")
+                    .map(({ id, content }) => ({
                     id: Case("Culture", id),
                     content: {
                         parent: entryId,
@@ -366,7 +388,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 })),
             ];
         case "HomunculusTypes":
-            return database.getAllInstanceContainersOfEntity("HomunculusType").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("HomunculusType")
+                .map(({ id, content }) => ({
                 id: Case("HomunculusType", id),
                 content: {
                     parent: entryId,
@@ -398,7 +422,12 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 }
                 return undefined;
             };
-            return database.getAllInstanceContainersOfEntity("BlessedTradition").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("BlessedTradition")
+                .filter(selectOptionCategory.BlessedTraditions.onlyType
+                ? ({ content }) => content.type.kind === selectOptionCategory.BlessedTraditions.onlyType?.kind
+                : constant(true))
+                .map(({ id, content }) => ({
                 id: Case("BlessedTradition", id),
                 content: {
                     parent: entryId,
@@ -435,13 +464,13 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
         }
         case "Properties": {
             const getPrerequisites = (id) => {
-                if (selectOptionCategory.Properties.require_knowledge !== undefined ||
+                if (selectOptionCategory.Properties.requireActiveSelectionOnEntry !== undefined ||
                     selectOptionCategory.Properties.require_minimum_spellworks_on !== undefined) {
-                    const knowledgePrerequisite = selectOptionCategory.Properties.require_knowledge !== undefined
+                    const knowledgePrerequisite = selectOptionCategory.Properties.requireActiveSelectionOnEntry !== undefined
                         ? {
                             level: 1,
                             prerequisite: Case("Single", Case("Activatable", {
-                                id: Case("MagicalSpecialAbility", idMap.MagicalSpecialAbility.PropertyKnowledge),
+                                id: selectOptionCategory.Properties.requireActiveSelectionOnEntry,
                                 active: true,
                                 options: [Case("Property", id)],
                             })),
@@ -463,7 +492,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 }
                 return undefined;
             };
-            return database.getAllInstanceContainersOfEntity("Property").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Property")
+                .map(({ id, content }) => ({
                 id: Case("Property", id),
                 content: {
                     parent: entryId,
@@ -478,13 +509,13 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
         }
         case "Aspects": {
             const getPrerequisites = (id) => {
-                if (selectOptionCategory.Aspects.require_knowledge !== undefined ||
+                if (selectOptionCategory.Aspects.requireActiveSelectionOnEntry !== undefined ||
                     selectOptionCategory.Aspects.require_minimum_liturgies_on !== undefined) {
-                    const knowledgePrerequisite = selectOptionCategory.Aspects.require_knowledge !== undefined
+                    const knowledgePrerequisite = selectOptionCategory.Aspects.requireActiveSelectionOnEntry !== undefined
                         ? {
                             level: 1,
                             prerequisite: Case("Single", Case("Activatable", {
-                                id: Case("KarmaSpecialAbility", idMap.KarmaSpecialAbility.AspectKnowledge),
+                                id: selectOptionCategory.Aspects.requireActiveSelectionOnEntry,
                                 active: true,
                                 options: [Case("Aspect", id)],
                             })),
@@ -525,7 +556,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 }))
                     .filter(value => Object.keys(value.content.translations).length > 0);
             }
-            return database.getAllInstanceContainersOfEntity("Aspect").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Aspect")
+                .map(({ id, content }) => ({
                 id: Case("Aspect", id),
                 content: {
                     parent: entryId,
@@ -539,7 +572,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
             }));
         }
         case "Diseases":
-            return database.getAllInstanceContainersOfEntity("Disease").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Disease")
+                .map(({ id, content }) => ({
                 id: Case("Disease", id),
                 content: {
                     parent: entryId,
@@ -588,7 +623,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                         return assertExhaustive(poison.source_type);
                 }
             };
-            return database.getAllInstanceContainersOfEntity("Poison").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Poison")
+                .map(({ id, content }) => ({
                 id: Case("Poison", id),
                 content: {
                     parent: entryId,
@@ -619,7 +656,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
                 }
                 return undefined;
             };
-            return database.getAllInstanceContainersOfEntity("Language").map(({ id, content }) => ({
+            return database
+                .getAllInstanceContainersOfEntity("Language")
+                .map(({ id, content }) => ({
                 id: Case("Language", id),
                 content: {
                     parent: entryId,
@@ -695,7 +734,9 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database, idMap)
             return assertExhaustive(selectOptionCategory);
     }
 };
-const getExplicitSelectOptions = (id, database) => database.getAllChildInstanceContainersForParent("GeneralSelectOption", id).map(({ id, content }) => ({
+const getExplicitSelectOptions = (id, database) => database
+    .getAllChildInstanceContainersForParent("GeneralSelectOption", id)
+    .map(({ id, content }) => ({
     id: Case("General", id),
     content: {
         ...content,
@@ -704,14 +745,14 @@ const getExplicitSelectOptions = (id, database) => database.getAllChildInstanceC
     newApplications: [], // database.getAllChildInstanceContainersForParent("NewSkillApplication", Case("GeneralSelectOption", id)), // prevent duplicates as these can already be queried from the database
     uses: [], // database.getAllChildInstanceContainersForParent("SkillUse", Case("GeneralSelectOption", id)), // prevent duplicates as these can already be queried from the database
 }));
-const getSelectOptions = (selectOptions, id, database, idMap) => [
+const getSelectOptions = (selectOptions, id, database) => [
     ...(selectOptions.derived === undefined
         ? []
-        : getDerivedSelectOptions(selectOptions.derived, id, database, idMap)),
+        : getDerivedSelectOptions(selectOptions.derived, id, database)),
     ...getExplicitSelectOptions(id, database),
 ];
-const getSelectOptionsForResults = (database, idMap, entity, results) => results.reduce((acc, { id, content }) => {
-    const options = getSelectOptions(content.select_options ?? {}, Case(entity, id), database, idMap);
+const getSelectOptionsForResults = (database, entity, results) => results.reduce((acc, { id, content }) => {
+    const options = getSelectOptions(content.select_options ?? {}, Case(entity, id), database);
     if (options.length > 0) {
         acc[id] = options;
     }
@@ -775,7 +816,7 @@ const cacheKeyBase = {
     WandEnchantment: null,
     WeaponEnchantment: null,
 };
-export const activatableSelectOptionsCacheBuilder = (database, idMap) => Object.fromEntries(Object.keys(cacheKeyBase).map((entity) => [
+export const activatableSelectOptionsCacheBuilder = database => Object.fromEntries(Object.keys(cacheKeyBase).map((entity) => [
     entity,
-    getSelectOptionsForResults(database, idMap, entity, database.getAllInstanceContainersOfEntity(entity)),
+    getSelectOptionsForResults(database, entity, database.getAllInstanceContainersOfEntity(entity)),
 ]));

package/lib/cache/index.d.ts

@@ -5,15 +5,6 @@ import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts"
 import { type MagicalAndBlessedAdvantagesAndDisadvantagesCache } from "./magicalAndBlessedAdvantagesAndDisadvantages.ts";
 import { type NewApplicationsAndUsesCache, type ResolvedNewSkillApplication, type ResolvedSkillUse } from "./newApplicationsAndUses.ts";
 import { type DerivedTradeSecretsCache } from "./tradeSecrets.ts";
-/**
- * Identifiers of specific entries in the database that are used for creating the cache.
- */
-export type IdMap = {
-    Advantage: Record<"Blessed" | "Spellcaster", string>;
-    GeneralSpecialAbility: Record<"Weaponsmith" | "Armorer", string>;
-    MagicalSpecialAbility: Record<"PropertyKnowledge", string>;
-    KarmaSpecialAbility: Record<"AspectKnowledge", string>;
-};
 /**
  * The cache object containing all precomputed data.
  */
@@ -31,4 +22,4 @@ export type { ActivatableSelectOptionsCache, AncestorBloodAdvantagesCache, Magic
  * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
  * @returns The created cache object.
  */
-export declare const createCache: (db: TSONDB<TSONDBTypes>, idMap: IdMap) => Cache;
+export declare const createCache: (db: TSONDB<TSONDBTypes>) => Cache;

package/lib/cache/index.js

@@ -9,12 +9,16 @@ import { buildDerivedTradeSecretsCache } from "./tradeSecrets.js";
  * @param idMap An object containing identifiers of specific entries in the database that are used for creating the cache.
  * @returns The created cache object.
  */
-export const createCache = (db, idMap) => {
-    const activatableSelectOptions = activatableSelectOptionsCacheBuilder(db, idMap);
-    const ancestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
-    const derivedTradeSecrets = buildDerivedTradeSecretsCache(db, idMap);
-    const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, idMap);
-    const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, idMap, activatableSelectOptions);
+export const createCache = (db) => {
+    const settings = db.getSingletonInstanceOfEntity("Settings");
+    if (!settings) {
+        throw new Error("Settings not found in the database.");
+    }
+    const activatableSelectOptions = activatableSelectOptionsCacheBuilder(db, settings);
+    const ancestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, settings);
+    const derivedTradeSecrets = buildDerivedTradeSecretsCache(db, settings);
+    const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, settings);
+    const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, settings, activatableSelectOptions);
     return {
         activatableSelectOptions,
         ancestorBloodAdvantages,

package/lib/cache/internal.d.ts

@@ -1,4 +1,4 @@
 import type { TSONDB } from "tsondb";
+import type { Settings } from "../../gen/types.js";
 import type { TSONDBTypes } from "../main.ts";
-import type { IdMap } from "./index.ts";
-export type CacheBuilder<T = unknown, Args extends unknown[] = []> = (db: TSONDB<TSONDBTypes>, idMap: IdMap, ...args: Args) => T;
+export type CacheBuilder<T = unknown, Args extends unknown[] = []> = (db: TSONDB<TSONDBTypes>, settings: Settings, ...args: Args) => T;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -1,10 +1,10 @@
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
-const getAdvantageId = (idMap, type) => {
+const getAdvantageId = (settings, type) => {
     switch (type) {
         case "Magical":
-            return idMap.Advantage.Spellcaster;
+            return settings.supernaturalBaseAdvantages.spellcasters;
         case "Blessed":
-            return idMap.Advantage.Blessed;
+            return settings.supernaturalBaseAdvantages.blessed;
         default:
             return assertExhaustive(type);
     }
@@ -26,16 +26,16 @@ const isRatedFor = (type, ratedId) => {
             return assertExhaustive(ratedId);
     }
 };
-const isPrerequisiteFor = (idMap, type, prerequisite, getById, traversedIds) => {
+const isPrerequisiteFor = (settings, type, prerequisite, getById, traversedIds) => {
     switch (prerequisite.kind) {
         case "Activatable": {
             if (prerequisite.Activatable.id.kind === "Advantage" &&
-                prerequisite.Activatable.id.Advantage === getAdvantageId(idMap, type) &&
+                prerequisite.Activatable.id.Advantage === getAdvantageId(settings, type) &&
                 prerequisite.Activatable.active) {
                 return true;
             }
             const entry = getById(prerequisite.Activatable.id);
-            return entry !== undefined && is(idMap, type, entry, getById, traversedIds);
+            return entry !== undefined && is(settings, type, entry, getById, traversedIds);
         }
         case "Rated":
             return isRatedFor(type, prerequisite.Rated.id);
@@ -64,7 +64,7 @@ const isPrerequisiteFor = (idMap, type, prerequisite, getById, traversedIds) =>
             return assertExhaustive(prerequisite);
     }
 };
-const is = (idMap, type, entry, getById, traversedIds) => {
+const is = (settings, type, entry, getById, traversedIds) => {
     if (!entry.content.prerequisites || traversedIds.includes(entry.id)) {
         return false;
     }
@@ -73,11 +73,11 @@ const is = (idMap, type, entry, getById, traversedIds) => {
         entry.content.prerequisites.some(prerequisite => {
             switch (prerequisite.prerequisite.kind) {
                 case "Single":
-                    return isPrerequisiteFor(idMap, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
+                    return isPrerequisiteFor(settings, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
                 case "Disjunction":
-                    return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                    return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(settings, type, p, getById, newTraversedIds));
                 case "Group":
-                    return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                    return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(settings, type, p, getById, newTraversedIds));
                 default:
                     return assertExhaustive(prerequisite.prerequisite);
             }
@@ -91,16 +91,16 @@ const typeKeyMap = {
     Magical: null,
     Blessed: null,
 };
-const collectIds = (entity, type, database, idMap) => database
+const collectIds = (entity, type, database, settings) => database
     .getAllInstanceContainersOfEntity(entity)
-    .filter(entry => is(idMap, type, entry, database.getInstanceContainerOfEntityById.bind(database), []))
+    .filter(entry => is(settings, type, entry, database.getInstanceContainerOfEntityById.bind(database), []))
     .map(({ id }) => id);
-export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, idMap) => {
+export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, settings) => {
     return Object.fromEntries(Object.keys(entityKeyMap).map((entity) => [
         entity,
         Object.fromEntries(Object.keys(typeKeyMap).map((type) => [
             type,
-            collectIds(entity, type, database, idMap),
+            collectIds(entity, type, database, settings),
         ])),
     ]));
 };

package/lib/cache/tradeSecrets.js

@@ -31,7 +31,7 @@ const emptyDerivedHerbaryTradeSecretsCache = {
     HerbalAid: {},
     Poison: {},
 };
-export const buildDerivedTradeSecretsCache = (database, idMap) => {
+export const buildDerivedTradeSecretsCache = (database, settings) => {
     const cache = {
         equipment: emptyDerivedEquipmentTradeSecretsCache,
         herbary: emptyDerivedHerbaryTradeSecretsCache,
@@ -49,14 +49,14 @@ export const buildDerivedTradeSecretsCache = (database, idMap) => {
                     prerequisites: entity === "Weapon"
                         ? [
                             Case("Single", Case("Activatable", {
-                                id: Case("GeneralSpecialAbility", idMap.GeneralSpecialAbility.Weaponsmith),
+                                id: settings.derivedTradeSecrets.requiredSpecialAbilityForWeapons,
                                 active: true,
                             })),
                         ]
                         : entity === "Armor"
                             ? [
                                 Case("Single", Case("Activatable", {
-                                    id: Case("GeneralSpecialAbility", idMap.GeneralSpecialAbility.Armorer),
+                                    id: settings.derivedTradeSecrets.requiredSpecialAbilityForArmor,
                                     active: true,
                                 })),
                             ]

package/lib/main.d.ts

@@ -1,9 +1,10 @@
 import { Schema } from "tsondb/schema";
-import type { ChildEntityMap, EntityMap, EnumMap, TypeAliasMap } from "../gen/types.js";
+import type { ChildEntityMap, EntityMap, EnumMap, SingletonEntityMap, TypeAliasMap } from "../gen/types.js";
 declare module "tsondb/schema/gen" {
     interface Register {
         entityMap: EntityMap;
         childEntityMap: ChildEntityMap;
+        singletonEntityMap: SingletonEntityMap;
         enumMap: EnumMap;
         typeAliasMap: TypeAliasMap;
     }
@@ -11,6 +12,7 @@ declare module "tsondb/schema/gen" {
 export interface TSONDBTypes {
     entityMap: EntityMap;
     childEntityMap: ChildEntityMap;
+    singletonEntityMap: SingletonEntityMap;
     enumMap: EnumMap;
     typeAliasMap: TypeAliasMap;
 }

package/lib/main.js

@@ -137,6 +137,7 @@ export const schema = new Schema([
     Types.Script,
     Types.Sermon,
     Types.Service,
+    Types.Settings,
     Types.SexPractice,
     Types.SexSpecialAbility,
     Types.SickleRitual,

package/lib/types/Advantage.d.ts

@@ -8,6 +8,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
         MagicalPunishment: DB.EnumCase<null>;
         BlessedRank: DB.EnumCase<null>;
         BlessedTitle: DB.EnumCase<null>;
+        BlessedHonor: DB.EnumCase<null>;
+        BlessedPunishment: DB.EnumCase<null>;
     }, []>>, false>;
     nameBuilderRules: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ActivatableNameBuilderRules", DB.Object<{
         levelPlacement: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableNameLevelPlacement", {
@@ -32,19 +34,137 @@ export declare const Advantage: DB.Entity<"Advantage", {
             HomunculusTypes: DB.EnumCase<null>;
             BlessedTraditions: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"BlessedTraditionsSelectOptionCategory", DB.Object<{
                 require_principles: DB.MemberDecl<DB.Boolean, false>;
+                onlyType: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"BlessedTraditionTypeForSelectOptionCategory", {
+                    Church: DB.EnumCase<null>;
+                    Shamanistic: DB.EnumCase<null>;
+                }, []>>, false>;
             }>, []>>>;
             Elements: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"ElementsSelectOptionCategory", DB.Object<{
                 specific: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, false>;
             }>, []>>>;
             Properties: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"PropertiesSelectOptionCategory", DB.Object<{
-                require_knowledge: DB.MemberDecl<DB.Boolean, false>;
+                requireActiveSelectionOnEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+                    ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+                    BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                    ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
                 require_minimum_spellworks_on: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RequiredMinimumSkillsToBeOnSkillRating", DB.Object<{
                     number: DB.MemberDecl<DB.Integer, true>;
                     rating: DB.MemberDecl<DB.Integer, true>;
                 }>, []>>, false>;
             }>, []>>>;
             Aspects: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AspectSelectOptionCategory", DB.Object<{
-                require_knowledge: DB.MemberDecl<DB.Boolean, false>;
+                requireActiveSelectionOnEntry: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
+                    ArcaneOrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AttireEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Beutelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    BowlEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CauldronEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    ChronicleEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    DaggerRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FoolsHatEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Haubenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Hauerkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    InstrumentEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Keulenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Krallenkettenzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Kristallkugelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    OrbEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    RingEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Schweinetrommelzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SickleRitual: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SpellSwordEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    StaffEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    ToyEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Trinkhornzauber: DB.EnumCase<DB.ReferenceIdentifier>;
+                    WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AdvancedSkillSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    AncestorGlyph: DB.EnumCase<DB.ReferenceIdentifier>;
+                    BlessedTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    BrawlingSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CeremonialItemSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CombatStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    CommandSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FamiliarSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FatePointSexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    FatePointSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    GeneralSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    KarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    LiturgicalStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    LycantropicGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicalSign: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicalTradition: DB.EnumCase<DB.ReferenceIdentifier>;
+                    MagicStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    PactGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                    ProtectiveWardingCircleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Sermon: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SexSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SikaryanDrainSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    SkillStyleSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
+                    VampiricGift: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Vision: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                }, []>>, false>;
                 use_master_of_suffix_as_name: DB.MemberDecl<DB.Boolean, false>;
                 require_minimum_liturgies_on: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"RequiredMinimumSkillsToBeOnSkillRating", DB.Object<{
                     number: DB.MemberDecl<DB.Integer, true>;
@@ -1178,6 +1298,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                     style: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ValueMapStyle", {
                         Compressed: DB.EnumCase<null>;
                         Verbose: DB.EnumCase<null>;
+                        Grouped: DB.EnumCase<null>;
                     }, []>>, true>;
                     translations: DB.MemberDecl<DB.NestedEntityMap<"ValueMapTranslation", {
                         listPrefix: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"ResponsiveTextOptional", DB.Object<{

package/lib/types/AnimalDisease.d.ts

@@ -2,9 +2,12 @@ import * as DB from "tsondb/schema/dsl";
 export declare const AnimalDisease: DB.Entity<"AnimalDisease", {
     level: DB.MemberDecl<DB.Integer, true>;
     resistance: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"Resistance", {
-        Spirit: DB.EnumCase<null>;
-        Toughness: DB.EnumCase<null>;
-        LowerOfSpiritAndToughness: DB.EnumCase<null>;
+        Single: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"SingleResistance", DB.Object<{
+            derivedCharacteristic: DB.MemberDecl<DB.ReferenceIdentifier, true>;
+        }>, []>>>;
+        Minimum: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"MinimumResistance", DB.Object<{
+            derivedCharacteristics: DB.MemberDecl<DB.Array<DB.ReferenceIdentifier>, true>;
+        }>, []>>>;
     }, []>>, true>;
     cause: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.TypeAlias<"Cause", DB.Object<{
         chance: DB.MemberDecl<DB.Integer, false>;