@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/race.js

@@ -0,0 +1,146 @@
+import { anySameIndices } from "@elyukai/utils/array/filters";
+import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { deepEqual } from "@elyukai/utils/equality";
+import { on } from "@elyukai/utils/function";
+import { isNotNullish } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { sign } from "@elyukai/utils/string/number";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderCommonnessRatedAdvantagesAndDisadvantages, renderCommonnessRatedAdvantagesOrDisadvantages, renderValueWithPossibleTranslation, } from "./partial/commonnessRatedAdvantagesAndDisadvantages.js";
+import { MISSING_VALUE } from "./partial/unknown.js";
+const renderBaseValueItem = (label, value) => Reader.asks(({ translate }) => ({
+    label: translate(label),
+    value: value < 0 ? sign(value) : value.toString(),
+}));
+const renderAttributeAdjustmentsItem = (totalAttributesCount, adjustments) => Reader.asks(({ translate, translateMap, localeJoin, getInstanceById, }) => {
+    const getAttributeAbbreviation = (id) => translateMap(getInstanceById("Attribute", id)?.translations)
+        ?.abbreviation ?? MISSING_VALUE;
+    return {
+        label: translate("Attribute Adjustments"),
+        value: [
+            ...(adjustments.fixed?.map(adj => `${getAttributeAbbreviation(adj.id)} ${sign(adj.value)}`) ?? []),
+            ...(adjustments.selectable?.map(adj => `${adj.list.length === totalAttributesCount ? translate("one attribute of your choice") : localeJoin(adj.list.map(getAttributeAbbreviation), "disjunction")} ${sign(adj.value)}`) ?? []),
+        ].join("; "),
+    };
+});
+const renderVariantValues = (label, variants, selector, renderValue, translationSelector) => Reader.asks(({ translate, translateMap, localeCompare, localeJoin, }) => {
+    const values = variants.map(variant => {
+        const translation = translateMap(variant.translations);
+        return {
+            name: translation?.name ?? MISSING_VALUE,
+            value: selector(variant),
+            valueTranslation: translationSelector && translation !== undefined
+                ? translationSelector(translation)
+                : undefined,
+        };
+    });
+    const sameValues = anySameIndices(values, on(value => [value.value, value.valueTranslation], deepEqual));
+    if (sameValues.length === 1 && sameValues[0].length === values.length) {
+        return {
+            label: translate(label),
+            value: values[0] === undefined
+                ? MISSING_VALUE
+                : (values[0].valueTranslation ?? renderValue(values[0].value)),
+        };
+    }
+    else {
+        return {
+            label: translate(label),
+            value: [
+                {
+                    type: "definitionList",
+                    style: "nested",
+                    items: Map.groupBy(values
+                        .toSorted(on(item => item.name, localeCompare))
+                        .map(value => ({
+                        label: value.name,
+                        value: value.valueTranslation ?? renderValue(value.value),
+                    })), item => item.value)
+                        .entries()
+                        .map(([value, items]) => ({
+                        label: localeJoin(items.map(item => item.label), "conjunction"),
+                        value,
+                    }))
+                        .toArray(),
+                },
+            ],
+        };
+    }
+});
+const renderAutomaticAdvantagesOrDisadvantages = (entity, items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
+    ? translate("none")
+    : items
+        .map(item => {
+        const instanceTranslation = translateMap(getInstanceById(entity, item.id)?.translations);
+        return (instanceTranslation?.name_in_library ??
+            instanceTranslation?.name ??
+            MISSING_VALUE);
+    })
+        .toSorted(localeCompare)
+        .join(", "));
+const renderCommonCultures = (items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
+    ? translate("none")
+    : items
+        .map(itemId => translateMap(getInstanceById("Culture", itemId)?.translations)
+        ?.name)
+        .filter(isNotNullish)
+        .toSorted(localeCompare)
+        .join(", "));
+/**
+ * Get a JSON representation of the rules text for a race.
+ */
+export const getRaceEntityDescription = createEntityDescriptionCreator(({ getInstanceById, countInstances, getChildInstancesForInstanceId }, { translate, translateMap, join: localeJoin, compare: localeCompare }, { id, content: entry }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const totalAttributesCount = countInstances("Attribute");
+    const raceVariants = getChildInstancesForInstanceId("RaceVariant", id).map(variant => variant.content);
+    const env = {
+        translate,
+        translateMap,
+        localeJoin,
+        localeCompare,
+        getInstanceById,
+    };
+    return {
+        title: translation.name,
+        className: "race",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("AP Value"),
+                        value: translate(".input {$value :number} {{{$value} Adventure Points}}", { value: entry.ap_value }),
+                    },
+                    renderBaseValueItem("Life Point Base Value", entry.base_values.life_points).run(env),
+                    renderBaseValueItem("Spirit Base Value", entry.base_values.spirit).run(env),
+                    renderBaseValueItem("Toughness Base Value", entry.base_values.toughness).run(env),
+                    renderBaseValueItem("Movement Base Value", entry.base_values.movement).run(env),
+                    renderAttributeAdjustmentsItem(totalAttributesCount, entry.attribute_adjustments).run(env),
+                    renderVariantValues("Common Cultures", raceVariants, v => v.common_cultures, cultures => renderCommonCultures(cultures).run(env)).run(env),
+                    entry.automatic_advantages === undefined
+                        ? undefined
+                        : renderValueWithPossibleTranslation("Automatic Advantages", entry.automatic_advantages, v => renderAutomaticAdvantagesOrDisadvantages("Advantage", v).run(env), translation.automatic_advantages).run(env),
+                    entry.automatic_disadvantages === undefined
+                        ? undefined
+                        : renderValueWithPossibleTranslation("Automatic Disadvantages", entry.automatic_disadvantages, v => renderAutomaticAdvantagesOrDisadvantages("Disadvantage", v).run(env), translation.automatic_disadvantages).run(env),
+                    entry.strongly_recommended_advantages === undefined &&
+                        entry.strongly_recommended_disadvantages === undefined
+                        ? undefined
+                        : {
+                            label: translate("Strongly recommended Advantages and Disadvantages"),
+                            value: `${translate("The following advantages and disadvantages distinguish Aventurian {$race}. You should choose these advantages and disadvantages. If you don’t want to take them, talk to your GM.", { race: translation.name })} ${renderCommonnessRatedAdvantagesAndDisadvantages(entry.strongly_recommended_advantages, entry.strongly_recommended_disadvantages).run(env)}`,
+                        },
+                    renderVariantValues("Common Advantages", raceVariants, v => v.common_advantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.common_advantages).run(env),
+                    renderVariantValues("Common Disadvantages", raceVariants, v => v.common_disadvantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.common_disadvantages).run(env),
+                    renderVariantValues("Uncommon Advantages", raceVariants, v => v.uncommon_advantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Advantage", advs).run(env), vt => vt.uncommon_advantages).run(env),
+                    renderVariantValues("Uncommon Disadvantages", raceVariants, v => v.uncommon_disadvantages, advs => renderCommonnessRatedAdvantagesOrDisadvantages("Disadvantage", advs).run(env), vt => vt.uncommon_disadvantages).run(env),
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/sexPractice.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Get a JSON representation of the rules text for a sex practice.
+ */
+export declare const getSexPracticeEntityDescription: import("../creator.js").EntityDescriptionCreator<"SexPractice", {
+    getInstanceById: import("../helpers/getTypes.js").GetInstanceById<"Publication">;
+}, import("../index.js").EntityDescription>;

package/lib/entities/sexPractice.js

@@ -0,0 +1,33 @@
+import { createEntityDescriptionCreator } from "../creator.js";
+/**
+ * Get a JSON representation of the rules text for a sex practice.
+ */
+export const getSexPracticeEntityDescription = createEntityDescriptionCreator((_, { translate, translateMap }, { content: entry }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: translation.name,
+        className: "sex-practice",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    { label: translate("Rules"), value: translation.rules },
+                    { label: translate("Duration"), value: translation.duration },
+                    translation.prerequisites === undefined
+                        ? undefined
+                        : {
+                            label: translate("Prerequisites"),
+                            value: translation.prerequisites,
+                        },
+                    translation.failed === undefined
+                        ? undefined
+                        : { label: translate("Failed"), value: translation.failed },
+                ],
+            },
+        ],
+        references: entry.src,
+    };
+});

