noxaeapi-sdk 0.4.0__py3-none-any.whl

noxaeapi_sdk/modules/leaderboard.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import List, Optional
+
+from ..http_engine import HttpEngine
+from ..types import LeaderboardEntry, LeaderboardSourceInfo
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class LeaderboardModule:
+    """Wraps the generic, pluggable ``/v1/leaderboards/*`` routes.
+
+    This is a unified view over every ranking source registered on the
+    server — economy currencies, mcMMO power level, AuraSkills power
+    level, etc — so you don't need to know ahead of time which plugins
+    are installed.
+
+    Use :meth:`list` to discover available source IDs, then pass one to
+    :meth:`get_top`. Sources that are registered but currently
+    unavailable (e.g. the backing plugin isn't loaded) raise
+    ``NoxAeApiError`` with the source's own unavailable status (424 for
+    economy currencies, 503 for mcMMO/AuraSkills) when you call
+    :meth:`get_top`.
+    """
+
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def list(self) -> List[LeaderboardSourceInfo]:
+        """List every registered leaderboard source and its availability."""
+        return self._http.request("GET", "leaderboards")
+
+    def get_top(self, id: str, limit: Optional[int] = None) -> List[LeaderboardEntry]:
+        """Get ranked entries for one leaderboard source (see :meth:`list` for valid IDs)."""
+        return self._http.request("GET", f"leaderboards/{_q(id)}/top", query={"limit": limit})

noxaeapi_sdk/modules/luckperms.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import Dict, List
+
+from ..http_engine import HttpEngine
+from ..types import GroupInfo, PermissionNode
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class LuckPermsModule:
+    """Wraps the ``/v1/luckperms/*`` routes.
+
+    These only exist on the server when the LuckPerms mod is loaded —
+    calling any method here against a server without it will fail
+    (typically a 404). There's no separate "is this available" flag from
+    the SDK's side; check ``client.plugins.list()`` for LuckPerms if you
+    need to branch on it ahead of time.
+
+    Unlike most other modules, these POST/DELETE bodies are sent as real
+    JSON (the server reads them with ``ctx.bodyAsClass(...)``, not
+    ``ctx.formParam(...)``) — none of these calls pass ``form=True``.
+    """
+
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def get_player_groups(self, uuid: str) -> List[str]:
+        """Get the groups a player belongs to."""
+        return self._http.request("GET", f"luckperms/player/{_q(uuid)}/groups")
+
+    def get_player_permissions(self, uuid: str) -> List[PermissionNode]:
+        """Get a player's effective permission nodes."""
+        return self._http.request("GET", f"luckperms/player/{_q(uuid)}/permissions")
+
+    def add_player_permission(self, uuid: str, permission: str, value: bool = True) -> None:
+        """Add a permission node to a player."""
+        return self._http.request(
+            "POST", f"luckperms/player/{_q(uuid)}/permission", body={"permission": permission, "value": value}
+        )
+
+    def check_player_permission(self, uuid: str, permission: str) -> Dict[str, object]:
+        """Check whether a player has a given permission."""
+        return self._http.request(
+            "POST", f"luckperms/player/{_q(uuid)}/check-permission", body={"permission": permission}
+        )
+
+    def remove_player_permission(self, uuid: str, permission: str) -> None:
+        """Remove a permission node from a player."""
+        return self._http.request(
+            "DELETE", f"luckperms/player/{_q(uuid)}/permission", body={"permission": permission}
+        )
+
+    def set_player_group(self, uuid: str, group: str) -> None:
+        """Set a player's primary group."""
+        return self._http.request("POST", f"luckperms/player/{_q(uuid)}/group", body={"group": group})
+
+    def remove_player_group(self, uuid: str, group_name: str) -> None:
+        """Remove a group from a player."""
+        return self._http.request("DELETE", f"luckperms/player/{_q(uuid)}/group/{_q(group_name)}")
+
+    def get_groups(self) -> List[str]:
+        """List all known groups."""
+        return self._http.request("GET", "luckperms/groups")
+
+    def create_group(self, name: str) -> Dict[str, str]:
+        """Create a new LuckPerms group. The name is lowercased server-side.
+
+        Raises ``NoxAeApiError`` with a 409 status if the group already exists.
+        """
+        return self._http.request("POST", "luckperms/groups", body={"name": name})
+
+    def delete_group(self, name: str) -> None:
+        """Delete a LuckPerms group by name.
+
+        The ``default`` group can't be deleted (400 — every user without
+        an explicit group inherits from it) and a 404 is raised if it
+        doesn't exist.
+        """
+        return self._http.request("DELETE", f"luckperms/group/{_q(name)}")
+
+    def get_group_permissions(self, name: str) -> GroupInfo:
+        """Get the permissions attached to a specific group."""
+        return self._http.request("GET", f"luckperms/group/{_q(name)}/permissions")

