@archivist-gg/dnd5e 0.1.0

package/dist/pc/pc.types.d.ts

@@ -0,0 +1,514 @@
+import type { Ability } from "../types/choice.js";
+import type { ArmorEntity } from "../armor/armor.types.js";
+import type { WeaponEntity } from "../weapon/weapon.types.js";
+import type { ItemEntity } from "../item/item.types.js";
+import type { SkillSlug, Feature } from "@archivist-gg/dnd5e";
+import type { ClassEntity } from "@archivist-gg/dnd5e/class/class.types";
+import type { RaceEntity } from "@archivist-gg/dnd5e/race/race.types";
+import type { SubclassEntity } from "@archivist-gg/dnd5e/subclass/subclass.types";
+import type { BackgroundEntity } from "@archivist-gg/dnd5e/background/background.types";
+import type { FeatEntity } from "@archivist-gg/dnd5e/feat/feat.types";
+import type { Spell } from "@archivist-gg/dnd5e/spell/spell.types";
+import type { OptionalFeatureEntity } from "@archivist-gg/dnd5e/types/optional-feature.types";
+import type { ConditionSlug } from "./conditions.constants.js";
+/** A persisted decision value: entity slug / inline value (string), multi-select
+ *  slugs (string[]), or an ability-points allocation. Stale/odd legacy values
+ *  survive parsing (schema is permissive); readers narrow defensively. */
+export type ChoiceValue = string | string[] | Partial<Record<Ability, number>>;
+export type LevelChoices = Record<string, ChoiceValue>;
+export interface ClassEntry {
+    name: string;
+    level: number;
+    subclass: string | null;
+    choices: Record<number, LevelChoices>;
+}
+export type SlotKey = "mainhand" | "offhand" | "armor" | "shield";
+export interface EquipmentEntryOverrides {
+    name?: string;
+    bonus?: number;
+    damage_bonus?: number;
+    extra_damage?: string;
+    ac_bonus?: number;
+    action?: "action" | "bonus-action" | "reaction" | "free" | "special";
+    range?: string;
+    resist?: string[];
+    immune?: string[];
+    vulnerable?: string[];
+    condition_immune?: string[];
+}
+export interface EquipmentEntryState {
+    charges?: {
+        current: number;
+        max: number;
+    };
+    recovery?: {
+        amount: string;
+        reset: "dawn" | "short" | "long" | "special";
+    };
+    depletion_risk?: {
+        trigger: string;
+        roll: string;
+        threshold: number;
+        effect: string;
+    };
+}
+export type EquipmentEntry = {
+    item: string;
+    equipped?: boolean;
+    attuned?: boolean;
+    qty?: number;
+    notes?: string;
+    slot?: SlotKey | null;
+    overrides?: EquipmentEntryOverrides;
+    state?: EquipmentEntryState;
+    /** Build-only provenance tag for gear the Builder's Equipment step seeded
+     *  on the character's behalf (e.g. `"builder:starting"`, `"builder:gold-buy"`).
+     *  Lets the step reconcile its own grants on re-pick / mode-switch without
+     *  touching hand-managed entries. Stripped by finishBuild — absent on every
+     *  finished file. */
+    granted_by?: string;
+};
+export interface ResolvedEquipped {
+    index: number;
+    entity: ArmorEntity | WeaponEntity | ItemEntity | null;
+    entityType: string | null;
+    entry: EquipmentEntry;
+}
+export interface EquippedSlots {
+    mainhand?: ResolvedEquipped;
+    offhand?: ResolvedEquipped;
+    armor?: ResolvedEquipped;
+    shield?: ResolvedEquipped;
+}
+export type Edition = "2014" | "2024";
+export type AbilityMethod = "standard-array" | "point-buy" | "archivist-point-buy" | "rolled" | "manual";
+export interface SpellOverride {
+    slug: string;
+    overrides: Record<string, unknown>;
+}
+export interface KnownSpellObject {
+    spell: string;
+    class?: string;
+    source?: "class" | "feat" | "item" | "race" | "domain";
+    prepared?: boolean;
+    always_prepared?: boolean;
+}
+export type KnownSpellEntry = string | KnownSpellObject;
+export type PassiveKind = "perception" | "investigation" | "insight";
+export interface CharacterOverrides {
+    scores?: Partial<Record<Ability, number>>;
+    saves?: Partial<Record<Ability, {
+        bonus?: number;
+        proficient?: boolean;
+    }>>;
+    skills?: Partial<Record<SkillSlug, {
+        bonus: number;
+        proficiency?: "none" | "proficient" | "expertise";
+    }>>;
+    passives?: Partial<{
+        perception: number;
+        investigation: number;
+        insight: number;
+    }>;
+    hp?: {
+        max?: number;
+    };
+    ac?: number;
+    speed?: number;
+    initiative?: number;
+    spellcasting?: {
+        saveDC?: number;
+        attackBonus?: number;
+    };
+    spell_slots?: Record<number, number>;
+    attunement_limit?: number;
+}
+export interface CharacterState {
+    hp: {
+        current: number;
+        max: number;
+        temp: number;
+    };
+    hit_dice: Record<string, {
+        used: number;
+        total: number;
+    }>;
+    spell_slots: Record<number, {
+        used: number;
+        total: number;
+    }>;
+    spell_slots_pact?: {
+        level: number;
+        used: number;
+        total: number;
+    };
+    concentration: string | null;
+    conditions: ConditionSlug[];
+    exhaustion: number;
+    death_saves?: {
+        successes: number;
+        failures: number;
+    };
+    inspiration: number;
+    feature_uses: Record<string, {
+        used: number;
+        max: number;
+    }>;
+    /** Phase 3 activatable buffs: ids/slugs of activatable features/boons currently
+     *  toggled on. Their effects fold into recalc only while listed here. */
+    active_buffs?: string[];
+    /** @deprecated SP5: moved to Character.currency. Tolerated until Task 4 parser migration strips it. */
+    currency?: {
+        cp: number;
+        sp: number;
+        ep: number;
+        gp: number;
+        pp: number;
+    };
+    /** @deprecated SP5: removed; per-entry attuned flag is canonical. Tolerated until Task 4 parser migration strips it. */
+    attuned_items?: string[];
+}
+export interface Character {
+    name: string;
+    edition: Edition;
+    /** Present and `true` only while the file is a Builder draft (autosaved,
+     *  resumable). Removed by the Builder's Finish action, which flips the file
+     *  to the full character sheet. Absent on every pre-Builder/finished file. */
+    builder?: boolean;
+    alignment?: string;
+    /** Optional free-text age ("26", "Ageless") — Details step. */
+    age?: string;
+    race: string | null;
+    subrace: string | null;
+    background: string | null;
+    class: ClassEntry[];
+    /** Race/background decision selections, keyed `race:<choice-id>` /
+     *  `background:<choice-id>` (SP2 Plan 3). */
+    origin_choices?: Record<string, ChoiceValue>;
+    abilities: Record<Ability, number>;
+    ability_method: AbilityMethod;
+    /** Persisted Roll-method ability pool (six 4d6-drop-lowest totals) while the
+     *  file is a Builder draft. Present only in `rolled` mode during a build so
+     *  the rolled pool survives view close / Obsidian restart (UI state cannot);
+     *  the Abilities step + Base popover read their pool from here. Removed by the
+     *  Builder's Finish action (see finishBuild) — a finished file carries none. */
+    builder_rolls?: number[];
+    /** Persisted Equipment-step mode while the file is a Builder draft: "starting"
+     *  takes the class/background starting-gear grants, "gold" buys with rolled
+     *  starting gold, "empty" begins with nothing. Present only during a build;
+     *  removed by the Builder's Finish action (see finishBuild). */
+    builder_equipment_mode?: "starting" | "gold" | "empty";
+    skills: {
+        proficient: SkillSlug[];
+        expertise: SkillSlug[];
+    };
+    spells: {
+        known: KnownSpellEntry[];
+        overrides: SpellOverride[];
+        view?: "by-level" | "table";
+    };
+    equipment: EquipmentEntry[];
+    overrides: CharacterOverrides;
+    currency?: {
+        cp: number;
+        sp: number;
+        ep: number;
+        gp: number;
+        pp: number;
+    };
+    notes?: string;
+    defenses?: {
+        resistances?: string[];
+        immunities?: string[];
+        vulnerabilities?: string[];
+        condition_immunities?: string[];
+    };
+    state: CharacterState;
+}
+export type FeatureSource = {
+    kind: "class";
+    slug: string;
+    level: number;
+} | {
+    kind: "subclass";
+    slug: string;
+    level: number;
+} | {
+    kind: "race";
+    slug: string;
+} | {
+    kind: "background";
+    slug: string;
+} | {
+    kind: "feat";
+    slug: string;
+};
+export interface ResolvedFeature {
+    feature: Feature;
+    source: FeatureSource;
+}
+export interface ResolvedSpell {
+    entity: Spell;
+    slug: string;
+    classSlug: string | null;
+    source: "class" | "feat" | "item" | "race" | "domain";
+    prepared: boolean;
+    alwaysPrepared: boolean;
+}
+export interface ResolvedClass {
+    entity: ClassEntity | null;
+    level: number;
+    subclass: SubclassEntity | null;
+    choices: Record<number, LevelChoices>;
+}
+export interface ResolvedPoolEntry {
+    slug: string;
+    entity: OptionalFeatureEntity;
+}
+/** A materialized selection pool: count from the table column, prereq-filtered
+ *  candidates, player picks (from the choices ledger), and subclass auto-grants. */
+export interface ResolvedPool {
+    id: string;
+    label: string;
+    /** Which resolved class declared this pool (for ledger anchoring + writes). */
+    classIndex: number;
+    /** Picks allowed at the current level (table column value). */
+    count: number;
+    /** Lowest class level where count >= 1 — the stable persistence key level. */
+    anchorLevel: number;
+    selected: ResolvedPoolEntry[];
+    available: ResolvedPoolEntry[];
+    grants: ResolvedPoolEntry[];
+}
+export interface ResolvedCharacter {
+    definition: Character;
+    race: RaceEntity | null;
+    classes: ResolvedClass[];
+    background: BackgroundEntity | null;
+    feats: FeatEntity[];
+    totalLevel: number;
+    features: ResolvedFeature[];
+    spells: ResolvedSpell[];
+    pools: ResolvedPool[];
+    state: CharacterState;
+}
+export interface ProficiencySet {
+    categories: string[];
+    specific: string[];
+}
+export interface ACTerm {
+    source: string;
+    amount: number;
+    kind: "armor" | "shield" | "item" | "unarmored" | "override" | "dex" | "ability" | "feature";
+}
+export interface AttackRow {
+    id: string;
+    name: string;
+    range?: string;
+    toHit: number;
+    damageDice: string;
+    damageType: string;
+    extraDamage?: string;
+    properties: string[];
+    proficient: boolean;
+    breakdown: {
+        toHit: ACTerm[];
+        damage: ACTerm[];
+    };
+    informational?: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    /** Hand slot the attack came from. Used by Actions tab to find the
+     *  originating equipment entry for the row-expand panel. */
+    slotKey?: "mainhand" | "offhand";
+    /** Short caption under the weapon name in the Actions tab table.
+     *  e.g. "martial · versatile". Display-only. */
+    subLabel?: string;
+    /** Action-economy cost for the Cost badge. Defaults to "action" at
+     *  render time when absent. Settable via entry.overrides.action. */
+    actionCost?: "action" | "bonus-action" | "reaction" | "free" | "special";
+    /** When set, the weapon is being wielded one-handed but has a versatile
+     *  two-handed option. The Actions tab renders both lines stacked in the
+     *  damage cell instead of emitting a second row. */
+    versatile?: {
+        damageDice: string;
+    };
+    /** Lowest natural-roll threshold that scores a critical hit on this attack,
+     *  from `crit-range` feature effects (e.g. 19 = "crit on 19–20"). Display-only
+     *  metadata mapped on in recalc; absent (undefined) for the normal 20-only
+     *  crit so untouched attack rows are unchanged. The weapons table renders a
+     *  "crit X–20" caption whenever it is set and < 20. */
+    critRange?: number;
+    /** Order-preserving display-only captions from `reroll-damage` / `attack-rule`
+     *  feature effects (e.g. ["Reroll 2s", "No disadvantage firing in melee"]).
+     *  Mapped on in recalc; absent (undefined) when no such effect is present so
+     *  untouched attack rows are unchanged. The weapons table renders these joined
+     *  with " · " as a muted caption under the weapon name. */
+    attackNotes?: string[];
+}
+export interface AppliedBonuses {
+    ability_bonuses: Partial<Record<Ability, number>>;
+    ability_statics: Partial<Record<Ability, number>>;
+    save_bonus: number;
+    speed_bonuses: {
+        walk: number;
+        fly: number | "walk" | null;
+        swim: number;
+        climb: number;
+    };
+    spell_attack: number;
+    spell_save_dc: number;
+    defenses: {
+        resistances: string[];
+        immunities: string[];
+        vulnerabilities: string[];
+        condition_immunities: string[];
+    };
+    informational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    senses: Record<import("@archivist-gg/dnd5e/types/feature-effect").SenseType, number>;
+}
+export interface DerivedEquipment {
+    ac: number;
+    acBreakdown: ACTerm[];
+    acInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    attacks: AttackRow[];
+    equippedSlots: EquippedSlots;
+    carriedWeight: number;
+    attunementUsed: number;
+    attunementLimit: number;
+}
+/**
+ * A structured advantage/disadvantage entry surfaced from a `roll-modifier`
+ * feature effect. Order-preserving pass-through list on DerivedStats (no
+ * dedupe/merge) — each entry carries the owning feature's name as `label`
+ * for tooltips. `scope` absent = applies to all rolls of that `roll` type;
+ * `condition` absent = always-on (not situational).
+ */
+export interface RollModifierEntry {
+    mode: "advantage" | "disadvantage";
+    roll: "ability-check" | "saving-throw" | "attack";
+    scope?: string;
+    condition?: string;
+    label: string;
+}
+export interface DerivedStats {
+    totalLevel: number;
+    proficiencyBonus: number;
+    scores: Record<Ability, number>;
+    mods: Record<Ability, number>;
+    saves: Record<Ability, {
+        bonus: number;
+        proficient: boolean;
+    }>;
+    proficiencies: {
+        armor: ProficiencySet;
+        weapons: ProficiencySet;
+        tools: ProficiencySet;
+        languages: string[];
+        saves: Ability[];
+    };
+    skills: Record<SkillSlug, {
+        bonus: number;
+        proficiency: "none" | "proficient" | "expertise";
+        ability: Ability;
+    }>;
+    passives: {
+        perception: number;
+        investigation: number;
+        insight: number;
+    };
+    /** Computed senses: max of race vision and feature-effect sense ranges. 0 = none per type. */
+    senses: Record<import("@archivist-gg/dnd5e/types/feature-effect").SenseType, number>;
+    hp: {
+        max: number;
+        current: number;
+        temp: number;
+    };
+    ac: number;
+    speed: number;
+    initiative: number;
+    spellcasting: {
+        ability: Ability;
+        saveDC: number;
+        attackBonus: number;
+        preparedCount?: number;
+    } | null;
+    /** One entry per casting class (multiclass-aware). Empty for non-casters. */
+    spellcastingClasses: SpellcastingClassInfo[];
+    /** Derived standard slot totals by spell level (before user override). */
+    derivedSpellSlots: Record<number, number>;
+    /** Warlock Pact Magic, or null. */
+    pactMagic: {
+        level: number;
+        total: number;
+    } | null;
+    /** Per-class known/prepared + cantrip limits (advisory). */
+    spellLimits: SpellLimitInfo[];
+    warnings: string[];
+    defenses: {
+        resistances: string[];
+        immunities: string[];
+        vulnerabilities: string[];
+        condition_immunities: string[];
+    };
+    acBreakdown: ACTerm[];
+    acInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    /** Situational saving-throw bonuses (e.g. +1 vs spells) for save tooltips. */
+    savesInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    /** Situational spell attack / save-DC bonuses for spellcasting tooltips. */
+    spellcastingInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    /** Situational speed bonuses (e.g. swim while underwater) for speed tooltips. */
+    speedInformational: import("@archivist-gg/dnd5e/item/item.conditions.types").InformationalBonus[];
+    /**
+     * Attacks per Attack action = 1 + max `extra-attack` effect count. Always ≥ 1
+     * (everyone gets one attack). The Actions "Attacks" heading shows `(×N)` when > 1.
+     */
+    attacksPerAction: number;
+    attacks: AttackRow[];
+    equippedSlots: EquippedSlots;
+    carriedWeight: number;
+    attunementUsed: number;
+    attunementLimit: number;
+    conditionEffects: ConditionEffects;
+    /**
+     * Structured advantage/disadvantage entries from `roll-modifier` effects.
+     * Order-preserving pass-through (no dedupe/merge); rendered as ADV/DIS chips.
+     */
+    rollModifiers: RollModifierEntry[];
+}
+export interface SpellcastingClassInfo {
+    classSlug: string;
+    className: string;
+    ability: Ability;
+    saveDC: number;
+    attackBonus: number;
+    casterType: "full" | "half" | "third" | "pact";
+    preparation: "known" | "prepared";
+}
+export interface SpellLimitInfo {
+    classSlug: string;
+    kind: "known" | "prepared";
+    cantripsKnown: number | null;
+    preparedOrKnown: number | null;
+}
+export interface ConditionEffects {
+    speed_multiplier: number;
+    speed_reduction_ft: number;
+    speed_floor_zero: boolean;
+    hp_max_multiplier: number;
+    d20_test_penalty: number;
+    exhaustion_level: number;
+    attack_disadvantage: boolean;
+    attack_advantage: boolean;
+    attack_advantage_against: boolean;
+    ability_check_disadvantage: boolean;
+    save_disadvantage_dex: boolean;
+    save_autofail_str: boolean;
+    save_autofail_dex: boolean;
+    saves_disadvantage_all: boolean;
+    actions_disabled: boolean;
+    reactions_disabled: boolean;
+    sources: Array<{
+        condition: ConditionSlug | "exhaustion";
+        level?: number;
+        effects: string[];
+    }>;
+}