package/lib/entities/skill.d.ts

@@ -1,13 +1,13 @@
-import { NewApplicationsAndUsesCache } from "optolith-database-schema/cache/newApplicationsAndUses";
-import { Skill } from "optolith-database-schema/types/Skill";
-import { All, GetById } from "../helpers/getTypes.js";
+import type { ActivatableIdentifier } from "optolith-database-schema/gen";
+import type { GetAllChildInstancesForParent, GetAllInstances, GetInstanceById } from "../helpers/getTypes.js";
+import type { GetAllResolvedNewSkillApplications, GetAllResolvedSkillUses } from "../index.js";
 /**
  * Get a JSON representation of the rules text for a skill.
  */
-export declare const getSkillEntityDescription: import("../index.js").EntityDescriptionCreator<Skill | undefined, {
-    getAttributeById: GetById.Static.Attribute;
-    blessedTraditions: All.Static.BlessedTraditions;
-    diseases: All.Static.Diseases;
-    regions: All.Static.Regions;
-    cache: NewApplicationsAndUsesCache;
+export declare const getSkillEntityDescription: import("../creator.js").EntityDescriptionCreator<"Skill", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | ActivatableIdentifier["kind"] | "Aspect">;
+    getAllInstances: GetAllInstances<"BlessedTradition" | "Disease" | "Region" | "SkillUse" | "NewSkillApplication">;
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<"SkillApplication">;
+    getAllResolvedNewSkillApplications: GetAllResolvedNewSkillApplications;
+    getAllResolvedSkillUses: GetAllResolvedSkillUses;
 }, import("../index.js").EntityDescription>;