noxaeapi_sdk/modules/misc.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import List
+
+from ..http_engine import HttpEngine
+from ..types import Advancement
+
+
+class AdvancementsModule:
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def list(self) -> List[Advancement]:
+        """List all advancements known to the server."""
+        return self._http.request("GET", "advancements")
+
+
+class PlaceholdersModule:
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def replace(self, uuid: str, message: str) -> str:
+        """Replace PlaceholderAPI-style placeholders (e.g. "%player_name%") in ``message`` for a player.
+
+        Server-side this is ``PAPIApi.replacePlaceholders``, which reads
+        form fields ``message`` and ``uuid`` — the field is literally
+        named ``message``, not ``text``.
+        """
+        return self._http.request("POST", "placeholders/replace", body={"uuid": uuid, "message": message}, form=True)

noxaeapi_sdk/modules/network.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any, Dict, Optional
+
+from ..http_engine import HttpEngine, Method, QueryValue
+from ..types import (
+    NetworkBroadcastResponse,
+    NetworkFindPlayerResponse,
+    NetworkHealthResponse,
+    NetworkPlayersResponse,
+    NetworkServerStatus,
+)
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class NetworkModule:
+    """Wraps the ``/v1/network/*`` routes.
+
+    These only exist when ``network.enabled: true`` is set in the
+    server's config with at least one backend server configured —
+    calling any method here against a server without the network
+    aggregator enabled will 404.
+
+    The aggregator fans requests out to every configured backend server
+    (each with its own base URL + key) and merges the results, so a
+    single call here can reflect the state of an entire network rather
+    than just the server you connected to.
+    """
+
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def status_all(self) -> Dict[str, list]:
+        """Get status (server info + online players) for every configured network server."""
+        return self._http.request("GET", "network/status")
+
+    def status_by_id(self, id: str) -> NetworkServerStatus:
+        """Get status for a single network server by its configured ID."""
+        return self._http.request("GET", f"network/status/{_q(id)}")
+
+    def players(self) -> NetworkPlayersResponse:
+        """Aggregate online players across every network server."""
+        return self._http.request("GET", "network/players")
+
+    def find_player(self, uuid: str) -> NetworkFindPlayerResponse:
+        """Find which network server a player is currently on by UUID."""
+        return self._http.request("GET", f"network/players/{_q(uuid)}")
+
+    def health(self) -> NetworkHealthResponse:
+        """Get aggregate health (TPS/memory) from every network server."""
+        return self._http.request("GET", "network/health")
+
+    def broadcast(self, message: str) -> NetworkBroadcastResponse:
+        """Broadcast a message to every server on the network.
+
+        Returns a map of server ID -> "success" | "error" (per-server
+        delivery result; a network-wide failure is only raised for a
+        malformed request).
+        """
+        return self._http.request("POST", "network/broadcast", body={"message": message}, form=True)
+
+    def forward(
+        self,
+        id: str,
+        method: Method,
+        path: str,
+        *,
+        body: Any = None,
+        query: Optional[Dict[str, QueryValue]] = None,
+        form: bool = False,
+    ) -> Any:
+        """Forward an arbitrary request to a specific network server's own REST API.
+
+        E.g. ``network.forward("survival", "POST", "server/exec",
+        body={"command": "say hi"}, form=True)`` reaches that server's
+        ``POST /v1/server/exec`` directly. Useful for endpoints the
+        aggregator doesn't have a dedicated method for (economy, worlds,
+        etc) on a specific server without instantiating a second client
+        pointed at it.
+
+        Note the target server responds according to its own route's
+        expected encoding (form vs JSON) — pass ``form=True`` the same
+        way you would for a direct call to that endpoint.
+        """
+        return self._http.request(
+            method, f"network/{_q(id)}/{path.lstrip('/')}", body=body, query=query, form=form
+        )

