@yaelouuu/fortnite-api 4.2.0 → 4.4.0

package/README.md

@@ -345,6 +345,127 @@ const psnAuth = await client.account.getExternalAuth('accountId123', 'psn');
 
 ---
 
+### News - **NEW**
+
+Get Fortnite news and announcements for all game modes.
+
+```typescript
+// Get Battle Royale news
+const brNews = await client.news.getBRNews();
+// Returns: MOTDs, platform messages, images, and videos
+
+// Get Save The World news
+const stwNews = await client.news.getSTWNews();
+
+// Get Creative news
+const creativeNews = await client.news.getCreativeNews();
+
+// Get all news at once
+const allNews = await client.news.getAllNews();
+// Returns: { br, stw, creative, lastModified }
+```
+
+---
+
+### Cosmetics - **NEW**
+
+Browse and search the complete Fortnite cosmetics catalog.
+
+#### Get All Cosmetics
+```typescript
+const cosmetics = await client.cosmetics.getAll({
+  page: 1,
+  pageSize: 50,
+  type: 'outfit',  // outfit, backpack, pickaxe, glider, emote, wrap, music, etc.
+  rarity: 'legendary',  // common, uncommon, rare, epic, legendary, mythic
+  set: 'Dark Series'
+});
+// Returns: Paginated list with item details
+```
+
+#### Get Cosmetic by ID
+```typescript
+const item = await client.cosmetics.getById('CID_123_Athena');
+// Returns: Detailed cosmetic information
+```
+
+#### Search Cosmetics
+```typescript
+const results = await client.cosmetics.search('galaxy', {
+  page: 1,
+  pageSize: 20,
+  type: 'outfit'
+});
+// Search by name or description
+```
+
+#### Get New Cosmetics
+```typescript
+const newItems = await client.cosmetics.getNew({
+  page: 1,
+  pageSize: 50
+});
+// Returns: Recently added cosmetics
+```
+
+---
+
+### Crew - **NEW**
+
+Fortnite Crew subscription pack information.
+
+```typescript
+// Get current month's Crew Pack
+const current = await client.crew.getCurrent();
+// Returns: Current crew pack with cosmetics and details
+
+// Get Crew Pack history
+const history = await client.crew.getHistory();
+// Returns: All previous crew packs
+```
+
+---
+
+### Map - **NEW**
+
+Current and historical Fortnite map data.
+
+```typescript
+// Get current map with POIs
+const map = await client.map.getCurrent();
+// Returns: Map data with points of interest
+
+// Get map image URL
+const mapImage = await client.map.getImage();
+// Returns: Current map image URL
+
+// Get historical map data
+const history = await client.map.getHistory();
+// Returns: Previous map versions
+```
+
+---
+
+### Playlists - **NEW**
+
+Fortnite playlists and game modes.
+
+```typescript
+// Get all playlists
+const allPlaylists = await client.playlists.getAll();
+// Returns: All game modes and playlists
+
+// Get active playlists only
+const active = await client.playlists.getActive();
+// Returns: Currently available playlists
+
+// Get specific playlist
+const playlist = await client.playlists.getById('Playlist_DefaultSolo');
+// Returns: Detailed playlist information
+```
+
+---
+
 ### FN (Fortnite Game) - **NEW**
 
 Fortnite-specific game data including inventory, features, and settings.
@@ -497,6 +618,32 @@ MIT
 
 ## 🆕 Changelog
 
+### v4.3.0 (2026-01-08)
+- ✨ **NEW** `NewsResource` with 4 methods:
+  - Battle Royale news
+  - Save The World news
+  - Creative news
+  - All news in one call
+- ✨ **NEW** `CosmeticsResource` with 4 methods:
+  - Browse all cosmetics with filters (type, rarity, set)
+  - Search cosmetics by name
+  - Get cosmetic by ID
+  - Get newly added cosmetics
+- ✨ **NEW** `CrewResource` with 2 methods:
+  - Current Crew Pack
+  - Crew Pack history
+- ✨ **NEW** `MapResource` with 3 methods:
+  - Current map with POIs
+  - Map image URL
+  - Historical map data
+- ✨ **NEW** `PlaylistsResource` with 3 methods:
+  - All playlists/game modes
+  - Active playlists only
+  - Specific playlist by ID
+- 📝 Comprehensive TypeScript types for all new endpoints
+- 🎯 Complete SDK coverage for all API endpoints
+- ✅ 100% backward compatible
+
 ### v4.2.0 (2026-01-06)
 - ✨ **NEW** `AccountResource` with 8 methods:
   - Account lookups by ID, display name, and external platforms

