fortnite-api-sdk 0.1.0__py3-none-any.whl

fortnite_api/__init__.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from . import models
+from .client import AsyncFortniteAPI, FortniteAPI
+from .errors import FortniteAPIError
+
+__version__ = "0.1.0"
+
+__all__ = ["FortniteAPI", "AsyncFortniteAPI", "FortniteAPIError", "models", "__version__"]

fortnite_api/_transport.py

@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import os
+from typing import Any, BinaryIO, Union
+
+import httpx
+from pydantic import BaseModel
+
+from .errors import FortniteAPIError
+
+DEFAULT_BASE_URL = "https://prod.api-fortnite.com/api"
+
+FileInput = Union[bytes, bytearray, BinaryIO, str]
+
+
+class _BaseTransport:
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        fortnite_token: str | None = None,
+    ) -> None:
+        if not api_key:
+            raise ValueError("api_key is required")
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.root_url = self.base_url[:-4] if self.base_url.endswith("/api") else self.base_url
+        self.timeout = timeout
+        self.fortnite_token = fortnite_token
+
+    def _url(self, path: str, version: str | None) -> str:
+        if version is None:
+            return f"{self.root_url}{path}"
+        return f"{self.base_url}/{version}{path}"
+
+    def _headers(self, fortnite_token: str | None, json: bool = True) -> dict[str, str]:
+        headers = {"x-api-key": self.api_key}
+        if json:
+            headers["Content-Type"] = "application/json"
+        token = fortnite_token or self.fortnite_token
+        if token:
+            headers["x-fortnite-token"] = token
+        return headers
+
+    @staticmethod
+    def _clean(params: dict[str, Any] | None) -> dict[str, Any] | None:
+        if not params:
+            return None
+        cleaned = {k: v for k, v in params.items() if v is not None}
+        return cleaned or None
+
+    @staticmethod
+    def _error(resp: httpx.Response) -> FortniteAPIError:
+        try:
+            data: Any = resp.json()
+        except Exception:
+            data = {"error": "Request failed"}
+        message = None
+        if isinstance(data, dict):
+            message = data.get("error") or data.get("title") or data.get("detail")
+        return FortniteAPIError(message or f"Request failed with status {resp.status_code}", resp.status_code, data)
+
+    @staticmethod
+    def _parse(data: Any, model: type[BaseModel] | None, is_list: bool) -> Any:
+        if model is None:
+            return data
+        if is_list:
+            if isinstance(data, dict):
+                lists = [v for v in data.values() if isinstance(v, list)]
+                if len(lists) == 1:
+                    data = lists[0]
+            return [model.model_validate(item) for item in data]
+        return model.model_validate(data)
+
+    @staticmethod
+    def _unwrap(data: Any) -> Any:
+        if isinstance(data, dict):
+            if "success" in data:
+                if not data.get("success"):
+                    raise FortniteAPIError(data.get("error") or "Request failed", 422, data)
+                if "data" in data:
+                    return data["data"]
+                if "results" in data:
+                    return data["results"]
+            elif "data" in data and "status" in data:
+                return data["data"]
+        return data
+
+    @staticmethod
+    def _file_tuple(file: FileInput, filename: str | None) -> tuple[str, bytes, str]:
+        if isinstance(file, str):
+            with open(file, "rb") as handle:
+                content = handle.read()
+            name = filename or os.path.basename(file)
+        elif isinstance(file, (bytes, bytearray)):
+            content = bytes(file)
+            name = filename or "replay.replay"
+        else:
+            content = file.read()
+            name = filename or getattr(file, "name", "replay.replay")
+        return (name, content, "application/octet-stream")
+
+
+class SyncTransport(_BaseTransport):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._client = httpx.Client(timeout=self.timeout, follow_redirects=True)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        version: str | None,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: Any = None,
+        fortnite_token: str | None = None,
+        model: type[BaseModel] | None = None,
+        is_list: bool = False,
+    ) -> Any:
+        resp = self._client.request(
+            method,
+            self._url(path, version),
+            params=self._clean(params),
+            json=json_body,
+            headers=self._headers(fortnite_token),
+        )
+        if not resp.is_success:
+            raise self._error(resp)
+        return self._parse(self._unwrap(resp.json()), model, is_list)
+
+    def request_binary(self, path: str, version: str | None, *, fortnite_token: str | None = None) -> bytes:
+        resp = self._client.get(self._url(path, version), headers=self._headers(fortnite_token, json=False))
+        if not resp.is_success:
+            raise self._error(resp)
+        return resp.content
+
+    def request_redirect(
+        self, path: str, version: str | None, *, params: dict[str, Any] | None = None, fortnite_token: str | None = None
+    ) -> str | None:
+        resp = self._client.get(
+            self._url(path, version),
+            params=self._clean(params),
+            headers=self._headers(fortnite_token, json=False),
+            follow_redirects=False,
+        )
+        if resp.is_redirect:
+            return resp.headers.get("location")
+        if resp.is_success:
+            return str(resp.url)
+        raise self._error(resp)
+
+    def request_multipart(
+        self, path: str, files: Any, *, model: type[BaseModel] | None = None, is_list: bool = False, unwrap: bool = True
+    ) -> Any:
+        resp = self._client.post(self._url(path, "v1"), headers=self._headers(None, json=False), files=files)
+        if not resp.is_success:
+            raise self._error(resp)
+        data = self._unwrap(resp.json()) if unwrap else resp.json()
+        return self._parse(data, model, is_list)
+
+
+class AsyncTransport(_BaseTransport):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._client = httpx.AsyncClient(timeout=self.timeout, follow_redirects=True)
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def request(
+        self,
+        method: str,
+        path: str,
+        version: str | None,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: Any = None,
+        fortnite_token: str | None = None,
+        model: type[BaseModel] | None = None,
+        is_list: bool = False,
+    ) -> Any:
+        resp = await self._client.request(
+            method,
+            self._url(path, version),
+            params=self._clean(params),
+            json=json_body,
+            headers=self._headers(fortnite_token),
+        )
+        if not resp.is_success:
+            raise self._error(resp)
+        return self._parse(self._unwrap(resp.json()), model, is_list)
+
+    async def request_binary(self, path: str, version: str | None, *, fortnite_token: str | None = None) -> bytes:
+        resp = await self._client.get(self._url(path, version), headers=self._headers(fortnite_token, json=False))
+        if not resp.is_success:
+            raise self._error(resp)
+        return resp.content
+
+    async def request_redirect(
+        self, path: str, version: str | None, *, params: dict[str, Any] | None = None, fortnite_token: str | None = None
+    ) -> str | None:
+        resp = await self._client.get(
+            self._url(path, version),
+            params=self._clean(params),
+            headers=self._headers(fortnite_token, json=False),
+            follow_redirects=False,
+        )
+        if resp.is_redirect:
+            return resp.headers.get("location")
+        if resp.is_success:
+            return str(resp.url)
+        raise self._error(resp)
+
+    async def request_multipart(
+        self, path: str, files: Any, *, model: type[BaseModel] | None = None, is_list: bool = False, unwrap: bool = True
+    ) -> Any:
+        resp = await self._client.post(self._url(path, "v1"), headers=self._headers(None, json=False), files=files)
+        if not resp.is_success:
+            raise self._error(resp)
+        data = self._unwrap(resp.json()) if unwrap else resp.json()
+        return self._parse(data, model, is_list)