noxaeapi_sdk/modules/network_hub.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any, Dict, Optional
+
+from ..http_engine import HttpEngine, Method, QueryValue
+from ..types import (
+    NetworkHubBroadcastResponse,
+    NetworkHubFindPlayerResponse,
+    NetworkHubNode,
+    NetworkHubPlayersResponse,
+    NetworkHubStatusResponse,
+)
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class NetworkHubModule:
+    """Wraps the ``/v1/network/*`` routes exposed by the **NoxAeApi-Velocity** network hub.
+
+    This is a separate plugin/process from NoxAeApi-main, run on the
+    Velocity proxy and listening on its own port (``NetworkHubConfig``'s
+    ``api-port``, distinct from any individual backend's own REST port).
+
+    Point a :class:`~noxaeapi_sdk.client.NoxAeApiNetworkHubClient` (not
+    the regular :class:`~noxaeapi_sdk.client.NoxAeApiClient`) at that
+    port to use this module. Backend Paper/Bukkit servers connect out to
+    the hub over WebSocket (``/network/register``) and push register /
+    heartbeat / player-join / player-quit events; the hub answers every
+    method below from its own in-memory registry, so calls here are
+    cheap and don't block on a live round trip to each backend the way
+    the older :class:`~noxaeapi_sdk.modules.network.NetworkModule`
+    (NoxAeApi-main's built-in aggregator) does.
+
+    Response shapes differ from ``NetworkModule`` even where the route
+    names match — e.g. :meth:`players` returns one flat proxy-wide
+    player list here, not a per-server breakdown — so the two modules'
+    types aren't interchangeable. There's also no hub equivalent of
+    ``/v1/network/health``; each node's last-reported health is embedded
+    in :meth:`status_all`/:meth:`status_by_id`'s ``health`` field
+    instead.
+    """
+
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def status_all(self) -> NetworkHubStatusResponse:
+        """Get last-known status (from the registry) for every backend node that has ever registered."""
+        return self._http.request("GET", "network/status")
+
+    def status_by_id(self, id: str) -> NetworkHubNode:
+        """Get last-known status for a single node by its configured ID."""
+        return self._http.request("GET", f"network/status/{_q(id)}")
+
+    def players(self) -> NetworkHubPlayersResponse:
+        """List every player currently connected to the proxy, straight from Velocity's own registry."""
+        return self._http.request("GET", "network/players")
+
+    def find_player(self, uuid: str) -> NetworkHubFindPlayerResponse:
+        """Find which backend server a player is currently on by UUID (proxy-authoritative)."""
+        return self._http.request("GET", f"network/players/{_q(uuid)}")
+
+    def broadcast(self, message: str) -> NetworkHubBroadcastResponse:
+        """Broadcast a message directly to every player connected to the proxy.
+
+        Unlike ``NetworkModule.broadcast``, this doesn't forward to each
+        backend's ``/v1/chat/broadcast`` — the proxy already has every
+        player in hand — so it still delivers even to servers with no
+        REST API of their own reachable from the hub.
+        """
+        return self._http.request("POST", "network/broadcast", body={"message": message}, form=True)
+
+    def forward(
+        self,
+        id: str,
+        method: Method,
+        path: str,
+        *,
+        body: Any = None,
+        query: Optional[Dict[str, QueryValue]] = None,
+        form: bool = False,
+    ) -> Any:
+        """Forward an arbitrary request to a specific backend node's own REST API.
+
+        E.g. ``hub.forward("survival", "POST", "server/exec",
+        body={"command": "say hi"}, form=True)`` reaches that backend's
+        ``POST /v1/server/exec`` directly. Useful for endpoints the hub
+        doesn't have a dedicated method for (economy, worlds, etc)
+        without instantiating a second client pointed at that backend
+        directly.
+
+        The target backend responds according to its own route's
+        expected encoding (form vs JSON) — pass ``form=True`` the same
+        way you would for a direct call to that endpoint.
+        """
+        return self._http.request(
+            method, f"network/{_q(id)}/{path.lstrip('/')}", body=body, query=query, form=form
+        )