package/dist/client.d.ts

@@ -10,6 +10,14 @@ import { BattlePassResource } from "./resources/battlepass";
 import { QuestsResource } from "./resources/quests";
 import { AccountResource } from "./resources/account";
 import { FNResource } from "./resources/fn";
+import { FriendsResource } from "./resources/friends";
+import { StatsResource } from "./resources/stats";
+import { EventsResource } from "./resources/events";
+import { NewsResource } from "./resources/news";
+import { CosmeticsResource } from "./resources/cosmetics";
+import { CrewResource } from "./resources/crew";
+import { MapResource } from "./resources/map";
+import { PlaylistsResource } from "./resources/playlists";
 export interface ClientOptions {
     apiKey: string;
     baseUrl?: string;
@@ -29,6 +37,14 @@ export declare class FortniteAPI {
     quests: QuestsResource;
     account: AccountResource;
     fn: FNResource;
+    friends: FriendsResource;
+    stats: StatsResource;
+    events: EventsResource;
+    news: NewsResource;
+    cosmetics: CosmeticsResource;
+    crew: CrewResource;
+    map: MapResource;
+    playlists: PlaylistsResource;
     constructor(options: ClientOptions);
     /**
      * Internal method to make HTTP requests

package/dist/client.js

@@ -14,6 +14,14 @@ const battlepass_1 = require("./resources/battlepass");
 const quests_1 = require("./resources/quests");
 const account_1 = require("./resources/account");
 const fn_1 = require("./resources/fn");
+const friends_1 = require("./resources/friends");
+const stats_1 = require("./resources/stats");
+const events_1 = require("./resources/events");
+const news_1 = require("./resources/news");
+const cosmetics_1 = require("./resources/cosmetics");
+const crew_1 = require("./resources/crew");
+const map_1 = require("./resources/map");
+const playlists_1 = require("./resources/playlists");
 class FortniteAPI {
     constructor(options) {
         this.apiKey = options.apiKey;
@@ -32,6 +40,14 @@ class FortniteAPI {
         this.quests = new quests_1.QuestsResource(this);
         this.account = new account_1.AccountResource(this);
         this.fn = new fn_1.FNResource(this);
+        this.friends = new friends_1.FriendsResource(this);
+        this.stats = new stats_1.StatsResource(this);
+        this.events = new events_1.EventsResource(this);
+        this.news = new news_1.NewsResource(this);
+        this.cosmetics = new cosmetics_1.CosmeticsResource(this);
+        this.crew = new crew_1.CrewResource(this);
+        this.map = new map_1.MapResource(this);
+        this.playlists = new playlists_1.PlaylistsResource(this);
     }
     /**
      * Internal method to make HTTP requests

package/dist/resources/cosmetics.d.ts

@@ -0,0 +1,25 @@
+import { FortniteAPI } from "../client";
+import { CosmeticsResponse, CosmeticItem, CosmeticsPaginatedResponse, CosmeticsSearchParams } from "../types";
+export declare class CosmeticsResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get all cosmetics with pagination and filters
+     */
+    getAll(params?: CosmeticsSearchParams): Promise<CosmeticsPaginatedResponse>;
+    /**
+     * Get a specific cosmetic by ID
+     */
+    getById(id: string): Promise<CosmeticsResponse<CosmeticItem>>;
+    /**
+     * Search cosmetics by name or description
+     */
+    search(query: string, params?: Omit<CosmeticsSearchParams, 'search'>): Promise<CosmeticsPaginatedResponse>;
+    /**
+     * Get recently added cosmetics
+     */
+    getNew(params?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<CosmeticsPaginatedResponse>;
+}

package/dist/resources/cosmetics.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CosmeticsResource = void 0;
+class CosmeticsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get all cosmetics with pagination and filters
+     */
+    async getAll(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.page)
+            queryParams.set("page", params.page.toString());
+        if (params?.pageSize)
+            queryParams.set("pageSize", params.pageSize.toString());
+        if (params?.type)
+            queryParams.set("type", params.type);
+        if (params?.rarity)
+            queryParams.set("rarity", params.rarity);
+        if (params?.set)
+            queryParams.set("set", params.set);
+        if (params?.search)
+            queryParams.set("search", params.search);
+        const query = queryParams.toString();
+        const endpoint = query ? `/cosmetics/all?${query}` : "/cosmetics/all";
+        return this.client.request(endpoint);
+    }
+    /**
+     * Get a specific cosmetic by ID
+     */
+    async getById(id) {
+        return this.client.request(`/cosmetics/${id}`);
+    }
+    /**
+     * Search cosmetics by name or description
+     */
+    async search(query, params) {
+        const queryParams = new URLSearchParams();
+        queryParams.set("q", query);
+        if (params?.page)
+            queryParams.set("page", params.page.toString());
+        if (params?.pageSize)
+            queryParams.set("pageSize", params.pageSize.toString());
+        if (params?.type)
+            queryParams.set("type", params.type);
+        if (params?.rarity)
+            queryParams.set("rarity", params.rarity);
+        if (params?.set)
+            queryParams.set("set", params.set);
+        return this.client.request(`/cosmetics/search?${queryParams.toString()}`);
+    }
+    /**
+     * Get recently added cosmetics
+     */
+    async getNew(params) {
+        const queryParams = new URLSearchParams();
+        if (params?.page)
+            queryParams.set("page", params.page.toString());
+        if (params?.pageSize)
+            queryParams.set("pageSize", params.pageSize.toString());
+        const query = queryParams.toString();
+        const endpoint = query ? `/cosmetics/new?${query}` : "/cosmetics/new";
+        return this.client.request(endpoint);
+    }
+}
+exports.CosmeticsResource = CosmeticsResource;