fortnite_api/client.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ._transport import DEFAULT_BASE_URL, AsyncTransport, SyncTransport
+from .resources import AccountResource, AsyncAccountResource, AesResource, AsyncAesResource, AssetsResource, AsyncAssetsResource, CalendarResource, AsyncCalendarResource, CosmeticsResource, AsyncCosmeticsResource, CrewResource, AsyncCrewResource, EventsResource, AsyncEventsResource, FNResource, AsyncFNResource, FriendsResource, AsyncFriendsResource, MapResource, AsyncMapResource, NewsResource, AsyncNewsResource, OAuthResource, AsyncOAuthResource, ParsingResource, AsyncParsingResource, PlaylistsResource, AsyncPlaylistsResource, ProfileResource, AsyncProfileResource, QuestsResource, AsyncQuestsResource, ReplaysResource, AsyncReplaysResource, ShopResource, AsyncShopResource, BattlePassResource, AsyncBattlePassResource, StatsResource, AsyncStatsResource, TournamentsResource, AsyncTournamentsResource, WeaponsResource, AsyncWeaponsResource
+
+class FortniteAPI:
+    """Client for the Fortnite API (https://api-fortnite.com)."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        fortnite_token: str | None = None,
+    ) -> None:
+        self._t = SyncTransport(api_key, base_url, timeout, fortnite_token)
+        self.account = AccountResource(self._t)
+        self.aes = AesResource(self._t)
+        self.assets = AssetsResource(self._t)
+        self.calendar = CalendarResource(self._t)
+        self.cosmetics = CosmeticsResource(self._t)
+        self.crew = CrewResource(self._t)
+        self.events = EventsResource(self._t)
+        self.fn = FNResource(self._t)
+        self.friends = FriendsResource(self._t)
+        self.map = MapResource(self._t)
+        self.news = NewsResource(self._t)
+        self.oauth = OAuthResource(self._t)
+        self.parsing = ParsingResource(self._t)
+        self.playlists = PlaylistsResource(self._t)
+        self.profile = ProfileResource(self._t)
+        self.quests = QuestsResource(self._t)
+        self.replays = ReplaysResource(self._t)
+        self.shop = ShopResource(self._t)
+        self.battlepass = BattlePassResource(self._t)
+        self.stats = StatsResource(self._t)
+        self.tournaments = TournamentsResource(self._t)
+        self.weapons = WeaponsResource(self._t)
+
+    def health(self) -> Any:
+        return self._t.request("GET", "/health", None, model=None, is_list=False)
+
+    def close(self) -> None:
+        self._t.close()
+
+    def __enter__(self) -> FortniteAPI:
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+
+class AsyncFortniteAPI:
+    """Client for the Fortnite API (https://api-fortnite.com)."""
+
+    def __init__(
+        self,
+        api_key: str,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 30.0,
+        fortnite_token: str | None = None,
+    ) -> None:
+        self._t = AsyncTransport(api_key, base_url, timeout, fortnite_token)
+        self.account = AsyncAccountResource(self._t)
+        self.aes = AsyncAesResource(self._t)
+        self.assets = AsyncAssetsResource(self._t)
+        self.calendar = AsyncCalendarResource(self._t)
+        self.cosmetics = AsyncCosmeticsResource(self._t)
+        self.crew = AsyncCrewResource(self._t)
+        self.events = AsyncEventsResource(self._t)
+        self.fn = AsyncFNResource(self._t)
+        self.friends = AsyncFriendsResource(self._t)
+        self.map = AsyncMapResource(self._t)
+        self.news = AsyncNewsResource(self._t)
+        self.oauth = AsyncOAuthResource(self._t)
+        self.parsing = AsyncParsingResource(self._t)
+        self.playlists = AsyncPlaylistsResource(self._t)
+        self.profile = AsyncProfileResource(self._t)
+        self.quests = AsyncQuestsResource(self._t)
+        self.replays = AsyncReplaysResource(self._t)
+        self.shop = AsyncShopResource(self._t)
+        self.battlepass = AsyncBattlePassResource(self._t)
+        self.stats = AsyncStatsResource(self._t)
+        self.tournaments = AsyncTournamentsResource(self._t)
+        self.weapons = AsyncWeaponsResource(self._t)
+
+    async def health(self) -> Any:
+        return await self._t.request("GET", "/health", None, model=None, is_list=False)
+
+    async def close(self) -> None:
+        await self._t.close()
+
+    async def __aenter__(self) -> AsyncFortniteAPI:
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.close()
+

fortnite_api/errors.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class FortniteAPIError(Exception):
+    """Raised when the Fortnite API returns a non-success HTTP status."""
+
+    def __init__(self, message: str, status: int, data: Any = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.data = data
+
+    def __str__(self) -> str:
+        return f"[{self.status}] {self.message}"

fortnite_api/models.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FNModel(BaseModel):
+    model_config = ConfigDict(populate_by_name=True, extra="allow")
+
+
+class CompleteOAuthRequest(FNModel):
+    flow_id: str | None = Field(default=None, alias="flowId")
+
+class CosmeticDto(FNModel):
+    id: str | None = None
+    type: str | None = None
+    name: str | None = None
+    description: str | None = None
+    rarity: str | None = None
+    series: str | None = None
+    set: str | None = None
+    icon: str | None = None
+    introduction: CosmeticIntroductionDto | None = None
+    images: CosmeticImagesDto | None = None
+    tags: list[str] | None = None
+
+class CosmeticDtoPaginatedResultDto(FNModel):
+    page: int | None = None
+    page_size: int | None = Field(default=None, alias="pageSize")
+    total: int | None = None
+    total_pages: int | None = Field(default=None, alias="totalPages")
+    data: list[CosmeticDto] | None = None
+
+class CosmeticImagesDto(FNModel):
+    small_icon: str | None = Field(default=None, alias="smallIcon")
+    icon: str | None = None
+    large_icon: str | None = Field(default=None, alias="largeIcon")
+
+class CosmeticIntroductionDto(FNModel):
+    chapter: int | None = None
+    season: int | None = None
+    absolute_season: int | None = Field(default=None, alias="absoluteSeason")
+
+class ExchangeCodeRequest(FNModel):
+    code: str | None = None
+    redirect_uri: str | None = Field(default=None, alias="redirectUri")
+    client_id: str | None = Field(default=None, alias="clientId")
+    client_secret: str | None = Field(default=None, alias="clientSecret")
+
+class LinkAccountRequest(FNModel):
+    code: str | None = None
+    redirect_uri: str | None = Field(default=None, alias="redirectUri")
+    client_id: str | None = Field(default=None, alias="clientId")
+    client_secret: str | None = Field(default=None, alias="clientSecret")
+
+class MapDataDto(FNModel):
+    version: str | None = None
+    chapter: int | None = None
+    season: int | None = None
+    patch: str | None = None
+    release_date: str | None = Field(default=None, alias="releaseDate")
+    image_url: str | None = Field(default=None, alias="imageUrl")
+    pois: list[PoiDto] | None = None
+
+class MapHistoryEntryDto(FNModel):
+    version: str | None = None
+    chapter: int | None = None
+    season: int | None = None
+    patch: str | None = None
+    release_date: str | None = Field(default=None, alias="releaseDate")
+    has_image: bool | None = Field(default=None, alias="hasImage")
+    image_url: str | None = Field(default=None, alias="imageUrl")
+    has_pois: bool | None = Field(default=None, alias="hasPois")
+
+class PatchInfoDto(FNModel):
+    patch: str | None = None
+    is_current: bool | None = Field(default=None, alias="isCurrent")
+    archived_at: str | None = Field(default=None, alias="archivedAt")
+    weapon_count: int | None = Field(default=None, alias="weaponCount")
+    mode_counts: dict[str, int] | None = Field(default=None, alias="modeCounts")
+
+class PoiDto(FNModel):
+    name: str | None = None
+    x: float | None = None
+    y: float | None = None
+    type: str | None = None
+
+class ProblemDetails(FNModel):
+    type: str | None = None
+    title: str | None = None
+    status: int | None = None
+    detail: str | None = None
+    instance: str | None = None
+
+class RarityDefinitionDto(FNModel):
+    name: str | None = None
+    color: str | None = None
+    sort_order: int | None = Field(default=None, alias="sortOrder")
+
+class RefreshDeviceRequest(FNModel):
+    account_id: str | None = Field(default=None, alias="accountId")
+    device_id: str | None = Field(default=None, alias="deviceId")
+    secret: str | None = None
+
+class RefreshTokenRequest(FNModel):
+    refresh_token: str | None = Field(default=None, alias="refreshToken")
+
+class SeasonEntryDto(FNModel):
+    season_date_begin: str | None = Field(default=None, alias="seasonDateBegin")
+    season_date_end: str | None = Field(default=None, alias="seasonDateEnd")
+    season_number: int | None = Field(default=None, alias="seasonNumber")
+    ex_time: int | None = Field(default=None, alias="exTime")
+
+class ShopBundleDto(FNModel):
+    name: str | None = None
+    info: str | None = None
+    items: int | None = None
+    regular_price: int | None = Field(default=None, alias="regularPrice")
+    final_price: int | None = Field(default=None, alias="finalPrice")
+    discount: int | None = None
+
+class ShopCatalogEntryDto(FNModel):
+    offer_id: str | None = Field(default=None, alias="offerId")
+    dev_name: str | None = Field(default=None, alias="devName")
+    title: str | None = None
+    sort_priority: int | None = Field(default=None, alias="sortPriority")
+    prices: list[ShopPriceDto] | None = None
+    item_grants: list[ShopItemGrantDto] | None = Field(default=None, alias="itemGrants")
+    bundle: ShopBundleDto | None = None
+    section_id: str | None = Field(default=None, alias="sectionId")
+    section_display_name: str | None = Field(default=None, alias="sectionDisplayName")
+    section_priority: int | None = Field(default=None, alias="sectionPriority")
+    section_background: str | None = Field(default=None, alias="sectionBackground")
+    offer_visual: str | None = Field(default=None, alias="offerVisual")
+    style_visuals: list[str] | None = Field(default=None, alias="styleVisuals")
+    juno_visual: str | None = Field(default=None, alias="junoVisual")
+    tile_size: str | None = Field(default=None, alias="tileSize")
+    meta_info: list[ShopMetaInfoDto] | None = Field(default=None, alias="metaInfo")
+
+class ShopCosmeticDto(FNModel):
+    type: str | None = None
+    name: str | None = None
+    display_name: str | None = Field(default=None, alias="displayName")
+    description: str | None = None
+    short_description: str | None = Field(default=None, alias="shortDescription")
+    rarity: str | None = None
+    images: ShopCosmeticImagesDto | None = None
+    set: str | None = None
+    introduction: ShopCosmeticIntroductionDto | None = None
+    tags: list[str] | None = None
+
+class ShopCosmeticImagesDto(FNModel):
+    icon: str | None = None
+    large_icon: str | None = Field(default=None, alias="largeIcon")
+
+class ShopCosmeticIntroductionDto(FNModel):
+    chapter: int | None = None
+    season: int | None = None
+
+class ShopItemGrantDto(FNModel):
+    template_id: str | None = Field(default=None, alias="templateId")
+    quantity: int | None = None
+    cosmetic: ShopCosmeticDto | None = None
+
+class ShopMetaInfoDto(FNModel):
+    key: str | None = None
+    value: str | None = None
+
+class ShopPriceDto(FNModel):
+    currency_type: str | None = Field(default=None, alias="currencyType")
+    regular_price: int | None = Field(default=None, alias="regularPrice")
+    final_price: int | None = Field(default=None, alias="finalPrice")
+    sale_type: str | None = Field(default=None, alias="saleType")
+
+class ShopResponseDto(FNModel):
+    refresh_interval_hrs: float | None = Field(default=None, alias="refreshIntervalHrs")
+    daily_purchase_hrs: float | None = Field(default=None, alias="dailyPurchaseHrs")
+    expiration: str | None = None
+    storefronts: list[ShopStorefrontDto] | None = None
+
+class ShopStorefrontDto(FNModel):
+    name: str | None = None
+    catalog_entries: list[ShopCatalogEntryDto] | None = Field(default=None, alias="catalogEntries")
+
+class WeaponListItemDto(FNModel):
+    id: str | None = None
+    display_name: str | None = Field(default=None, alias="displayName")
+    description: str | None = None
+    rarity: str | None = None
+    type: str | None = None
+    category: str | None = None
+    ammo_type: str | None = Field(default=None, alias="ammoType")
+    trigger_type: str | None = Field(default=None, alias="triggerType")
+    search_tags: str | None = Field(default=None, alias="searchTags")
+    in_current_loot_pool: bool | None = Field(default=None, alias="inCurrentLootPool")
+    item_type: str | None = Field(default=None, alias="itemType")
+    gamemodes: list[str] | None = None
+    patch: str | None = None
+    tags: list[str] | None = None
+    stats: Any | None = None
+    images: Any | None = None
+
+
+__all__ = [
+    "CompleteOAuthRequest",
+    "CosmeticDto",
+    "CosmeticDtoPaginatedResultDto",
+    "CosmeticImagesDto",
+    "CosmeticIntroductionDto",
+    "ExchangeCodeRequest",
+    "LinkAccountRequest",
+    "MapDataDto",
+    "MapHistoryEntryDto",
+    "PatchInfoDto",
+    "PoiDto",
+    "ProblemDetails",
+    "RarityDefinitionDto",
+    "RefreshDeviceRequest",
+    "RefreshTokenRequest",
+    "SeasonEntryDto",
+    "ShopBundleDto",
+    "ShopCatalogEntryDto",
+    "ShopCosmeticDto",
+    "ShopCosmeticImagesDto",
+    "ShopCosmeticIntroductionDto",
+    "ShopItemGrantDto",
+    "ShopMetaInfoDto",
+    "ShopPriceDto",
+    "ShopResponseDto",
+    "ShopStorefrontDto",
+    "WeaponListItemDto",
+]
+
+for _m in list(__all__):
+    globals()[_m].model_rebuild()

fortnite_api/resources/__init__.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from .account import AccountResource, AsyncAccountResource
+from .aes import AesResource, AsyncAesResource
+from .assets import AssetsResource, AsyncAssetsResource
+from .calendar import CalendarResource, AsyncCalendarResource
+from .cosmetics import CosmeticsResource, AsyncCosmeticsResource
+from .crew import CrewResource, AsyncCrewResource
+from .events import EventsResource, AsyncEventsResource
+from .fn import FNResource, AsyncFNResource
+from .friends import FriendsResource, AsyncFriendsResource
+from .map import MapResource, AsyncMapResource
+from .news import NewsResource, AsyncNewsResource
+from .oauth import OAuthResource, AsyncOAuthResource
+from .parsing import ParsingResource, AsyncParsingResource
+from .playlists import PlaylistsResource, AsyncPlaylistsResource
+from .profile import ProfileResource, AsyncProfileResource
+from .quests import QuestsResource, AsyncQuestsResource
+from .replays import ReplaysResource, AsyncReplaysResource
+from .shop import ShopResource, AsyncShopResource
+from .battlepass import BattlePassResource, AsyncBattlePassResource
+from .stats import StatsResource, AsyncStatsResource
+from .tournaments import TournamentsResource, AsyncTournamentsResource
+from .weapons import WeaponsResource, AsyncWeaponsResource
+
+__all__ = [
+    "AccountResource",
+    "AsyncAccountResource",
+    "AesResource",
+    "AsyncAesResource",
+    "AssetsResource",
+    "AsyncAssetsResource",
+    "CalendarResource",
+    "AsyncCalendarResource",
+    "CosmeticsResource",
+    "AsyncCosmeticsResource",
+    "CrewResource",
+    "AsyncCrewResource",
+    "EventsResource",
+    "AsyncEventsResource",
+    "FNResource",
+    "AsyncFNResource",
+    "FriendsResource",
+    "AsyncFriendsResource",
+    "MapResource",
+    "AsyncMapResource",
+    "NewsResource",
+    "AsyncNewsResource",
+    "OAuthResource",
+    "AsyncOAuthResource",
+    "ParsingResource",
+    "AsyncParsingResource",
+    "PlaylistsResource",
+    "AsyncPlaylistsResource",
+    "ProfileResource",
+    "AsyncProfileResource",
+    "QuestsResource",
+    "AsyncQuestsResource",
+    "ReplaysResource",
+    "AsyncReplaysResource",
+    "ShopResource",
+    "AsyncShopResource",
+    "BattlePassResource",
+    "AsyncBattlePassResource",
+    "StatsResource",
+    "AsyncStatsResource",
+    "TournamentsResource",
+    "AsyncTournamentsResource",
+    "WeaponsResource",
+    "AsyncWeaponsResource",
+]

fortnite_api/resources/_base.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+
+class Resource:
+    def __init__(self, transport: object) -> None:
+        self._t = transport