@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/partial/commonnessRatedAdvantagesAndDisadvantages.js

@@ -0,0 +1,40 @@
+import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { mapNullable } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { ensureNonEmpty } from "@optolith/helpers/array";
+import { parensIf } from "./rated/activatable/parensIf.js";
+import { MISSING_VALUE } from "./unknown.js";
+const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInstanceById, entity, item) => {
+    const instance = getInstanceById(entity, item.id);
+    const instanceTranslation = translateMap(instance?.translations);
+    const customTranslation = translateMap(item.translations);
+    const name = instanceTranslation?.name_in_library ?? instanceTranslation?.name;
+    return name !== undefined &&
+        customTranslation?.options !== undefined &&
+        name.endsWith(")")
+        ? `${name.slice(0, -1)}; ${customTranslation.options})`
+        : (name ?? MISSING_VALUE) + parensIf(customTranslation?.options);
+};
+/**
+ * Render the names of either commonness-rated advantages or commonness-rated disadvantages.
+ */
+export const renderCommonnessRatedAdvantagesOrDisadvantages = (entity, items) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => items === undefined || !isNotEmpty(items)
+    ? translate("none")
+    : items
+        .map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, entity, item))
+        .toSorted(localeCompare)
+        .join(", "));
+/**
+ * Render the names of commonness-rated advantages and disadvantages together.
+ */
+export const renderCommonnessRatedAdvantagesAndDisadvantages = (advantages, disadvantages) => Reader.asks(({ translate, translateMap, getInstanceById, localeCompare }) => mapNullable(ensureNonEmpty([
+    ["Advantage", advantages],
+    ["Disadvantage", disadvantages],
+].flatMap(([entity, items]) => items?.map(item => renderCommonnessRatedAdvantageOrDisadvantageName(translateMap, getInstanceById, entity, item)) ?? [])), renderedItems => renderedItems.toSorted(localeCompare).join(", ")) ?? translate("none"));
+/**
+ * Render a value with a possible translation, falling back to explicity rendering the value if no translation is available.
+ */
+export const renderValueWithPossibleTranslation = (label, value, renderValue, valueTranslation) => Reader.asks(({ translate }) => ({
+    label: translate(label),
+    value: valueTranslation ?? renderValue(value),
+}));

package/lib/entities/partial/dice.d.ts

@@ -0,0 +1,10 @@
+import type { Dice } from "optolith-database-schema/gen";
+import type { Translate } from "../../helpers/translate.js";
+/**
+ * Renders a dice expression like "2D6" into a localized string.
+ */
+export declare const renderDice: (translate: Translate, dice: Dice) => string;
+/**
+ * Renders a dice expression with an additional flat modifier, like "2D6+3" or "2D6-1".
+ */
+export declare const renderDiceAndFlat: (translate: Translate, dice: Dice, flat: number | undefined) => string;

package/lib/entities/partial/dice.js

@@ -0,0 +1,13 @@
+import { additionFormatter, subtractionFormatter } from "./mathOperation.js";
+/**
+ * Renders a dice expression like "2D6" into a localized string.
+ */
+export const renderDice = (translate, dice) => translate("{$count}D{$sides}", { count: dice.number, sides: dice.sides });
+/**
+ * Renders a dice expression with an additional flat modifier, like "2D6+3" or "2D6-1".
+ */
+export const renderDiceAndFlat = (translate, dice, flat) => flat === undefined || flat === 0
+    ? renderDice(translate, dice)
+    : flat > 0
+        ? additionFormatter(renderDice(translate, dice), flat)
+        : subtractionFormatter(renderDice(translate, dice), flat);

package/lib/entities/partial/herbary.d.ts