package/dist/race/race.codec.d.ts

@@ -0,0 +1,9 @@
+import type { DocCodec } from "@archivist-gg/core";
+import type { RaceEntity } from "./race.types.js";
+/**
+ * Normalizing codec (0c.1a). `parse` delegates to `parseRace`, which seeds the
+ * `edition: "2014"` default and validates against `raceEntitySchema`. `serialize`
+ * stays `yaml.dump` (the edit-save path uses obsidian's separate serializer; gate
+ * (d) verifies `yaml.dump` round-trips through `parseRace`).
+ */
+export declare const raceCodec: DocCodec<RaceEntity>;

package/dist/race/race.codec.js

@@ -0,0 +1,13 @@
+import {
+  raceCodec
+} from "../chunk-PKC77VZP.js";
+import "../chunk-IDTDACM6.js";
+import "../chunk-FFULAF2P.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  raceCodec
+};

package/dist/race/race.entity-type.d.ts

@@ -0,0 +1,2 @@
+import type { EntityType } from "@archivist-gg/core";
+export declare const raceEntityType: EntityType;

package/dist/race/race.parser.d.ts

@@ -0,0 +1,3 @@
+import type { RaceEntity } from "./race.types.js";
+import { ParseResult } from "@archivist-gg/core";
+export declare function parseRace(source: string): ParseResult<RaceEntity>;

