@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/partial/prerequisites/single/ratedSum.js

@@ -0,0 +1,21 @@
+import { isNotNullish } from "@optolith/helpers/nullable";
+import { printDisplayOption } from "../displayOption.js";
+/**
+ * Get the translation of a rated sum prerequisite.
+ */
+export const printRatedSumPrerequisite = (getInstanceById, locale, prerequisite) => {
+    if (prerequisite.display_option !== undefined) {
+        return printDisplayOption(locale.translateMap, prerequisite.display_option);
+    }
+    const skills = prerequisite.targets
+        .map(skillId => locale.translateMap(getInstanceById("Skill", skillId)?.translations)?.name)
+        .filter(isNotNullish);
+    return {
+        value: locale.translate("the SR for {$skill} combined must add up to at least {$minRating}", {
+            skill: locale.join(skills, "conjunction"),
+            minRating: prerequisite.sum,
+        }),
+        sentenceType: undefined,
+        isMeta: false,
+    };
+};

package/lib/entities/partial/prerequisites/single/rule.d.ts

@@ -0,0 +1,7 @@
+import { RulePrerequisite } from "optolith-database-schema/gen";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { PrerequisitePart } from "../part.js";
+/**
+ * Get the translation of a rule prerequisite.
+ */
+export declare const printRulePrerequisite: (_locale: LocaleEnvironment, _prerequisite: RulePrerequisite) => PrerequisitePart | undefined;

package/lib/entities/partial/prerequisites/single/rule.js

@@ -0,0 +1,4 @@
+/**
+ * Get the translation of a rule prerequisite.
+ */
+export const printRulePrerequisite = (_locale, _prerequisite) => undefined;

package/lib/entities/partial/prerequisites/single/sex.d.ts

@@ -0,0 +1,7 @@
+import type { SexPrerequisite } from "optolith-database-schema/gen";
+import type { Translate } from "../../../../helpers/translate.js";
+import { PrerequisitePart } from "../part.js";
+/**
+ * Get the translation of a (binary) sex prerequisite.
+ */
+export declare const printBinarySexPrerequisite: (translate: Translate, prerequisite: SexPrerequisite) => PrerequisitePart | undefined;

package/lib/entities/partial/prerequisites/single/sex.js

@@ -0,0 +1,19 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+const printId = (translate, id) => {
+    switch (id.kind) {
+        case "Male":
+            return translate("Male");
+        case "Female":
+            return translate("Female");
+        default:
+            return assertExhaustive(id);
+    }
+};
+/**
+ * Get the translation of a (binary) sex prerequisite.
+ */
+export const printBinarySexPrerequisite = (translate, prerequisite) => ({
+    value: printId(translate, prerequisite.id),
+    sentenceType: undefined,
+    isMeta: false,
+});

package/lib/entities/partial/prerequisites/single/sexualCharacteristic.d.ts

@@ -0,0 +1,7 @@
+import { SexualCharacteristicPrerequisite } from "optolith-database-schema/gen";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { PrerequisitePart } from "../part.js";
+/**
+ * Get the translation of a sexual characteristic prerequisite.
+ */
+export declare const printSexualCharacteristicPrerequisite: (locale: LocaleEnvironment, prerequisite: SexualCharacteristicPrerequisite) => PrerequisitePart | undefined;

package/lib/entities/partial/prerequisites/single/sexualCharacteristic.js

@@ -0,0 +1,21 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+const printId = (locale, id) => {
+    switch (id.kind) {
+        case "Penis":
+            return locale.translate("Penis");
+        case "Vagina":
+            return locale.translate("Vagina");
+        default:
+            return assertExhaustive(id);
+    }
+};
+/**
+ * Get the translation of a sexual characteristic prerequisite.
+ */
+export const printSexualCharacteristicPrerequisite = (locale, prerequisite) => ({
+    value: locale.translate("Person with {$sexualCharacteristic}", {
+        sexualCharacteristic: printId(locale, prerequisite.id),
+    }),
+    sentenceType: undefined,
+    isMeta: false,
+});

