avrae-ls 0.3.1__py3-none-any.whl → 0.4.1__py3-none-any.whl

avrae_ls/api.py

@@ -23,7 +23,7 @@ class _DirMixin:
     METHODS: ClassVar[list[str]] = []
 
     def __dir__(self) -> list[str]:
-        data_keys = list(getattr(self, "data", {}).keys())
+        data_keys = list(getattr(self, "_data", {}).keys())
         return sorted(set(self.ATTRS + self.METHODS + data_keys))
 
     def __post_init__(self) -> None:
@@ -57,21 +57,21 @@ class SimpleRollResult(_DirMixin):
 # === Context API ===
 @dataclass
 class GuildAPI(_DirMixin):
-    data: Mapping[str, Any] = field(default_factory=dict)
+    _data: Mapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["name", "id"]
     METHODS: ClassVar[list[str]] = ["servsettings"]
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Guild"))
+        return str(self._data.get("name", "Guild"))
 
     @property
     def id(self) -> int | None:
-        raw = self.data.get("id")
+        raw = self._data.get("id")
         return int(raw) if raw is not None else None
 
     def servsettings(self) -> Mapping[str, Any] | None:
-        return self.data.get("servsettings")
+        return self._data.get("servsettings")
 
     def __getitem__(self, item: str) -> Any:
         if isinstance(item, int):
@@ -87,17 +87,17 @@ class GuildAPI(_DirMixin):
 
 @dataclass
 class CategoryAPI(_DirMixin):
-    data: Mapping[str, Any] = field(default_factory=dict)
+    _data: Mapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["name", "id"]
     METHODS: ClassVar[list[str]] = []
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Category"))
+        return str(self._data.get("name", "Category"))
 
     @property
     def id(self) -> int | None:
-        raw = self.data.get("id")
+        raw = self._data.get("id")
         return int(raw) if raw is not None else None
 
     def __getitem__(self, item: str) -> Any:
@@ -106,32 +106,32 @@ class CategoryAPI(_DirMixin):
 
 @dataclass
 class ChannelAPI(_DirMixin):
-    data: Mapping[str, Any] = field(default_factory=dict)
+    _data: Mapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["name", "id", "topic", "category", "parent"]
     METHODS: ClassVar[list[str]] = []
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "channel"))
+        return str(self._data.get("name", "channel"))
 
     @property
     def id(self) -> int | None:
-        raw = self.data.get("id")
+        raw = self._data.get("id")
         return int(raw) if raw is not None else None
 
     @property
     def topic(self) -> str | None:
-        val = self.data.get("topic")
+        val = self._data.get("topic")
         return str(val) if val is not None else None
 
     @property
     def category(self) -> CategoryAPI | None:
-        cat = self.data.get("category")
+        cat = self._data.get("category")
         return CategoryAPI(cat) if cat is not None else None
 
     @property
     def parent(self) -> ChannelAPI | None:
-        parent = self.data.get("parent")
+        parent = self._data.get("parent")
         return ChannelAPI(parent) if parent is not None else None
 
     def __getitem__(self, item: str) -> Any:
@@ -140,17 +140,17 @@ class ChannelAPI(_DirMixin):
 
 @dataclass
 class RoleAPI(_DirMixin):
-    data: Mapping[str, Any] = field(default_factory=dict)
+    _data: Mapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["name", "id"]
     METHODS: ClassVar[list[str]] = []
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Role"))
+        return str(self._data.get("name", "Role"))
 
     @property
     def id(self) -> int | None:
-        raw = self.data.get("id")
+        raw = self._data.get("id")
         return int(raw) if raw is not None else None
 
     def __getitem__(self, item: str) -> Any:
@@ -159,29 +159,29 @@ class RoleAPI(_DirMixin):
 
 @dataclass
 class AuthorAPI(_DirMixin):
-    data: Mapping[str, Any] = field(default_factory=dict)
+    _data: Mapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["name", "id", "discriminator", "display_name", "roles"]
     METHODS: ClassVar[list[str]] = ["get_roles"]
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "User"))
+        return str(self._data.get("name", "User"))
 
     @property
     def id(self) -> int | None:
-        raw = self.data.get("id")
+        raw = self._data.get("id")
         return int(raw) if raw is not None else None
 
     @property
     def discriminator(self) -> str:
-        return str(self.data.get("discriminator", "0000"))
+        return str(self._data.get("discriminator", "0000"))
 
     @property
     def display_name(self) -> str:
-        return str(self.data.get("display_name", self.name))
+        return str(self._data.get("display_name", self.name))
 
     def get_roles(self) -> list[RoleAPI]:
-        roles = self.data.get("roles") or []
+        roles = self._data.get("roles") or []
         return [RoleAPI(r) for r in roles]
 
     @property
@@ -197,48 +197,48 @@ class AuthorAPI(_DirMixin):
 
 @dataclass
 class AliasContextAPI(_DirMixin):
-    data: Mapping[str, Any] = field(default_factory=dict)
+    _data: Mapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["guild", "channel", "author", "prefix", "alias", "message_id"]
     METHODS: ClassVar[list[str]] = []
 
     @property
     def guild(self) -> GuildAPI | None:
         """Guild info for the alias invocation (server context)."""
-        guild_data = self.data.get("guild")
+        guild_data = self._data.get("guild")
         return GuildAPI(guild_data) if guild_data is not None else None
 
     @property
     def channel(self) -> ChannelAPI | None:
         """Channel where the alias was invoked."""
-        channel_data = self.data.get("channel")
+        channel_data = self._data.get("channel")
         return ChannelAPI(channel_data) if channel_data is not None else None
 
     @property
     def author(self) -> AuthorAPI | None:
         """User who invoked the alias."""
-        author_data = self.data.get("author")
+        author_data = self._data.get("author")
         return AuthorAPI(author_data) if author_data is not None else None
 
     @property
     def prefix(self) -> str | None:
         """Command prefix that triggered the alias (e.g., `!`)."""
-        val = self.data.get("prefix")
+        val = self._data.get("prefix")
         return str(val) if val is not None else None
 
     @property
     def alias(self) -> str | None:
         """Alias name that was run."""
-        val = self.data.get("alias")
+        val = self._data.get("alias")
         return str(val) if val is not None else None
 
     @property
     def message_id(self) -> int | None:
         """Discord message id for the invocation."""
-        raw = self.data.get("message_id")
+        raw = self._data.get("message_id")
         return int(raw) if raw is not None else None
 
     def __getattr__(self, item: str) -> Any:
