@optolith/entity-descriptions 0.2.1 → 0.3.1

package/lib/entities/curriculum.js

@@ -0,0 +1,266 @@
+import { partition } from "@elyukai/utils/array/groups";
+import { Dictionary } from "@elyukai/utils/dictionary";
+import { deepEqual } from "@elyukai/utils/equality";
+import { sign } from "@elyukai/utils/string/number";
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
+import { isNotNullish, mapNullable } from "@optolith/helpers/nullable";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { getBaseProfessionPackageForCurriculum } from "./partial/professions.js";
+import { parensIf } from "./partial/rated/activatable/parensIf.js";
+import { MISSING_VALUE } from "./partial/unknown.js";
+const renderElectiveSpellworks = (translate, translateMap, localeCompare, getInstanceById, electiveSpellworks) => {
+    switch (electiveSpellworks.kind) {
+        case "DefinedByGameMaster":
+            return translate("All, at the GM’s discretion");
+        case "Specific":
+            return electiveSpellworks.Specific.list
+                .map(item => mapNullable(translateMap(getInstanceById(item.id)?.translations)?.name, name => {
+                if (item.restriction === undefined) {
+                    return name;
+                }
+                return (name +
+                    parensIf(translateMap(getInstanceById("Element", item.restriction.Element)
+                        ?.translations)?.name ?? MISSING_VALUE));
+            }))
+                .filter(isNotNullish)
+                .toSorted(localeCompare)
+                .join(", ");
+        default:
+            return assertExhaustive(electiveSpellworks);
+    }
+};
+const renderRestrictedSpellworks = (translate, translateMap, localeCompare, localeJoin, getInstanceById, restrictedSpellworks) => {
+    const restrictedGroups = Dictionary.groupBy(restrictedSpellworks, restriction => restriction.kind === "Spellwork"
+        ? "spellwork"
+        : restriction.kind === "Property" &&
+            restriction.Property.maximum !== undefined
+            ? "restrictedProperty"
+            : restriction.kind === "Property" ||
+                restriction.kind === "DemonSummoning"
+                ? "property"
+                : "other");
+    const addExclusion = (excludedSpellworks) => {
+        if (excludedSpellworks === undefined) {
+            return "";
+        }
+        const translatedSpellworks = excludedSpellworks
+            .map(excludedSpellwork => translateMap(getInstanceById(excludedSpellwork)?.translations)?.name)
+            .filter(isNotNullish);
+        if (translatedSpellworks.length === 0) {
+            return "";
+        }
+        return ` (${translate("except {$list}", {
+            list: localeJoin(translatedSpellworks, "conjunction"),
+        })})`;
+    };
+    const restrictedProperties = restrictedGroups.get("restrictedProperty")?.map(restriction => translate(".input {$count :number} {{only {$count} additional spellworks with the Property {$property}}}", {
+        count: restriction.Property.maximum,
+        property: translateMap(getInstanceById("Property", restriction.Property.id)
+            ?.translations)?.name ?? MISSING_VALUE,
+    }) + addExclusion(restriction.Property.exclude)) ?? [];
+    const propertyGroup = restrictedGroups.get("property");
+    const translatedProperties = propertyGroup
+        ?.map(restriction => {
+        switch (restriction.kind) {
+            case "Property":
+                return translateMap(getInstanceById("Property", restriction.Property.id)
+                    ?.translations)?.name;
+            case "DemonSummoning":
+                return translate("Demon Summoning");
+            default:
+                return assertExhaustive(restriction);
+        }
+    })
+        .filter(isNotNullish)
+        .toSorted(localeCompare) ?? [];
+    const properties = translatedProperties.length > 0
+        ? [
+            translate("no spellworks with the Property {$property}", {
+                property: localeJoin(translatedProperties, "disjunction"),
+            }),
+        ]
+        : [];
+    const spellworkGroup = restrictedGroups.get("spellwork");
+    const translatedSpellworks = spellworkGroup
+        ?.map(restriction => translateMap(getInstanceById(restriction.Spellwork)?.translations)
+        ?.name)
+        .filter(isNotNullish)
+        .toSorted(localeCompare) ?? [];
+    const spellworks = translatedSpellworks.length > 0
+        ? [
+            translate("the following spells are not taught: {$spells}", {
+                spells: translatedSpellworks.join(", "),
+            }),
+        ]
+        : [];
+    const otherGroup = restrictedGroups.get("other");
+    const others = otherGroup?.map(restriction => {
+        switch (restriction.kind) {
+            case "Borbaradian":
+                return translate("no Borbaradian spellworks");
+            case "DamageIntelligent":
+                return translate("no spellworks that inflict DP or sDP on intelligent creatures");
+            default:
+                return assertExhaustive(restriction);
+        }
+    }) ?? [];
+    return [
+        ...restrictedProperties,
+        ...properties,
+        ...others,
+        ...spellworks,
+    ].join("; ");
+};
+const renderSpellworkAdjustment = (translateMap, getInstanceById, adjustment) => `${translateMap(getInstanceById(adjustment.id)?.translations)?.name ??
+    MISSING_VALUE} ${adjustment.points}${parensIf(adjustment.tradition === undefined
+    ? undefined
+    : translateMap(getInstanceById("MagicalTradition", adjustment.tradition)
+        ?.translations)?.name)}`;
+const renderAbilityAdjustmentName = (translateMap, getInstanceById, abilityAdjustment) => {
+    switch (abilityAdjustment.kind) {
+        case "Skill":
+            return (translateMap(getInstanceById("Skill", abilityAdjustment.Skill.id)?.translations)?.name ?? MISSING_VALUE);
+        case "CombatTechnique":
+            return (translateMap(getInstanceById(abilityAdjustment.CombatTechnique.id)?.translations)?.name ?? MISSING_VALUE);
+        case "Spellwork":
+            return ((translateMap(getInstanceById(abilityAdjustment.Spellwork.id)?.translations)?.name ?? MISSING_VALUE) +
+                parensIf(abilityAdjustment.Spellwork.tradition === undefined
+                    ? undefined
+                    : translateMap(getInstanceById("MagicalTradition", abilityAdjustment.Spellwork.tradition)?.translations)?.name));
+        default:
+            return assertExhaustive(abilityAdjustment);
+    }
+};
+const renderAbilityAdjustmentBaseValue = (baseProfessionPackage, abilityAdjustment) => {
+    switch (abilityAdjustment.kind) {
+        case "Skill":
+            return baseProfessionPackage.skills?.find(skill => skill.id === abilityAdjustment.Skill.id)?.rating_modifier;
+        case "CombatTechnique":
+            return baseProfessionPackage.combat_techniques?.find(skill => deepEqual(skill.id, abilityAdjustment.CombatTechnique.id))?.rating_modifier;
+        case "Spellwork":
+            return baseProfessionPackage.spells?.find(spell => spell.id.some(someSpell => someSpell.kind === "Spellwork" &&
+                deepEqual(someSpell.Spellwork.id, abilityAdjustment.Spellwork.id)))?.rating_modifier;
+        default:
+            return assertExhaustive(abilityAdjustment);
+    }
+};
+const renderAbilityAdjustmentModifierValue = (abilityAdjustment) => {
+    switch (abilityAdjustment.kind) {
+        case "Skill":
+            return abilityAdjustment.Skill.points;
+        case "CombatTechnique":
+            return abilityAdjustment.CombatTechnique.points;
+        case "Spellwork":
+            return abilityAdjustment.Spellwork.points;
+        default:
+            return assertExhaustive(abilityAdjustment);
+    }
+};
+const renderAbilityAdjustmentDefaultValue = (abilityAdjustment) => {
+    switch (abilityAdjustment.kind) {
+        case "Skill":
+            return 0;
+        case "CombatTechnique":
+            return 6;
+        case "Spellwork":
+            return 0;
+        default:
+            return assertExhaustive(abilityAdjustment);
+    }
+};
+const renderAbilityAdjustment = (translate, translateMap, getInstanceById, baseProfessionPackage) => baseProfessionPackage === undefined
+    ? abilityAdjustment => `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${sign(renderAbilityAdjustmentModifierValue(abilityAdjustment))}`
+    : abilityAdjustment => {
+        const basePoints = (renderAbilityAdjustmentBaseValue(baseProfessionPackage, abilityAdjustment) ?? 0) + renderAbilityAdjustmentDefaultValue(abilityAdjustment);
+        return translate("{$replacement} instead of {$base}", {
+            base: basePoints,
+            replacement: `${renderAbilityAdjustmentName(translateMap, getInstanceById, abilityAdjustment)} ${basePoints + renderAbilityAdjustmentModifierValue(abilityAdjustment)}`,
+        });
+    };
+const renderAbilityAdjustments = (translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, list) => list
+    ?.map(renderAbilityAdjustment(translate, translateMap, getInstanceById, baseProfessionPackage))
+    .toSorted(localeCompare)
+    .join(", ") ?? translate("none");
+/**
+ * Get a JSON representation of the rules text for a curriculum.
+ */
+export const getCurriculumEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getAllInstances, getChildInstancesForInstanceId, idMap }, { translate, translateMap, compare: localeCompare, join: localeJoin }, { content: entry, id }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    const baseProfessionPackage = getBaseProfessionPackageForCurriculum(getAllInstances, getChildInstancesForInstanceId, idMap, id)?.content;
+    return {
+        title: translation.name,
+        className: "curriculum",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("Guideline"),
+                        value: translateMap(getInstanceById("Guideline", entry.guideline)?.translations)?.name ?? MISSING_VALUE,
+                    },
+                    {
+                        label: translate("Elective Spellworks Package"),
+                        value: entry.elective_spellworks === undefined
+                            ? translate("none")
+                            : renderElectiveSpellworks(translate, translateMap, localeCompare, getInstanceById, entry.elective_spellworks),
+                    },
+                    {
+                        label: translate("Restricted Spellworks"),
+                        value: entry.restricted_spellworks === undefined
+                            ? translate("none")
+                            : renderRestrictedSpellworks(translate, translateMap, localeCompare, localeJoin, getInstanceById, entry.restricted_spellworks),
+                    },
+                ],
+            },
+            ...getChildInstancesForInstanceId("LessonPackage", id)
+                .map(lessonPackage => mapNullable(translateMap(lessonPackage.content.translations), (lessonPackageTranslation) => {
+                const [boni, mali] = partition(lessonPackage.content.skills ?? [], adjustment => {
+                    switch (adjustment.kind) {
+                        case "Skill":
+                            return adjustment.Skill.points > 0;
+                        case "CombatTechnique":
+                            return adjustment.CombatTechnique.points > 0;
+                        case "Spellwork":
+                            return adjustment.Spellwork.points > 0;
+                        default:
+                            return assertExhaustive(adjustment);
+                    }
+                });
+                return {
+                    type: "labeled",
+                    label: lessonPackageTranslation.name,
+                    value: {
+                        type: "definitionList",
+                        items: [
+                            {
+                                label: translate("Spellwork Changes"),
+                                value: lessonPackageTranslation?.spellwork_changes ??
+                                    lessonPackage.content.spellwork_changes
+                                        ?.map(change => translate("{$replacement} instead of {$base}", {
+                                        base: renderSpellworkAdjustment(translateMap, getInstanceById, change.base),
+                                        replacement: renderSpellworkAdjustment(translateMap, getInstanceById, change.replacement),
+                                    }))
+                                        .join(", ") ??
+                                    translate("none"),
+                            },
+                            {
+                                label: translate("Skills (+)"),
+                                value: renderAbilityAdjustments(translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, boni),
+                            },
+                            {
+                                label: translate("Skills (−)"),
+                                value: renderAbilityAdjustments(translate, translateMap, localeCompare, getInstanceById, baseProfessionPackage, mali),
+                            },
+                        ],
+                    },
+                };
+            }))
+                .filter(isNotNullish),
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/derivedCharacteristic.d.ts