@@ -0,0 +1,28 @@
+import type { AlternativeName, LaboratoryLevel, Resistance } from "optolith-database-schema/gen";
+import type { GetInstanceById } from "../../helpers/getTypes.js";
+import type { LocaleMap, Translate, TranslateMap } from "../../helpers/translate.js";
+import type { IdMap } from "../../index.js";
+/**
+ * Renders a laboratory level into a localized string.
+ */
+export declare const renderLaboratoryLevel: (translate: Translate, level: LaboratoryLevel) => string;
+/**
+ * Renders a resistance into a localized string.
+ */
+export declare const renderResistance: (translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"DerivedCharacteristic">, idMap: IdMap, resistance: Resistance) => string;
+/**
+ * Renders a chance value into a localized string.
+ */
+export declare const renderChance: (translate: Translate, translateMap: TranslateMap, item: {
+    chance?: number;
+    translations?: LocaleMap<{
+        chance?: string;
+    }>;
+}, includePercentage?: boolean) => string | undefined;
+/**
+ * Renders a list of alternative names into a localized string, or returns undefined if there are no alternative names.
+ */
+export declare const renderAlternativeNames: (translate: Translate, alternativeNames: AlternativeName[] | undefined) => {
+    label: string;
+    value: string;
+} | undefined;

package/lib/entities/partial/herbary.js

@@ -0,0 +1,65 @@
+import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { renderDice } from "./dice.js";
+import { parensIf } from "./rated/activatable/parensIf.js";
+import { MISSING_VALUE } from "./unknown.js";
+/**
+ * Renders a laboratory level into a localized string.
+ */
+export const renderLaboratoryLevel = (translate, level) => {
+    switch (level.kind) {
+        case "ArchaicLaboratory":
+            return translate("Archaic laboratory");
+        case "WitchKitchen":
+            return translate("Witch kitchen");
+        case "AlchemistsLaboratory":
+            return translate("Alchemist’s laboratory");
+        default:
+            return assertExhaustive(level);
+    }
+};
+/**
+ * Renders a resistance into a localized string.
+ */
+export const renderResistance = (translate, translateMap, getInstanceById, idMap, resistance) => {
+    switch (resistance.kind) {
+        case "Spirit":
+            return (translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Spirit)?.translations)?.name ?? MISSING_VALUE);
+        case "Toughness":
+            return (translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Toughness)?.translations)?.name ?? MISSING_VALUE);
+        case "LowerOfSpiritAndToughness": {
+            const spiritTranslation = translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Spirit)?.translations)?.name ?? MISSING_VALUE;
+            const toughnessTranslation = translateMap(getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic.Toughness)?.translations)?.name ?? MISSING_VALUE;
+            return translate("{$first} or {$second}, depending on which value is lower", {
+                first: spiritTranslation,
+                second: toughnessTranslation,
+            });
+        }
+        default:
+            return assertExhaustive(resistance);
+    }
+};
+/**
+ * Renders a chance value into a localized string.
+ */
+export const renderChance = (translate, translateMap, item, includePercentage = false) => translateMap(item.translations)?.chance ??
+    (item.chance === undefined
+        ? undefined
+        : translate("{$valueRange} on {$dice}", {
+            valueRange: item.chance === 5 ? 1 : `1–${item.chance / 5}`,
+            dice: renderDice(translate, { number: 1, sides: 20 }),
+        }) +
+            (includePercentage
+                ? `, ${translate(".input {$value :number} {{{$value}%}}", { value: item.chance })}`
+                : ""));
+/**
+ * Renders a list of alternative names into a localized string, or returns undefined if there are no alternative names.
+ */
+export const renderAlternativeNames = (translate, alternativeNames) => alternativeNames === undefined || !isNotEmpty(alternativeNames)
+    ? undefined
+    : {
+        label: translate(".input {$hiddenCount :number} {{Alternative Names}}", { hiddenCount: alternativeNames.length }),
+        value: alternativeNames
+            .map(name => name.name + parensIf(name.region))
+            .join(", "),
+    };

package/lib/entities/partial/map.d.ts