noxaeapi_sdk/modules/noxauth.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import urllib.parse
+
+from ..http_engine import HttpEngine
+from ..types import NoxAuthPlayerInfo, PasswordCheckResult
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class NoxAuthModule:
+    """Wraps the ``/v1/noxauth/*`` routes.
+
+    These only work when ``noxauth.enabled`` is set to ``true`` in the
+    server's ``noxaeapi-config.yml`` and the NoxAuth plugin is installed.
+
+    ``check_password``'s body is sent as real JSON (the server parses it
+    with ``Gson...fromJson(ctx.body(), PasswordCheckRequest.class)``, not
+    ``ctx.formParam(...)``) — it does not pass ``form=True``.
+    """
+
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def get_player_auth(self, name: str) -> NoxAuthPlayerInfo:
+        """Get NoxAuth registration/auth info for a player by name."""
+        return self._http.request("GET", f"noxauth/player/{_q(name)}")
+
+    def check_password(self, name: str, password: str) -> PasswordCheckResult:
+        """Check whether a password matches a player's stored NoxAuth password."""
+        return self._http.request(
+            "POST", f"noxauth/player/{_q(name)}/check-password", body={"password": password}
+        )

noxaeapi_sdk/modules/players.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any, Dict, List, Optional, Union
+
+from ..http_engine import HttpEngine
+from ..types import Gamemode, InventoryItem, OfflinePlayer, OnlinePlayer, PlayerStats
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class PlayersModule:
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def list(self) -> List[OnlinePlayer]:
+        """List currently online players."""
+        return self._http.request("GET", "players")
+
+    def list_all(self) -> List[OfflinePlayer]:
+        """List all players the server has ever seen (online + offline)."""
+        return self._http.request("GET", "players/all")
+
+    def get(self, uuid: str) -> Union[OnlinePlayer, OfflinePlayer]:
+        """Get a single player by UUID (works for online or offline players)."""
+        return self._http.request("GET", f"players/{_q(uuid)}")
+
+    def get_inventory(self, player_uuid: str, world_uuid: str) -> List[InventoryItem]:
+        """Get a player's inventory in a specific world."""
+        return self._http.request("GET", f"players/{_q(player_uuid)}/{_q(world_uuid)}/inventory")
+
+    def kick(self, uuid: str, reason: Optional[str] = None) -> None:
+        """Kick an online player, optionally with a reason."""
+        body: Optional[Dict[str, Any]] = {"reason": reason} if reason else None
+        return self._http.request("POST", f"players/{_q(uuid)}/kick", body=body, form=True)
+
+    def ban(self, uuid: str, reason: Optional[str] = None, expiry: Optional[str] = None) -> None:
+        """Ban a player, optionally with a reason and an ISO-8601 expiry (e.g. "2030-01-01T00:00:00Z").
+
+        Omit ``expiry`` for a permanent ban.
+        """
+        body: Optional[Dict[str, Any]] = {"reason": reason, "expiry": expiry} if (reason or expiry) else None
+        return self._http.request("POST", f"players/{_q(uuid)}/ban", body=body, form=True)
+
+    def unban(self, uuid: str) -> None:
+        """Remove a player's ban."""
+        return self._http.request("DELETE", f"players/{_q(uuid)}/ban")
+
+    def teleport(self, uuid: str, location: Dict[str, Any]) -> None:
+        """Teleport a player to a location, e.g. ``{"x": 0, "y": 64, "z": 0, "world": "world"}``."""
+        return self._http.request("POST", f"players/{_q(uuid)}/teleport", body=location, form=True)
+
+    def set_gamemode(self, uuid: str, gamemode: Gamemode) -> None:
+        """Change a player's gamemode."""
+        return self._http.request(
+            "PUT", f"players/{_q(uuid)}/gamemode", body={"gamemode": gamemode}, form=True
+        )
+
+    def get_stats(self, uuid: str) -> PlayerStats:
+        """Get kill/death/playtime/block stats for a player."""
+        return self._http.request("GET", f"players/{_q(uuid)}/stats")