package/lib/entities/partial/prerequisites/single/socialStatus.d.ts

@@ -0,0 +1,8 @@
+import type { SocialStatusPrerequisite } from "optolith-database-schema/gen";
+import { type GetInstanceById } from "../../../../helpers/getTypes.js";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { PrerequisitePart } from "../part.js";
+/**
+ * Get the translation of a social status prerequisite.
+ */
+export declare const printSocialStatusPrerequisite: (getInstanceById: GetInstanceById<"SocialStatus">, locale: LocaleEnvironment, prerequisite: SocialStatusPrerequisite) => PrerequisitePart | undefined;

package/lib/entities/partial/prerequisites/single/socialStatus.js

@@ -0,0 +1,21 @@
+import { printDisplayOption } from "../displayOption.js";
+/**
+ * Get the translation of a social status prerequisite.
+ */
+export const printSocialStatusPrerequisite = (getInstanceById, locale, prerequisite) => {
+    if (prerequisite.display_option !== undefined) {
+        return printDisplayOption(locale.translateMap, prerequisite.display_option);
+    }
+    const socialStatus = getInstanceById("SocialStatus", prerequisite.id);
+    const socialStatusTranslation = locale.translateMap(socialStatus?.translations);
+    if (socialStatusTranslation === undefined) {
+        return undefined;
+    }
+    return {
+        value: `${locale.translate("Social Status {$minStatus} or higher", {
+            minStatus: `*${socialStatusTranslation.name}*`,
+        })} `,
+        sentenceType: undefined,
+        isMeta: false,
+    };
+};

package/lib/entities/partial/prerequisites/single/state.d.ts

@@ -0,0 +1,8 @@
+import { StatePrerequisite } from "optolith-database-schema/gen";
+import { type GetInstanceById } from "../../../../helpers/getTypes.js";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { PrerequisitePart } from "../part.js";
+/**
+ * Get the translation of a state prerequisite.
+ */
+export declare const printStatePrerequisite: (getInstanceById: GetInstanceById<"State">, locale: LocaleEnvironment, prerequisite: StatePrerequisite) => PrerequisitePart | undefined;

package/lib/entities/partial/prerequisites/single/state.js

@@ -0,0 +1,20 @@
+import { printDisplayOption } from "../displayOption.js";
+/**
+ * Get the translation of a state prerequisite.
+ */
+export const printStatePrerequisite = (getInstanceById, locale, prerequisite) => {
+    if (prerequisite.display_option !== undefined) {
+        return printDisplayOption(locale.translateMap, prerequisite.display_option);
+    }
+    const state = getInstanceById("State", prerequisite.id);
+    const stateTranslation = locale.translateMap(state?.translations);
+    if (stateTranslation === undefined) {
+        return undefined;
+    }
+    return {
+        label: `${locale.translate("State")} `,
+        value: `*${stateTranslation.name}*`,
+        sentenceType: undefined,
+        isMeta: false,
+    };
+};

package/lib/entities/partial/prerequisites/single/text.d.ts

@@ -0,0 +1,7 @@
+import { TextPrerequisite } from "optolith-database-schema/gen";
+import { LocaleEnvironment } from "../../../../helpers/locale.js";
+import { PrerequisitePart } from "../part.js";
+/**
+ * Get the translation of a text prerequisite.
+ */
+export declare const printTextPrerequisite: (locale: LocaleEnvironment, prerequisite: TextPrerequisite) => PrerequisitePart;

package/lib/entities/partial/prerequisites/single/text.js

@@ -0,0 +1,9 @@
+import { MISSING_VALUE } from "../../unknown.js";
+/**
+ * Get the translation of a text prerequisite.
+ */
+export const printTextPrerequisite = (locale, prerequisite) => ({
+    value: locale.translateMap(prerequisite.translations)?.text ?? MISSING_VALUE,
+    sentenceType: prerequisite.sentence_type,
+    isMeta: prerequisite.is_meta ?? false,
+});

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