package/lib/entities/skill.js

@@ -1,109 +1,142 @@
 import { isNotNullish } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { createEntityDescriptionCreator } from "../index.js";
-import { createImprovementCost } from "./partial/rated/improvementCost.js";
-import { getTextForCheck } from "./partial/rated/skillCheck.js";
+import { fromUniformCase } from "tsondb/schema/gen";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderImprovementCost } from "./partial/rated/improvementCost.js";
+import { renderSkillCheck } from "./partial/rated/skillCheck.js";
+const getUsesOrNewApplications = (getInstanceById, locale, items) => items
+    .map(x => {
+    const name = locale.translateMap(x.content.translations)?.name;
+    if (name !== undefined) {
+        return name;
+    }
+    const { parent: parentId } = x.content;
+    if (parentId.kind === "GeneralSelectOption") {
+        return undefined;
+    }
+    return locale.translateMap(getInstanceById(parentId.kind, fromUniformCase(parentId))?.translations)?.name;
+    // if (parentTranslations === undefined) {
+    //   return undefined
+    // }
+    // return printActivatableNameChunk(
+    //   locale,
+    //   getNameComponents<BaseSpecialAbilityTranslation>(
+    //     getInstanceById,
+    //     locale,
+    //     parentId,
+    //     undefined,
+    //     undefined,
+    //     parentTranslations,
+    //     translation => translation.name,
+    //     id => getResolvedSelectOptionById(parentId, id),
+    //     false,
+    //   ).full,
+    // )
+})
+    .filter(isNotNullish)
+    .sort(locale.compare);
 /**
  * Get a JSON representation of the rules text for a skill.
  */
