optolith-database-schema 0.16.3 → 0.16.5

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.16.5](https://github.com/elyukai/optolith-database-schema/compare/v0.16.4...v0.16.5) (2024-02-29)
+
+
+### Features
+
+* add missing activatable and rated identifiers ([a34676b](https://github.com/elyukai/optolith-database-schema/commit/a34676b3c3a7d91621d285447eb913d6888e2c8e))
+* convert many used keys to their english fallback and add some new keys ([ae07fd2](https://github.com/elyukai/optolith-database-schema/commit/ae07fd2b6def34c4a5269202a9ac3a3b8e735b37))
+
+
+### Bug Fixes
+
+* add missing identifier handling to magical and blessed advantages and disadvantages cache ([eba871a](https://github.com/elyukai/optolith-database-schema/commit/eba871a0e7ea803775a30c01e2d2c278bd60856f))
+* applications and uses for select options ([c21b851](https://github.com/elyukai/optolith-database-schema/commit/c21b8512817204129a9213b330abc811b64dad13))
+
+### [0.16.4](https://github.com/elyukai/optolith-database-schema/compare/v0.16.3...v0.16.4) (2024-01-21)
+
+
+### Features
+
+* magical and blessed advantages and disadvantages identifier cache ([4dc6e3d](https://github.com/elyukai/optolith-database-schema/commit/4dc6e3dec721019af728db6b68138498da4b1775))
+
 ### [0.16.3](https://github.com/elyukai/optolith-database-schema/compare/v0.16.2...v0.16.3) (2024-01-18)
 
 

package/lib/cache/activatableSelectOptions.js

@@ -104,6 +104,11 @@ const getApValueForSkillish = (config, id, ic) => {
             return assertExhaustive(config);
     }
 };
+const convertSkillApplicationOrUse = (id, applicationOrUse) => ({
+    id: applicationOrUse.id,
+    skill: { tag: "Single", single: { id } },
+    translations: applicationOrUse.translations,
+});
 const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
     switch (selectOptionCategory.tag) {
         case "Blessings":
@@ -529,16 +534,8 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
                             const id = { tag: "Skill", skill: skill.id };
                             return {
                                 id,
-                                skill_uses: category.skills.skill_uses?.map(use => ({
-                                    id: use.id,
-                                    skill: { tag: "Single", single: { id } },
-                                    translations: use.translations,
-                                })),
-                                skill_applications: category.skills.skill_applications?.map(use => ({
-                                    id: use.id,
-                                    skill: { tag: "Single", single: { id } },
-                                    translations: use.translations,
-                                })),
+                                skill_uses: category.skills.skill_uses?.map(use => convertSkillApplicationOrUse(id, use)),
+                                skill_applications: category.skills.skill_applications?.map(use => convertSkillApplicationOrUse(id, use)),
                                 prerequisites: getSkillishPrerequisites(category.skills.prerequisites, id),
                                 ap_value: getApValueForSkillish(category.skills.ap_value ?? apValueGen, id, skill.improvement_cost),
                                 src: skill.src,
@@ -691,22 +688,36 @@ const getDerivedSelectOptions = (selectOptionCategory, entryId, database) => {
             return assertExhaustive(selectOptionCategory);
     }
 };
+const joinLocaleMaps = (a, b, join) => {
+    const combinedLocaleMap = {};
+    for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+        const newValue = join(a[key], b[key]);
+        if (newValue != null) {
+            combinedLocaleMap[key] = newValue;
+        }
+    }
+    return combinedLocaleMap;
+};
 const getExplicitSelectOptions = (explicitSelectOptions, database) => explicitSelectOptions
     .map((explicitSelectOption) => {
     switch (explicitSelectOption.tag) {
         case "General":
             return {
+                ...explicitSelectOption.general,
                 id: { tag: "General", general: explicitSelectOption.general.id },
-                translations: explicitSelectOption.general.translations,
             };
         case "Skill": {
             const skill = database.skills.find(p => p[0] === explicitSelectOption.skill.id.skill)?.[1];
             if (skill === undefined) {
                 return undefined;
             }
+            const id = { tag: "Skill", skill: explicitSelectOption.skill.id.skill };
             return {
-                id: { tag: "Skill", skill: explicitSelectOption.skill.id.skill },
-                translations: mapObject(skill.translations, t10n => ({ name: t10n.name })),
+                ...explicitSelectOption.skill,
+                id,
+                skill_applications: explicitSelectOption.skill.skill_applications?.map(use => convertSkillApplicationOrUse(id, use)),
+                skill_uses: explicitSelectOption.skill.skill_uses?.map(use => convertSkillApplicationOrUse(id, use)),
+                translations: joinLocaleMaps(explicitSelectOption.skill.translations ?? {}, skill.translations, (explicit, base) => base === undefined ? undefined : { ...explicit, name: base.name }),
             };
         }
         case "CombatTechnique":
@@ -718,10 +729,9 @@ const getExplicitSelectOptions = (explicitSelectOptions, database) => explicitSe
                         return undefined;
                     }
                     return {
+                        ...explicitSelectOption.combat_technique,
                         id: { tag: "CloseCombatTechnique", close_combat_technique: id },
-                        translations: mapObject(closeCombatTechnique.translations, t10n => ({
-                            name: t10n.name,
-                        })),
+                        translations: joinLocaleMaps(explicitSelectOption.combat_technique.translations ?? {}, closeCombatTechnique.translations, (explicit, base) => base === undefined ? undefined : { ...explicit, name: base.name }),
                     };
                 }
                 case "RangedCombatTechnique": {
@@ -731,10 +741,9 @@ const getExplicitSelectOptions = (explicitSelectOptions, database) => explicitSe
                         return undefined;
                     }
                     return {
+                        ...explicitSelectOption.combat_technique,
                         id: { tag: "RangedCombatTechnique", ranged_combat_technique: id },
-                        translations: mapObject(rangedCombatTechnique.translations, t10n => ({
-                            name: t10n.name,
-                        })),
+                        translations: joinLocaleMaps(explicitSelectOption.combat_technique.translations ?? {}, rangedCombatTechnique.translations, (explicit, base) => base === undefined ? undefined : { ...explicit, name: base.name }),
                     };
                 }
                 default:
@@ -857,6 +866,8 @@ const getSelectOptionsForResults = (database, idTag, results) => results.reduce(
                 return { tag: "Krallenkettenzauber", krallenkettenzauber: id };
             case "Trinkhornzauber":
                 return { tag: "Trinkhornzauber", trinkhornzauber: id };
+            case "MagicalSign":
+                return { tag: "MagicalSign", magical_sign: id };
             default:
                 return assertExhaustive(idTag);
         }

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.d.ts

@@ -0,0 +1,20 @@
+import type { CacheConfig } from "../cacheConfig.js";
+export type MagicalAndBlessedAdvantagesAndDisadvantagesCache = {
+    advantages: {
+        magical: {
+            ids: number[];
+        };
+        blessed: {
+            ids: number[];
+        };
+    };
+    disadvantages: {
+        magical: {
+            ids: number[];
+        };
+        blessed: {
+            ids: number[];
+        };
+    };
+};
+export declare const config: CacheConfig<MagicalAndBlessedAdvantagesAndDisadvantagesCache>;

package/lib/cache/magicalAndBlessedAdvantagesAndDisadvantages.js

@@ -0,0 +1,164 @@
+import { assertExhaustive } from "../helpers/typeSafety.js";
+const BLESSED_ID = 12;
+const SPELLCASTER_ID = 47;
+const getAdvantageId = (type) => {
+    switch (type) {
+        case "Magical":
+            return SPELLCASTER_ID;
+        case "Blessed":
+            return BLESSED_ID;
+        default:
+            return assertExhaustive(type);
+    }
+};
+const isRatedFor = (type, ratedId) => {
+    switch (ratedId.tag) {
+        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 = (type, prerequisite, getById, traversedIds) => {
+    switch (prerequisite.tag) {
+        case "Activatable": {
+            if (prerequisite.activatable.id.tag === "Advantage" &&
+                prerequisite.activatable.id.advantage === getAdvantageId(type) &&
+                prerequisite.activatable.active) {
+                return true;
+            }
+            const entry = getById(prerequisite.activatable.id);
+            return entry !== undefined && is(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 "ExternalEnhancement":
+        case "Text":
+        case "NoOtherAncestorBloodAdvantage":
+        case "SexualCharacteristic":
+            return false;
+        default:
+            return assertExhaustive(prerequisite);
+    }
+};
+const is = (type, entry, getById, traversedIds) => {
+    if (!entry.prerequisites || traversedIds.includes(entry.id)) {
+        return false;
+    }
+    const newTraversedIds = [...traversedIds, entry.id];
+    return (entry.prerequisites !== undefined &&
+        entry.prerequisites.some(prerequisite => {
+            switch (prerequisite.prerequisite.tag) {
+                case "Single":
+                    return isPrerequisiteFor(type, prerequisite.prerequisite.single, getById, newTraversedIds);
+                case "Disjunction":
+                    return prerequisite.prerequisite.disjunction.list.some(p => isPrerequisiteFor(type, p, getById, newTraversedIds));
+                case "Group":
+                    return prerequisite.prerequisite.group.list.some(p => isPrerequisiteFor(type, p, getById, newTraversedIds));
+                default:
+                    return assertExhaustive(prerequisite.prerequisite);
+            }
+        }));
+};
+export const config = {
+    builder(database) {
+        const getActivatableById = (id) => {
+            // prettier-ignore
+            switch (id.tag) {
+                case "AdvancedCombatSpecialAbility": return database.advancedCombatSpecialAbilities.find(([entryId]) => entryId === id.advanced_combat_special_ability)?.[1];
+                case "AdvancedKarmaSpecialAbility": return database.advancedKarmaSpecialAbilities.find(([entryId]) => entryId === id.advanced_karma_special_ability)?.[1];
+                case "AdvancedMagicalSpecialAbility": return database.advancedMagicalSpecialAbilities.find(([entryId]) => entryId === id.advanced_magical_special_ability)?.[1];
+                case "AdvancedSkillSpecialAbility": return database.advancedSkillSpecialAbilities.find(([entryId]) => entryId === id.advanced_skill_special_ability)?.[1];
+                case "Advantage": return database.advantages.find(([entryId]) => entryId === id.advantage)?.[1];
+                case "AncestorGlyph": return database.ancestorGlyphs.find(([entryId]) => entryId === id.ancestor_glyph)?.[1];
+                case "ArcaneOrbEnchantment": return database.arcaneOrbEnchantments.find(([entryId]) => entryId === id.arcane_orb_enchantment)?.[1];
+                case "AttireEnchantment": return database.attireEnchantments.find(([entryId]) => entryId === id.attire_enchantment)?.[1];
+                case "BlessedTradition": return database.blessedTraditions.find(([entryId]) => entryId === id.blessed_tradition)?.[1];
+                case "BowlEnchantment": return database.bowlEnchantments.find(([entryId]) => entryId === id.bowl_enchantment)?.[1];
+                case "BrawlingSpecialAbility": return database.brawlingSpecialAbilities.find(([entryId]) => entryId === id.brawling_special_ability)?.[1];
+                case "CauldronEnchantment": return database.cauldronEnchantments.find(([entryId]) => entryId === id.cauldron_enchantment)?.[1];
+                case "CeremonialItemSpecialAbility": return database.ceremonialItemSpecialAbilities.find(([entryId]) => entryId === id.ceremonial_item_special_ability)?.[1];
+                case "ChronicleEnchantment": return database.chronicleEnchantments.find(([entryId]) => entryId === id.chronicle_enchantment)?.[1];
+                case "CombatSpecialAbility": return database.combatSpecialAbilities.find(([entryId]) => entryId === id.combat_special_ability)?.[1];
+                case "CombatStyleSpecialAbility": return database.combatStyleSpecialAbilities.find(([entryId]) => entryId === id.combat_style_special_ability)?.[1];
+                case "CommandSpecialAbility": return database.commandSpecialAbilities.find(([entryId]) => entryId === id.command_special_ability)?.[1];
+                case "DaggerRitual": return database.daggerRituals.find(([entryId]) => entryId === id.dagger_ritual)?.[1];
+                case "Disadvantage": return database.disadvantages.find(([entryId]) => entryId === id.disadvantage)?.[1];
+                case "FamiliarSpecialAbility": return database.familiarSpecialAbilities.find(([entryId]) => entryId === id.familiar_special_ability)?.[1];
+                case "FatePointSexSpecialAbility": return database.fatePointSexSpecialAbilities.find(([entryId]) => entryId === id.fate_point_sex_special_ability)?.[1];
+                case "FatePointSpecialAbility": return database.fatePointSpecialAbilities.find(([entryId]) => entryId === id.fate_point_special_ability)?.[1];
+                case "FoolsHatEnchantment": return database.foolsHatEnchantments.find(([entryId]) => entryId === id.fools_hat_enchantment)?.[1];
+                case "GeneralSpecialAbility": return database.generalSpecialAbilities.find(([entryId]) => entryId === id.general_special_ability)?.[1];
+                case "InstrumentEnchantment": return database.instrumentEnchantments.find(([entryId]) => entryId === id.instrument_enchantment)?.[1];
+                case "KarmaSpecialAbility": return database.karmaSpecialAbilities.find(([entryId]) => entryId === id.karma_special_ability)?.[1];
+                case "Krallenkettenzauber": return database.krallenkettenzauber.find(([entryId]) => entryId === id.krallenkettenzauber)?.[1];
+                case "LiturgicalStyleSpecialAbility": return database.liturgicalStyleSpecialAbilities.find(([entryId]) => entryId === id.liturgical_style_special_ability)?.[1];
+                case "LycantropicGift": return database.lycantropicGifts.find(([entryId]) => entryId === id.lycantropic_gift)?.[1];
+                case "MagicalSign": return database.magicalSigns.find(([entryId]) => entryId === id.magical_sign)?.[1];
+                case "MagicalSpecialAbility": return database.magicalSpecialAbilities.find(([entryId]) => entryId === id.magical_special_ability)?.[1];
+                case "MagicalTradition": return database.magicalTraditions.find(([entryId]) => entryId === id.magical_tradition)?.[1];
+                case "MagicStyleSpecialAbility": return database.magicStyleSpecialAbilities.find(([entryId]) => entryId === id.magic_style_special_ability)?.[1];
+                case "OrbEnchantment": return database.orbEnchantments.find(([entryId]) => entryId === id.orb_enchantment)?.[1];
+                case "PactGift": return database.pactGifts.find(([entryId]) => entryId === id.pact_gift)?.[1];
+                case "ProtectiveWardingCircleSpecialAbility": return database.protectiveWardingCircleSpecialAbilities.find(([entryId]) => entryId === id.protective_warding_circle_special_ability)?.[1];
+                case "RingEnchantment": return database.ringEnchantments.find(([entryId]) => entryId === id.ring_enchantment)?.[1];
+                case "Sermon": return database.sermons.find(([entryId]) => entryId === id.sermon)?.[1];
+                case "SexSpecialAbility": return database.sexSpecialAbilities.find(([entryId]) => entryId === id.sex_special_ability)?.[1];
+                case "SickleRitual": return database.sickleRituals.find(([entryId]) => entryId === id.sickle_ritual)?.[1];
+                case "SikaryanDrainSpecialAbility": return database.sikaryanDrainSpecialAbilities.find(([entryId]) => entryId === id.sikaryan_drain_special_ability)?.[1];
+                case "SkillStyleSpecialAbility": return database.skillStyleSpecialAbilities.find(([entryId]) => entryId === id.skill_style_special_ability)?.[1];
+                case "SpellSwordEnchantment": return database.spellSwordEnchantments.find(([entryId]) => entryId === id.spell_sword_enchantment)?.[1];
+                case "StaffEnchantment": return database.staffEnchantments.find(([entryId]) => entryId === id.staff_enchantment)?.[1];
+                case "ToyEnchantment": return database.toyEnchantments.find(([entryId]) => entryId === id.toy_enchantment)?.[1];
+                case "Trinkhornzauber": return database.trinkhornzauber.find(([entryId]) => entryId === id.trinkhornzauber)?.[1];
+                case "VampiricGift": return database.vampiricGifts.find(([entryId]) => entryId === id.vampiric_gift)?.[1];
+                case "Vision": return database.visions.find(([entryId]) => entryId === id.vision)?.[1];
+                case "WandEnchantment": return database.wandEnchantments.find(([entryId]) => entryId === id.wand_enchantment)?.[1];
+                case "WeaponEnchantment": return database.weaponEnchantments.find(([entryId]) => entryId === id.weapon_enchantment)?.[1];
+                default:
+                    return assertExhaustive(id);
+            }
+        };
+        // prettier-ignore
+        return {
+            advantages: {
+                magical: {
+                    ids: database.advantages.filter(([_, entry]) => is("Magical", entry, getActivatableById, [])).map(([id]) => id),
+                },
+                blessed: {
+                    ids: database.advantages.filter(([_, entry]) => is("Blessed", entry, getActivatableById, [])).map(([id]) => id),
+                },
+            },
+            disadvantages: {
+                magical: {
+                    ids: database.disadvantages.filter(([_, entry]) => is("Magical", entry, getActivatableById, [])).map(([id]) => id),
+                },
+                blessed: {
+                    ids: database.disadvantages.filter(([_, entry]) => is("Blessed", entry, getActivatableById, [])).map(([id]) => id),
+                },
+            },
+        };
+    },
+};

package/lib/config/cache.d.ts

@@ -1,13 +1,16 @@
 import * as ActivatableSelectOptions from "../cache/activatableSelectOptions.js";
 import * as AncestorBloodAdvantages from "../cache/ancestorBloodAdvantages.js";
+import * as MagicalAndBlessedAdvantagesAndDisadvantages from "../cache/magicalAndBlessedAdvantagesAndDisadvantages.js";
 import * as NewApplicationsAndUses from "../cache/newApplicationsAndUses.js";
 export type CacheMap = {
     activatableSelectOptions: ActivatableSelectOptions.ActivatableSelectOptionsCache;
     ancestorBloodAdvantages: AncestorBloodAdvantages.AncestorBloodAdvantagesCache;
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantages.MagicalAndBlessedAdvantagesAndDisadvantagesCache;
     newApplicationsAndUses: NewApplicationsAndUses.NewApplicationsAndUsesCache;
 };
 export declare const cacheMap: {
     activatableSelectOptions: import("../cacheConfig.js").CacheConfig<ActivatableSelectOptions.ActivatableSelectOptionsCache>;
     ancestorBloodAdvantages: import("../cacheConfig.js").CacheConfig<AncestorBloodAdvantages.AncestorBloodAdvantagesCache>;
+    magicalAndBlessedAdvantagesAndDisadvantages: import("../cacheConfig.js").CacheConfig<MagicalAndBlessedAdvantagesAndDisadvantages.MagicalAndBlessedAdvantagesAndDisadvantagesCache>;
     newApplicationsAndUses: import("../cacheConfig.js").CacheConfig<NewApplicationsAndUses.NewApplicationsAndUsesCache, [generatedSelectOptions: ActivatableSelectOptions.ActivatableSelectOptionsCache]>;
 };

package/lib/config/cache.js

@@ -1,8 +1,10 @@
 import * as ActivatableSelectOptions from "../cache/activatableSelectOptions.js";
 import * as AncestorBloodAdvantages from "../cache/ancestorBloodAdvantages.js";
+import * as MagicalAndBlessedAdvantagesAndDisadvantages from "../cache/magicalAndBlessedAdvantagesAndDisadvantages.js";
 import * as NewApplicationsAndUses from "../cache/newApplicationsAndUses.js";
 export const cacheMap = {
     activatableSelectOptions: ActivatableSelectOptions.config,
     ancestorBloodAdvantages: AncestorBloodAdvantages.config,
+    magicalAndBlessedAdvantagesAndDisadvantages: MagicalAndBlessedAdvantagesAndDisadvantages.config,
     newApplicationsAndUses: NewApplicationsAndUses.config,
 };

package/lib/main.js

@@ -78,10 +78,12 @@ export const buildCache = async (cachePaths, validResults, options = {}) => {
     const { pretty = false } = options;
     const activatableSelectOptionsCache = cacheMap.activatableSelectOptions.builder(validResults);
     const ancestorBloodAdvantagesCache = cacheMap.ancestorBloodAdvantages.builder(validResults);
+    const magicalAndBlessedAdvantagesAndDisadvantagesCache = cacheMap.magicalAndBlessedAdvantagesAndDisadvantages.builder(validResults);
     const newApplicationsAndUsesCache = cacheMap.newApplicationsAndUses.builder(validResults, activatableSelectOptionsCache);
     const cacheData = {
         activatableSelectOptions: activatableSelectOptionsCache,
         ancestorBloodAdvantages: ancestorBloodAdvantagesCache,
+        magicalAndBlessedAdvantagesAndDisadvantages: magicalAndBlessedAdvantagesAndDisadvantagesCache,
         newApplicationsAndUses: newApplicationsAndUsesCache,
     };
     for (const [cacheName, cachePath] of Object.entries(cachePaths)) {

package/lib/types/UI.d.ts

@@ -60,7 +60,6 @@ export type UI = {
     "Install Later": NonEmptyString;
     "No update available": NonEmptyString;
     "You're running the latest version available.": NonEmptyString;
-    "initialization.loadtableserror": NonEmptyString;
     "Characters": NonEmptyString;
     "Groups": NonEmptyString;
     "Library": NonEmptyString;
@@ -211,6 +210,9 @@ export type UI = {
      * - `0`: Length in cm
      */
     "general.lengthvalue": NonEmptyString;
+    /**
+     * As in *2D6*.
+     */
     "D": NonEmptyString;
     "general.none": NonEmptyString;
     "general.or": NonEmptyString;
@@ -220,11 +222,6 @@ export type UI = {
     "general.emptylistplaceholder": NonEmptyString;
     "general.emptylistnoresultsplaceholder": NonEmptyString;
     "No Results": NonEmptyString;
-    /**
-     * - `0`: Name of element
-     * - `1`: AP value
-     */
-    "general.withapvalue": NonEmptyString;
     "Search": NonEmptyString;
     "Sort By": NonEmptyString;
     "Name": NonEmptyString;
@@ -235,38 +232,26 @@ export type UI = {
     "general.filters.sort.bycost": NonEmptyString;
     "general.filters.sort.byweight": NonEmptyString;
     "general.filters.showactivatedentries": NonEmptyString;
-    "general.dialogs.savebtn": NonEmptyString;
     "Done": NonEmptyString;
-    "general.dialogs.deletebtn": NonEmptyString;
-    "general.dialogs.yesbtn": NonEmptyString;
-    "general.dialogs.nobtn": NonEmptyString;
-    "general.dialogs.okbtn": NonEmptyString;
+    "OK": NonEmptyString;
     "Cancel": NonEmptyString;
-    "general.dialogs.copybtn": NonEmptyString;
-    "general.dialogs.createbtn": NonEmptyString;
-    "general.dialogs.applybtn": NonEmptyString;
+    "Create": NonEmptyString;
+    "Apply": NonEmptyString;
     "Add": NonEmptyString;
-    "general.dialogs.notenoughap.title": NonEmptyString;
-    /**
-     * - `0`: Missing AP
-     */
-    "general.dialogs.notenoughap.message": NonEmptyString;
-    /**
-     * - `0`: Category in which the limit is reached
-     */
-    "general.dialogs.reachedaplimit.title": NonEmptyString;
-    /**
-     * - `0`: Missing AP
-     * - `1`: Maximum possible AP spent on category
-     * - `2`: Category in which the limit is reached
-     */
-    "general.dialogs.reachedaplimit.message": NonEmptyString;
-    "general.dialogs.reachedaplimit.advantages": NonEmptyString;
-    "general.dialogs.reachedaplimit.magicaladvantages": NonEmptyString;
-    "general.dialogs.reachedaplimit.blessedadvantages": NonEmptyString;
-    "general.dialogs.reachedaplimit.disadvantages": NonEmptyString;
-    "general.dialogs.reachedaplimit.magicaldisadvantages": NonEmptyString;
-    "general.dialogs.reachedaplimit.blesseddisadvantages": NonEmptyString;
+    "Not enough AP": NonEmptyString;
+    "You are missing {0} Adventure Points to do this.": PluralizationCategories;
+    "Exceeding Adventure Points limit for advantages": NonEmptyString;
+    "You cannot spend more than {0} AP on advantages. You would exceed this limit by {1} AP.": NonEmptyString;
+    "Exceeding Adventure Points limit for magical advantages": NonEmptyString;
+    "You cannot spend more than {0} AP on magical advantages. You would exceed this limit by {1} AP.": NonEmptyString;
+    "Exceeding Adventure Points limit for blessed advantages": NonEmptyString;
+    "You cannot spend more than {0} AP on blessed advantages. You would exceed this limit by {1} AP.": NonEmptyString;
+    "Exceeding Adventure Points limit for disadvantages": NonEmptyString;
+    "You cannot receive more than {0} AP from disadvantages. You would exceed this limit by {1} AP.": NonEmptyString;
+    "Exceeding Adventure Points limit for magical disadvantages": NonEmptyString;
+    "You cannot receive more than {0} AP from magical disadvantages. You would exceed this limit by {1} AP.": NonEmptyString;
+    "Exceeding Adventure Points limit for blessed disadvantages": NonEmptyString;
+    "You cannot receive more than {0} AP from blessed disadvantages. You would exceed this limit by {1} AP.": NonEmptyString;
     "heroes.filters.origin.allheroes": NonEmptyString;
     "heroes.filters.origin.ownheroes": NonEmptyString;
     "heroes.filters.origin.sharedheroes": NonEmptyString;
@@ -320,7 +305,6 @@ export type UI = {
     "wiki.filters.specialabilities.all": NonEmptyString;
     "wiki.filters.itemtemplates": NonEmptyString;
     "wiki.filters.itemtemplates.all": NonEmptyString;
-    "imprint.title": NonEmptyString;
     "Edit Name": NonEmptyString;
     "Change Name": NonEmptyString;
     "Edit Profession Name": NonEmptyString;
@@ -356,6 +340,7 @@ export type UI = {
     "Reroll Size": NonEmptyString;
     "Reroll Weight": NonEmptyString;
     "personaldata.cultureareaknowledge": NonEmptyString;
+    "You can save up no more than 10 AP to use later during the game, and you cannot begin the game with a negative AP balance.": NonEmptyString;
     "sheets.printtopdfbtn": NonEmptyString;
     "sheets.dialogs.pdfexportsavelocation.title": NonEmptyString;
     "sheets.dialogs.pdfsaved": NonEmptyString;
@@ -769,55 +754,14 @@ export type UI = {
     "How many points do you want to remove?": NonEmptyString;
     "Remove": NonEmptyString;
     "Permanently Spent": NonEmptyString;
-    "advantages.filters.commonadvantages": NonEmptyString;
-    "disadvantages.filters.commondisadvantages": NonEmptyString;
-    "advantagesdisadvantages.addbtn": NonEmptyString;
-    "advantagesdisadvantages.afraidof": NonEmptyString;
-    "advantagesdisadvantages.immunityto": NonEmptyString;
-    "advantagesdisadvantages.hatredfor": NonEmptyString;
-    "advantagesdisadvantages.header.name": NonEmptyString;
-    "advantagesdisadvantages.header.adventurepoints": NonEmptyString;
-    "advantagesdisadvantages.header.adventurepoints.tooltip": NonEmptyString;
-    /**
-     * - `0`: Current AP spent on advantages
-     * - `1`: Maximum possible AP spent on advantages
-     */
-    "advantagesdisadvantages.apspent.spentonadvantages": NonEmptyString;
-    /**
-     * - `0`: Current AP spent on magic advantages
-     * - `1`: Maximum possible AP spent on magic advantages
-     */
-    "advantagesdisadvantages.apspent.spentonmagicadvantages": NonEmptyString;
-    /**
-     * - `0`: Current AP spent on blessed advantages
-     * - `1`: Maximum possible AP spent on blessed advantages
-     */
-    "advantagesdisadvantages.apspent.spentonblessedadvantages": NonEmptyString;
-    /**
-     * - `0`: Current AP spent on disadvantages
-     * - `1`: Maximum possible AP spent on disadvantages
-     */
-    "advantagesdisadvantages.apspent.spentondisadvantages": NonEmptyString;
-    /**
-     * - `0`: Current AP spent on magic disadvantages
-     * - `1`: Maximum possible AP spent on magic disadvantages
-     */
-    "advantagesdisadvantages.apspent.spentonmagicdisadvantages": NonEmptyString;
-    /**
-     * - `0`: Current AP spent on blessed disadvantages
-     * - `1`: Maximum possible AP spent on blessed disadvantages
-     */
-    "advantagesdisadvantages.apspent.spentonblesseddisadvantages": NonEmptyString;
-    "advantagesdisadvantages.dialogs.customcost.title": NonEmptyString;
+    "Common Advantages": NonEmptyString;
+    "Common Disadvantages": NonEmptyString;
+    "Custom AP Cost": NonEmptyString;
     /**
      * - `0`: Entry name
      */
-    "advantagesdisadvantages.dialogs.customcost.for": NonEmptyString;
-    "specialabilities.addbtn": NonEmptyString;
-    "specialabilities.header.name": NonEmptyString;
-    "specialabilities.header.group": NonEmptyString;
-    "specialabilities.header.adventurepoints": NonEmptyString;
-    "specialabilities.header.adventurepoints.tooltip": NonEmptyString;
+    "AP Cost for {0}": NonEmptyString;
+    "Custom option": NonEmptyString;
     "specialabilities.nativetonguelevel": NonEmptyString;
     "inlinewiki.rule": NonEmptyString;
     "inlinewiki.effect": NonEmptyString;
@@ -860,32 +804,24 @@ export type UI = {
      * - `0`: Minimum social status
      */
     "inlinewiki.socialstatusxorhigher": NonEmptyString;
-    "skills.commonskills": NonEmptyString;
-    "skills.header.name": NonEmptyString;
-    "skills.header.skillrating": NonEmptyString;
-    "skills.header.skillrating.tooltip": NonEmptyString;
-    "skills.header.group": NonEmptyString;
-    "skills.header.check": NonEmptyString;
-    "skills.header.improvementcost": NonEmptyString;
-    "skills.header.improvementcost.tooltip": NonEmptyString;
+    "Common Skills": NonEmptyString;
+    "SR": NonEmptyString;
+    "Skill Rating": NonEmptyString;
+    "IC": NonEmptyString;
     "New Applications": NonEmptyString;
     "Uses": NonEmptyString;
-    "showfrequency.stronglyrecommended": NonEmptyString;
-    "showfrequency.common": NonEmptyString;
-    "showfrequency.uncommon": NonEmptyString;
-    "showfrequency.unfamiliarspells": NonEmptyString;
-    "combattechniques.header.name": NonEmptyString;
-    "combattechniques.header.group": NonEmptyString;
-    "combattechniques.header.combattechniquerating": NonEmptyString;
-    "combattechniques.header.combattechniquerating.tooltip": NonEmptyString;
-    "combattechniques.header.improvementcost": NonEmptyString;
-    "combattechniques.header.improvementcost.tooltip": NonEmptyString;
-    "combattechniques.header.primaryattribute": NonEmptyString;
-    "combattechniques.header.primaryattribute.tooltip": NonEmptyString;
-    "combattechniques.header.attack": NonEmptyString;
-    "combattechniques.header.attack.tooltip": NonEmptyString;
-    "combattechniques.header.parry": NonEmptyString;
-    "combattechniques.header.parry.tooltip": NonEmptyString;
+    "Strongly Recommended": NonEmptyString;
+    "Common": NonEmptyString;
+    "Uncommon": NonEmptyString;
+    "Unfamiliar Spells": NonEmptyString;
+    "CTR": NonEmptyString;
+    "Combat Technique Rating": NonEmptyString;
+    "P": NonEmptyString;
+    "Primary Attribute(s)": NonEmptyString;
+    "AT": NonEmptyString;
+    "Attack": NonEmptyString;
+    "PA": NonEmptyString;
+    "Parry": NonEmptyString;
     "Close Combat": NonEmptyString;
     "Ranged Combat": NonEmptyString;
     "inlinewiki.special": NonEmptyString;
@@ -901,18 +837,8 @@ export type UI = {
     "Animist Powers": NonEmptyString;
     "Geode Rituals": NonEmptyString;
     "Zibilja Rituals": NonEmptyString;
-    "spells.addbtn": NonEmptyString;
-    "spells.header.name": NonEmptyString;
-    "spells.header.property": NonEmptyString;
-    "spells.header.group": NonEmptyString;
-    "spells.header.skillrating": NonEmptyString;
-    "spells.header.skillrating.tooltip": NonEmptyString;
-    "spells.header.check": NonEmptyString;
-    "spells.header.checkmodifier": NonEmptyString;
-    "spells.header.checkmodifier.tooltip": NonEmptyString;
-    "spells.header.improvementcost": NonEmptyString;
-    "spells.header.improvementcost.tooltip": NonEmptyString;
-    "spells.groups.cantrip": NonEmptyString;
+    "Mod": NonEmptyString;
+    "Check Modifier": NonEmptyString;
     "spells.traditions.general": NonEmptyString;
     "magicalactions.animistforces.tribes.general": NonEmptyString;
     "inlinewiki.castingtime": NonEmptyString;

package/lib/types/_Identifier.d.ts

@@ -547,6 +547,24 @@ export type TrinkhornzauberIdentifier = {
      */
     trinkhornzauber: number;
 };
+export type MagicalRuneIdentifier = {
+    tag: "MagicalRune";
+    /**
+     * The magical rune’s identifier.
+     * @integer
+     * @minimum 1
+     */
+    magical_rune: number;
+};
+export type MagicalSignIdentifier = {
+    tag: "MagicalSign";
+    /**
+     * The magical sign’s identifier.
+     * @integer
+     * @minimum 1
+     */
+    magical_sign: number;
+};
 export type LanguageIdentifier = {
     tag: "Language";
     /**