@@ -0,0 +1,49 @@
+import type { ResponsiveTextOptional } from "optolith-database-schema/gen";
+import type { LocaleMap, Translate, TranslateMap } from "../../helpers/translate.js";
+import { type StdReader } from "./reader.js";
+/**
+ * Renders a map of options to a string.
+ */
+export declare const renderMap: <M extends {
+    options: MO[];
+    translations?: LocaleMap<MT>;
+}, MOT = M extends {
+    options: {
+        translations?: LocaleMap<infer MOT_>;
+    }[];
+} ? MOT_ : never, MT = M extends {
+    translations?: LocaleMap<infer MT_>;
+} ? MT_ : never, MO extends {
+    translations?: LocaleMap<MOT>;
+} = M extends {
+    options: (infer MO_ & {
+        translations?: LocaleMap<MOT>;
+    })[];
+} ? MO_ : never>(translate: Translate, translateMap: TranslateMap, map: M, getValue: (option: MO) => string | number, surroundValues: ((values: string) => string) | undefined, getLabel: (optionTranslation: MOT) => string, getListPrefix: (translation: MT) => string | undefined, getListSuffix: (translation: MT) => string | undefined, getReplacement: (translation: MT) => string | undefined, ...moreToAppend: ({
+    surround: (values: string) => string;
+    getAdditionalValue: (option: MO, optionTranslation: MOT) => string | number;
+} | undefined)[]) => string;
+/**
+ * Renders a map of options to a string.
+ */
+export declare const renderResponsiveMap: <M extends {
+    options: MO[];
+    translations?: LocaleMap<{
+        list_prepend?: ResponsiveTextOptional;
+        listPrefix?: ResponsiveTextOptional;
+        list_append?: ResponsiveTextOptional;
+        listSuffix?: ResponsiveTextOptional;
+        replacement?: ResponsiveTextOptional;
+    }>;
+}, MO extends {
+    translations?: LocaleMap<{
+        label: ResponsiveTextOptional;
+    }>;
+} = M extends {
+    options: (infer MO_)[];
+} ? MO_ : never>(map: M, getValue: (option: MO) => string | number, surroundValues: ((values: string) => string) | undefined, ...moreToAppend: ({
+    surround: (values: string) => string;
+    getAdditionalValue: (option: MO, optionTranslation: {
+        label: ResponsiveTextOptional;
+    }) => string | number;
+} | undefined)[]) => StdReader<string, "t" | "tm" | "rts">;

package/lib/entities/partial/map.js

@@ -0,0 +1,43 @@
+import { mapNullableDefault } from "@elyukai/utils/nullable";
+import { Reader } from "@elyukai/utils/reader";
+import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
+import { getResponsiveTextOptional } from "./responsiveText.js";
+import { MISSING_VALUE } from "./unknown.js";
+/**
+ * Renders a map of options to a string.
+ */
+export const renderMap = (translate, translateMap, map, getValue, surroundValues = values => values, getLabel, getListPrefix, getListSuffix, getReplacement, ...moreToAppend) => {
+    const translation = translateMap(map.translations);
+    if (translation === undefined) {
+        return MISSING_VALUE;
+    }
+    const replacement = getReplacement(translation);
+    if (replacement !== undefined) {
+        return replacement;
+    }
+    return `${surroundValues(map.options.map(option => getValue(option)).join("/"))} ${translate("for")} ${mapNullableDefault(getListPrefix(translation), listPrefix => `${listPrefix} `, "")}${map.options
+        .map(option => {
+        const optionTranslation = translateMap(option.translations);
+        if (optionTranslation === undefined) {
+            return MISSING_VALUE;
+        }
+        return getLabel(optionTranslation);
+    })
+        .join("/")}${mapNullableDefault(getListSuffix(translation), listSuffix => ` ${listSuffix}`, "")}${moreToAppend
+        .filter(isNotNullish)
+        .map(({ surround, getAdditionalValue }) => surround(map.options
+        .map(option => {
+        const optionTranslation = translateMap(option.translations);
+        if (optionTranslation === undefined) {
+            return MISSING_VALUE;
+        }
+        return getAdditionalValue(option, optionTranslation);
+    })
+        .join("/")))
+        .join("")}`;
+};
+/**
+ * Renders a map of options to a string.
+ */
+export const renderResponsiveMap = (map, getValue, surroundValues, ...moreToAppend) => Reader.asks(({ translate, translateMap, responsiveTextSize }) => renderMap(translate, translateMap, map, getValue, surroundValues, translation => getResponsiveTextOptional(translation.label, responsiveTextSize) ??
+    translation.label.full, translation => mapNullable(translation.listPrefix ?? translation.list_prepend, text => getResponsiveTextOptional(text, responsiveTextSize)), translation => mapNullable(translation.listSuffix ?? translation.list_append, text => getResponsiveTextOptional(text, responsiveTextSize)), translation => mapNullable(translation.replacement, text => getResponsiveTextOptional(text, responsiveTextSize)), ...moreToAppend));

