@yaelouuu/fortnite-api 7.1.0 → 7.2.0

package/dist/resources/oauth.d.ts

@@ -1,5 +1,5 @@
 import { FortniteAPI } from "../client";
-import { OAuthCompleteResponse, OAuthDeviceRefreshResponse, OAuthExchangeCodeResponse, OAuthFlowResponse, OAuthRefreshResponse } from "../types";
+import { OAuthCompleteResponse, OAuthDeviceRefreshResponse, OAuthExchangeCodeResponse, OAuthFlowResponse, OAuthRefreshResponse, OAuthAuthorizeUrlResponse } from "../types";
 export declare class OauthResource {
     private client;
     constructor(client: FortniteAPI);
@@ -37,4 +37,29 @@ export declare class OauthResource {
         deviceId: string;
         secret: string;
     }): Promise<OAuthDeviceRefreshResponse>;
+    /**
+     * Get Epic Games authorization URL - GET /oauth/authorize-url
+     * Returns the URL to redirect the user to for standard Epic login (no device confirmation page).
+     * After login, Epic redirects to your redirect_uri with ?code=...
+     * Then call linkAccount() with that code to get the Fortnite access token and device auth.
+     * @param redirectUri - Optional redirect URI registered with Epic
+     */
+    getAuthorizeUrl(redirectUri?: string): Promise<OAuthAuthorizeUrlResponse>;
+    /**
+     * Link Epic account - POST /oauth/link
+     * Exchanges an Epic authorization code (from GET /oauth/authorize-url flow) for a
+     * Fortnite access token and device auth credentials.
+     * Store the returned deviceAuth (accountId + deviceId + secret) and use refreshDevice()
+     * to silently re-authenticate in the future — no browser required.
+     * @param params.code - Authorization code returned by Epic in the redirect URI
+     * @param params.redirectUri - Must match the redirect URI used in getAuthorizeUrl()
+     * @param params.clientId - Optional custom Epic OAuth client ID
+     * @param params.clientSecret - Optional custom Epic OAuth client secret
+     */
+    linkAccount(params: {
+        code: string;
+        redirectUri?: string;
+        clientId?: string;
+        clientSecret?: string;
+    }): Promise<OAuthCompleteResponse>;
 }

package/dist/resources/oauth.js

@@ -52,5 +52,33 @@ class OauthResource {
             body: JSON.stringify(params),
         });
     }
+    /**
+     * Get Epic Games authorization URL - GET /oauth/authorize-url
+     * Returns the URL to redirect the user to for standard Epic login (no device confirmation page).
+     * After login, Epic redirects to your redirect_uri with ?code=...
+     * Then call linkAccount() with that code to get the Fortnite access token and device auth.
+     * @param redirectUri - Optional redirect URI registered with Epic
+     */
+    async getAuthorizeUrl(redirectUri) {
+        const query = redirectUri ? `?redirectUri=${encodeURIComponent(redirectUri)}` : "";
+        return this.client.request(`/oauth/authorize-url${query}`, {}, "v1");
+    }
+    /**
+     * Link Epic account - POST /oauth/link
+     * Exchanges an Epic authorization code (from GET /oauth/authorize-url flow) for a
+     * Fortnite access token and device auth credentials.
+     * Store the returned deviceAuth (accountId + deviceId + secret) and use refreshDevice()
+     * to silently re-authenticate in the future — no browser required.
+     * @param params.code - Authorization code returned by Epic in the redirect URI
+     * @param params.redirectUri - Must match the redirect URI used in getAuthorizeUrl()
+     * @param params.clientId - Optional custom Epic OAuth client ID
+     * @param params.clientSecret - Optional custom Epic OAuth client secret
+     */
+    async linkAccount(params) {
+        return this.client.request("/oauth/link", {
+            method: "POST",
+            body: JSON.stringify(params),
+        }, "v1");
+    }
 }
 exports.OauthResource = OauthResource;

package/dist/resources/parsing.d.ts