noxaeapi_sdk/modules/plugins.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import List
+
+from ..http_engine import HttpEngine
+from ..types import Plugin
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class PluginsModule:
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def list(self) -> List[Plugin]:
+        """List all installed plugins/mods."""
+        return self._http.request("GET", "plugins")
+
+    def install(self, download_url: str) -> None:
+        """Install a plugin by downloading it from a direct URL.
+
+        This is a privileged endpoint — requires a write-enabled API key.
+        Server-side (``PluginApi.installPlugin``) reads the form field
+        ``downloadUrl``, not ``source``.
+        """
+        return self._http.request("POST", "plugins", body={"downloadUrl": download_url}, form=True)
+
+    def enable(self, name: str) -> None:
+        """Enable a plugin by name."""
+        return self._http.request("POST", f"plugins/{_q(name)}/enable")
+
+    def disable(self, name: str) -> None:
+        """Disable a plugin by name."""
+        return self._http.request("POST", f"plugins/{_q(name)}/disable")

noxaeapi_sdk/modules/server.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+import urllib.parse
+from typing import Any, Dict, List, Optional
+
+from ..http_engine import HttpEngine
+from ..types import ServerInfo, WhitelistEntry
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class ServerModule:
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def ping(self) -> Dict[str, str]:
+        """Basic liveness check."""
+        return self._http.request("GET", "ping")
+
+    def info(self) -> ServerInfo:
+        """Get server info: version, MOTD, TPS, health, player counts, etc."""
+        return self._http.request("GET", "server")
+
+    def exec(self, command: str, wait_ms: Optional[int] = None) -> str:
+        """Run a console command on the server, returning its console output.
+
+        This is a privileged endpoint — requires a write-enabled API key.
+        ``wait_ms`` is how long to wait for output before returning
+        (server default 500ms if omitted). The server returns the joined
+        output as a plain JSON string, not ``{"lines": [...]}``.
+        """
+        return self._http.request("POST", "server/exec", body={"command": command, "time": wait_ms}, form=True)
+
+    def get_ops(self) -> List[WhitelistEntry]:
+        """List server operators."""
+        return self._http.request("GET", "server/ops")
+
+    def op_player(self, uuid: str) -> None:
+        """Grant operator status to a player.
+
+        Server-side (``ServerApi.opPlayer``) reads the form field
+        ``playerUuid``, not ``uuid`` — the field name matters here.
+        """
+        return self._http.request("POST", "server/ops", body={"playerUuid": uuid}, form=True)
+
+    def deop_player(self, uuid: str) -> None:
+        """Revoke operator status from a player.
+
+        Server-side (``ServerApi.deopPlayer``) reads this from the query
+        string (``playerUuid``), not the request body.
+        """
+        return self._http.request("DELETE", "server/ops", query={"playerUuid": uuid})
+
+    def get_whitelist(self) -> List[WhitelistEntry]:
+        """Get the current whitelist."""
+        return self._http.request("GET", "server/whitelist")
+
+    def add_to_whitelist(self, uuid: str, name: Optional[str] = None) -> None:
+        """Add a player to the whitelist."""
+        return self._http.request("POST", "server/whitelist", body={"uuid": uuid, "name": name}, form=True)
+
+    def remove_from_whitelist(self, uuid: str) -> None:
+        """Remove a player from the whitelist.
+
+        Server-side (``ServerApi.whitelistDelete``) reads ``uuid``/``name``
+        from the query string, not the request body.
+        """
+        return self._http.request("DELETE", "server/whitelist", query={"uuid": uuid})
+
+    def restart(self) -> None:
+        """Restart the server. This is a privileged endpoint — requires a write-enabled API key."""
+        return self._http.request("POST", "server/restart")
+
+    def get_logs(self, lines: Optional[int] = None) -> Dict[str, List[str]]:
+        """Tail the server console log."""
+        return self._http.request("GET", "server/logs", query={"lines": lines})
+
+    def get_entities(self, world: Optional[str] = None) -> Dict[str, Any]:
+        """Get entity counts on the server, optionally scoped to a world."""
+        return self._http.request("GET", "server/entities", query={"world": world})
+
+    def get_chunks(self, world: Optional[str] = None) -> Dict[str, Any]:
+        """Get loaded chunk counts, optionally scoped to a world."""
+        return self._http.request("GET", "server/chunks", query={"world": world})
+
+    def ban_ip(self, ip: str, reason: Optional[str] = None) -> None:
+        """Ban an IP address."""
+        return self._http.request("POST", "server/ban-ip", body={"ip": ip, "reason": reason}, form=True)
+
+    def get_objective(self, name: str) -> Any:
+        """Get a scoreboard objective's scores by objective name."""
+        return self._http.request("GET", f"scoreboard/{_q(name)}")
+
+    def get_scoreboard(self) -> Any:
+        """List all scoreboard objectives and tracked entries."""
+        return self._http.request("GET", "scoreboard")
+
+    def set_score(self, objective: str, entry: str, value: int) -> None:
+        """Set a score for an entry on an objective."""
+        return self._http.request(
+            "POST", f"scoreboard/{_q(objective)}/score", body={"entry": entry, "value": value}, form=True
+        )
+
+    def reset_score(self, objective: str, entry: str) -> None:
+        """Reset (remove) a score for an entry on an objective.
+
+        Server-side (``ServerApi.resetScore``) reads ``entry`` from the
+        query string, not the request body.
+        """
+        return self._http.request("DELETE", f"scoreboard/{_q(objective)}/score", query={"entry": entry})
+
+    def broadcast(self, message: str) -> None:
+        """Broadcast a message to every player on the server."""
+        return self._http.request("POST", "chat/broadcast", body={"message": message}, form=True)
+
+    def tell(self, uuid: str, message: str) -> None:
+        """Send a private message to a specific player.
+
+        Server-side (``ServerApi.tellPost``) reads the form field
+        ``playerUuid``, not ``uuid``.
+        """
+        return self._http.request(
+            "POST", "chat/tell", body={"playerUuid": uuid, "message": message}, form=True
+        )

