@optolith/entity-descriptions 0.11.1 → 0.11.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.11.2](https://github.com/Optolith/entity-descriptions/compare/v0.11.1...v0.11.2) (2026-09-14)
+
+### Bug Fixes
+
+* activatable prerequisite disjunctions ([7895f89](https://github.com/Optolith/entity-descriptions/commit/7895f89735315a6a97a7a03bbcdc1c58361763b9)), closes [#52](https://github.com/Optolith/entity-descriptions/issues/52)
+* correctly signed and labeled AP value depending on active entries ([27e3a7a](https://github.com/Optolith/entity-descriptions/commit/27e3a7a4975368651b443520f08bdd918e81a019))
+* correctly signed value in IC derived AP value ([99fa203](https://github.com/Optolith/entity-descriptions/commit/99fa20395d8e9a378194673388d38e26938982bd))
+* derived combat technique ap value ([0ad0554](https://github.com/Optolith/entity-descriptions/commit/0ad0554f2eee7857dbaa7717a3742e70b5735f1f))
 ## [0.11.1](https://github.com/Optolith/entity-descriptions/compare/v0.11.0...v0.11.1) (2026-09-13)
 
 ### Features

package/lib/entities/activatable.js

@@ -22,7 +22,7 @@ import { printAdvantageDisadvantagePrerequisites, printGeneralPrerequisites, } f
 import { printActivatableName, } from "./partial/prerequisites/single/activatable.js";
 import { renderStandaloneCostMap } from "./partial/rated/activatable/cost.js";
 import { parensIf } from "./partial/rated/activatable/parensIf.js";
-import { attributedNameR, localeSortR, nameR, translateR, } from "./partial/reader.js";
+import { attributedNameR, localeSortR, nameR, translateR } from "./partial/reader.js";
 import { getResponsiveText, getResponsiveTextOptional, ResponsiveTextSize, } from "./partial/responsiveText.js";
 import { formatTimeSpan } from "./partial/units/timeSpan.js";
 import { MISSING_VALUE } from "./partial/unknown.js";
@@ -545,7 +545,12 @@ const normalizeId = (entityName, id) => {
 };
 const renderAdvancedSpecialAbilityName = (translate, translateMap, getInstanceById, getResolvedSelectOptionById, entityName, id, option) => {
     const normalizedId = normalizeId(entityName, id);
-    return `^[${mapNullable(printActivatableName(getInstanceById, translate, normalizedId, option, undefined, getResolvedSelectOptionById, false), name => renderActivatableNameComponents(translateMap, name, false)) ?? MISSING_VALUE}](entity: "${normalizedId.kind}", instance: "${fromUniformCase(normalizedId)}", style: "normal")`;
+    return `^[${mapNullable(printActivatableName(normalizedId, option, undefined).run({
+        getInstanceById,
+        translate,
+        getResolvedSelectOptionById,
+        displayedInProfession: false,
+    }), name => renderActivatableNameComponents(translateMap, name, false)) ?? MISSING_VALUE}](entity: "${normalizedId.kind}", instance: "${fromUniformCase(normalizedId)}", style: "normal")`;
 };
 const renderAdvancedValue = (translate, translateMap, localeJoin, localeCompare, getInstanceById, getResolvedSelectOptionById, entityName, advanced) => {
     if (advanced.every(entry => entry.kind === "OneOf") &&
@@ -792,6 +797,7 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
         getInstanceById,
         localeCompare: locale.compare,
         localeJoin: locale.join,
+        getResolvedSelectOptionById,
     };
     const baseEntry = entry;
     const wrappedId = Case(entityName, id);
@@ -870,11 +876,11 @@ export const getActivatableEntityDescription = createEntityDescriptionCreator(({
                     mapNullable(entry.prerequisites ?? (isAdvancedSpecialAbilityKind(entityName) ? [] : undefined), prerequisites => ({
                         label: translate("Prerequisites"),
                         value: wrappedId.kind === "Advantage" || wrappedId.kind === "Disadvantage"
-                            ? printAdvantageDisadvantagePrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites, translation.name, wrappedId.kind)
-                            : printGeneralPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites, mapNullable(baseEntry.levels, levels => ({
+                            ? printAdvantageDisadvantagePrerequisites(prerequisites, translation.name, wrappedId.kind).run(env)
+                            : printGeneralPrerequisites(prerequisites, mapNullable(baseEntry.levels, levels => ({
                                 id: wrappedId,
                                 levels,
-                            })), renderTrailingAdvancedPrerequisitesNote(translate, entityName)),
+                            })), renderTrailingAdvancedPrerequisitesNote(translate, entityName)).run(env),
                     })),
                     mapNullable(baseEntry.combat_techniques, combatTechniques => ({
                         label: translate("Combat Techniques"),

package/lib/entities/elixir.js

@@ -13,6 +13,14 @@ export const getElixirEntityDescription = createEntityDescriptionCreator(({ getI
     if (translation === undefined) {
         return undefined;
     }
+    const env = {
+        translate,
+        translateMap,
+        getInstanceById,
+        localeCompare: locale.compare,
+        localeJoin: locale.join,
+        getResolvedSelectOptionById,
+    };
     return {
         title: translation.name,
         className: "elixir",
@@ -48,7 +56,7 @@ export const getElixirEntityDescription = createEntityDescriptionCreator(({ getI
                         value: translate("{$value} AP", {
                             value: entry.trade_secret.ap_value,
                         }) +
-                            parensIf(mapNullable(entry.trade_secret.prerequisites, prerequisites => `${translate("Prerequisites")}: ${printPlainGeneralPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites)}`)),
+                            parensIf(mapNullable(entry.trade_secret.prerequisites, prerequisites => `${translate("Prerequisites")}: ${printPlainGeneralPrerequisites(prerequisites).run(env)}`)),
                     },
                     translation.special === undefined
                         ? undefined

package/lib/entities/influence.js

@@ -9,6 +9,15 @@ export const getInfluenceEntityDescription = createEntityDescriptionCreator(({ g
     if (translation === undefined) {
         return undefined;
     }
+    const env = {
+        translate,
+        translateMap,
+        getInstanceById,
+        localeCompare: locale.compare,
+        localeJoin: locale.join,
+        getResolvedSelectOptionById,
+        getChildInstancesForInstanceId,
+    };
     return {
         title: translation.name,
         className: "influence",
@@ -32,7 +41,7 @@ export const getInfluenceEntityDescription = createEntityDescriptionCreator(({ g
                             ? undefined
                             : {
                                 label: translate("Prerequisites"),
-                                value: printInfluencePrerequisites(getInstanceById, getResolvedSelectOptionById, getChildInstancesForInstanceId, locale, entry.prerequisites),
+                                value: printInfluencePrerequisites(entry.prerequisites).run(env),
                             },
                     ],
                 },

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

@@ -43,7 +43,7 @@ export declare const combineNameComponents: (elements: ActivatableNameComponents
 /**
  * Renders the name components of an activatable entry, combining multiple options into one string.
  */
-export declare const renderCombinedActivatableNameComponents: (translateMap: TranslateMap, components: CombinedActivatableNameComponents, formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
+export declare const renderCombinedActivatableNameComponents: (translateMap: TranslateMap, components: CombinedActivatableNameComponents, formatAsPrerequisite: boolean, join?: (list: string[]) => string, context?: string) => string;
 /**
  * Renders the name components of multiple activatable entries.
  */
@@ -51,7 +51,7 @@ export declare const renderMultipleStandaloneActivatableNameComponents: (transla
 /**
  * Renders the name components of multiple activatable entries, combining parts if possible.
  */
-export declare const renderActivatableNameComponentsCombinedIfPossible: (translateMap: TranslateMap, components: ActivatableNameComponents[], formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
+export declare const renderActivatableNameComponentsCombinedIfPossible: (translate: Translate, translateMap: TranslateMap, components: ActivatableNameComponents[], formatAsPrerequisite: boolean, join?: (list: string[]) => string) => string;
 /**
  * Renders the options of an activatable entry, combining them if necessary.
  */

package/lib/entities/partial/activatableNameChunks.js

@@ -6,6 +6,8 @@ import { isNotNullish } from "@elyukai/utils/nullable";
 import { mapObject } from "@optolith/helpers/object";
 import { romanize } from "@optolith/helpers/roman";
 import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { fromUniformCase } from "tsondb/schema/gen";
+import { attributedInstance } from "./markdown.js";
 import { MISSING_VALUE } from "./unknown.js";
 const combineChunks = (a, b, join) => {
     if (typeof a === "string") {
@@ -127,22 +129,34 @@ export const combineNameComponents = (elements) => {
 /**
  * Renders the name components of an activatable entry, combining multiple options into one string.
  */
-export const renderCombinedActivatableNameComponents = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => renderActivatableNameComponents(translateMap, {
+export const renderCombinedActivatableNameComponents = (translateMap, components, formatAsPrerequisite, join = list => list.join(", "), context = "prerequisite") => attributedInstance(renderActivatableNameComponents(translateMap, {
     ...components,
     nameBuilderRules: {
         ...components.nameBuilderRules,
         useParenthesis: true,
     },
     options: join(components.options.map(chunk => renderActivatableNameChunk(translateMap, normalizeChunks(chunk)))),
-}, formatAsPrerequisite);
+}, formatAsPrerequisite), components.id.kind, fromUniformCase(components.id), { context });
 /**
  * Renders the name components of multiple activatable entries.
  */
-export const renderMultipleStandaloneActivatableNameComponents = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => join(components.map(item => renderActivatableNameComponents(translateMap, item, formatAsPrerequisite)));
+export const renderMultipleStandaloneActivatableNameComponents = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => join(components.map(item => attributedInstance(renderActivatableNameComponents(translateMap, item, formatAsPrerequisite), item.id.kind, fromUniformCase(item.id), { context: '"prerequisite"' })));
 /**
  * Renders the name components of multiple activatable entries, combining parts if possible.
  */
-export const renderActivatableNameComponentsCombinedIfPossible = (translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => {
+export const renderActivatableNameComponentsCombinedIfPossible = (translate, translateMap, components, formatAsPrerequisite, join = list => list.join(", ")) => {
+    if (isNotEmpty(components) &&
+        components.length > 1 &&
+        (components.every(c => c.id.kind === "MagicalTradition") ||
+            components.every(c => c.id.kind === "BlessedTradition"))) {
+        return (attributedInstance(`${translate("Tradition")} (`, components[0].id.kind, undefined, {
+            context: '"prerequisite"',
+        }) +
+            join(components.map(c => c.options === undefined
+                ? MISSING_VALUE
+                : attributedInstance(renderActivatableNameChunk(translateMap, normalizeChunks(c.options)), c.id.kind, fromUniformCase(c.id), { context: '"prerequisite"' }))) +
+            attributedInstance(`)`, components[0].id.kind, undefined, { context: '"prerequisite"' }));
+    }
     const combined = combineNameComponents(components);
     if (combined === undefined) {
         return renderMultipleStandaloneActivatableNameComponents(translateMap, components, formatAsPrerequisite, join);

package/lib/entities/partial/adventurePointsValue.js

@@ -35,7 +35,7 @@ const renderFixedSelectOptionsAdventurePointsValue = (locale, getAllSelectOption
             .join("; ");
     }
 };
-const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSelectOptions, getNameForSelectOptionId, config, applyNegative) => {
+const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, derivedRangeStart, getAllSelectOptions, getNameForSelectOptionId, config, applyNegative) => {
     if (config === undefined) {
         return MISSING_VALUE;
     }
@@ -43,8 +43,8 @@ const renderSelectOptionsAdventurePointsValue = (locale, derivedLabel, getAllSel
         case "DerivedFromImprovementCost": {
             const start = derivedLabel();
             return `${start}: ${locale.translate("{$value} Adventure Points", {
-                value: Array.from({ length: 4 }, (_, index) => (index + 1) * (config.DerivedFromImprovementCost.multiplier ?? 1) +
-                    (config.DerivedFromImprovementCost.offset ?? 0)).join("/"),
+                value: Array.from({ length: 5 - derivedRangeStart }, (_, index) => applyNegative((index + derivedRangeStart) * (config.DerivedFromImprovementCost.multiplier ?? 1) +
+                    (config.DerivedFromImprovementCost.offset ?? 0))).join("/"),
             })}`;
         }
         case "Fixed":
@@ -220,9 +220,9 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                             default:
                                 return translate("A/B/C/D ability");
                         }
-                    }, getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.Skills.ap_value, applyNegative);
+                    }, 1, getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.Skills.ap_value, applyNegative);
                 case "CombatTechniques":
-                    return renderSelectOptionsAdventurePointsValue(locale, () => translate("B/C/D combat technique"), getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.CombatTechniques.ap_value, applyNegative);
+                    return renderSelectOptionsAdventurePointsValue(locale, () => translate("B/C/D combat technique"), 2, getAllSelectOptions, getNameForSelectOptionId, derivedSelectOptions.CombatTechniques.ap_value, applyNegative);
                 case "TargetCategories":
                     return MISSING_VALUE;
                 default:
@@ -231,20 +231,27 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
         }
         case "DependingOnActive":
             return `${translate(".input {$value :number} {{{$value} Adventure Points}}", {
-                value: value.DependingOnActive.inactive,
+                value: applyNegative(value.DependingOnActive.inactive),
             })} (${translate(".input {$value :number} {{{$value} Adventure Points with {$name}}}", {
-                value: value.DependingOnActive.active,
+                value: applyNegative(value.DependingOnActive.active),
                 name: getNameForId(value.DependingOnActive.id) ?? MISSING_VALUE,
             })})`;
         case "DependingOnActiveInstances":
             switch (value.DependingOnActiveInstances.kind) {
                 case "Threshold":
-                    return translate(".input {$value :number} {{{$value} Adventure Points}}", {
-                        value: value.DependingOnActiveInstances.Threshold.normal,
-                    });
+                    if (entry.levels === undefined) {
+                        return translate(".input {$value :number} {{{$value} Adventure Points}}", {
+                            value: applyNegative(value.DependingOnActiveInstances.Threshold.normal),
+                        });
+                    }
+                    else {
+                        return translate(".input {$value :number} {{{$value} Adventure Points per level}}", {
+                            value: applyNegative(value.DependingOnActiveInstances.Threshold.normal),
+                        });
+                    }
                 case "Expression": {
                     const expression = value.DependingOnActiveInstances.Expression;
-                    const values = Array.from({ length: entry.maximum ?? 3 }, (_, index) => evaluateMathOperation(expression, exprValue => {
+                    const values = Array.from({ length: entry.maximum ?? 3 }, (_, index) => applyNegative(evaluateMathOperation(expression, exprValue => {
                         switch (exprValue.kind) {
                             case "Constant":
                                 return exprValue.Constant;
@@ -253,7 +260,7 @@ export const renderAdventurePointsValue = (locale, getNameForId, getNameForSelec
                             default:
                                 return assertExhaustive(exprValue);
                         }
-                    })).join("/");
+                    }))).join("/");
                     const labels = Array.from({ length: entry.maximum ?? 3 }, (_, index) => `${(index + 1).toFixed()}.`).join("/");
                     if (entry.maximum !== undefined) {
                         return translate("{$values} Adventure Points for the {$labels} purchase", {

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

@@ -1,7 +1,7 @@
 import type { CommonnessRatedAdvantageDisadvantage } from "@optolith/database-schema/gen";
+import type { StdReader } from "../../env.js";
 import type { TranslationKeysWithoutParams } from "../../helpers/translate.js";
 import type { RawDefinitionListEntityDescriptionSectionItem } from "../../index.js";
-import type { StdReader } from "./reader.js";
 /**
  * Render the names of either commonness-rated advantages or commonness-rated disadvantages.
  */

package/lib/entities/partial/commonnessRatedAdvantagesAndDisadvantages.js

@@ -50,7 +50,7 @@ const renderCommonnessRatedAdvantageOrDisadvantageName = (translateMap, getInsta
             level,
             nameBuilderRules: makeNameBuilderRulesWithDefaults(instance.nameBuilderRules),
             options,
-        }, false, list => list.toSorted(localeCompare).join(", "));
+        }, false, list => list.toSorted(localeCompare).join(", "), "commonness");
     }, entity, item.id) ?? MISSING_VALUE);
 };
 /**

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

@@ -1,6 +1,6 @@
 import type { ImprovementCost, RatedIdentifier, SkillWithEnhancementsIdentifier } from "@optolith/database-schema/gen";
+import type { StdReader } from "../../env.js";
 import type { RawEntityDescriptionSection } from "../../index.js";
-import { type StdReader } from "./reader.js";
 /**
  * Render the enhancements section for an entity description, if applicable.
  */

package/lib/entities/partial/enhancements.js

@@ -6,7 +6,7 @@ import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { getAdventurePointsForActivation } from "@optolith/adventure-points/improvement-cost";
 import { filterIncludedPublicationEntriesMapR } from "../../references/publicationOptions.js";
 import { printEnhancementPrerequisites } from "./prerequisites/index.js";
-import { getChildInstancesForInstanceIdR, translateMapR, translateR, } from "./reader.js";
+import { getChildInstancesForInstanceIdR, translateMapR, translateR } from "./reader.js";
 const getEnhancementAPValue = (adventurePoints, parentImprovementCost) => {
     switch (adventurePoints.kind) {
         case "DerivedFromImprovementCost":
@@ -18,9 +18,18 @@ const getEnhancementAPValue = (adventurePoints, parentImprovementCost) => {
             return assertExhaustive(adventurePoints);
     }
 };
-const renderEnhancement = (enhancement, parentImprovementCost) => translateMapR(enhancement.content.translations).thenW(translation => Reader.ask().map(env => translation === undefined
-    ? undefined
-    : `- ^[${translation.name}](entity: "Enhancement") (${env.translate("SR {$value}", { value: enhancement.content.skill_rating })}, ${env.translate("{$value} AP", { value: getEnhancementAPValue(enhancement.content.adventurePoints, parentImprovementCost) })}): ${translation.effect.split("\n").join("\n  ")}${enhancement.content.prerequisites === undefined ? "" : ` ${env.translate(".input {$hiddenCount :number} {{Prerequisites}}", { hiddenCount: enhancement.content.prerequisites.length })}: ${printEnhancementPrerequisites(env.getInstanceById, { translate: env.translate, translateMap: env.translateMap, compare: env.localeCompare, join: env.localeJoin }, enhancement.content.prerequisites)}`}`));
+const renderEnhancement = (enhancement, parentImprovementCost) => {
+    const { prerequisites } = enhancement.content;
+    return translateMapR(enhancement.content.translations).thenW(translation => translation === undefined
+        ? Reader.of(undefined)
+        : translateR("SR {$value}", { value: enhancement.content.skill_rating }).thenW(sr => translateR("{$value} AP", {
+            value: getEnhancementAPValue(enhancement.content.adventurePoints, parentImprovementCost),
+        }).thenW(ap => (prerequisites === undefined
+            ? Reader.of("")
+            : translateR(".input {$hiddenCount :number} {{Prerequisites}}", {
+                hiddenCount: prerequisites.length,
+            }).thenW(prerequisitesLabel => printEnhancementPrerequisites(prerequisites).map(prerequisitesText => ` ${prerequisitesLabel}: ${prerequisitesText}`))).map(prerequisitesText => `- ^[${translation.name}](entity: "Enhancement") (${sr}, ${ap}): ${translation.effect.split("\n").join("\n  ")}${prerequisitesText}`))));
+};
 /**
  * Render the enhancements section for an entity description, if applicable.
  */

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

@@ -1,7 +1,7 @@
 import { Reader } from "@elyukai/utils/reader";
 import type { ParameterMapStyle, ResponsiveTextOptional } from "@optolith/database-schema/gen";
+import type { StdEnv, StdReader } from "../../env.js";
 import type { LocaleMap } from "../../helpers/translate.js";
-import { type StdEnv, type StdReader } from "./reader.js";
 /**
  * Renders a map of options to a string.
  */

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

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

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

@@ -4,24 +4,7 @@ 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);
-    }
-};
-/**
- * Get the translation of a display option.
- */
-export const printDisplayOptionR = (displayOption) => {
+export const printDisplayOption = (displayOption) => {
     switch (displayOption.kind) {
         case "Hide":
             return Reader.of(undefined);

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

@@ -1,67 +1,69 @@
-import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, PublicationPrerequisites, RatedIdentifier, SpellworkPrerequisites } from "@optolith/database-schema/gen";
-import type { GetAllChildInstancesForParent, GetInstanceById } from "../../../helpers/getTypes.js";
-import type { LocaleEnvironment } from "../../../helpers/locale.js";
-import type { GetResolvedSelectOptionById } from "./single/activatable.js";
+import { Reader } from "@elyukai/utils/reader";
+import type { ActivatableIdentifier, AdvantageDisadvantagePrerequisites, AnimistPowerPrerequisites, ArcaneTraditionPrerequisites, DerivedCharacteristicPrerequisites, EnhancementPrerequisites, GeneralPrerequisites, GeodeRitualPrerequisites, InfluencePrerequisites, LanguagePrerequisites, LiturgyPrerequisites, PersonalityTraitPrerequisites, PlainGeneralPrerequisites, ProfessionPrerequisites, PublicationPrerequisites, SpellworkPrerequisites } from "@optolith/database-schema/gen";
+import type { StdEnv } from "../../../env.js";
+import { printAdvantageDisadvantagePrerequisiteGroup, printAnimistPowerPrerequisiteGroup, printArcaneTraditionPrerequisiteGroup, printDerivedCharacteristicPrerequisiteGroup, printEnhancementPrerequisiteGroup, printGeneralPrerequisiteGroup, printGeodeRitualPrerequisiteGroup, printInfluencePrerequisiteGroup, printLanguagePrerequisiteGroup, printLiturgyPrerequisiteGroup, printPersonalityTraitPrerequisiteGroup, printProfessionPrerequisiteGroup, printPublicationPrerequisiteGroup, printSpellworkPrerequisiteGroup } from "./prerequisiteGroups.js";
+type DeriveEnvF<T extends (...args: any[]) => any> = ReturnType<T> extends Reader<infer E, unknown> ? E : never;
 /**
  * Print derived characteristic prerequisites as a string.
  */
-export declare const printDerivedCharacteristicPrerequisites: (locale: LocaleEnvironment, value: DerivedCharacteristicPrerequisites) => string;
+export declare const printDerivedCharacteristicPrerequisites: (value: DerivedCharacteristicPrerequisites) => Reader<DeriveEnvF<typeof printDerivedCharacteristicPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print publication prerequisites as a string.
  */
-export declare const printPublicationPrerequisites: (getInstanceById: GetInstanceById<"Publication">, locale: LocaleEnvironment, value: PublicationPrerequisites) => string;
+export declare const printPublicationPrerequisites: (value: PublicationPrerequisites) => Reader<DeriveEnvF<typeof printPublicationPrerequisiteGroup> & StdEnv<"lj" | "lc">, 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" | "PersonalityTrait" | "Blessing" | "Cantrip">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: PlainGeneralPrerequisites) => string;
+export declare const printPlainGeneralPrerequisites: (value: PlainGeneralPrerequisites) => Reader<DeriveEnvF<typeof printGeneralPrerequisiteGroup>, 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" | "PersonalityTrait" | "Blessing" | "Cantrip">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
+export declare const printGeneralPrerequisites: (value: GeneralPrerequisites, printPreviousLevelPrerequisites?: {
     id: ActivatableIdentifier;
     levels: number;
-}, trailingText?: string) => string;
+}, trailingText?: string) => Reader<DeriveEnvF<typeof printGeneralPrerequisiteGroup>, 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;
+export declare const printProfessionPrerequisites: (value: ProfessionPrerequisites) => Reader<DeriveEnvF<typeof printProfessionPrerequisiteGroup> & StdEnv<"lj" | "lc">, 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" | "PersonalityTrait" | "Blessing" | "Cantrip">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: AdvantageDisadvantagePrerequisites, name: string, type: "Advantage" | "Disadvantage") => string;
+export declare const printAdvantageDisadvantagePrerequisites: (value: AdvantageDisadvantagePrerequisites, name: string, type: "Advantage" | "Disadvantage") => Reader<DeriveEnvF<typeof printAdvantageDisadvantagePrerequisiteGroup>, string>;
 /**
  * Print arcane tradition prerequisites as a string.
  */
-export declare const printArcaneTraditionPrerequisites: (getInstanceById: GetInstanceById<"Culture">, locale: LocaleEnvironment, value: ArcaneTraditionPrerequisites) => string;
+export declare const printArcaneTraditionPrerequisites: (value: ArcaneTraditionPrerequisites) => Reader<DeriveEnvF<typeof printArcaneTraditionPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print personality trait prerequisites as a string.
  */
-export declare const printPersonalityTraitPrerequisites: (getInstanceById: GetInstanceById<"Race" | "Culture" | "PersonalityTrait">, locale: LocaleEnvironment, value: PersonalityTraitPrerequisites) => string;
+export declare const printPersonalityTraitPrerequisites: (value: PersonalityTraitPrerequisites) => Reader<DeriveEnvF<typeof printPersonalityTraitPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print spellwork prerequisites as a string.
  */
-export declare const printSpellworkPrerequisites: (getInstanceById: GetInstanceById<RatedIdentifier["kind"]>, locale: LocaleEnvironment, value: SpellworkPrerequisites) => string;
+export declare const printSpellworkPrerequisites: (value: SpellworkPrerequisites) => Reader<DeriveEnvF<typeof printSpellworkPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print liturgy prerequisites as a string.
  */
-export declare const printLiturgyPrerequisites: (locale: LocaleEnvironment, value: LiturgyPrerequisites) => string;
+export declare const printLiturgyPrerequisites: (value: LiturgyPrerequisites) => Reader<DeriveEnvF<typeof printLiturgyPrerequisiteGroup> & StdEnv<"t" | "tm" | "lj" | "lc">, string>;
 /**
  * Print influence prerequisites as a string.
  */
-export declare const printInfluencePrerequisites: (getInstanceById: GetInstanceById<"Influence" | "Race" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, getChildInstancesForInstanceId: GetAllChildInstancesForParent<"ProfessionVersion">, locale: LocaleEnvironment, value: InfluencePrerequisites) => string;
+export declare const printInfluencePrerequisites: (value: InfluencePrerequisites) => Reader<DeriveEnvF<typeof printInfluencePrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print language prerequisites as a string.
  */
-export declare const printLanguagePrerequisites: (getInstanceById: GetInstanceById<"Race" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: LanguagePrerequisites) => string;
+export declare const printLanguagePrerequisites: (value: LanguagePrerequisites) => Reader<DeriveEnvF<typeof printLanguagePrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print animist power prerequisites as a string.
  */
-export declare const printAnimistPowerPrerequisites: (getInstanceById: GetInstanceById<"AnimistPower">, locale: LocaleEnvironment, value: AnimistPowerPrerequisites) => string;
+export declare const printAnimistPowerPrerequisites: (value: AnimistPowerPrerequisites) => Reader<DeriveEnvF<typeof printAnimistPowerPrerequisiteGroup> & StdEnv<"t" | "lj" | "lc">, string>;
 /**
  * Print geode ritual prerequisites as a string.
  */
-export declare const printGeodeRitualPrerequisites: (getInstanceById: GetInstanceById<"Influence" | ActivatableIdentifier["kind"] | "Aspect">, getResolvedSelectOptionById: GetResolvedSelectOptionById, locale: LocaleEnvironment, value: GeodeRitualPrerequisites) => string;
+export declare const printGeodeRitualPrerequisites: (value: GeodeRitualPrerequisites) => Reader<DeriveEnvF<typeof printGeodeRitualPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
 /**
  * Print enhancement prerequisites as a string.
  */
-export declare const printEnhancementPrerequisites: (getInstanceById: GetInstanceById<RatedIdentifier["kind"] | "Enhancement">, locale: Pick<LocaleEnvironment, "translate" | "translateMap" | "compare" | "join">, value: EnhancementPrerequisites) => string;
+export declare const printEnhancementPrerequisites: (value: EnhancementPrerequisites) => Reader<DeriveEnvF<typeof printEnhancementPrerequisiteGroup> & StdEnv<"lj" | "lc">, string>;
+export {};