-export const getSkillEntityDescription = createEntityDescriptionCreator(({ getAttributeById, blessedTraditions, diseases, regions, cache }, { translate, translateMap, compare: localeCompare }, entry) => {
+export const getSkillEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getAllInstances, getChildInstancesForInstanceId, getAllResolvedNewSkillApplications, getAllResolvedSkillUses, }, locale, { content: entry, id }) => {
+    const { translate, translateMap, compare: localeCompare } = locale;
     const translation = translateMap(entry.translations);
     if (translation === undefined) {
         return undefined;
     }
-    const newApplications = (entry === undefined ? [] : cache.newApplications[entry.id] ?? [])
-        .map((x) => translateMap(x.data.translations)?.name)
-        .filter(isNotNullish)
-        .sort(localeCompare);
-    const uses = (entry === undefined ? [] : cache.uses[entry.id] ?? [])
-        .map((x) => translateMap(x.data.translations)?.name)
-        .filter(isNotNullish)
-        .sort(localeCompare);
-    const applications = (() => {
-        switch (entry.applications.tag) {
-            case "Derived":
-                return (() => {
-                    switch (entry.applications.derived) {
-                        case "BlessedTraditions":
-                            return Object.values(blessedTraditions)
-                                .map((x) => translateMap(x.translations)?.name)
-                                .filter(isNotNullish)
-                                .sort(localeCompare);
-                        case "Diseases":
-                            return Object.values(diseases)
-                                .map((x) => translateMap(x.translations)?.name)
-                                .filter(isNotNullish)
-                                .sort(localeCompare);
-                        case "Regions":
-                            return Object.values(regions)
-                                .map((x) => translateMap(x.translations)?.name)
-                                .filter(isNotNullish)
-                                .sort(localeCompare);
-                        default:
-                            return assertExhaustive(entry.applications.derived);
-                    }
-                })();
-            case "Explicit":
-                return entry.applications.explicit
-                    .map((x) => translateMap(x.translations)?.name)
-                    .filter(isNotNullish)
-                    .sort(localeCompare);
-            default:
-                return assertExhaustive(entry.applications);
-        }
-    })();
+    const newApplications = getUsesOrNewApplications(getInstanceById, locale, getAllResolvedNewSkillApplications(id));
+    const uses = getUsesOrNewApplications(getInstanceById, locale, getAllResolvedSkillUses(id));
+    const applications = [
+        ...getChildInstancesForInstanceId("SkillApplication", id)
+            .map(x => translateMap(x.content.translations)?.name)
+            .filter(isNotNullish)
+            .sort(localeCompare),
+        ...(() => {
+            switch (entry.applications.derived?.kind) {
+                case "BlessedTraditions":
+                    return getAllInstances("BlessedTradition")
+                        .map(x => translateMap(x.content.translations)?.name)
+                        .filter(isNotNullish)
+                        .sort(localeCompare);
+                case "Diseases":
+                    return getAllInstances("Disease")
+                        .map(x => translateMap(x.content.translations)?.name)
+                        .filter(isNotNullish)
+                        .sort(localeCompare);
+                case "Regions":
+                    return getAllInstances("Region")
+                        .map(x => translateMap(x.content.translations)?.name)
+                        .filter(isNotNullish)
+                        .sort(localeCompare);
+                case undefined:
+                    return [];
+                default:
+                    return assertExhaustive(entry.applications.derived);
+            }
+        })(),
+    ];
     return {
         title: translation.name,
         className: "skill",
         body: [
-            newApplications.length === 0
-                ? undefined
-                : {
-                    label: translate("New Applications"),
-                    value: newApplications.join(", "),
-                },
-            uses.length === 0
-                ? undefined
-                : {
-                    label: translate("Uses"),
-                    value: uses.join(", "),
-                },
-            getTextForCheck({ translate, translateMap, getAttributeById }, entry.check),
-            {
-                label: translate("Applications"),
-                value: applications.join(", "),
-            },
-            {
-                label: translate("Encumbrance"),
-                value: entry.encumbrance === "True"
-                    ? translate("Yes")
-                    : entry.encumbrance === "False"
-                        ? translate("No")
-                        : translation.encumbrance_description ?? translate("Maybe"),
-            },
-            translation?.tools === undefined
-                ? undefined
-                : {
-                    label: translate("Tools"),
-                    value: translation.tools,
-                },
-            {
-                label: translate("Quality"),
-                value: translation.quality,
-            },
-            {
-                label: translate("Failed Check"),
-                value: translation.failed,
-            },
-            {
-                label: translate("Critical Success"),
-                value: translation.critical,
-            },
             {
-                label: translate("Botch"),
-                value: translation.botch,
+                type: "definitionList",
+                items: [
+                    newApplications.length === 0
+                        ? undefined
+                        : {
+                            label: translate("New Applications"),
+                            value: newApplications.join(", "),
+                        },
+                    uses.length === 0
+                        ? undefined
+                        : {
+                            label: translate("Uses"),
+                            value: uses.join(", "),
+                        },
+                    renderSkillCheck(entry.check).run({
+                        translate,
+                        translateMap,
+                        getInstanceById,
+                    }),
+                    {
+                        label: translate("Applications"),
+                        value: applications.join(", "),
+                    },
+                    {
+                        label: translate("Encumbrance"),
+                        value: entry.encumbrance.kind === "Yes"
+                            ? translate("Yes")
+                            : entry.encumbrance.kind === "No"
+                                ? translate("No")
+                                : (translation.encumbrance_description ??
+                                    translate("Maybe")),
+                    },
+                    translation?.tools === undefined
+                        ? undefined
+                        : {
+                            label: translate("Tools"),
+                            value: translation.tools,
+                        },
+                    {
+                        label: translate("Quality"),
+                        value: translation.quality,
+                    },
+                    {
+                        label: translate("Failed Check"),
+                        value: translation.failed,
+                    },
+                    {
+                        label: translate("Critical Success"),
+                        value: translation.critical,
+                    },
+                    {
+                        label: translate("Botch"),
+                        value: translation.botch,
+                    },
+                    renderImprovementCost(entry.improvement_cost).run({ translate }),
+                ],
             },
-            createImprovementCost(translate, entry.improvement_cost),
         ],
     };
 });

package/lib/entities/spell.d.ts

@@ -1,38 +1,95 @@
-import { Cantrip } from "optolith-database-schema/types/Cantrip";
-import { DerivedCharacteristic } from "optolith-database-schema/types/DerivedCharacteristic";
-import { Ritual } from "optolith-database-schema/types/Ritual";
-import { Spell } from "optolith-database-schema/types/Spell";
-import { GetById } from "../helpers/getTypes.js";
+import type { GetAllChildInstancesForParent, GetInstanceById } from "../helpers/getTypes.js";
+import { type IdMap } from "../index.js";
 /**
  * Get a JSON representation of the rules text for a cantrip.
  */