package/lib/entities/partial/mathOperation.d.ts

@@ -0,0 +1,36 @@
+import type { MathOperation } from "optolith-database-schema/gen";
+type UnaryFormatter = (value: string | number) => string;
+type BinaryFormatter = (left: string | number, right: string | number) => string;
+/**
+ * Typographic formatter for addition.
+ */
+export declare const additionFormatter: BinaryFormatter;
+/**
+ * Typographic formatter for subtraction.
+ */
+export declare const subtractionFormatter: BinaryFormatter;
+/**
+ * Typographic formatter for multiplication.
+ */
+export declare const multiplicationFormatter: BinaryFormatter;
+/**
+ * Typographic formatter for division.
+ */
+export declare const divisionFormatter: BinaryFormatter;
+/**
+ * Typographic formatter for exponentiation. Uses Markdown syntax.
+ */
+export declare const exponentiationFormatter: BinaryFormatter;
+/**
+ * Typographic formatter for grouping (parentheses).
+ */
+export declare const groupFormatter: UnaryFormatter;
+/**
+ * Render a math operation as a string, using the provided function to render the values.
+ */
+export declare const renderMathOperation: <T>(operation: MathOperation<T>, renderValue: (value: T) => string) => string;
+/**
+ * Evaluate a math operation, using the provided function to evaluate the values.
+ */
+export declare const evaluateMathOperation: <T>(operation: MathOperation<T>, evaluateValue: (value: T) => number) => number;
+export {};

package/lib/entities/partial/mathOperation.js