package/dist/race/race.parser.js

@@ -0,0 +1,12 @@
+import {
+  parseRace
+} from "../chunk-IDTDACM6.js";
+import "../chunk-FFULAF2P.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  parseRace
+};

package/dist/race/race.schema.d.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+export declare const raceEntitySchema: z.ZodObject<{
+    slug: z.ZodString;
+    name: z.ZodString;
+    edition: z.ZodEnum<{
+        2014: "2014";
+        2024: "2024";
+    }>;
+    source: z.ZodString;
+    description: z.ZodString;
+    size: z.ZodEnum<{
+        medium: "medium";
+        tiny: "tiny";
+        small: "small";
+        large: "large";
+        huge: "huge";
+    }>;
+    speed: z.ZodObject<{
+        walk: z.ZodOptional<z.ZodNumber>;
+        fly: z.ZodOptional<z.ZodNumber>;
+        swim: z.ZodOptional<z.ZodNumber>;
+        climb: z.ZodOptional<z.ZodNumber>;
+        burrow: z.ZodOptional<z.ZodNumber>;
+        hover: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    ability_score_increases: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        ability: z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        choose: z.ZodNumber;
+        pool: z.ZodArray<z.ZodEnum<{
+            str: "str";
+            dex: "dex";
+            con: "con";
+            int: "int";
+            wis: "wis";
+            cha: "cha";
+        }>>;
+        amount: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    age: z.ZodString;
+    alignment: z.ZodString;
+    vision: z.ZodObject<{
+        darkvision: z.ZodOptional<z.ZodNumber>;
+        blindsight: z.ZodOptional<z.ZodNumber>;
+        tremorsense: z.ZodOptional<z.ZodNumber>;
+        truesight: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    languages: z.ZodObject<{
+        fixed: z.ZodArray<z.ZodString>;
+        choice: z.ZodOptional<z.ZodObject<{
+            count: z.ZodNumber;
+            from: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    variant_label: z.ZodString;
+    traits: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+    choices: z.ZodOptional<z.ZodArray<z.ZodType<import("../index.js").Choice, unknown, z.core.$ZodTypeInternals<import("../index.js").Choice, unknown>>>>;
+    subspecies_of: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;

package/dist/race/race.schema.js

@@ -0,0 +1,11 @@
+import {
+  raceEntitySchema
+} from "../chunk-FFULAF2P.js";
+import "../chunk-DABBCYTT.js";
+import "../chunk-WYGD2UGN.js";
+import "../chunk-PZOWBI3B.js";
+import "../chunk-CDW7R2QT.js";
+import "../chunk-NXR3BD2V.js";
+export {
+  raceEntitySchema
+};

package/dist/race/race.types.d.ts

@@ -0,0 +1,44 @@
+import type { Feature, Ability, Speed, Choice } from "@archivist-gg/dnd5e";
+import type { Edition } from "@archivist-gg/dnd5e/types/edition";
+export type Size = "tiny" | "small" | "medium" | "large" | "huge";
+export type FixedAbilityIncrease = {
+    ability: Ability;
+    amount: number;
+};
+export type ChoiceAbilityIncrease = {
+    choose: number;
+    pool: Ability[];
+    amount: number;
+};
+export type AbilityScoreIncrease = FixedAbilityIncrease | ChoiceAbilityIncrease;
+export interface Vision {
+    darkvision?: number;
+    blindsight?: number;
+    tremorsense?: number;
+    truesight?: number;
+}
+export interface LanguageProficiencies {
+    fixed: string[];
+    choice?: {
+        count: number;
+        from: string | string[];
+    };
+}
+export interface RaceEntity {
+    slug: string;
+    name: string;
+    edition: Edition;
+    source: string;
+    description: string;
+    size: Size;
+    speed: Speed;
+    ability_score_increases: AbilityScoreIncrease[];
+    age: string;
+    alignment: string;
+    vision: Vision;
+    languages: LanguageProficiencies;
+    variant_label: string;
+    traits: Feature[];
+    choices?: Choice[];
+    subspecies_of?: string;
+}