@@ -3,16 +3,101 @@ import { ParsedReplayData } from "../types";
 export declare class ParsingResource {
     private client;
     constructor(client: FortniteAPI);
+    private buildFormData;
+    private buildMultiFormData;
     /**
-     * Parse a single Fortnite replay file
-     * @param file - File object (Browser) or Blob/Buffer (Node.js)
-     * @param filename - Optional filename (required in Node.js)
+     * Parse a single Fortnite replay file — full parse.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object (Browser) or Blob (Node.js)
+     * @param filename - Filename (required in Node.js when passing a Blob)
      */
     parseReplay(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
     /**
-     * Parse multiple Fortnite replay files in batch
+     * Parse a single replay — stats only (faster, skips movement/zones/kill feed).
+     * Returns: name, replayId, version, stats (elims, damage, accuracy, placement, assists, etc.).
+     * Subject to per-plan parsing quota limits (1 credit).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayStats(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse a single replay — map context.
+     * Returns: bus flight path + drop window, all storm circles with timing, supply drops, llamas, reboot vans.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayMap(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse a single replay — ground loot data.
+     * Returns all items that were on the ground near the player: position, item ID, picked-up status and time.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayLoot(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse a single replay — match timeline.
+     * Returns all events relative to bus drop: kills, knocks, own death, damage dealt/taken, healed, pickups.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayTimeline(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse a single replay — storm zone data.
+     * Returns all safe zone phases with circle positions, timing, damage per tick, and phase count.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayZones(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse a single replay — full player lobby.
+     * Returns all players with placement, kills, death info, cosmetics, and team data.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayLobby(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse a single replay — full broadcast payload.
+     * Combines all data: header, stats, full lobby, storm zones, map objects, ground loot, and timeline.
+     * Equivalent to calling all parse endpoints in one request.
+     * Subject to per-plan parsing quota limits (20 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    parseReplayBroadcast(file: File | Blob, filename?: string): Promise<ParsedReplayData>;
+    /**
+     * Parse multiple replay files in batch — full parse.
+     * All files are processed in parallel.
+     * Subject to per-plan parsing quota limits (10 credits).
      * @param files - Array of File objects or Blobs
-     * @param filenames - Optional array of filenames (required in Node.js)
+     * @param filenames - Filenames (required in Node.js when passing Blobs)
      */
     parseMultipleReplays(files: (File | Blob)[], filenames?: string[]): Promise<ParsedReplayData[]>;
+    /**
+     * Parse multiple replay files — stats only.
+     * Faster than full parse — skips movement, zones, and kill feed.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Filenames (required in Node.js)
+     */
+    parseMultipleReplaysStats(files: (File | Blob)[], filenames?: string[]): Promise<ParsedReplayData[]>;
+    /**
+     * Parse multiple replay files — map context for each.
+     * Returns bus path, storm circles, supply drops, llamas, reboot vans per file.
+     * Subject to per-plan parsing quota limits (10 credits).
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Filenames (required in Node.js)
+     */
+    parseMultipleReplaysMap(files: (File | Blob)[], filenames?: string[]): Promise<ParsedReplayData[]>;
+    /**
+     * Parse multiple replay files — ground loot data for each.
+     * Subject to per-plan parsing quota limits (10 credits).
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Filenames (required in Node.js)
+     */
+    parseMultipleReplaysLoot(files: (File | Blob)[], filenames?: string[]): Promise<ParsedReplayData[]>;
 }

package/dist/resources/parsing.js

@@ -5,48 +5,194 @@ class ParsingResource {
     constructor(client) {
         this.client = client;
     }
-    /**
-     * Parse a single Fortnite replay file
-     * @param file - File object (Browser) or Blob/Buffer (Node.js)
-     * @param filename - Optional filename (required in Node.js)
-     */
-    async parseReplay(file, filename) {
+    buildFormData(file, filename) {
         const formData = new FormData();
-        // In browser: File object has name
-        // In Node.js: Need to pass filename
         if (file instanceof File) {
-            formData.append("File", file);
+            formData.append("file", file);
         }
         else {
-            formData.append("File", file, filename || "replay.replay");
+            formData.append("file", file, filename || "replay.replay");
         }
-        const response = await this.client.requestMultipart("/parsing", formData);
+        return formData;
+    }
+    buildMultiFormData(files, filenames) {
+        const formData = new FormData();
+        files.forEach((file, index) => {
+            if (file instanceof File) {
+                formData.append("files", file);
+            }
+            else {
+                formData.append("files", file, filenames?.[index] || `replay-${index}.replay`);
+            }
+        });
+        return formData;
+    }
+    /**
+     * Parse a single Fortnite replay file — full parse.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object (Browser) or Blob (Node.js)
+     * @param filename - Filename (required in Node.js when passing a Blob)
+     */
+    async parseReplay(file, filename) {
+        const response = await this.client.requestMultipart("/parsing", this.buildFormData(file, filename));
         if (!response.success || !response.data) {
             throw new Error(response.error || "Failed to parse replay");
         }
         return response.data;
     }
     /**
-     * Parse multiple Fortnite replay files in batch
+     * Parse a single replay — stats only (faster, skips movement/zones/kill feed).
+     * Returns: name, replayId, version, stats (elims, damage, accuracy, placement, assists, etc.).
+     * Subject to per-plan parsing quota limits (1 credit).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayStats(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/stats", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay stats");
+        }
+        return response.data;
+    }
+    /**
+     * Parse a single replay — map context.
+     * Returns: bus flight path + drop window, all storm circles with timing, supply drops, llamas, reboot vans.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayMap(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/map", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay map");
+        }
+        return response.data;
+    }
+    /**
+     * Parse a single replay — ground loot data.
+     * Returns all items that were on the ground near the player: position, item ID, picked-up status and time.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayLoot(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/loot", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay loot");
+        }
+        return response.data;
+    }
+    /**
+     * Parse a single replay — match timeline.
+     * Returns all events relative to bus drop: kills, knocks, own death, damage dealt/taken, healed, pickups.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayTimeline(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/timeline", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay timeline");
+        }
+        return response.data;
+    }
+    /**
+     * Parse a single replay — storm zone data.
+     * Returns all safe zone phases with circle positions, timing, damage per tick, and phase count.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayZones(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/zones", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay zones");
+        }
+        return response.data;
+    }
+    /**
+     * Parse a single replay — full player lobby.
+     * Returns all players with placement, kills, death info, cosmetics, and team data.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayLobby(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/lobby", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay lobby");
+        }
+        return response.data;
+    }
+    /**
+     * Parse a single replay — full broadcast payload.
+     * Combines all data: header, stats, full lobby, storm zones, map objects, ground loot, and timeline.
+     * Equivalent to calling all parse endpoints in one request.
+     * Subject to per-plan parsing quota limits (20 credits).
+     * @param file - File object or Blob
+     * @param filename - Filename (required in Node.js)
+     */
+    async parseReplayBroadcast(file, filename) {
+        const response = await this.client.requestMultipart("/parsing/broadcast", this.buildFormData(file, filename));
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to parse replay broadcast");
+        }
+        return response.data;
+    }
+    /**
+     * Parse multiple replay files in batch — full parse.
+     * All files are processed in parallel.
+     * Subject to per-plan parsing quota limits (10 credits).
      * @param files - Array of File objects or Blobs
-     * @param filenames - Optional array of filenames (required in Node.js)
+     * @param filenames - Filenames (required in Node.js when passing Blobs)
      */
     async parseMultipleReplays(files, filenames) {
-        const formData = new FormData();
-        files.forEach((file, index) => {
-            if (file instanceof File) {
-                formData.append("Files", file);
-            }
-            else {
-                const name = filenames?.[index] || `replay-${index}.replay`;
-                formData.append("Files", file, name);
-            }
-        });
-        const response = await this.client.requestMultipart("/parsing/multiple", formData);
+        const response = await this.client.requestMultipart("/parsing/multiple", this.buildMultiFormData(files, filenames));
         if (!response.success || !response.results) {
             throw new Error(response.error || "Failed to parse replays");
         }
         return response.results;
     }
+    /**
+     * Parse multiple replay files — stats only.
+     * Faster than full parse — skips movement, zones, and kill feed.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Filenames (required in Node.js)
+     */
+    async parseMultipleReplaysStats(files, filenames) {
+        const response = await this.client.requestMultipart("/parsing/multiple/stats", this.buildMultiFormData(files, filenames));
+        if (!response.success || !response.results) {
+            throw new Error(response.error || "Failed to parse replays stats");
+        }
+        return response.results;
+    }
+    /**
+     * Parse multiple replay files — map context for each.
+     * Returns bus path, storm circles, supply drops, llamas, reboot vans per file.
+     * Subject to per-plan parsing quota limits (10 credits).
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Filenames (required in Node.js)
+     */
+    async parseMultipleReplaysMap(files, filenames) {
+        const response = await this.client.requestMultipart("/parsing/multiple/map", this.buildMultiFormData(files, filenames));
+        if (!response.success || !response.results) {
+            throw new Error(response.error || "Failed to parse replays map");
+        }
+        return response.results;
+    }
+    /**
+     * Parse multiple replay files — ground loot data for each.
+     * Subject to per-plan parsing quota limits (10 credits).
+     * @param files - Array of File objects or Blobs
+     * @param filenames - Filenames (required in Node.js)
+     */
+    async parseMultipleReplaysLoot(files, filenames) {
+        const response = await this.client.requestMultipart("/parsing/multiple/loot", this.buildMultiFormData(files, filenames));
+        if (!response.success || !response.results) {
+            throw new Error(response.error || "Failed to parse replays loot");
+        }
+        return response.results;
+    }
 }
 exports.ParsingResource = ParsingResource;

package/dist/resources/playlists.d.ts

@@ -5,14 +5,18 @@ export declare class PlaylistsResource {
     constructor(client: FortniteAPI);
     /**
      * Get all Fortnite playlists/gamemodes
+     * @param lang - Language code (default: en)
      */
-    getAll(): Promise<PlaylistsResponse>;
+    getAll(lang?: string): Promise<PlaylistsResponse>;
     /**
      * Get currently active playlists/gamemodes
+     * @param lang - Language code (default: en)
      */
-    getActive(): Promise<ActivePlaylistsResponse>;
+    getActive(lang?: string): Promise<ActivePlaylistsResponse>;
     /**
      * Get a specific playlist by ID
+     * @param playlistId - Playlist identifier
+     * @param lang - Language code (default: en)
      */
-    getById(playlistId: string): Promise<PlaylistResponse>;
+    getById(playlistId: string, lang?: string): Promise<PlaylistResponse>;
 }

package/dist/resources/playlists.js

@@ -7,21 +7,28 @@ class PlaylistsResource {
     }
     /**
      * Get all Fortnite playlists/gamemodes
+     * @param lang - Language code (default: en)
      */
-    async getAll() {
-        return this.client.request("/playlists", {}, "v2");
+    async getAll(lang) {
+        const query = lang ? `?lang=${encodeURIComponent(lang)}` : "";
+        return this.client.request(`/playlists${query}`, {}, "v2");
     }
     /**
      * Get currently active playlists/gamemodes
+     * @param lang - Language code (default: en)
      */
-    async getActive() {
-        return this.client.request("/playlists/active", {}, "v2");
+    async getActive(lang) {
+        const query = lang ? `?lang=${encodeURIComponent(lang)}` : "";
+        return this.client.request(`/playlists/active${query}`, {}, "v2");
     }
     /**
      * Get a specific playlist by ID
+     * @param playlistId - Playlist identifier
+     * @param lang - Language code (default: en)
      */
-    async getById(playlistId) {
-        return this.client.request(`/playlists/${playlistId}`, {}, "v2");
+    async getById(playlistId, lang) {
+        const query = lang ? `?lang=${encodeURIComponent(lang)}` : "";
+        return this.client.request(`/playlists/${playlistId}${query}`, {}, "v2");
     }
 }
 exports.PlaylistsResource = PlaylistsResource;

package/dist/resources/profiles.d.ts

@@ -18,9 +18,14 @@ export declare class ProfilesResource {
     getLevel(accountId: string, fortniteToken: string): Promise<ProfileLevel>;
     /**
      * Get enriched ranked progress — human-readable rank names, game mode labels, season dates.
-     * @param displayName - Epic Games display name
+     * Accepts either a display name or an account ID. Account ID is preferred: it is faster
+     * (skips the name→ID lookup) and is not affected by display name changes.
+     * @param displayName - Epic Games display name (ignored if accountId is provided)
+     * @param options - Optional: pass `accountId` to bypass the name lookup
      */
-    getRanked(displayName: string): Promise<RankedProgress[]>;
+    getRanked(displayName: string, options?: {
+        accountId?: string;
+    }): Promise<RankedProgress[]>;
     /**
      * Get all available ranked game mode tracks — modes, division counts, and season dates.
      * @param options - Optional filters

package/dist/resources/profiles.js

@@ -24,10 +24,20 @@ class ProfilesResource {
     }
     /**
      * Get enriched ranked progress — human-readable rank names, game mode labels, season dates.
-     * @param displayName - Epic Games display name
+     * Accepts either a display name or an account ID. Account ID is preferred: it is faster
+     * (skips the name→ID lookup) and is not affected by display name changes.
+     * @param displayName - Epic Games display name (ignored if accountId is provided)
+     * @param options - Optional: pass `accountId` to bypass the name lookup
      */
-    async getRanked(displayName) {
-        return this.client.request(`/profile/ranked?displayName=${encodeURIComponent(displayName)}`);
+    async getRanked(displayName, options) {
+        const params = new URLSearchParams();
+        if (options?.accountId) {
+            params.append("accountId", options.accountId);
+        }
+        else {
+            params.append("displayName", displayName);
+        }
+        return this.client.request(`/profile/ranked?${params.toString()}`);
     }
     /**
      * Get all available ranked game mode tracks — modes, division counts, and season dates.

package/dist/resources/quests.d.ts

@@ -1,53 +1,12 @@
 import { FortniteAPI } from "../client";
 import { QuestsResponse } from "../types";
-/**
- * QuestsResource provides access to Fortnite quests and account progression data
- *
- * This resource allows you to fetch player quest progress, XP, playtime, and account level.
- * All methods require the user's personal Fortnite OAuth token obtained through the OAuth flow.
- *
- * @example
- * ```typescript
- * // Get quests for an account
- * const quests = await client.quests.getQuests(
- *   "account-id-here",
- *   "user-fortnite-token-here"
- * );
- * ```
- */
 export declare class QuestsResource {
     private client;
     constructor(client: FortniteAPI);
     /**
-     * Get account quests and level information
-     *
-     * Retrieves comprehensive quest data including:
-     * - Active quest progress and completion status
-     * - Account XP and level information
-     * - Total playtime statistics
-     * - Quest rewards and milestones
-     *
-     * **Authentication**: Requires user's personal Fortnite OAuth token
-     *
-     * **API Version**: v2
-     *
-     * **Rate Limit**: Standard API rate limits apply
-     *
-     * @param accountId - Epic Games Account ID (32 character hexadecimal string)
-     * @param fortniteToken - User's Fortnite access token obtained from OAuth flow
-     *
-     * @returns Promise resolving to quest progress, XP, playtime, and account level data
-     *
-     * @throws {FortniteAPIError} When the request fails (invalid token, account not found, etc.)
-     *
-     * @example
-     * ```typescript
-     * const accountId = "a1b2c3d4e5f6..."; // 32 character account ID
-     * const token = "eg1~..."; // User's Fortnite OAuth token
-     *
-     * const questData = await client.quests.getQuests(accountId, token);
-     * console.log(questData);
-     * ```
+     * Get active quests and challenges for a player. Requires x-fortnite-token.
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User's Fortnite access token (required)
      */
     getQuests(accountId: string, fortniteToken: string): Promise<QuestsResponse>;
 }

package/dist/resources/quests.js

@@ -1,55 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QuestsResource = void 0;
-/**
- * QuestsResource provides access to Fortnite quests and account progression data
- *
- * This resource allows you to fetch player quest progress, XP, playtime, and account level.
- * All methods require the user's personal Fortnite OAuth token obtained through the OAuth flow.
- *
- * @example
- * ```typescript
- * // Get quests for an account
- * const quests = await client.quests.getQuests(
- *   "account-id-here",
- *   "user-fortnite-token-here"
- * );
- * ```
- */
 class QuestsResource {
     constructor(client) {
         this.client = client;
     }
     /**
-     * Get account quests and level information
-     *
-     * Retrieves comprehensive quest data including:
-     * - Active quest progress and completion status
-     * - Account XP and level information
-     * - Total playtime statistics
-     * - Quest rewards and milestones
-     *
-     * **Authentication**: Requires user's personal Fortnite OAuth token
-     *
-     * **API Version**: v2
-     *
-     * **Rate Limit**: Standard API rate limits apply
-     *
-     * @param accountId - Epic Games Account ID (32 character hexadecimal string)
-     * @param fortniteToken - User's Fortnite access token obtained from OAuth flow
-     *
-     * @returns Promise resolving to quest progress, XP, playtime, and account level data
-     *
-     * @throws {FortniteAPIError} When the request fails (invalid token, account not found, etc.)
-     *
-     * @example
-     * ```typescript
-     * const accountId = "a1b2c3d4e5f6..."; // 32 character account ID
-     * const token = "eg1~..."; // User's Fortnite OAuth token
-     *
-     * const questData = await client.quests.getQuests(accountId, token);
-     * console.log(questData);
-     * ```
+     * Get active quests and challenges for a player. Requires x-fortnite-token.
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User's Fortnite access token (required)
      */
     async getQuests(accountId, fortniteToken) {
         return this.client.request(`/quests/${accountId}`, {