optolith-database-schema 0.28.3 → 0.29.1

package/lib/cache/ancestorBloodAdvantages.d.ts

@@ -0,0 +1,4 @@
+import type { Advantage_ID } from "../../gen/types.js";
+import type { CacheBuilder } from "./internal.ts";
+export type AncestorBloodAdvantagesCache = Advantage_ID[];
+export declare const buildAncestorBloodAdvantagesCache: CacheBuilder<AncestorBloodAdvantagesCache>;

package/lib/cache/ancestorBloodAdvantages.js

@@ -0,0 +1,13 @@
+export const buildAncestorBloodAdvantagesCache = database => database
+    .getAllInstanceContainersOfEntity("Advantage")
+    .filter(({ content }) => content.prerequisites?.some(p => {
+    switch (p.prerequisite.kind) {
+        case "Single":
+            return p.prerequisite.Single.kind === "NoOtherAncestorBloodAdvantage";
+        case "Disjunction":
+            return p.prerequisite.Disjunction.list.some(d => d.kind === "NoOtherAncestorBloodAdvantage");
+        case "Group":
+            return p.prerequisite.Group.list.some(g => g.kind === "NoOtherAncestorBloodAdvantage");
+    }
+}))
+    .map(({ id }) => id);

package/lib/cache/index.d.ts