-export declare const getCantripEntityDescription: import("../index.js").EntityDescriptionCreator<Cantrip | undefined, {
-    getTargetCategoryById: GetById.Static.TargetCategory;
-    getPropertyById: GetById.Static.Property;
-    getMagicalTraditionById: GetById.Static.MagicalTradition;
-    getCurriculumById: GetById.Static.Curriculum;
+export declare const getCantripEntityDescription: import("../creator.js").EntityDescriptionCreator<"Cantrip", {
+    getInstanceById: GetInstanceById<"Publication" | "TargetCategory" | "Property" | "MagicalTradition" | "Curriculum">;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a skill.
  */
-export declare const getSpellEntityDescription: import("../index.js").EntityDescriptionCreator<Spell | undefined, {
-    getAttributeById: GetById.Static.Attribute;
-    getSpirit: () => DerivedCharacteristic | undefined;
-    getToughness: () => DerivedCharacteristic | undefined;
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    getTargetCategoryById: GetById.Static.TargetCategory;
-    getPropertyById: GetById.Static.Property;
-    getMagicalTraditionById: GetById.Static.MagicalTradition;
+export declare const getSpellEntityDescription: import("../creator.js").EntityDescriptionCreator<"Spell", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic">;
+    idMap: IdMap;
 }, import("../index.js").EntityDescription>;
 /**
  * Get a JSON representation of the rules text for a ritual.
  */
-export declare const getRitualEntityDescription: import("../index.js").EntityDescriptionCreator<Ritual | undefined, {
-    getAttributeById: GetById.Static.Attribute;
-    getSpirit: () => DerivedCharacteristic | undefined;
-    getToughness: () => DerivedCharacteristic | undefined;
-    getSkillModificationLevelById: GetById.Static.SkillModificationLevel;
-    getTargetCategoryById: GetById.Static.TargetCategory;
-    getPropertyById: GetById.Static.Property;
-    getMagicalTraditionById: GetById.Static.MagicalTradition;
+export declare const getRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"Ritual", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a curse.
+ */
+export declare const getCurseEntityDescription: import("../creator.js").EntityDescriptionCreator<"Curse", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for an Elven magical song.
+ */
+export declare const getElvenMagicalSongEntityDescription: import("../creator.js").EntityDescriptionCreator<"ElvenMagicalSong", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic" | "Skill">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a domination ritual.
+ */
+export declare const getDominationRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"DominationRitual", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic" | "SkillModificationLevel">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a magical dance.
+ */
+export declare const getMagicalDanceEntityDescription: import("../creator.js").EntityDescriptionCreator<"MagicalDance", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic" | "ArcaneBardTradition" | "ArcaneDancerTradition">;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a magical melody.
+ */
+export declare const getMagicalMelodyEntityDescription: import("../creator.js").EntityDescriptionCreator<"MagicalMelody", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic" | "Skill" | "ArcaneBardTradition" | "ArcaneDancerTradition">;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a familiar’s trick.
+ */
+export declare const getFamiliarsTrickEntityDescription: import("../creator.js").EntityDescriptionCreator<"FamiliarsTrick", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic" | "AnimalType">;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a animist power.
+ */
+export declare const getAnimistPowerEntityDescription: import("../creator.js").EntityDescriptionCreator<"AnimistPower", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | "AnimistPower" | "Tribe">;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a Goede ritual.
+ */
+export declare const getGeodeRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"GeodeRitual", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic" | "Influence">;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a jester trick.
+ */
+export declare const getJesterTrickEntityDescription: import("../creator.js").EntityDescriptionCreator<"JesterTrick", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a Zibilja ritual.
+ */
+export declare const getZibiljaRitualEntityDescription: import("../creator.js").EntityDescriptionCreator<"ZibiljaRitual", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "SkillModificationLevel" | "TargetCategory" | "Property" | "MagicalTradition" | "DerivedCharacteristic">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;
+/**
+ * Get a JSON representation of the rules text for a magical rune.
+ */
+export declare const getMagicalRuneEntityDescription: import("../creator.js").EntityDescriptionCreator<"MagicalRune", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Property" | "DerivedCharacteristic" | "Skill">;
+    getChildInstancesForInstanceId: GetAllChildInstancesForParent<"MagicalRuneOption">;
+    idMap: IdMap;
 }, import("../index.js").EntityDescription>;