@@ -0,0 +1,107 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+/**
+ * Typographic formatter for addition.
+ */
+export const additionFormatter = (left, right) => 
+// eslint-disable-next-line no-irregular-whitespace
+`${left} + ${right}`;
+/**
+ * Typographic formatter for subtraction.
+ */
+export const subtractionFormatter = (left, right) => 
+// eslint-disable-next-line no-irregular-whitespace
+`${left} − ${right}`;
+/**
+ * Typographic formatter for multiplication.
+ */
+export const multiplicationFormatter = (left, right) => 
+// eslint-disable-next-line no-irregular-whitespace
+`${left} × ${right}`;
+/**
+ * Typographic formatter for division.
+ */
+export const divisionFormatter = (left, right) => 
+// eslint-disable-next-line no-irregular-whitespace
+`${left} / ${right}`;
+/**
+ * Typographic formatter for exponentiation. Uses Markdown syntax.
+ */
+export const exponentiationFormatter = (left, right) => `${left}^${right}^`;
+/**
+ * Typographic formatter for grouping (parentheses).
+ */
+export const groupFormatter = value => `(${value})`;
+/**
+ * Render a math operation as a string, using the provided function to render the values.
+ */
+export const renderMathOperation = (operation, renderValue) => {
+    const renderWithParenthesis = (op, addParenthesisTo = []) => {
+        const rendered = renderMathOperation(op, renderValue);
+        return addParenthesisTo.includes(op.kind)
+            ? groupFormatter(rendered)
+            : rendered;
+    };
+    const renderBinary = ([left, right], options) => options.formatter(renderWithParenthesis(left, options.addParenthesisTo), renderWithParenthesis(right, options.addParenthesisToRight ?? options.addParenthesisTo));
+    switch (operation.kind) {
+        case "Value":
+            return renderValue(operation.Value);
+        case "Addition":
+            return renderBinary(operation.Addition, { formatter: additionFormatter });
+        case "Subtraction":
+            return renderBinary(operation.Subtraction, {
+                formatter: subtractionFormatter,
+                addParenthesisToRight: ["Addition", "Subtraction"],
+            });
+        case "Multiplication":
+            return renderBinary(operation.Multiplication, {
+                formatter: multiplicationFormatter,
+                addParenthesisTo: ["Addition", "Subtraction"],
+            });
+        case "Division":
+            return renderBinary(operation.Division, {
+                formatter: divisionFormatter,
+                addParenthesisTo: ["Addition", "Subtraction"],
+            });
+        case "Exponentiation":
+            return renderBinary(operation.Exponentiation, {
+                formatter: exponentiationFormatter,
+            });
+        default:
+            return assertExhaustive(operation);
+    }
+};
+/**
+ * Evaluate a math operation, using the provided function to evaluate the values.
+ */
+export const evaluateMathOperation = (operation, evaluateValue) => {
+    switch (operation.kind) {
+        case "Value":
+            return evaluateValue(operation.Value);
+        case "Addition": {
+            const [left, right] = operation.Addition;
+            return (evaluateMathOperation(left, evaluateValue) +
+                evaluateMathOperation(right, evaluateValue));
+        }
+        case "Subtraction": {
+            const [left, right] = operation.Subtraction;
+            return (evaluateMathOperation(left, evaluateValue) -
+                evaluateMathOperation(right, evaluateValue));
+        }
+        case "Multiplication": {
+            const [left, right] = operation.Multiplication;
+            return (evaluateMathOperation(left, evaluateValue) *
+                evaluateMathOperation(right, evaluateValue));
+        }
+        case "Division": {
+            const [left, right] = operation.Division;
+            return (evaluateMathOperation(left, evaluateValue) /
+                evaluateMathOperation(right, evaluateValue));
+        }
+        case "Exponentiation": {
+            const [left, right] = operation.Exponentiation;
+            return Math.pow(evaluateMathOperation(left, evaluateValue), evaluateMathOperation(right, evaluateValue));
+        }
+        default:
+            return assertExhaustive(operation);
+    }
+};

package/lib/entities/partial/prerequisites/displayOption.d.ts

@@ -0,0 +1,7 @@
+import { DisplayOption } from "optolith-database-schema/gen";
+import type { TranslateMap } from "../../../helpers/translate.js";
+import { PrerequisitePart } from "./part.js";
+/**
+ * Get the translation of a display option.
+ */
+export declare const printDisplayOption: (translateMap: TranslateMap, displayOption: DisplayOption) => PrerequisitePart | undefined;

package/lib/entities/partial/prerequisites/displayOption.js

@@ -0,0 +1,19 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { MISSING_VALUE } from "../unknown.js";
+/**
+ * Get the translation of a display option.
+ */
+export const printDisplayOption = (translateMap, displayOption) => {
+    switch (displayOption.kind) {
+        case "Hide":
+            return undefined;
+        case "ReplaceWith":
+            return {
+                value: translateMap(displayOption.ReplaceWith.translations)?.replacement ?? MISSING_VALUE,
+                sentenceType: displayOption.ReplaceWith.sentence_type,
+                isMeta: false,
+            };
+        default:
+            return assertExhaustive(displayOption);
+    }
+};

package/lib/entities/partial/prerequisites/index.d.ts