@@ -0,0 +1,31 @@
+import type { TSONDB } from "tsondb";
+import type { TSONDBTypes } from "../main.ts";
+import { type ActivatableSelectOptionsCache, type ResolvedSelectOption, type ResolvedSelectOptionIdentifier } from "./activatableSelectOptions.ts";
+import { type AncestorBloodAdvantagesCache } from "./ancestorBloodAdvantages.ts";
+import { type MagicalAndBlessedAdvantagesAndDisadvantagesCache } from "./magicalAndBlessedAdvantagesAndDisadvantages.ts";
+import { type NewApplicationsAndUsesCache, type ResolvedNewSkillApplication, type ResolvedSkillUse } from "./newApplicationsAndUses.ts";
+/**
+ * Identifiers of specific entries in the database that are used for creating the cache.
+ */
+export type IdMap = {
+    Advantage: Record<"Blessed" | "Spellcaster", string>;
+    MagicalSpecialAbility: Record<"PropertyKnowledge", string>;
+    KarmaSpecialAbility: Record<"AspectKnowledge", string>;
+};
+/**
+ * The cache object containing all precomputed data.
+ */
+export type Cache = {
+    activatableSelectOptions: ActivatableSelectOptionsCache;
+    sncestorBloodAdvantages: AncestorBloodAdvantagesCache;
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantagesCache;
+    newApplicationsAndUses: NewApplicationsAndUsesCache;
+};
+export type { ActivatableSelectOptionsCache, AncestorBloodAdvantagesCache, MagicalAndBlessedAdvantagesAndDisadvantagesCache, NewApplicationsAndUsesCache, ResolvedNewSkillApplication, ResolvedSelectOption, ResolvedSelectOptionIdentifier, ResolvedSkillUse, };
+/**
+ * Creates the cache by precomputing all necessary data from the database.
+ * @param db The TSONDB instance containing the database.
+ * @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;

package/lib/cache/index.js

@@ -0,0 +1,22 @@
+import { activatableSelectOptionsCacheBuilder, } from "./activatableSelectOptions.js";
+import { buildAncestorBloodAdvantagesCache, } from "./ancestorBloodAdvantages.js";
+import { buildMagicalAndBlessedAdvantagesAndDisadvantagesCache, } from "./magicalAndBlessedAdvantagesAndDisadvantages.js";
+import { buildNewApplicationsAndUsesCache, } from "./newApplicationsAndUses.js";
+/**
+ * Creates the cache by precomputing all necessary data from the database.
+ * @param db The TSONDB instance containing the database.
+ * @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 sncestorBloodAdvantages = buildAncestorBloodAdvantagesCache(db, idMap);
+    const magicalAndBlessedAdvantagesAndDisadvantages = buildMagicalAndBlessedAdvantagesAndDisadvantagesCache(db, idMap);
+    const newApplicationsAndUses = buildNewApplicationsAndUsesCache(db, idMap, activatableSelectOptions);
+    return {
+        activatableSelectOptions,
+        sncestorBloodAdvantages,
+        magicalAndBlessedAdvantagesAndDisadvantages,
+        newApplicationsAndUses,
+    };
+};

package/lib/cache/internal.d.ts

@@ -0,0 +1,4 @@
+import type { TSONDB } from "tsondb";
+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;

package/lib/cache/internal.js

@@ -0,0 +1 @@
+export {};

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.d.ts

@@ -0,0 +1,3 @@
+import type { CacheBuilder } from "./internal.ts";
+export type MagicalAndBlessedAdvantagesAndDisadvantagesCache = Record<"Advantage" | "Disadvantage", Record<"Magical" | "Blessed", string[]>>;
+export declare const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache: CacheBuilder<MagicalAndBlessedAdvantagesAndDisadvantagesCache>;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -0,0 +1,103 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+const getAdvantageId = (idMap, type) => {
+    switch (type) {
+        case "Magical":
+            return idMap.Advantage.Spellcaster;
+        case "Blessed":
+            return idMap.Advantage.Blessed;
+        default:
+            return assertExhaustive(type);
+    }
+};
+const isRatedFor = (type, ratedId) => {
+    switch (ratedId.kind) {
+        case "Spell":
+        case "Ritual":
+            return type === "Magical";
+        case "LiturgicalChant":
+        case "Ceremony":
+            return type === "Blessed";
+        case "Attribute":
+        case "Skill":
+        case "CloseCombatTechnique":
+        case "RangedCombatTechnique":
+            return false;
+        default:
+            return assertExhaustive(ratedId);
+    }
+};
+const isPrerequisiteFor = (idMap, type, prerequisite, getById, traversedIds) => {
+    switch (prerequisite.kind) {
+        case "Activatable": {
+            if (prerequisite.Activatable.id.kind === "Advantage" &&
+                prerequisite.Activatable.id.Advantage === getAdvantageId(idMap, type) &&
+                prerequisite.Activatable.active) {
+                return true;
+            }
+            const entry = getById(prerequisite.Activatable.id);
+            return entry !== undefined && is(idMap, type, entry, getById, traversedIds);
+        }
+        case "Rated":
+            return isRatedFor(type, prerequisite.Rated.id);
+        case "CommonSuggestedByRCP":
+        case "Sex":
+        case "Race":
+        case "Culture":
+        case "Pact":
+        case "SocialStatus":
+        case "State":
+        case "Rule":
+        case "PrimaryAttribute":
+        case "BlessedTradition":
+        case "MagicalTradition":
+        case "RatedMinimumNumber":
+        case "RatedSum":
+        case "Enhancement":
+        case "Text":
+        case "NoOtherAncestorBloodAdvantage":
+        case "SexualCharacteristic":
+            return false;
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+const is = (idMap, type, entry, getById, traversedIds) => {
+    if (!entry.content.prerequisites || traversedIds.includes(entry.id)) {
+        return false;
+    }
+    const newTraversedIds = [...traversedIds, entry.id];
+    return (entry.content.prerequisites !== undefined &&
+        entry.content.prerequisites.some(prerequisite => {
+            switch (prerequisite.prerequisite.kind) {
+                case "Single":
+                    return isPrerequisiteFor(idMap, type, prerequisite.prerequisite.Single, getById, newTraversedIds);
+                case "Disjunction":
+                    return prerequisite.prerequisite.Disjunction.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                case "Group":
+                    return prerequisite.prerequisite.Group.list.some(p => isPrerequisiteFor(idMap, type, p, getById, newTraversedIds));
+                default:
+                    return assertExhaustive(prerequisite.prerequisite);
+            }
+        }));
+};
+const entityKeyMap = {
+    Advantage: null,
+    Disadvantage: null,
+};
+const typeKeyMap = {
+    Magical: null,
+    Blessed: null,
+};
+const collectIds = (entity, type, database, idMap) => database
+    .getAllInstanceContainersOfEntity(entity)
+    .filter(entry => is(idMap, type, entry, database.getInstanceContainerOfEntityById.bind(database), []))
+    .map(({ id }) => id);
+export const buildMagicalAndBlessedAdvantagesAndDisadvantagesCache = (database, idMap) => {
+    return Object.fromEntries(Object.keys(entityKeyMap).map((entity) => [
+        entity,
+        Object.fromEntries(Object.keys(typeKeyMap).map((type) => [
+            type,
+            collectIds(entity, type, database, idMap),
+        ])),
+    ]));
+};

package/lib/cache/newApplicationsAndUses.d.ts

@@ -0,0 +1,22 @@
+import type { ActivatableIdentifier, NewSkillApplication, NewSkillApplicationOrUseParentIdentifier, Skill_ID, SkillUse } from "../../gen/types.js";
+import type { ActivatableSelectOptionsCache } from "./activatableSelectOptions.ts";
+import type { CacheBuilder } from "./internal.ts";
+export type ResolvedNewSkillApplication = {
+    id: string;
+    content: Omit<NewSkillApplication, "parent"> & {
+        parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+    };
+};
+export type ResolvedSkillUse = {
+    id: string;
+    content: Omit<SkillUse, "parent"> & {
+        parent: NewSkillApplicationOrUseParentIdentifier | ActivatableIdentifier;
+    };
+};
+export type NewApplicationsAndUsesCache = {
+    newApplications: Record<Skill_ID, ResolvedNewSkillApplication[]>;
+    uses: Record<Skill_ID, ResolvedSkillUse[]>;
+};
+export declare const buildNewApplicationsAndUsesCache: CacheBuilder<NewApplicationsAndUsesCache, [
+    generatedSelectOptions: ActivatableSelectOptionsCache
+]>;

package/lib/cache/newApplicationsAndUses.js

@@ -0,0 +1,12 @@
+const groupByAffectedSkill = (entries, prev = {}) => entries.reduce((acc, entry) => entry.content.skills.reduce((acc1, skillId) => ({ ...acc1, [skillId]: [...(acc1[skillId] ?? []), entry] }), acc), prev);
+const addGeneratedEntries = (generatedSelectOptions, prev) => Object.values(generatedSelectOptions).reduce((acc, byInstance) => Object.values(byInstance).reduce((acc1, resolvedSelectOptions) => resolvedSelectOptions.reduce((acc2, selectOption) => ({
+    newApplications: groupByAffectedSkill(selectOption.newApplications, acc2.newApplications),
+    uses: groupByAffectedSkill(selectOption.uses, acc2.uses),
+}), acc1), acc), prev);
+export const buildNewApplicationsAndUsesCache = (database, _idMap, generatedSelectOptions) => {
+    const cache = {
+        newApplications: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("NewSkillApplication")),
+        uses: groupByAffectedSkill(database.getAllInstanceContainersOfEntity("SkillUse")),
+    };
+    return addGeneratedEntries(generatedSelectOptions, cache);
+};

package/lib/types/Advantage.d.ts

@@ -46,8 +46,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                 prerequisites: DB.MemberDecl<DB.Array<DB.IncludeIdentifier<[], DB.Enum<"LanguagesSelectOptionCategoryPrerequisite", {
                     SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                         id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -99,6 +97,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                             WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                             WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                         }, []>>, true>;
                         active: DB.MemberDecl<DB.Boolean, true>;
                         level: DB.MemberDecl<DB.Integer, false>;
@@ -134,8 +134,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -187,6 +185,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -220,8 +220,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -273,6 +271,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -293,8 +293,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -346,6 +344,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -366,8 +366,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -419,6 +417,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -439,8 +439,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -492,6 +490,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -529,8 +529,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -582,6 +580,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -602,8 +602,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
                             }>, []>>>;
                             SelectOption: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"OptionPrerequisite", DB.Object<{
                                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -655,6 +653,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                                 }, []>>, true>;
                                 active: DB.MemberDecl<DB.Boolean, true>;
                                 level: DB.MemberDecl<DB.Integer, false>;
@@ -695,8 +695,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
     }>, []>>, false>;
     explicit_select_options: DB.MemberDecl<DB.ChildEntities<DB.Entity<"GeneralSelectOption", {
         parent: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"SelectOptionParentIdentifier", {
-            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
+            TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
             AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
             AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
             AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -748,7 +747,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
             Vision: DB.EnumCase<DB.ReferenceIdentifier>;
             WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
             WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
-            TradeSecret: DB.EnumCase<DB.ReferenceIdentifier>;
+            Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+            Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
         }, []>>, true>;
         profession_only: DB.MemberDecl<DB.Boolean, false>;
         skill_applications: DB.MemberDecl<DB.ChildEntities<DB.Entity<"NewSkillApplication", {
@@ -852,7 +852,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, 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>;
@@ -955,8 +955,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
             }>, []>>>;
             Fixed: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"FixedAutomaticEntryTarget", DB.Object<{
                 id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                     AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1008,6 +1006,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                     Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                     WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                     WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                    Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                 }, []>>, true>;
                 level: DB.MemberDecl<DB.Integer, false>;
             }>, []>>>;
@@ -1060,8 +1060,6 @@ export declare const Advantage: DB.Entity<"Advantage", {
         }>, []>>>;
         DependingOnActive: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActive", DB.Object<{
             id: DB.MemberDecl<DB.IncludeIdentifier<[], DB.Enum<"ActivatableIdentifier", {
-                Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
-                Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedCombatSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedKarmaSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
                 AdvancedMagicalSpecialAbility: DB.EnumCase<DB.ReferenceIdentifier>;
@@ -1113,6 +1111,8 @@ export declare const Advantage: DB.Entity<"Advantage", {
                 Vision: DB.EnumCase<DB.ReferenceIdentifier>;
                 WandEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
                 WeaponEnchantment: DB.EnumCase<DB.ReferenceIdentifier>;
+                Advantage: DB.EnumCase<DB.ReferenceIdentifier>;
+                Disadvantage: DB.EnumCase<DB.ReferenceIdentifier>;
             }, []>>, true>;
             active: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsSingleValue", DB.Integer, []>>, true>;
             inactive: DB.MemberDecl<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsSingleValue", DB.Integer, []>>, true>;
@@ -1123,7 +1123,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                 threshold: DB.MemberDecl<DB.Integer, true>;
                 alternative: DB.MemberDecl<DB.Integer, true>;
             }>, []>>>;
-            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.js").MathOperation>, []>>>;
+            Expression: DB.EnumCase<DB.IncludeIdentifier<[], DB.TypeAlias<"AdventurePointsDependingOnActiveInstancesExpression", DB.IncludeIdentifier<DB.Param<string, DB.Type>[], import("./_MathExpression.ts").MathOperation>, []>>>;
         }, []>>>;
         Indefinite: DB.EnumCase<null>;
     }, []>>, true>;
@@ -1147,7 +1147,7 @@ export declare const Advantage: DB.Entity<"Advantage", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;

package/lib/types/AnimalDisease.d.ts

@@ -41,7 +41,7 @@ export declare const AnimalDisease: DB.Entity<"AnimalDisease", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;

package/lib/types/Blessing.d.ts

@@ -69,7 +69,7 @@ export declare const Blessing: DB.Entity<"Blessing", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;

package/lib/types/Cantrip.d.ts

@@ -97,7 +97,7 @@ export declare const Cantrip: DB.Entity<"Cantrip", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;

package/lib/types/Ceremony.d.ts

@@ -529,7 +529,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;
@@ -643,7 +643,7 @@ export declare const Ceremony: DB.Entity<"Ceremony", {
                         }, []>>, false>;
                     }>, []>>>, true>;
                     isRemoved: DB.MemberDecl<DB.Boolean, false>;
-                }>, []>>, 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>;

package/lib/types/CombatTechnique.d.ts

@@ -53,7 +53,7 @@ export declare const CloseCombatTechnique: DB.Entity<"CloseCombatTechnique", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;
@@ -119,7 +119,7 @@ export declare const RangedCombatTechnique: DB.Entity<"RangedCombatTechnique", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;

package/lib/types/Condition.d.ts

@@ -18,7 +18,7 @@ export declare const Condition: DB.Entity<"Condition", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;

package/lib/types/Culture.d.ts

@@ -86,7 +86,7 @@ export declare const Culture: DB.Entity<"Culture", {
                     }, []>>, false>;
                 }>, []>>>, true>;
                 isRemoved: DB.MemberDecl<DB.Boolean, false>;
-            }>, []>>, 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>;