@yaelouuu/fortnite-api 7.1.1 → 7.2.0

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/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}`, {

package/dist/resources/replays.d.ts

@@ -0,0 +1,82 @@
+import { FortniteAPI } from "../client";
+import { ParsedReplayData } from "../types";
+/**
+ * Replays Resource
+ * Download and parse tournament server replay files by match ID.
+ * Match IDs come from Epic's tournament events API.
+ * All parse endpoints subject to per-plan parsing quota limits.
+ */
+export declare class ReplaysResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Download a tournament replay file by match ID.
+     * Returns the raw .replay binary as an ArrayBuffer.
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    download(matchId: string): Promise<ArrayBuffer>;
+    /**
+     * Get the raw chunk manifest (metadata) for a tournament replay.
+     * Returns Events, DataChunks, Checkpoints arrays with timing info.
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    getMetadata(matchId: string): Promise<any>;
+    /**
+     * Download and fully parse a tournament replay — full parse.
+     * Returns the same structure as POST /api/v1/parsing.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parse(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — stats only.
+     * Faster than full parse. Returns name, replayId, version, playlist, teamSize, teamCount, isTournament, tournamentRound, stats.
+     * Subject to per-plan parsing quota limits (1 credit).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parseStats(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — map context.
+     * Returns bus path, storm circles, supply drops, llamas, reboot vans.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parseMap(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — ground loot.
+     * Server replays give whole-map loot coverage (vs ~150m radius for client replays).
+     * Returns all item spawns: position, item ID, picked-up status and time.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parseLoot(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — full player lobby.
+     * Returns all players with kills, placement, damage, reboots, headshots, teamKills, death info, and cosmetics.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parseLobby(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — storm zones.
+     * Returns all safe zone phases with timing, positions, and damage per tick.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parseZones(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — match timeline.
+     * Returns chronological event feed: kills, knocks, death, damage dealt/taken, heals, pickups.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    parseTimeline(matchId: string): Promise<ParsedReplayData>;
+    /**
+     * Download and parse a tournament replay — full broadcast payload.
+     * Combines all data: 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 matchId - Match ID from Epic's tournament events API
+     */
+    parseBroadcast(matchId: string): Promise<ParsedReplayData>;
+}

package/dist/resources/replays.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReplaysResource = void 0;
+/**
+ * Replays Resource
+ * Download and parse tournament server replay files by match ID.
+ * Match IDs come from Epic's tournament events API.
+ * All parse endpoints subject to per-plan parsing quota limits.
+ */
+class ReplaysResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Download a tournament replay file by match ID.
+     * Returns the raw .replay binary as an ArrayBuffer.
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async download(matchId) {
+        return this.client.requestBinary(`/replays/${encodeURIComponent(matchId)}`);
+    }
+    /**
+     * Get the raw chunk manifest (metadata) for a tournament replay.
+     * Returns Events, DataChunks, Checkpoints arrays with timing info.
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async getMetadata(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/metadata`, {}, "v1");
+    }
+    /**
+     * Download and fully parse a tournament replay — full parse.
+     * Returns the same structure as POST /api/v1/parsing.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parse(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — stats only.
+     * Faster than full parse. Returns name, replayId, version, playlist, teamSize, teamCount, isTournament, tournamentRound, stats.
+     * Subject to per-plan parsing quota limits (1 credit).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parseStats(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/stats`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — map context.
+     * Returns bus path, storm circles, supply drops, llamas, reboot vans.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parseMap(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/map`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — ground loot.
+     * Server replays give whole-map loot coverage (vs ~150m radius for client replays).
+     * Returns all item spawns: position, item ID, picked-up status and time.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parseLoot(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/loot`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — full player lobby.
+     * Returns all players with kills, placement, damage, reboots, headshots, teamKills, death info, and cosmetics.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parseLobby(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/lobby`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — storm zones.
+     * Returns all safe zone phases with timing, positions, and damage per tick.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parseZones(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/zones`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — match timeline.
+     * Returns chronological event feed: kills, knocks, death, damage dealt/taken, heals, pickups.
+     * Subject to per-plan parsing quota limits (5 credits).
+     * @param matchId - Match ID from Epic's tournament events API
+     */
+    async parseTimeline(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/timeline`, {}, "v1");
+    }
+    /**
+     * Download and parse a tournament replay — full broadcast payload.
+     * Combines all data: 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 matchId - Match ID from Epic's tournament events API
+     */
+    async parseBroadcast(matchId) {
+        return this.client.request(`/replays/${encodeURIComponent(matchId)}/parse/broadcast`, {}, "v1");
+    }
+}
+exports.ReplaysResource = ReplaysResource;

package/dist/resources/shop.d.ts

@@ -5,16 +5,17 @@ export declare class ShopResource {
     constructor(client: FortniteAPI);
     /**
      * Get current shop items with optional filtering
-     * @param options - Query options
-     * @param options.type - Filter by cosmetic type: outfit, emote, pickaxe, glider, backpack, wrap, music, loadingscreen, contrail, spray, toy, emoji, pet, bundle
+     * @param options.type - Filter by cosmetic type (e.g. outfit, emote, pickaxe, glider)
      * @param options.section - Filter by shop section name (e.g. "Featured", "Daily", "Kicks")
-     * @param options.rarity - Filter by rarity: common, uncommon, rare, epic, legendary, mythic
-     * @param options.search - Search items by name (e.g. "galaxy", "travis")
+     * @param options.rarity - Filter by rarity (e.g. rare, epic, legendary)
+     * @param options.search - Search items by name
+     * @param options.lang - Language code (default: en)
      */
     getCurrent(options?: {
         type?: string;
         section?: string;
         rarity?: string;
         search?: string;
+        lang?: string;
     }): Promise<Shop>;
 }

package/dist/resources/shop.js

@@ -7,11 +7,11 @@ class ShopResource {
     }
     /**
      * Get current shop items with optional filtering
-     * @param options - Query options
-     * @param options.type - Filter by cosmetic type: outfit, emote, pickaxe, glider, backpack, wrap, music, loadingscreen, contrail, spray, toy, emoji, pet, bundle
+     * @param options.type - Filter by cosmetic type (e.g. outfit, emote, pickaxe, glider)
      * @param options.section - Filter by shop section name (e.g. "Featured", "Daily", "Kicks")
-     * @param options.rarity - Filter by rarity: common, uncommon, rare, epic, legendary, mythic
-     * @param options.search - Search items by name (e.g. "galaxy", "travis")
+     * @param options.rarity - Filter by rarity (e.g. rare, epic, legendary)
+     * @param options.search - Search items by name
+     * @param options.lang - Language code (default: en)
      */
     async getCurrent(options) {
         const params = new URLSearchParams();
@@ -23,6 +23,8 @@ class ShopResource {
             params.set("rarity", options.rarity);
         if (options?.search)
             params.set("search", options.search);
+        if (options?.lang)
+            params.set("lang", options.lang);
         const query = params.toString() ? `?${params.toString()}` : "";
         return this.client.request(`/shop${query}`);
     }