@@ -0,0 +1,67 @@
+import { AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, PublicationPrerequisites, SpecialAbilityIdentifier, SpellworkPrerequisites, type ActivatableIdentifier, type RatedIdentifier } from "optolith-database-schema/gen";
+import type { GetInstanceById } from "../../../helpers/getTypes.js";
+import { LocaleEnvironment } from "../../../helpers/locale.js";
+import { GetResolvedSelectOptionById } from "./single/activatable.js";
+/**
+ * Print derived characteristic prerequisites as a string.
+ */
+export declare const printDerivedCharacteristicPrerequisites: (locale: LocaleEnvironment, value: DerivedCharacteristicPrerequisites) => string;
+/**
+ * Print publication prerequisites as a string.
+ */
+export declare const printPublicationPrerequisites: (getInstanceById: GetInstanceById<"Publication">, locale: LocaleEnvironment, value: PublicationPrerequisites) => string;
+/**
+ * Print plain general prerequisites as a string.
+ */
+export declare const printPlainGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: PlainGeneralPrerequisites) => string;
+/**
+ * Print general prerequisites as a string.
+ */
+export declare const printGeneralPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
+    id: SpecialAbilityIdentifier;
+    levels: number;
+}) => string;
+/**
+ * Print profession prerequisites as a string.
+ */
+export declare const printProfessionPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: Pick<LocaleEnvironment, "translate" | "translateMap" | "compare" | "join">, value: ProfessionPrerequisites) => string;
+/**
+ * Print advantage disadvantage prerequisites as a string.
+ */
+export declare const printAdvantageDisadvantagePrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PactCategory" | "PactDomain" | "SocialStatus" | "State" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Property" | "Aspect" | "Enhancement">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: AdvantageDisadvantagePrerequisites, name: string, type: "Advantage" | "Disadvantage") => string;
+/**
+ * Print arcane tradition prerequisites as a string.
+ */
+export declare const printArcaneTraditionPrerequisites: (getInstanceById: GetInstanceById<"Culture">, locale: LocaleEnvironment, value: ArcaneTraditionPrerequisites) => string;
+/**
+ * Print personality trait prerequisites as a string.
+ */
+export declare const printPersonalityTraitPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PersonalityTrait">, locale: LocaleEnvironment, value: PersonalityTraitPrerequisites) => string;
+/**
+ * Print spellwork prerequisites as a string.
+ */
+export declare const printSpellworkPrerequisites: (getInstanceById: GetInstanceById<RatedIdentifier["kind"]>, locale: LocaleEnvironment, value: SpellworkPrerequisites) => string;
+/**
+ * Print liturgy prerequisites as a string.
+ */
+export declare const printLiturgyPrerequisites: (locale: LocaleEnvironment, value: LiturgyPrerequisites) => string;
+/**
+ * Print influence prerequisites as a string.
+ */
+export declare const printInfluencePrerequisites: (getInstanceById: GetInstanceById<"Influence">, locale: LocaleEnvironment, value: InfluencePrerequisites) => string;
+/**
+ * Print language prerequisites as a string.
+ */
+export declare const printLanguagePrerequisites: (getInstanceById: GetInstanceById<"Race" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: LanguagePrerequisites) => string;
+/**
+ * Print animist power prerequisites as a string.
+ */
+export declare const printAnimistPowerPrerequisites: (getInstanceById: GetInstanceById<"AnimistPower">, locale: LocaleEnvironment, value: AnimistPowerPrerequisites) => string;
+/**
+ * Print geode ritual prerequisites as a string.
+ */
+export declare const printGeodeRitualPrerequisites: (getInstanceById: GetInstanceById<"Influence">, locale: LocaleEnvironment, value: GeodeRitualPrerequisites) => string;
+/**
+ * Print enhancement prerequisites as a string.
+ */
+export declare const printEnhancementPrerequisites: (getInstanceById: GetInstanceById<RatedIdentifier["kind"] | "Enhancement">, locale: LocaleEnvironment, value: EnhancementPrerequisites) => string;