@@ -0,0 +1,9 @@
+import type { GetInstanceById } from "../helpers/getTypes.js";
+import type { IdMap } from "../index.js";
+/**
+ * Get a JSON representation of the rules text for a derived characteristic.
+ */
+export declare const getDerivedCharacteristicEntityDescription: import("../creator.js").EntityDescriptionCreator<"DerivedCharacteristic", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "DerivedCharacteristic">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;

package/lib/entities/derivedCharacteristic.js

@@ -0,0 +1,91 @@
+import { assertExhaustive } from "@optolith/helpers/typeSafety";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderMathOperation } from "./partial/mathOperation.js";
+import { MISSING_VALUE } from "./partial/unknown.js";
+const getAttribute = (getInstanceById, translateMap, attributeId, style = "full") => {
+    const attribute = getInstanceById("Attribute", attributeId);
+    if (attribute === undefined) {
+        return MISSING_VALUE;
+    }
+    switch (style) {
+        case "full":
+            return translateMap(attribute.translations)?.name ?? MISSING_VALUE;
+        case "compact":
+            return translateMap(attribute.translations)?.abbreviation ?? MISSING_VALUE;
+        default:
+            return assertExhaustive(style);
+    }
+};
+const getRaceBaseValue = (translate, translateMap, getInstanceById, idMap, raceBaseValue, style = "full") => {
+    const instance = getInstanceById("DerivedCharacteristic", idMap.DerivedCharacteristic[raceBaseValue.kind]);
+    const translation = translateMap(instance?.translations);
+    if (translation === undefined) {
+        return MISSING_VALUE;
+    }
+    switch (style) {
+        case "full":
+            return translate("Base {$name} from Race", translation);
+        case "compact":
+            return translate("Race Base {$abbreviation}", translation);
+        default:
+            return assertExhaustive(style);
+    }
+};
+const renderBaseCalculation = (getInstanceById, translate, translateMap, idMap, calculation, style = "full") => renderMathOperation(calculation, value => {
+    switch (value.kind) {
+        case "Constant":
+            return value.Constant.toString(10);
+        case "Attribute":
+            return getAttribute(getInstanceById, translateMap, value.Attribute, style);
+        case "RaceBaseValue":
+            return getRaceBaseValue(translate, translateMap, getInstanceById, idMap, value.RaceBaseValue, style);
+        case "PrimaryAttribute":
+            switch (style) {
+                case "full":
+                    switch (value.PrimaryAttribute.kind) {
+                        case "Magical":
+                            return translate("Primary attribute for the magic user’s Tradition");
+                        case "Blessed":
+                            return translate("Primary attribute for the Blessed One’s Tradition");
+                        default:
+                            return assertExhaustive(value.PrimaryAttribute);
+                    }
+                case "compact":
+                    return translate("Primary Attribute");
+                default:
+                    return assertExhaustive(style);
+            }
+        default:
+            return assertExhaustive(value);
+    }
+});
+/**
+ * Get a JSON representation of the rules text for a derived characteristic.
+ */
+export const getDerivedCharacteristicEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, { translate, translateMap }, { content: entry }) => {
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: `${translation.name} (${translation.abbreviation})`,
+        className: "derived-characteristic",
+        body: [
+            translation.description === undefined
+                ? undefined
+                : {
+                    type: "plain",
+                    text: translation.description,
+                },
+            {
+                type: "definitionList",
+                items: [
+                    {
+                        label: translate("Base Value"),
+                        value: renderBaseCalculation(getInstanceById, translate, translateMap, idMap, entry.calculation.base),
+                    },
+                ],
+            },
+        ],
+    };
+});