@@ -0,0 +1,15 @@
+import type { Profession_ID, ProfessionPackage } from "optolith-database-schema/gen";
+import type { GetAllChildInstancesForParent, GetAllInstances } from "../../helpers/getTypes.js";
+import type { TranslateMap } from "../../helpers/translate.js";
+import type { IdMap } from "../../index.js";
+/**
+ * Finds the base profession package for a given curriculum.
+ */
+export declare const getBaseProfessionPackageForCurriculum: (getAllInstances: GetAllInstances<"Profession">, getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionVersion" | "ProfessionPackage">, idMap: IdMap, curriculumId: string) => {
+    id: string;
+    content: ProfessionPackage;
+} | undefined;
+/**
+ * Gets the name of a profession, regardless of the profession version.
+ */
+export declare const getProfessionName: (translateMap: TranslateMap, getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionVersion">, professionId: Profession_ID) => string | undefined;

package/lib/entities/partial/professions.js

@@ -0,0 +1,19 @@
+import { reduceWhile } from "@elyukai/utils/array/reductions";
+import { isNotNullish } from "@elyukai/utils/nullable";
+/**
+ * Finds the base profession package for a given curriculum.
+ */
+export const getBaseProfessionPackageForCurriculum = (getAllInstances, getChildInstancesForInstanceId, idMap, curriculumId) => {
+    const baseProfession = getAllInstances("Profession").find(profession => profession.content.group.kind === "Magical" &&
+        profession.content.group.Magical.curriculum === curriculumId);
+    if (baseProfession === undefined) {
+        return undefined;
+    }
+    return reduceWhile(getChildInstancesForInstanceId("ProfessionVersion", baseProfession.id), (_acc, version) => getChildInstancesForInstanceId("ProfessionPackage", version.id).find(professionPackage => professionPackage.content.experience_level ===
+        idMap.ExperienceLevel.Experienced), isNotNullish, undefined);
+};
+/**
+ * Gets the name of a profession, regardless of the profession version.
+ */
+export const getProfessionName = (translateMap, getChildInstancesForInstanceId, professionId) => translateMap(getChildInstancesForInstanceId("ProfessionVersion", professionId)[0]
+    ?.content.translations)?.name.default;

package/lib/entities/partial/rated/activatable/castingTime.d.ts

@@ -1,13 +1,22 @@
-import { FastCastingTime, SlowCastingTime } from "optolith-database-schema/types/_ActivatableSkillCastingTime";
-import { GetById } from "../../../../helpers/getTypes.js";
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { ResponsiveTextSize } from "../../responsiveText.js";
-import { Entity } from "./entity.js";
+import { CastingTime, FastCastingTime, FastSkillNonModifiableCastingTime, SlowCastingTime, SlowSkillNonModifiableCastingTime } from "optolith-database-schema/gen";
+import { type StdReader } from "../../reader.js";
+/**
+ * Renders the text for a non-modifiable casting time of a fast activatable skill.
+ */
+export declare const renderFastSkillNonModifiableCastingTime: (value: FastSkillNonModifiableCastingTime) => StdReader<string, "t" | "rts">;
+/**
+ * Get the text for a non-modifiable casting time of a slow activatable skill.
+ */
+export declare const renderSlowSkillNonModifiableCastingTime: (value: SlowSkillNonModifiableCastingTime) => StdReader<string, "t" | "rts">;
+/**
+ * Translate casting time.
+ */
+export declare const renderCastingTime: <NonModifiable extends object>(renderNonModifiableCastingTime: (value: NonModifiable) => StdReader<string, "t" | "rts" | "s" | "nms">, value: CastingTime<NonModifiable>) => StdReader<string, "t" | "rts" | "s" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the text for the casting time of a fast activatable skill.
  */
-export declare const getFastCastingTimeTranslation: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: FastCastingTime) => string;
+export declare const renderFastCastingTime: (value: FastCastingTime) => StdReader<string, "t" | "rts" | "nms" | "ibi", "SkillModificationLevel">;
 /**
  * Get the text for the casting time of a slow activatable skill.
  */