-        return self.data.get(item)
+        return self._data.get(item)
 
     def __getitem__(self, item: str) -> Any:
         return getattr(self, str(item))
@@ -305,7 +305,7 @@ _SKILL_ABILITIES = {
 
 @dataclass
 class AliasBaseStats(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     prof_bonus_override: int | None = None
     ATTRS: ClassVar[list[str]] = [
         "prof_bonus",
@@ -322,31 +322,31 @@ class AliasBaseStats(_DirMixin):
     def prof_bonus(self) -> int:
         if self.prof_bonus_override is not None:
             return self.prof_bonus_override
-        return _safe_int(self.data.get("prof_bonus"), 2)
+        return _safe_int(self._data.get("prof_bonus"), 2)
 
     @property
     def strength(self) -> int:
-        return _safe_int(self.data.get("strength"), 10)
+        return _safe_int(self._data.get("strength"), 10)
 
     @property
     def dexterity(self) -> int:
-        return _safe_int(self.data.get("dexterity"), 10)
+        return _safe_int(self._data.get("dexterity"), 10)
 
     @property
     def constitution(self) -> int:
-        return _safe_int(self.data.get("constitution"), 10)
+        return _safe_int(self._data.get("constitution"), 10)
 
     @property
     def intelligence(self) -> int:
-        return _safe_int(self.data.get("intelligence"), 10)
+        return _safe_int(self._data.get("intelligence"), 10)
 
     @property
     def wisdom(self) -> int:
-        return _safe_int(self.data.get("wisdom"), 10)
+        return _safe_int(self._data.get("wisdom"), 10)
 
     @property
     def charisma(self) -> int:
-        return _safe_int(self.data.get("charisma"), 10)
+        return _safe_int(self._data.get("charisma"), 10)
 
     def get_mod(self, stat: str) -> int:
         stat_lower = str(stat).lower()
@@ -385,14 +385,14 @@ class AliasBaseStats(_DirMixin):
 
 @dataclass
 class AliasLevels(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     ATTRS: ClassVar[list[str]] = ["total_level"]
     METHODS: ClassVar[list[str]] = ["get"]
 
     @property
     def total_level(self) -> int | float:
         total = 0
-        for _, value in self.data.items():
+        for _, value in self._data.items():
             try:
                 total += value
             except Exception:
@@ -403,7 +403,7 @@ class AliasLevels(_DirMixin):
         return total
 
     def get(self, cls_name: str, default: int | float = 0) -> int | float:
-        val = self.data.get(str(cls_name))
+        val = self._data.get(str(cls_name))
         if val is None:
             return default
         try:
@@ -412,40 +412,40 @@ class AliasLevels(_DirMixin):
             return default
 
     def __iter__(self) -> Iterable[tuple[str, Any]]:
-        return iter(self.data.items())
+        return iter(self._data.items())
 
     def __getitem__(self, item: str) -> Any:
-        return self.data[item]
+        return self._data[item]
 
 
 @dataclass
 class AliasAttack(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     parent_statblock: Mapping[str, Any]
     ATTRS: ClassVar[list[str]] = ["name", "verb", "proper", "activation_type", "raw"]
     METHODS: ClassVar[list[str]] = []
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Attack"))
+        return str(self._data.get("name", "Attack"))
 
     @property
     def verb(self) -> str | None:
-        val = self.data.get("verb")
+        val = self._data.get("verb")
         return str(val) if val is not None else None
 
     @property
     def proper(self) -> bool:
-        return bool(self.data.get("proper", False))
+        return bool(self._data.get("proper", False))
 
     @property
     def activation_type(self) -> int | None:
-        raw = self.data.get("activation_type")
+        raw = self._data.get("activation_type")
         return int(raw) if raw is not None else None
 
     @property
     def raw(self) -> Mapping[str, Any]:
-        return self.data.get("raw", self.data)
+        return self._data.get("raw", self._data)
 
     def __str__(self) -> str:
         damage = self.raw.get("damage")
@@ -483,17 +483,17 @@ class AliasAttackList(_DirMixin):
 
 @dataclass
 class AliasSkill(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     ATTRS: ClassVar[list[str]] = ["value", "prof", "bonus", "adv"]
     METHODS: ClassVar[list[str]] = ["d20"]
 
     @property
     def value(self) -> int:
-        return _safe_int(self.data.get("value"), 0)
+        return _safe_int(self._data.get("value"), 0)
 
     @property
     def prof(self) -> float | int:
-        raw = self.data.get("prof")
+        raw = self._data.get("prof")
         try:
             return float(raw)
         except Exception:
@@ -501,11 +501,11 @@ class AliasSkill(_DirMixin):
 
     @property
     def bonus(self) -> int:
-        return _safe_int(self.data.get("bonus"), 0)
+        return _safe_int(self._data.get("bonus"), 0)
 
     @property
     def adv(self) -> bool | None:
-        val = self.data.get("adv")
+        val = self._data.get("adv")
         if val is None:
             return None
         return bool(val)
@@ -545,7 +545,7 @@ class AliasSkill(_DirMixin):
 
 @dataclass
 class AliasSkills(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     prof_bonus: int
     abilities: Mapping[str, int]
     ATTRS: ClassVar[list[str]] = list(_SKILL_ABILITIES.keys())
@@ -559,7 +559,7 @@ class AliasSkills(_DirMixin):
 
     def _get_skill(self, name: str) -> AliasSkill:
         normalized = _SKILL_CANONICAL.get(name.lower().replace(" ", "").replace("_", ""), name)
-        skill_data = self.data.get(normalized) or self.data.get(name) or {}
+        skill_data = self._data.get(normalized) or self._data.get(name) or {}
         if not skill_data:
             ability = _SKILL_ABILITIES.get(normalized)
             ability_mod = 0
@@ -579,7 +579,7 @@ class AliasSkills(_DirMixin):
 
 @dataclass
 class AliasSaves(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     prof_bonus: int
     abilities: Mapping[str, int]
     ATTRS: ClassVar[list[str]] = []
@@ -587,7 +587,7 @@ class AliasSaves(_DirMixin):
 
     def get(self, base_stat: str) -> AliasSkill:
         normalized = base_stat.lower()
-        raw = self.data.get(normalized) or self.data.get(base_stat) or {}
+        raw = self._data.get(normalized) or self._data.get(base_stat) or {}
         if isinstance(raw, (int, float)):
             raw = {"value": raw}
         if not raw:
@@ -612,14 +612,14 @@ class ResistanceEntry:
 
 @dataclass
 class AliasResistances(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     ATTRS: ClassVar[list[str]] = ["resist", "vuln", "immune", "neutral"]
     METHODS: ClassVar[list[str]] = ["is_resistant", "is_immune", "is_vulnerable", "is_neutral"]
 
     @staticmethod
-    def _entries(key: str, data: Mapping[str, Any]) -> list[ResistanceEntry]:
+    def _entries(key: str, _data: Mapping[str, Any]) -> list[ResistanceEntry]:
         entries = []
-        for entry in data.get(key, []):
+        for entry in _data.get(key, []):
             entries.append(
                 ResistanceEntry(
                     dtype=str(entry.get("dtype", "")),
@@ -631,19 +631,19 @@ class AliasResistances(_DirMixin):
 
     @property
     def resist(self) -> list[ResistanceEntry]:
-        return self._entries("resist", self.data)
+        return self._entries("resist", self._data)
 
     @property
     def vuln(self) -> list[ResistanceEntry]:
-        return self._entries("vuln", self.data)
+        return self._entries("vuln", self._data)
 
     @property
     def immune(self) -> list[ResistanceEntry]:
-        return self._entries("immune", self.data)
+        return self._entries("immune", self._data)
 
     @property
     def neutral(self) -> list[ResistanceEntry]:
-        return self._entries("neutral", self.data)
+        return self._entries("neutral", self._data)
 
     def is_resistant(self, damage_type: str) -> bool:
         token = str(damage_type).lower()
@@ -675,32 +675,32 @@ class AliasResistances(_DirMixin):
 
 @dataclass
 class AliasSpellbookSpell(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     ATTRS: ClassVar[list[str]] = ["name", "dc", "sab", "mod", "prepared"]
     METHODS: ClassVar[list[str]] = []
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Spell"))
+        return str(self._data.get("name", "Spell"))
 
     @property
     def dc(self) -> int | None:
-        raw = self.data.get("dc")
+        raw = self._data.get("dc")
         return int(raw) if raw is not None else None
 
     @property
     def sab(self) -> int | None:
-        raw = self.data.get("sab")
+        raw = self._data.get("sab")
         return int(raw) if raw is not None else None
 
     @property
     def mod(self) -> int | None:
-        raw = self.data.get("mod")
+        raw = self._data.get("mod")
         return int(raw) if raw is not None else None
 
     @property
     def prepared(self) -> bool:
-        return bool(self.data.get("prepared", True))
+        return bool(self._data.get("prepared", True))
 
     def __getitem__(self, item: str) -> Any:
         return getattr(self, str(item))
@@ -711,7 +711,7 @@ class AliasSpellbookSpell(_DirMixin):
 
 @dataclass
 class AliasSpellbook(_DirMixin):
-    data: MutableMapping[str, Any]
+    _data: MutableMapping[str, Any]
     _spells_cache: list[AliasSpellbookSpell] = field(default_factory=list, init=False)
     ATTRS: ClassVar[list[str]] = [
         "dc",
@@ -739,40 +739,40 @@ class AliasSpellbook(_DirMixin):
 
     @property
     def dc(self) -> int:
-        return _safe_int(self.data.get("dc"), 10)
+        return _safe_int(self._data.get("dc"), 10)
 
     @property
     def sab(self) -> int:
-        return _safe_int(self.data.get("sab"), 0)
+        return _safe_int(self._data.get("sab"), 0)
 
     @property
     def caster_level(self) -> int:
-        return _safe_int(self.data.get("caster_level"), 0)
+        return _safe_int(self._data.get("caster_level"), 0)
 
     @property
     def spell_mod(self) -> int:
-        return _safe_int(self.data.get("spell_mod"), 0)
+        return _safe_int(self._data.get("spell_mod"), 0)
 
     @property
     def spells(self) -> list[AliasSpellbookSpell]:
         if not self._spells_cache:
-            spell_list = self.data.get("spells") or []
+            spell_list = self._data.get("spells") or []
             self._spells_cache = [AliasSpellbookSpell(s) for s in spell_list]
         return self._spells_cache
 
     @property
     def pact_slot_level(self) -> int | None:
-        raw = self.data.get("pact_slot_level")
+        raw = self._data.get("pact_slot_level")
         return int(raw) if raw is not None else None
 
     @property
     def num_pact_slots(self) -> int | None:
-        raw = self.data.get("num_pact_slots")
+        raw = self._data.get("num_pact_slots")
         return int(raw) if raw is not None else None
 
     @property
     def max_pact_slots(self) -> int | None:
-        raw = self.data.get("max_pact_slots")
+        raw = self._data.get("max_pact_slots")
         return int(raw) if raw is not None else None
 
     def find(self, spell_name: str) -> list[AliasSpellbookSpell]:
@@ -785,17 +785,17 @@ class AliasSpellbook(_DirMixin):
         return f"{slots}/{max_slots}"
 
     def get_max_slots(self, level: int) -> int:
-        slots = self.data.get("max_slots") or {}
+        slots = self._data.get("max_slots") or {}
         return _safe_int(slots.get(int(level)), 0)
 
     def get_slots(self, level: int) -> int:
-        slots = self.data.get("slots") or {}
+        slots = self._data.get("slots") or {}
         if int(level) == 0:
             return 1
         return _safe_int(slots.get(int(level)), 0)
 
     def set_slots(self, level: int, value: int, pact: bool = True) -> int:
-        slots = self.data.setdefault("slots", {})
+        slots = self._data.setdefault("slots", {})
         slots[int(level)] = int(value)
         return slots[int(level)]
 
@@ -804,16 +804,16 @@ class AliasSpellbook(_DirMixin):
         return self.set_slots(level, max(0, current - 1))
 
     def reset_slots(self) -> None:
-        slots = self.data.get("slots") or {}
-        max_slots = self.data.get("max_slots") or {}
+        slots = self._data.get("slots") or {}
+        max_slots = self._data.get("max_slots") or {}
         for level, maximum in max_slots.items():
             slots[int(level)] = _safe_int(maximum)
-        self.data["slots"] = slots
+        self._data["slots"] = slots
 
     def reset_pact_slots(self) -> None:
         if self.max_pact_slots is None:
             return
-        self.data["num_pact_slots"] = self.max_pact_slots
+        self._data["num_pact_slots"] = self.max_pact_slots
 
     def remaining_casts_of(self, spell: str, level: int) -> str:
         return self.slots_str(level)
@@ -833,14 +833,14 @@ class AliasSpellbook(_DirMixin):
 
 @dataclass
 class AliasCoinpurse(_DirMixin):
-    data: MutableMapping[str, Any] = field(default_factory=dict)
+    _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["pp", "gp", "ep", "sp", "cp", "total"]
     METHODS: ClassVar[list[str]] = ["coin_str", "compact_str", "modify_coins", "set_coins", "autoconvert", "get_coins"]
 
     def __getattr__(self, item: str) -> Any:
         if item in {"pp", "gp", "ep", "sp", "cp"}:
-            return _safe_int(self.data.get(item), 0)
-        return self.data.get(item)
+            return _safe_int(self._data.get(item), 0)
+        return self._data.get(item)
 
     def __getitem__(self, item: str) -> Any:
         return getattr(self, str(item))
@@ -866,26 +866,26 @@ class AliasCoinpurse(_DirMixin):
         cp: int = 0,
         autoconvert: bool = True,
     ) -> dict[str, Any]:
-        self.data["pp"] = self.pp + int(pp)
-        self.data["gp"] = self.gp + int(gp)
-        self.data["ep"] = self.ep + int(ep)
-        self.data["sp"] = self.sp + int(sp)
-        self.data["cp"] = self.cp + int(cp)
+        self._data["pp"] = self.pp + int(pp)
+        self._data["gp"] = self.gp + int(gp)
+        self._data["ep"] = self.ep + int(ep)
+        self._data["sp"] = self.sp + int(sp)
+        self._data["cp"] = self.cp + int(cp)
         return self.get_coins()
 
     def set_coins(self, pp: int, gp: int, ep: int, sp: int, cp: int) -> None:
-        self.data["pp"] = int(pp)
-        self.data["gp"] = int(gp)
-        self.data["ep"] = int(ep)
-        self.data["sp"] = int(sp)
-        self.data["cp"] = int(cp)
+        self._data["pp"] = int(pp)
+        self._data["gp"] = int(gp)
+        self._data["ep"] = int(ep)
+        self._data["sp"] = int(sp)
+        self._data["cp"] = int(cp)
 
     def autoconvert(self) -> None:
         total_cp = int(self.total * 100)
-        self.data["pp"], remainder = divmod(total_cp, 1000)
-        self.data["gp"], remainder = divmod(remainder, 100)
-        self.data["ep"], remainder = divmod(remainder, 50)
-        self.data["sp"], self.data["cp"] = divmod(remainder, 10)
+        self._data["pp"], remainder = divmod(total_cp, 1000)
+        self._data["gp"], remainder = divmod(remainder, 100)
+        self._data["ep"], remainder = divmod(remainder, 50)
+        self._data["sp"], self._data["cp"] = divmod(remainder, 10)
 
     def get_coins(self) -> dict[str, Any]:
         return {"pp": self.pp, "gp": self.gp, "ep": self.ep, "sp": self.sp, "cp": self.cp, "total": self.total}
@@ -893,23 +893,23 @@ class AliasCoinpurse(_DirMixin):
 
 @dataclass
 class AliasDeathSaves(_DirMixin):
-    data: MutableMapping[str, Any] = field(default_factory=dict)
+    _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["successes", "fails"]
     METHODS: ClassVar[list[str]] = ["succeed", "fail", "is_stable", "is_dead", "reset"]
 
     @property
     def successes(self) -> int:
-        return _safe_int(self.data.get("successes"), 0)
+        return _safe_int(self._data.get("successes"), 0)
 
     @property
     def fails(self) -> int:
-        return _safe_int(self.data.get("fails"), 0)
+        return _safe_int(self._data.get("fails"), 0)
 
     def succeed(self, num: int = 1) -> None:
-        self.data["successes"] = self.successes + int(num)
+        self._data["successes"] = self.successes + int(num)
 
     def fail(self, num: int = 1) -> None:
-        self.data["fails"] = self.fails + int(num)
+        self._data["fails"] = self.fails + int(num)
 
     def is_stable(self) -> bool:
         return self.successes >= 3 and self.fails < 3
@@ -918,8 +918,8 @@ class AliasDeathSaves(_DirMixin):
         return self.fails >= 3
 
     def reset(self) -> None:
-        self.data["successes"] = 0
-        self.data["fails"] = 0
+        self._data["successes"] = 0
+        self._data["fails"] = 0
 
     def __str__(self) -> str:
         return f"{self.successes} successes / {self.fails} failures"
@@ -927,7 +927,7 @@ class AliasDeathSaves(_DirMixin):
 
 @dataclass
 class AliasAction(_DirMixin):
-    data: Mapping[str, Any]
+    _data: Mapping[str, Any]
     parent_statblock: Mapping[str, Any]
     ATTRS: ClassVar[list[str]] = ["name", "activation_type", "activation_type_name", "description", "snippet"]
     METHODS: ClassVar[list[str]] = []
@@ -935,29 +935,29 @@ class AliasAction(_DirMixin):
     @property
     def name(self) -> str:
         """Action name."""
-        return str(self.data.get("name", "Action"))
+        return str(self._data.get("name", "Action"))
 
     @property
     def activation_type(self) -> int | None:
         """Numeric activation type (matches Avrae constants)."""
-        raw = self.data.get("activation_type")
+        raw = self._data.get("activation_type")
         return int(raw) if raw is not None else None
 
     @property
     def activation_type_name(self) -> str | None:
         """Human-readable activation type (e.g., ACTION, BONUS_ACTION)."""
-        val = self.data.get("activation_type_name")
+        val = self._data.get("activation_type_name")
         return str(val) if val is not None else None
 
     @property
     def description(self) -> str:
         """Long description of the action."""
-        return str(self.data.get("description", ""))
+        return str(self._data.get("description", ""))
 
     @property
     def snippet(self) -> str:
         """Short snippet shown in the sheet for the action."""
-        return str(self.data.get("snippet", self.description))
+        return str(self._data.get("snippet", self.description))
 
     def __str__(self) -> str:
         return f"**{self.name}**: {self.description}"
@@ -976,7 +976,7 @@ class AliasAction(_DirMixin):
 
 @dataclass
 class AliasCustomCounter(_DirMixin):
-    data: MutableMapping[str, Any] = field(default_factory=dict)
+    _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = [
         "name",
         "title",
@@ -993,48 +993,48 @@ class AliasCustomCounter(_DirMixin):
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Counter"))
+        return str(self._data.get("name", "Counter"))
 
     @property
     def title(self) -> str | None:
-        val = self.data.get("title")
+        val = self._data.get("title")
         return str(val) if val is not None else None
 
     @property
     def desc(self) -> str | None:
-        val = self.data.get("desc")
+        val = self._data.get("desc")
         return str(val) if val is not None else None
 
     @property
     def value(self) -> int:
-        return _safe_int(self.data.get("value"), 0)
+        return _safe_int(self._data.get("value"), 0)
 
     @property
     def max(self) -> int:
-        return _safe_int(self.data.get("max"), 2**31 - 1)
+        return _safe_int(self._data.get("max"), 2**31 - 1)
 
     @property
     def min(self) -> int:
-        return _safe_int(self.data.get("min"), -(2**31))
+        return _safe_int(self._data.get("min"), -(2**31))
 
     @property
     def reset_on(self) -> str | None:
-        val = self.data.get("reset_on")
+        val = self._data.get("reset_on")
         return str(val) if val is not None else None
 
     @property
     def display_type(self) -> str | None:
-        val = self.data.get("display_type")
+        val = self._data.get("display_type")
         return str(val) if val is not None else None
 
     @property
     def reset_to(self) -> int | None:
-        raw = self.data.get("reset_to")
+        raw = self._data.get("reset_to")
         return int(raw) if raw is not None else None
 
     @property
     def reset_by(self) -> str | None:
-        val = self.data.get("reset_by")
+        val = self._data.get("reset_by")
         return str(val) if val is not None else None
 
     def mod(self, value: int, strict: bool = False) -> int:
@@ -1046,7 +1046,7 @@ class AliasCustomCounter(_DirMixin):
             if val > self.max or val < self.min:
                 raise ValueError("Counter out of bounds")
         val = max(self.min, min(val, self.max))
-        self.data["value"] = val
+        self._data["value"] = val
         return val
 
     def reset(self) -> dict[str, Any]:
@@ -1085,7 +1085,7 @@ class AliasCustomCounter(_DirMixin):
 # === StatBlock + Character ===
 @dataclass
 class AliasStatBlock(_DirMixin):
-    data: MutableMapping[str, Any] = field(default_factory=dict)
+    _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = [
         "name",
         "stats",
@@ -1104,32 +1104,32 @@ class AliasStatBlock(_DirMixin):
     METHODS: ClassVar[list[str]] = ["set_hp", "modify_hp", "hp_str", "reset_hp", "set_temp_hp"]
 
     def _prof_bonus(self) -> int:
-        stats = self.data.get("stats") or {}
+        stats = self._data.get("stats") or {}
         if "prof_bonus" in stats:
             return _safe_int(stats.get("prof_bonus"), 2)
-        levels = self.data.get("levels") or self.data.get("class_levels") or {}
+        levels = self._data.get("levels") or self._data.get("class_levels") or {}
         total_level = sum(_safe_int(val, 0) for val in levels.values()) or 1
         return max(2, 2 + (math.ceil(total_level / 4)))
 
     @property
     def name(self) -> str:
         """Character or statblock name."""
-        return str(self.data.get("name", "Statblock"))
+        return str(self._data.get("name", "Statblock"))
 
     @property
     def stats(self) -> AliasBaseStats:
         """Ability scores and proficiency bonus helper."""
-        return AliasBaseStats(self.data.get("stats") or {}, prof_bonus_override=self._prof_bonus())
+        return AliasBaseStats(self._data.get("stats") or {}, prof_bonus_override=self._prof_bonus())
 
     @property
     def levels(self) -> AliasLevels:
         """Class levels keyed by class name."""
-        return AliasLevels(self.data.get("levels") or self.data.get("class_levels") or {})
+        return AliasLevels(self._data.get("levels") or self._data.get("class_levels") or {})
 
     @property
     def attacks(self) -> AliasAttackList:
         """Attacks available on the statblock."""
-        return AliasAttackList(self.data.get("attacks") or [], self.data)
+        return AliasAttackList(self._data.get("attacks") or [], self._data)
 
     @property
     def skills(self) -> AliasSkills:
@@ -1142,7 +1142,7 @@ class AliasStatBlock(_DirMixin):
             "wisdom": self.stats.wisdom,
             "charisma": self.stats.charisma,
         }
-        return AliasSkills(self.data.get("skills") or {}, self._prof_bonus(), abilities)
+        return AliasSkills(self._data.get("skills") or {}, self._prof_bonus(), abilities)
 
     @property
     def saves(self) -> AliasSaves:
@@ -1161,51 +1161,51 @@ class AliasStatBlock(_DirMixin):
             "wis": self.stats.wisdom,
             "cha": self.stats.charisma,
         }
-        return AliasSaves(self.data.get("saves") or {}, self._prof_bonus(), abilities)
+        return AliasSaves(self._data.get("saves") or {}, self._prof_bonus(), abilities)
 
     @property
     def resistances(self) -> AliasResistances:
         """Damage resistances, immunities, and vulnerabilities."""
-        return AliasResistances(self.data.get("resistances") or {})
+        return AliasResistances(self._data.get("resistances") or {})
 
     @property
     def ac(self) -> int | None:
         """Armor class."""
-        raw = self.data.get("ac")
+        raw = self._data.get("ac")
         return int(raw) if raw is not None else None
 
     @property
     def max_hp(self) -> int | None:
         """Maximum hit points."""
-        raw = self.data.get("max_hp")
+        raw = self._data.get("max_hp")
         return int(raw) if raw is not None else None
 
     @property
     def hp(self) -> int | None:
         """Current hit points."""
-        raw = self.data.get("hp")
+        raw = self._data.get("hp")
         return int(raw) if raw is not None else None
 
     @property
     def temp_hp(self) -> int:
         """Temporary hit points."""
-        return _safe_int(self.data.get("temp_hp"), 0)
+        return _safe_int(self._data.get("temp_hp"), 0)
 
     @property
     def spellbook(self) -> AliasSpellbook:
         """Known/prepared spells grouped by level."""
-        return AliasSpellbook(self.data.get("spellbook") or {})
+        return AliasSpellbook(self._data.get("spellbook") or {})
 
     @property
     def creature_type(self) -> str | None:
         """Creature type (e.g., humanoid, undead)."""
-        val = self.data.get("creature_type")
+        val = self._data.get("creature_type")
         return str(val) if val is not None else None
 
     def set_hp(self, new_hp: int) -> int:
         """Set current hit points."""
-        self.data["hp"] = int(new_hp)
-        return self.data["hp"]
+        self._data["hp"] = int(new_hp)
+        return self._data["hp"]
 
     def modify_hp(self, amount: int, ignore_temp: bool = False, overflow: bool = True) -> int:
         """Adjust hit points by `amount`, respecting overflow limits when requested."""
@@ -1213,7 +1213,7 @@ class AliasStatBlock(_DirMixin):
         new_hp = hp + int(amount)
         if not overflow and self.max_hp is not None:
             new_hp = max(0, min(new_hp, self.max_hp))
-        self.data["hp"] = new_hp
+        self._data["hp"] = new_hp
         return new_hp
 
     def hp_str(self) -> str:
@@ -1223,17 +1223,17 @@ class AliasStatBlock(_DirMixin):
     def reset_hp(self) -> int:
         """Restore to max HP and clear temp HP."""
         if self.max_hp is not None:
-            self.data["hp"] = self.max_hp
-        self.data["temp_hp"] = 0
+            self._data["hp"] = self.max_hp
+        self._data["temp_hp"] = 0
         return self.hp or 0
 
     def set_temp_hp(self, new_temp: int) -> int:
         """Set temporary hit points."""
-        self.data["temp_hp"] = int(new_temp)
+        self._data["temp_hp"] = int(new_temp)
         return self.temp_hp
 
     def __getattr__(self, item: str) -> Any:
-        return self.data.get(item)
+        return self._data.get(item)
 
     def __getitem__(self, item: str) -> Any:
         if isinstance(item, int) or (isinstance(item, str) and item.isdigit()):
@@ -1284,88 +1284,88 @@ class CharacterAPI(AliasStatBlock):
     ]
 
     def _consumable_map(self) -> MutableMapping[str, MutableMapping[str, Any]]:
-        consumables = self.data.setdefault("consumables", {})
+        consumables = self._data.setdefault("consumables", {})
         if isinstance(consumables, list):
             # normalize list payloads to map
             mapped: dict[str, MutableMapping[str, Any]] = {}
             for item in consumables:
                 name = str(item.get("name", f"cc_{len(mapped)}"))
                 mapped[name] = dict(item)
-            self.data["consumables"] = mapped
+            self._data["consumables"] = mapped
             consumables = mapped
         return consumables  # type: ignore[return-value]
 
     @property
     def actions(self) -> list[AliasAction]:
         """Actions on the character sheet (mapped from Beyond/custom actions)."""
-        acts = self.data.get("actions") or []
-        return [AliasAction(a, self.data) for a in acts]
+        acts = self._data.get("actions") or []
+        return [AliasAction(a, self._data) for a in acts]
 
     @property
     def coinpurse(self) -> AliasCoinpurse:
         """Coin totals by denomination."""
-        return AliasCoinpurse(self.data.get("coinpurse") or {})
+        return AliasCoinpurse(self._data.get("coinpurse") or {})
 
     @property
     def csettings(self) -> Mapping[str, Any]:
         """Character settings blob."""
-        return self.data.get("csettings", {})
+        return self._data.get("csettings", {})
 
     @property
     def race(self) -> str | None:
         """Race label."""
-        val = self.data.get("race")
+        val = self._data.get("race")
         return str(val) if val is not None else None
 
     @property
     def background(self) -> str | None:
         """Background name."""
-        val = self.data.get("background")
+        val = self._data.get("background")
         return str(val) if val is not None else None
 
     @property
     def owner(self) -> int | None:
         """Discord user id of the owning account."""
-        raw = self.data.get("owner")
+        raw = self._data.get("owner")
         return int(raw) if raw is not None else None
 
     @property
     def upstream(self) -> str | None:
         """Upstream character id (e.g., Beyond character slug)."""
-        val = self.data.get("upstream")
+        val = self._data.get("upstream")
         return str(val) if val is not None else None
 
     @property
     def sheet_type(self) -> str | None:
         """Source sheet provider (beyond, custom, etc.)."""
-        val = self.data.get("sheet_type")
+        val = self._data.get("sheet_type")
         return str(val) if val is not None else None
 
     @property
     def cvars(self) -> Mapping[str, Any]:
         """Character variables (string values)."""
-        return dict(self.data.get("cvars") or {})
+        return dict(self._data.get("cvars") or {})
 
     def get_cvar(self, name: str, default: Any = None) -> Optional[str]:
         """Fetch a character variable, returning `default` if missing."""
-        val = self.data.setdefault("cvars", {}).get(str(name), default)
+        val = self._data.setdefault("cvars", {}).get(str(name), default)
         return str(val) if val is not None else default
 
     def set_cvar(self, name: str, val: str) -> Optional[str]:
         """Sets a character variable. Avrae stores cvars as strings."""
         str_val = str(val) if val is not None else None
-        self.data.setdefault("cvars", {})[str(name)] = str_val
+        self._data.setdefault("cvars", {})[str(name)] = str_val
         return str_val
 
     def set_cvar_nx(self, name: str, val: str) -> str:
         """Set a character variable only if it does not already exist."""
-        cvars = self.data.setdefault("cvars", {})
+        cvars = self._data.setdefault("cvars", {})
         str_val = str(val) if val is not None else None
         return cvars.setdefault(str(name), str_val)
 
     def delete_cvar(self, name: str) -> Optional[str]:
         """Delete a character variable and return its old value if present."""
-        return self.data.setdefault("cvars", {}).pop(str(name), None)
+        return self._data.setdefault("cvars", {}).pop(str(name), None)
 
     @property
     def consumables(self) -> list[AliasCustomCounter]:
@@ -1509,18 +1509,18 @@ class CharacterAPI(AliasStatBlock):
     @property
     def death_saves(self) -> AliasDeathSaves:
         """Death save successes/failures."""
-        return AliasDeathSaves(self.data.get("death_saves") or {})
+        return AliasDeathSaves(self._data.get("death_saves") or {})
 
     @property
     def description(self) -> str | None:
         """Character description/biography."""
-        val = self.data.get("description")
+        val = self._data.get("description")
         return str(val) if val is not None else None
 
     @property
     def image(self) -> str | None:
         """Avatar or sheet image URL."""
-        val = self.data.get("image")
+        val = self._data.get("image")
         return str(val) if val is not None else None
 
 
@@ -1530,7 +1530,7 @@ MAX_COMBAT_METADATA_SIZE = 100000
 
 @dataclass
 class SimpleEffect(_DirMixin):
-    data: MutableMapping[str, Any]
+    _data: MutableMapping[str, Any]
     ATTRS: ClassVar[list[str]] = [
         "name",
         "duration",
@@ -1549,61 +1549,61 @@ class SimpleEffect(_DirMixin):
 
     @property
     def name(self) -> str:
-        return str(self.data.get("name", "Effect"))
+        return str(self._data.get("name", "Effect"))
 
     @property
     def duration(self) -> int | None:
-        raw = self.data.get("duration")
+        raw = self._data.get("duration")
         return int(raw) if raw is not None else None
 
     @property
     def remaining(self) -> int | None:
-        raw = self.data.get("remaining")
+        raw = self._data.get("remaining")
         return int(raw) if raw is not None else None
 
     @property
     def effect(self) -> Mapping[str, Any]:
-        return self.data.get("effects") or self.data.get("effect") or {}
+        return self._data.get("effects") or self._data.get("effect") or {}
 
     @property
     def attacks(self) -> list[Mapping[str, Any]]:
-        return list(self.data.get("attacks") or [])
+        return list(self._data.get("attacks") or [])
 
     @property
     def buttons(self) -> list[Mapping[str, Any]]:
-        return list(self.data.get("buttons") or [])
+        return list(self._data.get("buttons") or [])
 
     @property
     def conc(self) -> bool:
-        return bool(self.data.get("conc") or self.data.get("concentration", False))
+        return bool(self._data.get("conc") or self._data.get("concentration", False))
 
     @property
     def desc(self) -> str | None:
-        val = self.data.get("desc")
+        val = self._data.get("desc")
         return str(val) if val is not None else None
 
     @property
     def ticks_on_end(self) -> bool:
-        return bool(self.data.get("ticks_on_end") or self.data.get("end_on_turn_end", False))
+        return bool(self._data.get("ticks_on_end") or self._data.get("end_on_turn_end", False))
 
     @property
     def combatant_name(self) -> str | None:
-        val = self.data.get("combatant_name")
+        val = self._data.get("combatant_name")
         return str(val) if val is not None else None
 
     @property
     def parent(self) -> "SimpleEffect" | None:
-        parent = self.data.get("parent")
+        parent = self._data.get("parent")
         return SimpleEffect(parent) if parent else None
 
     @property
     def children(self) -> list["SimpleEffect"]:
-        return [SimpleEffect(c) for c in self.data.get("children", [])]
+        return [SimpleEffect(c) for c in self._data.get("children", [])]
 
     def set_parent(self, parent: "SimpleEffect") -> None:
         if not isinstance(parent, SimpleEffect):
             raise TypeError("Parent effect must be a SimpleEffect.")
-        self.data["parent"] = parent.data
+        self._data["parent"] = parent._data
 
     def __getitem__(self, item: str) -> Any:
         return getattr(self, str(item))
@@ -1640,68 +1640,68 @@ class SimpleCombatant(AliasStatBlock):
 
     def __post_init__(self) -> None:
         super().__post_init__()
-        self.data.setdefault("type", "combatant")
+        self._data.setdefault("type", "combatant")
 
     @property
     def id(self) -> str | None:
         """Unique combatant id."""
-        val = self.data.get("id")
+        val = self._data.get("id")
         return str(val) if val is not None else None
 
     @property
     def effects(self) -> list[SimpleEffect]:
         """Active effects on the combatant."""
-        return [SimpleEffect(e) for e in self.data.get("effects", [])]
+        return [SimpleEffect(e) for e in self._data.get("effects", [])]
 
     @property
     def init(self) -> int:
         """Initiative score."""
-        return _safe_int(self.data.get("init"), 0)
+        return _safe_int(self._data.get("init"), 0)
 
     @property
     def initmod(self) -> int:
         """Initiative modifier."""
-        return _safe_int(self.data.get("initmod"), 0)
+        return _safe_int(self._data.get("initmod"), 0)
 
     @property
     def type(self) -> str:
         """Combatant type (combatant/group)."""
-        return str(self.data.get("type", "combatant"))
+        return str(self._data.get("type", "combatant"))
 
     @property
     def note(self) -> str | None:
         """DM note attached to the combatant."""
-        val = self.data.get("note")
+        val = self._data.get("note")
         return str(val) if val is not None else None
 
     @property
     def controller(self) -> int | None:
         """Discord id of the controller (if any)."""
-        raw = self.data.get("controller")
+        raw = self._data.get("controller")
         return int(raw) if raw is not None else None
 
     @property
     def group(self) -> str | None:
         """Group name the combatant belongs to."""
-        val = self.data.get("group")
+        val = self._data.get("group")
         return str(val) if val is not None else None
 
     @property
     def race(self) -> str | None:
         """Race/creature type label."""
-        val = self.data.get("race")
+        val = self._data.get("race")
         return str(val) if val is not None else None
 
     @property
     def monster_name(self) -> str | None:
         """Monster name if this combatant represents a monster."""
-        val = self.data.get("monster_name")
+        val = self._data.get("monster_name")
         return str(val) if val is not None else None
 
     @property
     def is_hidden(self) -> bool:
         """Whether the combatant is hidden in the tracker."""
-        return bool(self.data.get("is_hidden", False))
+        return bool(self._data.get("is_hidden", False))
 
     def save(self, ability: str, adv: bool | None = None) -> SimpleRollResult:
         """Roll a saving throw using the combatant's stats."""
@@ -1740,28 +1740,28 @@ class SimpleCombatant(AliasStatBlock):
 
     def set_ac(self, ac: int) -> None:
         """Set armor class."""
-        self.data["ac"] = int(ac)
+        self._data["ac"] = int(ac)
 
     def set_maxhp(self, maxhp: int) -> None:
         """Set maximum HP."""
-        self.data["max_hp"] = int(maxhp)
+        self._data["max_hp"] = int(maxhp)
 
     def set_init(self, init: int) -> None:
         """Set initiative score."""
-        self.data["init"] = int(init)
+        self._data["init"] = int(init)
 
     def set_name(self, name: str) -> None:
         """Rename the combatant."""
-        self.data["name"] = str(name)
+        self._data["name"] = str(name)
 
     def set_group(self, group: str | None) -> str | None:
         """Assign the combatant to a group."""
-        self.data["group"] = str(group) if group is not None else None
+        self._data["group"] = str(group) if group is not None else None
         return self.group
 
     def set_note(self, note: str) -> None:
         """Attach/update a DM note."""
-        self.data["note"] = str(note) if note is not None else None
+        self._data["note"] = str(note) if note is not None else None
 
     def get_effect(self, name: str, strict: bool = False) -> SimpleEffect | None:
         """Find an effect by name (optionally requiring exact match)."""
@@ -1809,12 +1809,12 @@ class SimpleCombatant(AliasStatBlock):
         if parent is not None:
             if not isinstance(parent, SimpleEffect):
                 raise TypeError("Parent effect must be a SimpleEffect.")
-            payload["parent"] = parent.data
-        effects = self.data.setdefault("effects", [])
+            payload["parent"] = parent._data
+        effects = self._data.setdefault("effects", [])
         existing = self.get_effect(name, strict=True)
         if existing:
             try:
-                effects.remove(existing.data)
+                effects.remove(existing._data)
             except ValueError:
                 pass
         effects.append(payload)
@@ -1825,45 +1825,45 @@ class SimpleCombatant(AliasStatBlock):
         effect = self.get_effect(name, strict)
         if effect:
             try:
-                self.data.setdefault("effects", []).remove(effect.data)
+                self._data.setdefault("effects", []).remove(effect._data)
             except ValueError:
                 pass
 
 
 @dataclass
 class SimpleGroup(_DirMixin):
-    data: MutableMapping[str, Any] = field(default_factory=dict)
+    _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["combatants", "type", "init", "name", "id"]
     METHODS: ClassVar[list[str]] = ["get_combatant", "set_init"]
 
     def __post_init__(self) -> None:
         super().__post_init__()
-        self.data.setdefault("type", "group")
+        self._data.setdefault("type", "group")
 
     @property
     def combatants(self) -> list[SimpleCombatant]:
         """Members of the group."""
-        return [SimpleCombatant(c) for c in self.data.get("combatants", [])]
+        return [SimpleCombatant(c) for c in self._data.get("combatants", [])]
 
     @property
     def type(self) -> str:
         """Group type identifier (always 'group')."""
-        return str(self.data.get("type", "group"))
+        return str(self._data.get("type", "group"))
 
     @property
     def init(self) -> int:
         """Initiative score for the group."""
-        return _safe_int(self.data.get("init"), 0)
+        return _safe_int(self._data.get("init"), 0)
 
     @property
     def name(self) -> str:
         """Group name."""
-        return str(self.data.get("name", "Group"))
+        return str(self._data.get("name", "Group"))
 
     @property
     def id(self) -> str | None:
         """Group id."""
-        val = self.data.get("id")
+        val = self._data.get("id")
         return str(val) if val is not None else None
 
     def get_combatant(self, name: str, strict: bool | None = None) -> SimpleCombatant | None:
@@ -1883,7 +1883,7 @@ class SimpleGroup(_DirMixin):
         return None
 
     def set_init(self, init: int) -> None:
-        self.data["init"] = int(init)
+        self._data["init"] = int(init)
 
     def __getitem__(self, item: str) -> Any:
         return getattr(self, str(item))
@@ -1891,30 +1891,30 @@ class SimpleGroup(_DirMixin):
 
 @dataclass
 class SimpleCombat(_DirMixin):
-    data: MutableMapping[str, Any] = field(default_factory=dict)
+    _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["combatants", "groups", "me", "current", "name", "round_num", "turn_num", "metadata"]
     METHODS: ClassVar[list[str]] = ["get_combatant", "get_group", "set_metadata", "get_metadata", "delete_metadata", "set_round", "end_round"]
 
     @property
     def combatants(self) -> list[SimpleCombatant]:
         """All combatants in the encounter."""
-        return [SimpleCombatant(c) for c in self.data.get("combatants", [])]
+        return [SimpleCombatant(c) for c in self._data.get("combatants", [])]
 
     @property
     def groups(self) -> list[SimpleGroup]:
         """Combatant groups in the encounter."""
-        return [SimpleGroup(g) for g in self.data.get("groups", [])]
+        return [SimpleGroup(g) for g in self._data.get("groups", [])]
 
     @property
     def me(self) -> SimpleCombatant | None:
         """The player's combatant if present."""
-        me_data = self.data.get("me")
+        me_data = self._data.get("me")
         return SimpleCombatant(me_data) if me_data is not None else None
 
     @property
     def current(self) -> SimpleCombatant | SimpleGroup | None:
         """Current turn holder (combatant or group)."""
-        cur = self.data.get("current")
+        cur = self._data.get("current")
         if cur is None:
             return None
         if cur.get("type") == "group":
@@ -1924,23 +1924,23 @@ class SimpleCombat(_DirMixin):
     @property
     def name(self) -> str | None:
         """Name of the combat encounter."""
-        val = self.data.get("name")
+        val = self._data.get("name")
         return str(val) if val is not None else None
 
     @property
     def round_num(self) -> int:
         """Current round number."""
-        return _safe_int(self.data.get("round_num"), 1)
+        return _safe_int(self._data.get("round_num"), 1)
 
     @property
     def turn_num(self) -> int:
         """Current turn number within the round."""
-        return _safe_int(self.data.get("turn_num"), 1)
+        return _safe_int(self._data.get("turn_num"), 1)
 
     @property
     def metadata(self) -> MutableMapping[str, Any]:
         """Free-form metadata key/value store for the combat."""
-        return self.data.setdefault("metadata", {})
+        return self._data.setdefault("metadata", {})
 
     def get_combatant(self, name: str, strict: bool | None = None) -> SimpleCombatant | None:
         """Find a combatant by name (strict, substring, or fuzzy)."""
@@ -1993,15 +1993,15 @@ class SimpleCombat(_DirMixin):
 
     def set_round(self, round_num: int) -> None:
         """Advance combat to the specified round number."""
-        self.data["round_num"] = int(round_num)
+        self._data["round_num"] = int(round_num)
 
     def end_round(self) -> None:
         """Increment round number and reset turn counter."""
-        self.data["turn_num"] = 0
-        self.data["round_num"] = self.round_num + 1
+        self._data["turn_num"] = 0
+        self._data["round_num"] = self.round_num + 1
 
     def __getattr__(self, item: str) -> Any:
-        return self.data.get(item)
+        return self._data.get(item)
 
     def __getitem__(self, item: str) -> Any:
         return getattr(self, str(item))