package/lib/entities/disease.d.ts

@@ -0,0 +1,9 @@
+import type { GetInstanceById } from "../helpers/getTypes.js";
+import type { IdMap } from "../index.js";
+/**
+ * Get a JSON representation of the rules text for an optional rule.
+ */
+export declare const getDiseaseEntityDescription: import("../creator.js").EntityDescriptionCreator<"AnimalDisease" | "Disease", {
+    getInstanceById: GetInstanceById<"Publication" | "AnimalType" | "DerivedCharacteristic">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;

package/lib/entities/disease.js

@@ -0,0 +1,88 @@
+import { ensureNonEmpty } from "@elyukai/utils/array/nonEmpty";
+import { isNotNullish } from "@elyukai/utils/nullable";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderAnimalTypesSection } from "./partial/animalTypes.js";
+import { renderAlternativeNames, renderChance, renderResistance, } from "./partial/herbary.js";
+import { parensIf } from "./partial/rated/activatable/parensIf.js";
+import { MISSING_VALUE } from "./partial/unknown.js";
+const renderCauses = (translate, translateMap, causes) => causes
+    .map(cause => {
+    const causeTranslation = translateMap(cause.translations);
+    if (causeTranslation === undefined) {
+        return MISSING_VALUE;
+    }
+    return (causeTranslation.name +
+        parensIf(ensureNonEmpty([
+            renderChance(translate, translateMap, cause, true),
+            causeTranslation.note,
+        ].filter(isNotNullish))?.join("; ")));
+})
+    .join(", ");
+/**
+ * Get a JSON representation of the rules text for an optional rule.
+ */
+export const getDiseaseEntityDescription = createEntityDescriptionCreator(({ getInstanceById, idMap }, { translate, translateMap, compare: localeCompare }, { entity, content: entry }) => {
+    const baseEntry = entry;
+    const translation = translateMap(baseEntry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: translation.name,
+        className: "disease",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    renderAlternativeNames(translate, translation.alternative_names),
+                    { label: translate("Level"), value: baseEntry.level.toString() },
+                    { label: translate("Progress"), value: translation.progress },
+                    {
+                        label: translate("Resistance"),
+                        value: renderResistance(translate, translateMap, getInstanceById, idMap, baseEntry.resistance),
+                    },
+                    {
+                        label: translate("Incubation Time"),
+                        value: translation.incubation_time,
+                    },
+                    {
+                        label: translate("Damage"),
+                        value: translation.damage.default +
+                            (translation.damage.reduced === undefined
+                                ? ""
+                                : ` / ${translation.damage.reduced}`),
+                    },
+                    {
+                        label: translate("Duration"),
+                        value: translation.duration.default +
+                            (translation.duration.reduced === undefined
+                                ? ""
+                                : ` / ${translation.duration.reduced}`),
+                    },
+                    {
+                        label: translate("Causes"),
+                        value: renderCauses(translate, translateMap, baseEntry.cause),
+                    },
+                    translation.special === undefined
+                        ? undefined
+                        : { label: translate("Special"), value: translation.special },
+                    { label: translate("Treatment"), value: translation.treatment },
+                    { label: translate("Antidote"), value: translation.cure },
+                    entity === "AnimalDisease"
+                        ? renderAnimalTypesSection(translate, translateMap, localeCompare, getInstanceById, entry.animal_types)
+                        : undefined,
+                    entity === "AnimalDisease"
+                        ? {
+                            label: translate("Communicability to Intelligent Creatures"),
+                            value: entry.communicability_to_intelligent_creatures.length === 0
+                                ? translate("No")
+                                : `${translate("Yes")}; ${renderCauses(translate, translateMap, entry.communicability_to_intelligent_creatures)}`,
+                        }
+                        : undefined,
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: baseEntry.src,
+    };
+});