-export declare const getSlowCastingTimeTranslation: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: SlowCastingTime) => string;
+export declare const renderSlowCastingTime: (value: SlowCastingTime) => StdReader<string, "t" | "rts" | "nms" | "ibi", "SkillModificationLevel">;

package/lib/entities/partial/rated/activatable/castingTime.js

@@ -1,35 +1,50 @@
+import { Reader } from "@elyukai/utils/reader";
 import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-import { formatTimeSpan } from "../../units/timeSpan.js";
+import { Case } from "../../../../helpers/enums.js";
+import { getInstanceByIdFnR, modifiableBySpeedR, } from "../../reader.js";
+import { formatCombinedTimeSpanR, formatTimeSpanR, } from "../../units/timeSpan.js";
 import { MISSING_VALUE } from "../../unknown.js";
-import { getNonModifiableSuffixTranslation, ModifiableParameter, } from "./nonModifiableSuffix.js";
-import { getModifiableBySpeed, Speed } from "./speed.js";
-const getModifiableCastingTimeTranslation = (getSkillModificationLevelById, locale, speed, responsiveTextSize, value) => mapNullable(getSkillModificationLevelById(value.initial_modification_level), (modificationLevel) => getModifiableBySpeed((config) => formatTimeSpan(locale, responsiveTextSize, "Actions", config.casting_time), (config) => formatTimeSpan(locale, responsiveTextSize, config.casting_time.unit, config.casting_time.value), speed, modificationLevel)) ?? MISSING_VALUE;
-const getFastSkillNonModifiableCastingTimeTranslation = (locale, responsiveTextSize, value) => formatTimeSpan(locale, responsiveTextSize, "Actions", value.actions);
-const getSlowSkillNonModifiableCastingTimeTranslation = (locale, responsiveTextSize, value) => formatTimeSpan(locale, responsiveTextSize, value.unit, value.value);
-const getCastingTimeTranslation = (getNonModifiableCastingTimeTranslation, getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => {
-    switch (value.tag) {
+import { appendNonModifiableSuffix, ModifiableParameter, } from "./nonModifiableSuffix.js";
+import { Speed } from "./speed.js";
+const deriveModifiableCastingTime = (modificationLevelId) => getInstanceByIdFnR().thenW(getInstanceById => mapNullable(getInstanceById("SkillModificationLevel", modificationLevelId), modificationLevel => modifiableBySpeedR("casting_time", modificationLevel).map(castingTime => typeof castingTime === "number"
+    ? { value: castingTime, unit: Case("Actions") }
+    : castingTime)) ?? Reader.of(undefined));
+const renderModifiableCastingTime = (value) => deriveModifiableCastingTime(value.initial_modification_level).thenW(castingTime => castingTime === undefined
+    ? Reader.of(MISSING_VALUE)
+    : formatCombinedTimeSpanR(castingTime));
+const renderCastingTimeDuringLovemaking = (value) => formatCombinedTimeSpanR(value);
+/**
+ * Renders the text for a non-modifiable casting time of a fast activatable skill.
+ */
+export const renderFastSkillNonModifiableCastingTime = (value) => formatTimeSpanR(Case("Actions"), value.actions);
+/**
+ * Get the text for a non-modifiable casting time of a slow activatable skill.
+ */
+export const renderSlowSkillNonModifiableCastingTime = (value) => formatCombinedTimeSpanR(value);
+/**
+ * Translate casting time.
+ */
+export const renderCastingTime = (renderNonModifiableCastingTime, value) => {
+    switch (value.kind) {
         case "Modifiable":
-            return getModifiableCastingTimeTranslation(getSkillModificationLevelById, locale, speed, responsiveTextSize, value.modifiable);
+            return renderModifiableCastingTime(value.Modifiable);
         case "NonModifiable":
-            return (getNonModifiableCastingTimeTranslation(value.non_modifiable) +
-                getNonModifiableSuffixTranslation(locale, entity, ModifiableParameter.CastingTime, responsiveTextSize));
+            return renderNonModifiableCastingTime(value.NonModifiable).then(base => appendNonModifiableSuffix(ModifiableParameter.CastingTime, base));
         default:
             return assertExhaustive(value);
     }
 };
-const getCastingTimeDuringLovemakingTranslation = (locale, responsiveTextSize, value) => formatTimeSpan(locale, responsiveTextSize, value.unit, value.value);
-const getCastingTimeIncludingLovemakingTranslation = (getNonModifiableCastingTimeTranslation, getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, value) => [
-    mapNullable(value.default, (def) => getCastingTimeTranslation(getNonModifiableCastingTimeTranslation, getSkillModificationLevelById, locale, speed, entity, responsiveTextSize, def)),
-    mapNullable(value.during_lovemaking, (duringLovemaking) => getCastingTimeDuringLovemakingTranslation(locale, responsiveTextSize, duringLovemaking)),
-]
-    .filter(isNotNullish)
-    .join(" / ");
+const renderCastingTimeIncludingLovemaking = (renderNonModifiableCastingTime, value) => Reader.sequence([
+    mapNullable(value.default, def => renderCastingTime(renderNonModifiableCastingTime, def)) ?? Reader.of(undefined),
+    mapNullable(value.during_lovemaking, renderCastingTimeDuringLovemaking) ??
+        Reader.of(undefined),
+]).map(texts => texts.filter(isNotNullish).join(" / "));
 /**
  * Get the text for the casting time of a fast activatable skill.
  */
-export const getFastCastingTimeTranslation = (getSkillModificationLevelById, locale, entity, responsiveTextSize, value) => getCastingTimeIncludingLovemakingTranslation((nonModifiableValue) => getFastSkillNonModifiableCastingTimeTranslation(locale, responsiveTextSize, nonModifiableValue), getSkillModificationLevelById, locale, Speed.Fast, entity, responsiveTextSize, value);
+export const renderFastCastingTime = (value) => renderCastingTimeIncludingLovemaking(renderFastSkillNonModifiableCastingTime, value).with(env => ({ ...env, speed: Speed.Fast }));
 /**
  * Get the text for the casting time of a slow activatable skill.
  */
-export const getSlowCastingTimeTranslation = (getSkillModificationLevelById, locale, entity, responsiveTextSize, value) => getCastingTimeIncludingLovemakingTranslation((nonModifiableValue) => getSlowSkillNonModifiableCastingTimeTranslation(locale, responsiveTextSize, nonModifiableValue), getSkillModificationLevelById, locale, Speed.Slow, entity, responsiveTextSize, value);
+export const renderSlowCastingTime = (value) => renderCastingTimeIncludingLovemaking(renderSlowSkillNonModifiableCastingTime, value).with(env => ({ ...env, speed: Speed.Slow }));

package/lib/entities/partial/rated/activatable/checkResultBased.d.ts

@@ -1,7 +1,22 @@
-import { CheckResultBased } from "optolith-database-schema/types/_ActivatableSkillCheckResultBased";
-import { Translate } from "../../../../helpers/translate.js";
+import type { CheckResultBasedModifier, CheckResultValue } from "optolith-database-schema/gen";
+import { type StdReader } from "../../reader.js";
+interface CheckResultBased {
+    /**
+     * The base value that is derived from the check result.
+     */
+    base: CheckResultValue;
+    /**
+     * If defined, it modifies the base value.
+     */
+    modifier?: CheckResultBasedModifier;
+}
+/**
+ * Appends the modifier of a check-result-based parameter of an activatable skill to the base value, using the appropriate arithmetic formatter.
+ */
+export declare const appendCheckResultModifier: (left: string, modifier: CheckResultBasedModifier) => string;
 /**
  * Returns the value text for a check-result-based parameter of an activatable
  * skill.
  */
-export declare const getCheckResultBasedValueTranslation: (translate: Translate, value: CheckResultBased) => string;
+export declare const renderCheckResultBasedValue: (value: CheckResultBased) => StdReader<string, "t">;
+export {};

package/lib/entities/partial/rated/activatable/checkResultBased.js

@@ -1,28 +1,36 @@
 import { mapNullableDefault } from "@optolith/helpers/nullable";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
-const getCheckResultBaseValueTranslation = (translate, baseValue) => {
-    switch (baseValue) {
+import { divisionFormatter, multiplicationFormatter, } from "../../mathOperation.js";
+import { translateR } from "../../reader.js";
+const renderCheckResultBaseValue = (baseValue) => {
+    switch (baseValue.kind) {
         case "QualityLevels":
-            return translate("QL");
+            return translateR("QL");
         case "SkillPoints":
-            return translate("SP");
+            return translateR("SP");
         default:
             return assertExhaustive(baseValue);
     }
 };
-const getArithmeticSymbol = (arithmetic) => {
-    switch (arithmetic) {
+const getArithmeticFormatter = (arithmetic) => {
+    switch (arithmetic.kind) {
         case "Divide":
-            return ` / `;
+            return divisionFormatter;
         case "Multiply":
-            return ` × `;
+            return multiplicationFormatter;
         default:
             return assertExhaustive(arithmetic);
     }
 };
+/**
+ * Appends the modifier of a check-result-based parameter of an activatable skill to the base value, using the appropriate arithmetic formatter.
+ */
+export const appendCheckResultModifier = (left, modifier) => {
+    const formatter = getArithmeticFormatter(modifier.arithmetic);
+    return formatter(left, modifier.value);
+};
 /**
  * Returns the value text for a check-result-based parameter of an activatable
  * skill.
  */
-export const getCheckResultBasedValueTranslation = (translate, value) => getCheckResultBaseValueTranslation(translate, value.base) +
-    mapNullableDefault(value.modifier, (modifier) => getArithmeticSymbol(modifier.arithmetic) + modifier.value, "");
+export const renderCheckResultBasedValue = (value) => renderCheckResultBaseValue(value.base).map(base => mapNullableDefault(value.modifier, modifier => appendCheckResultModifier(base, modifier), base));

package/lib/entities/partial/rated/activatable/cost.d.ts

@@ -1,14 +1,94 @@
-import { OneTimeCost, SustainedCost } from "optolith-database-schema/types/_ActivatableSkillCost";
-import { GetById } from "../../../../helpers/getTypes.js";
-import { LocaleEnvironment } from "../../../../helpers/locale.js";
-import { ResponsiveTextSize } from "../../responsiveText.js";
-import { Entity } from "./entity.js";
-import { Speed } from "./speed.js";
+import { Reader } from "@elyukai/utils/reader";
+import { NonModifiableSustainedCost, OneTimeCost, SustainedCost, type CheckResultBasedModifier, type DurationUnitValue, type ElvenMagicalSongPermanentCost, type FirstPersonMagicalMelodyCost, type NonModifiableOneTimeCostPerCountable, type OneTimeCostMap, type ResponsiveText, type ResponsiveTextOptional, type ResponsiveTextReplace, type SkillModificationLevel_ID } from "optolith-database-schema/gen";
+import { type LocaleMap } from "../../../../helpers/translate.js";
+import { type StdEnv, type StdReader } from "../../reader.js";
+/**
+ * Returns the text for the modifiable one-time cost of an activatable skill.
+ */
+export declare const renderModifiableOneTimeCost: (value: {
+    initial_modification_level: SkillModificationLevel_ID;
+    permanent_value?: number;
+    translations?: LocaleMap<{
+        replacement?: ResponsiveTextReplace;
+        additional?: ResponsiveText;
+    }>;
+}) => StdReader<string, "t" | "tm" | "rts" | "eu" | "s" | "ibi", "SkillModificationLevel">;
+type NonModifiableOneTimeCost = {
+    is_minimum?: boolean;
+    value: number;
+    lp_value?: number;
+    permanent_value?: number;
+    interval?: DurationUnitValue;
+    permanent?: ElvenMagicalSongPermanentCost;
+    per?: NonModifiableOneTimeCostPerCountable;
+    translations?: LocaleMap<{
+        note?: ResponsiveTextOptional;
+    }>;
+};
+/**
+ * Returns the text for a non-modifiable one-time cost of an activatable skill.
+ */
+export declare const renderNonModifiableOneTimeCost: (value: NonModifiableOneTimeCost, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "rts" | "eu" | "nms" | "lj">;
+type IndefiniteCost = {
+    modifier?: CheckResultBasedModifier;
+    translations: LocaleMap<{
+        description: ResponsiveText;
+    }>;
+};
+/**
+ * Returns the text for the indefinite cost of an activatable skill.
+ */
+export declare const renderIndefiniteCost: (value: IndefiniteCost, shouldAppendNonModifiableSuffix: boolean) => StdReader<string, "t" | "tm" | "rts" | "eu" | "nms">;
+/**
+ * Returns the text for a one-time cost map of an activatable skill.
+ */
+export declare const renderOneTimeCostMap: (value: OneTimeCostMap) => StdReader<string, "t" | "tm" | "rts" | "nms" | "eu">;
 /**
  * Returns the text for the cost of a one-time activatable skill.
  */
-export declare const getOneTimeCostTranslation: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, speed: Speed, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: OneTimeCost) => string;
+export declare const renderOneTimeCost: (value: OneTimeCost) => StdReader<string, "t" | "tm" | "lj" | "rts" | "eu" | "s" | "nms" | "ibi", "SkillModificationLevel">;
+/**
+ * Returns the text for the non-modifiable cost of a sustained activatable skill.
+ */
+export declare const renderNonModifiableSustainedCost: (value: NonModifiableSustainedCost) => Reader<{
+    translate: import("../../../../helpers/translate.js").Translate;
+    energyUnit: import("../../units/energy.js").EnergyUnit;
+} & {
+    translate: import("../../../../helpers/translate.js").Translate;
+    responsiveTextSize: import("../../responsiveText.js").ResponsiveTextSize;
+} & StdEnv<"t" | "rts" | "tm" | "eu", never, never, never>, string>;
 /**
  * Returns the text for the cost of a sustained activatable skill.
  */
-export declare const getSustainedCostTranslation: (getSkillModificationLevelById: GetById.Static.SkillModificationLevel, locale: LocaleEnvironment, speed: Speed, entity: Entity, responsiveTextSize: ResponsiveTextSize, value: SustainedCost) => string;
+export declare const renderSustainedCost: (value: SustainedCost) => StdReader<string, "t" | "tm" | "rts" | "eu" | "s" | "nms" | "ibi", "SkillModificationLevel">;
+type MagicalActionCost = {
+    kind: "Fixed";
+    Fixed: NonModifiableOneTimeCost;
+} | {
+    kind: "Indefinite";
+    Indefinite: IndefiniteCost;
+} | {
+    kind: "FirstPerson";
+    FirstPerson: FirstPersonMagicalMelodyCost;
+} | {
+    kind: "ByPrimaryPatron";
+    ByPrimaryPatron?: {
+        interval?: DurationUnitValue;
+        translations?: LocaleMap<{
+            note: ResponsiveTextOptional;
+        }>;
+    };
+} | {
+    kind: "All";
+    All: {
+        minimum?: number;
+    };
+} | {
+    kind: "Map";
+    Map: OneTimeCostMap;
+};
+/**
+ * Generates the text for the cost specific to a magical action.
+ */
+export declare const renderMagicalActionCost: (cost: MagicalActionCost) => StdReader<string, "t" | "tm" | "rts" | "eu" | "nms" | "lj">;
+export {};