noxaeapi_sdk/modules/skills.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import urllib.parse
+
+from ..http_engine import HttpEngine
+from ..types import SkillInfo
+
+
+def _q(value: str) -> str:
+    return urllib.parse.quote(value, safe="")
+
+
+class SkillsModule:
+    """Wraps the ``/v1/skills/*`` routes (mcMMO / AuraSkills)."""
+
+    def __init__(self, http: HttpEngine) -> None:
+        self._http = http
+
+    def get_mcmmo_skills(self, uuid: str) -> SkillInfo:
+        """Get mcMMO skill levels and power level for a player.
+
+        Only works for **online** players — mcMMO's public ExperienceAPI
+        has no offline lookup, so this raises ``NoxAeApiNotFoundError`` if
+        the player isn't currently connected, and ``NoxAeApiServerError``
+        (503) if mcMMO isn't loaded on the target server.
+        """
+        return self._http.request("GET", f"skills/mcmmo/player/{_q(uuid)}")
+
+    def get_aura_skills(self, uuid: str) -> SkillInfo:
+        """Get AuraSkills skill levels and power level for a player.
+
+        Works for offline players. Raises ``NoxAeApiServerError`` (503)
+        if AuraSkills isn't loaded on the target server.
+        """
+        return self._http.request("GET", f"skills/auraskills/player/{_q(uuid)}")