package/lib/entities/elixir.d.ts

@@ -0,0 +1,10 @@
+import type { ActivatableIdentifier, RatedIdentifier } from "optolith-database-schema/gen";
+import type { GetInstanceById } from "../helpers/getTypes.js";
+import type { GetResolvedSelectOptionById } from "./partial/prerequisites/single/activatable.js";
+/**
+ * Get a JSON representation of the rules text for an elixir.
+ */
+export declare const getElixirEntityDescription: import("../creator.js").EntityDescriptionCreator<"Elixir", {
+    getInstanceById: GetInstanceById<"Publication" | "DerivedCharacteristic" | ActivatableIdentifier["kind"] | RatedIdentifier["kind"] | "Race" | "Culture" | "State" | "Enhancement" | "PactCategory" | "PactDomain" | "SocialStatus" | "Aspect" | "Property">;
+    getResolvedSelectOptionById: GetResolvedSelectOptionById;
+}, import("../index.js").EntityDescription>;

package/lib/entities/elixir.js

@@ -0,0 +1,76 @@
+import { mapNullable } from "@elyukai/utils/nullable";
+import { sign } from "@elyukai/utils/string/number";
+import { createEntityDescriptionCreator } from "../creator.js";
+import { renderAlternativeNames, renderLaboratoryLevel, } from "./partial/herbary.js";
+import { printPlainGeneralPrerequisites } from "./partial/prerequisites/index.js";
+import { parensIf } from "./partial/rated/activatable/parensIf.js";
+/**
+ * Get a JSON representation of the rules text for an elixir.
+ */
+export const getElixirEntityDescription = createEntityDescriptionCreator(({ getInstanceById, getResolvedSelectOptionById }, locale, { content: entry }) => {
+    const { translate, translateMap } = locale;
+    const translation = translateMap(entry.translations);
+    if (translation === undefined) {
+        return undefined;
+    }
+    return {
+        title: translation.name,
+        className: "elixir",
+        body: [
+            {
+                type: "definitionList",
+                items: [
+                    renderAlternativeNames(translate, translation.alternative_names),
+                    {
+                        label: translate("Typical Ingredients"),
+                        value: translation.typical_ingredients.join(", "),
+                    },
+                    {
+                        label: translate("Price of Ingredients/Level"),
+                        value: translate(".input {$value :number} {{{$value} silverthalers}}", { value: entry.cost_per_ingredient_level }),
+                    },
+                    {
+                        label: translate("Laboratory"),
+                        value: renderLaboratoryLevel(translate, entry.laboratory),
+                    },
+                    {
+                        label: translate("Brewing Difficulty"),
+                        value: sign(entry.brewing_difficulty),
+                    },
+                    {
+                        label: `${translate("Prerequisites")} (${translate("Brewing Process")})`,
+                        value: translation?.brewing_process_prerequisites ?? translate("none"),
+                    },
+                    {
+                        label: `${translate("AP Value")} (${translate("Trade Secret")})`,
+                        value: translate("{$value} AP", {
+                            value: entry.trade_secret.ap_value,
+                        }) +
+                            parensIf(mapNullable(entry.trade_secret.prerequisites, prerequisites => `${translate("Prerequisites")}: ${printPlainGeneralPrerequisites(getInstanceById, getResolvedSelectOptionById, locale, prerequisites)}`)),
+                    },
+                    translation.special === undefined
+                        ? undefined
+                        : {
+                            label: translate("Special"),
+                            value: translation.special,
+                        },
+                    {
+                        label: translate("Quality Levels"),
+                        value: [
+                            {
+                                type: "definitionList",
+                                style: "nested",
+                                items: translation.quality_levels.map((effectForLevel, index) => ({
+                                    label: (index + 1).toString(),
+                                    value: effectForLevel,
+                                })),
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+        errata: translation.errata,
+        references: entry.src,
+    };
+});

package/lib/entities/equipment.d.ts

@@ -0,0 +1,24 @@
+import type { EquipmentIdentifier, GenMeleeWeapon, GenRangedWeapon, LocaleMeasurementAdjustments } from "optolith-database-schema/gen";
+import { type TaggedEntity } from "../creator.js";
+import type { GetInstanceById } from "../helpers/getTypes.js";
+import type { Translate, TranslateMap } from "../helpers/translate.js";
+import type { IdMap, LabeledEntityDescriptionSection, RawEntityDescriptionSectionContent } from "../index.js";
+/**
+ * Get the name of an equipment item.
+ */
+export declare const getEquipmentName: (translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"SocialStatus">, entry: TaggedEntity<EquipmentIdentifier["kind"]>) => string;
+/**
+ * Render combat values of a melee weapon.
+ */
+export declare const renderMeleeWeapon: <Damage>(translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"Attribute" | "CloseCombatTechnique" | "Reach">, measurements: Required<LocaleMeasurementAdjustments>, renderDamage: (damage: Damage) => string, closeCombatTechniqueId: string, use: GenMeleeWeapon<Damage>) => LabeledEntityDescriptionSection<RawEntityDescriptionSectionContent>;
+/**
+ * Render combat values of a ranged weapon.
+ */
+export declare const renderRangedWeapon: <Damage>(translate: Translate, translateMap: TranslateMap, getInstanceById: GetInstanceById<"RangedCombatTechnique" | "Ammunition">, measurements: Required<LocaleMeasurementAdjustments>, renderDamage: (damage: Damage) => string, rangedCombatTechniqueId: string, use: GenRangedWeapon<Damage>) => LabeledEntityDescriptionSection<RawEntityDescriptionSectionContent>;
+/**
+ * Get a JSON representation of the rules text for equipment.
+ */
+export declare const getEquipmentEntityDescription: import("../creator.js").EntityDescriptionCreator<"Weapon" | "Armor" | "Ammunition" | "Animal" | "AnimalCare" | "BandageOrRemedy" | "Book" | "CeremonialItem" | "Clothes" | "ClothingPackage" | "Container" | "EquipmentOfBlessedOnes" | "GemOrPreciousStone" | "IlluminationLightSource" | "IlluminationRefillOrSupply" | "Jewelry" | "Laboratory" | "Liebesspielzeug" | "LuxuryGood" | "MagicalArtifact" | "MusicalInstrument" | "Newspaper" | "OrienteeringAid" | "RopeOrChain" | "Stationery" | "ThievesTool" | "ToolOfTheTrade" | "TravelGearOrTool" | "Vehicle" | "WeaponAccessory", {
+    getInstanceById: GetInstanceById<"Publication" | "Attribute" | "Reach" | "SocialStatus" | "CloseCombatTechnique" | "RangedCombatTechnique" | "MagicalTradition" | "BlessedTradition" | "DerivedCharacteristic" | "Ammunition" | "Race" | "Culture" | "Profession">;
+    idMap: IdMap;
+}, import("../index.js").EntityDescription>;