package/dist/resources/crew.d.ts

@@ -0,0 +1,14 @@
+import { FortniteAPI } from "../client";
+import { CrewPackResponse, CrewHistoryResponse } from "../types";
+export declare class CrewResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get current month's Crew Pack
+     */
+    getCurrent(): Promise<CrewPackResponse>;
+    /**
+     * Get Crew Pack history
+     */
+    getHistory(): Promise<CrewHistoryResponse>;
+}

package/dist/resources/crew.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrewResource = void 0;
+class CrewResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get current month's Crew Pack
+     */
+    async getCurrent() {
+        return this.client.request("/crew/current");
+    }
+    /**
+     * Get Crew Pack history
+     */
+    async getHistory() {
+        return this.client.request("/crew/history");
+    }
+}
+exports.CrewResource = CrewResource;

package/dist/resources/events.d.ts

@@ -0,0 +1,83 @@
+import { FortniteAPI } from "../client";
+import { EventWindows, PlayerEventHistory, TournamentDetails, ScoringRules, EventLeaderboard, PlayerEventData, EligibilityStatus, ArenaHype, EventRewards } from "../types";
+/**
+ * Events Resource
+ * Handles tournament and competitive events data
+ */
+export declare class EventsResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get event windows
+     * @param eventId - Event ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Event windows data
+     */
+    getEventWindows(eventId: string, fortniteToken?: string): Promise<EventWindows>;
+    /**
+     * Get player event history
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of events player participated in
+     */
+    getPlayerHistory(accountId: string, fortniteToken?: string): Promise<PlayerEventHistory[]>;
+    /**
+     * Get tournament details
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Tournament details
+     */
+    getTournamentDetails(eventId: string, eventWindowId: string, fortniteToken?: string): Promise<TournamentDetails>;
+    /**
+     * Get event scoring rules
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Scoring rules
+     */
+    getScoringRules(eventId: string, eventWindowId: string, fortniteToken?: string): Promise<ScoringRules>;
+    /**
+     * Get event leaderboard
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Leaderboard data
+     */
+    getLeaderboard(eventId: string, eventWindowId: string, options?: {
+        page?: number;
+    }, fortniteToken?: string): Promise<EventLeaderboard>;
+    /**
+     * Get player event data
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Player's event performance data
+     */
+    getPlayerEventData(eventId: string, eventWindowId: string, accountId: string, fortniteToken?: string): Promise<PlayerEventData>;
+    /**
+     * Check tournament eligibility
+     * @param accountId - Account ID
+     * @param eventId - Event ID
+     * @param fortniteToken - User Fortnite token (REQUIRED)
+     * @returns Eligibility status
+     */
+    checkEligibility(accountId: string, eventId: string, fortniteToken: string): Promise<EligibilityStatus>;
+    /**
+     * Get Arena hype and division
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Arena hype, division, and progress
+     */
+    getArenaHype(accountId: string, fortniteToken?: string): Promise<ArenaHype>;
+    /**
+     * Get event rewards/prizes
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Event rewards structure
+     */
+    getEventRewards(eventId: string, eventWindowId: string, fortniteToken?: string): Promise<EventRewards>;
+}

package/dist/resources/events.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsResource = void 0;
+/**
+ * Events Resource
+ * Handles tournament and competitive events data
+ */
+class EventsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get event windows
+     * @param eventId - Event ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Event windows data
+     */
+    async getEventWindows(eventId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/${eventId}/windows`, { headers }, "v2");
+    }
+    /**
+     * Get player event history
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of events player participated in
+     */
+    async getPlayerHistory(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/history/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get tournament details
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Tournament details
+     */
+    async getTournamentDetails(eventId, eventWindowId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/${eventId}/windows/${eventWindowId}`, { headers }, "v2");
+    }
+    /**
+     * Get event scoring rules
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Scoring rules
+     */
+    async getScoringRules(eventId, eventWindowId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/${eventId}/windows/${eventWindowId}/scoring`, { headers }, "v2");
+    }
+    /**
+     * Get event leaderboard
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Leaderboard data
+     */
+    async getLeaderboard(eventId, eventWindowId, options, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        const query = options?.page ? `?page=${options.page}` : "";
+        return this.client.request(`/events/${eventId}/windows/${eventWindowId}/leaderboard${query}`, { headers }, "v2");
+    }
+    /**
+     * Get player event data
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Player's event performance data
+     */
+    async getPlayerEventData(eventId, eventWindowId, accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/${eventId}/windows/${eventWindowId}/players/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Check tournament eligibility
+     * @param accountId - Account ID
+     * @param eventId - Event ID
+     * @param fortniteToken - User Fortnite token (REQUIRED)
+     * @returns Eligibility status
+     */
+    async checkEligibility(accountId, eventId, fortniteToken) {
+        const headers = {
+            "x-fortnite-token": fortniteToken,
+        };
+        return this.client.request(`/events/${eventId}/eligibility/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get Arena hype and division
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Arena hype, division, and progress
+     */
+    async getArenaHype(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/arena/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get event rewards/prizes
+     * @param eventId - Event ID
+     * @param eventWindowId - Event window ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Event rewards structure
+     */
+    async getEventRewards(eventId, eventWindowId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/events/${eventId}/windows/${eventWindowId}/rewards`, { headers }, "v2");
+    }
+}
+exports.EventsResource = EventsResource;

package/dist/resources/friends.d.ts

@@ -0,0 +1,68 @@
+import { FortniteAPI } from "../client";
+import { FriendsSummary, Friend, FriendRequest, BlockedUser, FriendshipInfo, SuggestedFriend } from "../types";
+/**
+ * Friends Resource
+ * Handles all friend-related operations
+ */
+export declare class FriendsResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get complete friends summary (most efficient - everything in one call)
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Complete summary with friends, requests, blocklist, settings
+     */
+    getSummary(accountId: string, fortniteToken?: string): Promise<FriendsSummary>;
+    /**
+     * Get friends list
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of friends with aliases and metadata
+     */
+    getFriendsList(accountId: string, fortniteToken?: string): Promise<Friend[]>;
+    /**
+     * Get incoming friend requests
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of incoming requests
+     */
+    getIncomingRequests(accountId: string, fortniteToken?: string): Promise<FriendRequest[]>;
+    /**
+     * Get outgoing friend requests
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of outgoing requests
+     */
+    getOutgoingRequests(accountId: string, fortniteToken?: string): Promise<FriendRequest[]>;
+    /**
+     * Get mutual friends between two users
+     * @param accountId - Your account ID
+     * @param friendId - Friend's account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of mutual friend account IDs
+     */
+    getMutualFriends(accountId: string, friendId: string, fortniteToken?: string): Promise<string[]>;
+    /**
+     * Get block list
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of blocked users
+     */
+    getBlocklist(accountId: string, fortniteToken?: string): Promise<BlockedUser[]>;
+    /**
+     * Get friendship info for specific friend
+     * @param accountId - Your account ID
+     * @param friendId - Friend's account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Friendship details including mutual count
+     */
+    getFriendshipInfo(accountId: string, friendId: string, fortniteToken?: string): Promise<FriendshipInfo>;
+    /**
+     * Get suggested friends
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of suggested friends
+     */
+    getSuggestedFriends(accountId: string, fortniteToken?: string): Promise<SuggestedFriend[]>;
+}

package/dist/resources/friends.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FriendsResource = void 0;
+/**
+ * Friends Resource
+ * Handles all friend-related operations
+ */
+class FriendsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get complete friends summary (most efficient - everything in one call)
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Complete summary with friends, requests, blocklist, settings
+     */
+    async getSummary(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/summary`, { headers }, "v1");
+    }
+    /**
+     * Get friends list
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of friends with aliases and metadata
+     */
+    async getFriendsList(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/friends`, { headers }, "v1");
+    }
+    /**
+     * Get incoming friend requests
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of incoming requests
+     */
+    async getIncomingRequests(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/incoming`, { headers }, "v1");
+    }
+    /**
+     * Get outgoing friend requests
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of outgoing requests
+     */
+    async getOutgoingRequests(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/outgoing`, { headers }, "v1");
+    }
+    /**
+     * Get mutual friends between two users
+     * @param accountId - Your account ID
+     * @param friendId - Friend's account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of mutual friend account IDs
+     */
+    async getMutualFriends(accountId, friendId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/friends/${friendId}/mutual`, { headers }, "v1");
+    }
+    /**
+     * Get block list
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of blocked users
+     */
+    async getBlocklist(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/blocklist`, { headers }, "v1");
+    }
+    /**
+     * Get friendship info for specific friend
+     * @param accountId - Your account ID
+     * @param friendId - Friend's account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Friendship details including mutual count
+     */
+    async getFriendshipInfo(accountId, friendId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/friends/${friendId}`, { headers }, "v1");
+    }
+    /**
+     * Get suggested friends
+     * @param accountId - Account ID
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of suggested friends
+     */
+    async getSuggestedFriends(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/friends/${accountId}/suggested`, { headers }, "v1");
+    }
+}
+exports.FriendsResource = FriendsResource;

package/dist/resources/map.d.ts

@@ -0,0 +1,18 @@
+import { FortniteAPI } from "../client";
+import { MapResponse, MapImageResponse, MapHistoryResponse } from "../types";
+export declare class MapResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get current Fortnite map with POIs
+     */
+    getCurrent(): Promise<MapResponse>;
+    /**
+     * Get current map image URL
+     */
+    getImage(): Promise<MapImageResponse>;
+    /**
+     * Get historical map data
+     */
+    getHistory(): Promise<MapHistoryResponse>;
+}

package/dist/resources/map.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapResource = void 0;
+class MapResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get current Fortnite map with POIs
+     */
+    async getCurrent() {
+        return this.client.request("/map");
+    }
+    /**
+     * Get current map image URL
+     */
+    async getImage() {
+        return this.client.request("/map/image");
+    }
+    /**
+     * Get historical map data
+     */
+    async getHistory() {
+        return this.client.request("/map/history");
+    }
+}
+exports.MapResource = MapResource;

package/dist/resources/news.d.ts

@@ -0,0 +1,22 @@
+import { FortniteAPI } from "../client";
+import { NewsResponse, BRNews, STWNews, CreativeNews, AllNews } from "../types";
+export declare class NewsResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get Battle Royale news
+     */
+    getBRNews(): Promise<NewsResponse<BRNews>>;
+    /**
+     * Get Save The World news
+     */
+    getSTWNews(): Promise<NewsResponse<STWNews>>;
+    /**
+     * Get Creative news
+     */
+    getCreativeNews(): Promise<NewsResponse<CreativeNews>>;
+    /**
+     * Get all news (BR, STW, Creative)
+     */
+    getAllNews(): Promise<NewsResponse<AllNews>>;
+}

package/dist/resources/news.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewsResource = void 0;
+class NewsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get Battle Royale news
+     */
+    async getBRNews() {
+        return this.client.request("/news/br");
+    }
+    /**
+     * Get Save The World news
+     */
+    async getSTWNews() {
+        return this.client.request("/news/stw");
+    }
+    /**
+     * Get Creative news
+     */
+    async getCreativeNews() {
+        return this.client.request("/news/creative");
+    }
+    /**
+     * Get all news (BR, STW, Creative)
+     */
+    async getAllNews() {
+        return this.client.request("/news");
+    }
+}
+exports.NewsResource = NewsResource;

package/dist/resources/playlists.d.ts

@@ -0,0 +1,18 @@
+import { FortniteAPI } from "../client";
+import { PlaylistsResponse, ActivePlaylistsResponse, PlaylistResponse } from "../types";
+export declare class PlaylistsResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get all Fortnite playlists/gamemodes
+     */
+    getAll(): Promise<PlaylistsResponse>;
+    /**
+     * Get currently active playlists/gamemodes
+     */
+    getActive(): Promise<ActivePlaylistsResponse>;
+    /**
+     * Get a specific playlist by ID
+     */
+    getById(playlistId: string): Promise<PlaylistResponse>;
+}

package/dist/resources/playlists.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlaylistsResource = void 0;
+class PlaylistsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get all Fortnite playlists/gamemodes
+     */
+    async getAll() {
+        return this.client.request("/playlists", {}, "v2");
+    }
+    /**
+     * Get currently active playlists/gamemodes
+     */
+    async getActive() {
+        return this.client.request("/playlists/active", {}, "v2");
+    }
+    /**
+     * Get a specific playlist by ID
+     */
+    async getById(playlistId) {
+        return this.client.request(`/playlists/${playlistId}`, {}, "v2");
+    }
+}
+exports.PlaylistsResource = PlaylistsResource;

package/dist/resources/stats.d.ts

@@ -0,0 +1,40 @@
+import { FortniteAPI } from "../client";
+import { PlayerStats, BulkStatsResponse, LeaderboardResponse, LeaderboardOptions } from "../types";
+/**
+ * Stats Resource
+ * Handles player statistics queries
+ */
+export declare class StatsResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get player stats with optional filters
+     * @param accountId - Account ID
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Player statistics
+     */
+    getPlayerStats(accountId: string, options?: {
+        startDate?: string;
+        endDate?: string;
+        stats?: string[];
+    }, fortniteToken?: string): Promise<PlayerStats>;
+    /**
+     * Get bulk stats for multiple players
+     * @param accountIds - Array of account IDs (max 100)
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of player statistics
+     */
+    getBulkStats(accountIds: string[], options?: {
+        stats?: string[];
+    }, fortniteToken?: string): Promise<BulkStatsResponse[]>;
+    /**
+     * Get leaderboard for specific stat
+     * @param stat - Stat name to query
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Leaderboard data
+     */
+    getLeaderboard(stat: string, options?: LeaderboardOptions, fortniteToken?: string): Promise<LeaderboardResponse>;
+}

package/dist/resources/stats.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatsResource = void 0;
+/**
+ * Stats Resource
+ * Handles player statistics queries
+ */
+class StatsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get player stats with optional filters
+     * @param accountId - Account ID
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Player statistics
+     */
+    async getPlayerStats(accountId, options, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        const queryParams = new URLSearchParams();
+        if (options?.startDate)
+            queryParams.append("startDate", options.startDate);
+        if (options?.endDate)
+            queryParams.append("endDate", options.endDate);
+        if (options?.stats)
+            queryParams.append("stats", options.stats.join(","));
+        const query = queryParams.toString();
+        const url = `/stats/${accountId}${query ? `?${query}` : ""}`;
+        return this.client.request(url, { headers }, "v2");
+    }
+    /**
+     * Get bulk stats for multiple players
+     * @param accountIds - Array of account IDs (max 100)
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Array of player statistics
+     */
+    async getBulkStats(accountIds, options, fortniteToken) {
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        const body = {
+            accountIds,
+        };
+        if (options?.stats) {
+            body.stats = options.stats;
+        }
+        return this.client.request("/stats/bulk", {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+        }, "v2");
+    }
+    /**
+     * Get leaderboard for specific stat
+     * @param stat - Stat name to query
+     * @param options - Query options
+     * @param fortniteToken - Optional user Fortnite token
+     * @returns Leaderboard data
+     */
+    async getLeaderboard(stat, options, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        const queryParams = new URLSearchParams();
+        if (options?.limit)
+            queryParams.append("limit", options.limit.toString());
+        if (options?.offset)
+            queryParams.append("offset", options.offset.toString());
+        if (options?.window)
+            queryParams.append("window", options.window);
+        const query = queryParams.toString();
+        const url = `/stats/leaderboard/${stat}${query ? `?${query}` : ""}`;
+        return this.client.request(url, { headers }, "v2");
+    }
+}
+exports.StatsResource = StatsResource;

package/dist/types/index.d.ts

@@ -355,3 +355,292 @@ export interface EntitlementCheck {
     entitlement?: boolean;
     [key: string]: any;
 }
+export interface FriendsSummary {
+    friends?: Friend[];
+    incoming?: FriendRequest[];
+    outgoing?: FriendRequest[];
+    blocklist?: BlockedUser[];
+    settings?: {
+        [key: string]: any;
+    };
+}
+export interface Friend {
+    accountId: string;
+    displayName?: string;
+    status: "ACCEPTED" | "PENDING";
+    direction: "INBOUND" | "OUTBOUND";
+    created: string;
+    favorite?: boolean;
+    mutual?: number;
+}
+export interface FriendRequest {
+    accountId: string;
+    displayName?: string;
+    status: string;
+    direction: string;
+    created: string;
+}
+export interface BlockedUser {
+    accountId: string;
+    displayName?: string;
+}
+export interface FriendshipInfo extends Friend {
+    mutual: number;
+}
+export interface SuggestedFriend {
+    accountId: string;
+    displayName?: string;
+    mutualFriends?: number;
+}
+export interface PlayerStats {
+    accountId: string;
+    stats: {
+        [key: string]: any;
+    };
+}
+export interface BulkStatsRequest {
+    accountIds: string[];
+    stats?: string[];
+}
+export interface BulkStatsResponse {
+    accountId: string;
+    stats: {
+        [key: string]: any;
+    };
+}
+export interface LeaderboardOptions {
+    limit?: number;
+    offset?: number;
+    window?: "alltime" | "season" | "weekly" | "daily";
+}
+export interface LeaderboardResponse {
+    stat: string;
+    window: string;
+    entries: Array<{
+        rank: number;
+        accountId: string;
+        displayName?: string;
+        value: number;
+    }>;
+    pagination?: {
+        limit: number;
+        offset: number;
+        total?: number;
+    };
+}
+export interface EventWindows {
+    eventId: string;
+    displayName?: string;
+    windows: Array<{
+        eventWindowId: string;
+        beginTime: string;
+        endTime: string;
+        round?: number;
+    }>;
+}
+export interface PlayerEventHistory {
+    eventId: string;
+    eventWindowId: string;
+    eventName?: string;
+    beginTime: string;
+    endTime: string;
+    region?: string;
+}
+export interface TournamentDetails {
+    eventId: string;
+    eventWindowId: string;
+    beginTime: string;
+    endTime: string;
+    round?: number;
+    payoutDelay?: number;
+    [key: string]: any;
+}
+export interface ScoringRules {
+    scoring: Array<{
+        eventName: string;
+        points: number;
+    }>;
+}
+export interface EventLeaderboard {
+    entries: Array<{
+        rank: number;
+        accountId: string;
+        teamId?: string;
+        pointsEarned: number;
+        score: number;
+        [key: string]: any;
+    }>;
+}
+export interface PlayerEventData {
+    accountId: string;
+    teamId?: string;
+    pointsEarned: number;
+    rank?: number;
+    percentile?: number;
+    sessions?: Array<any>;
+}
+export interface EligibilityStatus {
+    eligible: boolean;
+    reasons?: string[];
+}
+export interface ArenaHype {
+    accountId: string;
+    currentHype?: number;
+    division?: string;
+    divisionNumber?: number;
+    progress?: number;
+}
+export interface EventRewards {
+    prizes: Array<{
+        placement: string;
+        amount: number;
+        currency?: string;
+    }>;
+}
+export interface NewsResponse<T> {
+    status: number;
+    data: T;
+}
+export interface MOTD {
+    id: string;
+    title: string;
+    body: string;
+    image: string;
+    tileImage?: string;
+    videoURL?: string;
+    [key: string]: any;
+}
+export interface BRNews {
+    motds: MOTD[];
+    platform_motds?: MOTD[];
+    [key: string]: any;
+}
+export interface STWNews {
+    motds: MOTD[];
+    [key: string]: any;
+}
+export interface CreativeNews {
+    motds: MOTD[];
+    [key: string]: any;
+}
+export interface AllNews {
+    br: BRNews;
+    stw: STWNews;
+    creative: CreativeNews;
+    lastModified: string;
+}
+export interface CosmeticsResponse<T> {
+    status: number;
+    data: T;
+}
+export interface CosmeticsPaginatedResponse {
+    status: number;
+    data: CosmeticItem[];
+    pagination: {
+        page: number;
+        pageSize: number;
+        total: number;
+        totalPages: number;
+    };
+}
+export interface CosmeticItem {
+    id: string;
+    name: string;
+    description?: string;
+    type: string;
+    rarity: string;
+    series?: string;
+    set?: string;
+    images?: {
+        icon?: string;
+        featured?: string;
+        [key: string]: any;
+    };
+    introduction?: {
+        season?: number;
+        chapter?: number;
+    };
+    [key: string]: any;
+}
+export interface CosmeticsSearchParams {
+    page?: number;
+    pageSize?: number;
+    type?: string;
+    rarity?: string;
+    set?: string;
+    search?: string;
+}
+export interface CrewPackResponse {
+    status: number;
+    data: {
+        crew: {
+            name: string;
+            catalogEntries: any[];
+            refreshIntervalHrs: number;
+            dailyPurchaseHrs: number;
+        } | null;
+        count: number;
+        message: string;
+        lastModified: string;
+    };
+}
+export interface CrewHistoryResponse {
+    status: number;
+    data: {
+        history: any[];
+        count: number;
+        message: string;
+        lastModified: string;
+    };
+}
+export interface MapResponse {
+    status: number;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface MapImageResponse {
+    status: number;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface MapHistoryResponse {
+    status: number;
+    data: {
+        [key: string]: any;
+    };
+}
+export interface PlaylistsResponse {
+    status: number;
+    data: {
+        playlists: {
+            [playlistId: string]: Playlist;
+        };
+        conversion_config: any;
+        lastModified: string;
+    };
+}
+export interface ActivePlaylistsResponse {
+    status: number;
+    data: {
+        playlists: {
+            [playlistId: string]: Playlist;
+        };
+        count: number;
+        lastModified: string;
+    };
+}
+export interface PlaylistResponse {
+    status: number;
+    data: Playlist;
+}
+export interface Playlist {
+    id: string;
+    image: string;
+    playlist_name: string;
+    hidden: boolean;
+    _type: string;
+    lastModified?: string;
+    [key: string]: any;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaelouuu/fortnite-api",
-  "version": "4.2.0",
+  "version": "4.4.0",
   "description": "SDK for Fortnite Tournaments API by Royal Arena - Author : Yael Brinkert",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",