@yaelouuu/fortnite-api 4.5.0 → 4.6.0

package/dist/resources/events.d.ts

@@ -1,5 +1,5 @@
 import { FortniteAPI } from "../client";
-import { EventWindows, PlayerEventHistory, TournamentDetails, ScoringRules, EventLeaderboard, PlayerEventData, EligibilityStatus, ArenaHype, EventRewards } from "../types";
+import { EventWindows, PlayerEventHistory, TournamentDetails, ScoringRules, EventLeaderboard, PlayerEventData, EligibilityStatus, PlayerEligibilityResult, ArenaHype, EventRewards } from "../types";
 /**
  * Events Resource
  * Handles tournament and competitive events data
@@ -58,13 +58,25 @@ export declare class EventsResource {
      */
     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
+     * Get parsed tournament eligibility requirements.
+     * No user token needed — requirements are extracted from tournament metadata.
+     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
+     * @param eventWindowId - Optional: filter to a specific event window
+     * @returns Parsed eligibility requirements
+     */
+    checkEligibility(eventId: string, eventWindowId?: string): Promise<EligibilityStatus>;
+    /**
+     * Check a player's eligibility against tournament requirements.
+     * Cross-references ranked data with tournament requirements — no user token needed.
+     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
+     * @param accountId - Epic Games Account ID to check
+     * @param options - Optional platform and eventWindowId
+     * @returns Player eligibility check results
      */
-    checkEligibility(accountId: string, eventId: string, fortniteToken: string): Promise<EligibilityStatus>;
+    checkPlayerEligibility(eventId: string, accountId: string, options?: {
+        platform?: string;
+        eventWindowId?: string;
+    }): Promise<PlayerEligibilityResult>;
     /**
      * Get Arena hype and division
      * @param accountId - Account ID

package/dist/resources/events.js

@@ -95,17 +95,32 @@ class EventsResource {
         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
+     * Get parsed tournament eligibility requirements.
+     * No user token needed — requirements are extracted from tournament metadata.
+     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
+     * @param eventWindowId - Optional: filter to a specific event window
+     * @returns Parsed eligibility requirements
+     */
+    async checkEligibility(eventId, eventWindowId) {
+        const query = eventWindowId ? `?eventWindowId=${eventWindowId}` : "";
+        return this.client.request(`/events/${eventId}/eligibility${query}`, {}, "v2");
+    }
+    /**
+     * Check a player's eligibility against tournament requirements.
+     * Cross-references ranked data with tournament requirements — no user token needed.
+     * @param eventId - Event ID (e.g. epicgames_S39_RankedCupDuosBR_ASIA)
+     * @param accountId - Epic Games Account ID to check
+     * @param options - Optional platform and eventWindowId
+     * @returns Player eligibility check results
      */
-    async checkEligibility(accountId, eventId, fortniteToken) {
-        const headers = {
-            "x-fortnite-token": fortniteToken,
-        };
-        return this.client.request(`/events/${eventId}/eligibility/${accountId}`, { headers }, "v2");
+    async checkPlayerEligibility(eventId, accountId, options) {
+        const params = new URLSearchParams();
+        if (options?.platform)
+            params.set("platform", options.platform);
+        if (options?.eventWindowId)
+            params.set("eventWindowId", options.eventWindowId);
+        const query = params.toString() ? `?${params.toString()}` : "";
+        return this.client.request(`/events/${eventId}/eligibility/${accountId}${query}`, {}, "v2");
     }
     /**
      * Get Arena hype and division

package/dist/resources/oauth.d.ts

@@ -1,5 +1,5 @@
 import { FortniteAPI } from "../client";
-import { OAuthCompleteResponse, OAuthDeviceRefreshResponse, OAuthFlowResponse, OAuthRefreshResponse } from "../types";
+import { OAuthCompleteResponse, OAuthDeviceRefreshResponse, OAuthExchangeCodeResponse, OAuthFlowResponse, OAuthRefreshResponse } from "../types";
 export declare class OauthResource {
     private client;
     constructor(client: FortniteAPI);
@@ -18,6 +18,16 @@ export declare class OauthResource {
      * Use when access token expires (~2 hours)
      */
     refreshToken(refreshToken: string): Promise<OAuthRefreshResponse>;
+    /**
+     * Exchange authorization code for tokens - POST /oauth/exchange-code
+     * Clean web OAuth flow (no device code warning)
+     */
+    exchangeCode(params: {
+        code: string;
+        redirectUri: string;
+        clientId?: string;
+        clientSecret?: string;
+    }): Promise<OAuthExchangeCodeResponse>;
     /**
      * Refresh with device auth - POST /oauth/refresh-device
      * Use device auth credentials to get fresh tokens (never expires)

package/dist/resources/oauth.js

@@ -32,6 +32,16 @@ class OauthResource {
             body: JSON.stringify({ refreshToken }),
         });
     }
+    /**
+     * Exchange authorization code for tokens - POST /oauth/exchange-code
+     * Clean web OAuth flow (no device code warning)
+     */
+    async exchangeCode(params) {
+        return this.client.request("/oauth/exchange-code", {
+            method: "POST",
+            body: JSON.stringify(params),
+        });
+    }
     /**
      * Refresh with device auth - POST /oauth/refresh-device
      * Use device auth credentials to get fresh tokens (never expires)

package/dist/resources/profiles.d.ts

@@ -4,19 +4,24 @@ export declare class ProfilesResource {
     private client;
     constructor(client: FortniteAPI);
     /**
-     * Get profile progress by display name
+     * Get profile progress (ranked divisions, levels) by display name
+     * @param displayName - Epic Games display name
      */
     getProgress(displayName: string): Promise<any>;
     /**
      * Get profile stats by display name
+     * @param displayName - Epic Games display name
+     * @param timeWindow - Time period: "season" or "lifetime" (default: "lifetime")
      */
-    getStats(displayName: string): Promise<ProfileStats>;
+    getStats(displayName: string, timeWindow?: "season" | "lifetime"): Promise<ProfileStats>;
     /**
      * Get account info by ID
+     * @param accountId - Epic Games Account ID
      */
     getAccount(accountId: string): Promise<Profile>;
     /**
-     * Get multiple display names
+     * Get multiple display names by account IDs
+     * @param accountIds - Array of account IDs (max 100)
      */
     getDisplayNames(accountIds: string[]): Promise<Record<string, string>>;
 }

package/dist/resources/profiles.js

@@ -6,29 +6,39 @@ class ProfilesResource {
         this.client = client;
     }
     /**
-     * Get profile progress by display name
+     * Get profile progress (ranked divisions, levels) by display name
+     * @param displayName - Epic Games display name
      */
     async getProgress(displayName) {
-        return this.client.request(`/profile/progress?displayName=${displayName}`);
+        return this.client.request(`/profile/progress?displayName=${encodeURIComponent(displayName)}`);
     }
     /**
      * Get profile stats by display name
+     * @param displayName - Epic Games display name
+     * @param timeWindow - Time period: "season" or "lifetime" (default: "lifetime")
      */
-    async getStats(displayName) {
-        return this.client.request(`/profile/stats?displayName=${displayName}`);
+    async getStats(displayName, timeWindow) {
+        const params = new URLSearchParams({
+            displayName,
+        });
+        if (timeWindow)
+            params.set("timeWindow", timeWindow);
+        return this.client.request(`/profile/stats?${params.toString()}`);
     }
     /**
      * Get account info by ID
+     * @param accountId - Epic Games Account ID
      */
     async getAccount(accountId) {
         return this.client.request(`/account/${accountId}`);
     }
     /**
-     * Get multiple display names
+     * Get multiple display names by account IDs
+     * @param accountIds - Array of account IDs (max 100)
      */
     async getDisplayNames(accountIds) {
         const ids = accountIds.join(",");
-        return this.client.request(`/displaynames/multiple?ids=${ids}`);
+        return this.client.request(`/displaynames/multiple?ids=${encodeURIComponent(ids)}`);
     }
 }
 exports.ProfilesResource = ProfilesResource;

package/dist/resources/weapons.d.ts

@@ -1,10 +1,19 @@
 import { FortniteAPI } from "../client";
-import { Weapons } from "../types";
+import { WeaponsResponse } from "../types";
 export declare class WeaponsResource {
     private client;
     constructor(client: FortniteAPI);
     /**
-     * Get weapons and infos
+     * Get weapons data with optional filtering
+     * @param options - Query options
+     * @param options.version - Version filter: "current" (current season), "all" (every weapon), "unversioned", or a specific version like "39.50"
+     * @param options.category - Filter by category: assault-rifles, shotguns, smgs, snipers, pistols, explosives, marksman-rifles, bows, crossbows, melee, light-machine-guns
+     * @param options.search - Search weapons by name (e.g. "pump", "assault", "bolt")
+     * @returns Weapons response with metadata and data
      */
-    getWeapons(): Promise<Weapons>;
+    getWeapons(options?: {
+        version?: string;
+        category?: string;
+        search?: string;
+    }): Promise<WeaponsResponse>;
 }

package/dist/resources/weapons.js

@@ -6,10 +6,23 @@ class WeaponsResource {
         this.client = client;
     }
     /**
-     * Get weapons and infos
+     * Get weapons data with optional filtering
+     * @param options - Query options
+     * @param options.version - Version filter: "current" (current season), "all" (every weapon), "unversioned", or a specific version like "39.50"
+     * @param options.category - Filter by category: assault-rifles, shotguns, smgs, snipers, pistols, explosives, marksman-rifles, bows, crossbows, melee, light-machine-guns
+     * @param options.search - Search weapons by name (e.g. "pump", "assault", "bolt")
+     * @returns Weapons response with metadata and data
      */
-    async getWeapons() {
-        return this.client.request("/weapons", {}, "v2");
+    async getWeapons(options) {
+        const params = new URLSearchParams();
+        if (options?.version)
+            params.set("version", options.version);
+        if (options?.category)
+            params.set("category", options.category);
+        if (options?.search)
+            params.set("search", options.search);
+        const query = params.toString() ? `?${params.toString()}` : "";
+        return this.client.request(`/weapons${query}`, {}, "v2");
     }
 }
 exports.WeaponsResource = WeaponsResource;

package/dist/types/index.d.ts

@@ -180,9 +180,21 @@ export interface TournamentEligibilityResponse {
     newest_tournament_date: string | null;
     recent_tournaments: TournamentTrackerEntry[];
 }
-export interface Weapons {
-    key: WeaponsInfos;
+export interface WeaponsResponse {
+    version: string;
+    count: number;
+    source: "iesdev" | "lootpool" | "codenames" | "none";
+    codenames?: string[];
+    lootPool?: {
+        patchVersion: string;
+        lastUpdated: string;
+        replaysProcessed: number;
+    };
+    message?: string;
+    data: Record<string, WeaponsInfos>;
 }
+/** @deprecated Use WeaponsResponse instead */
+export type Weapons = WeaponsResponse;
 export interface WeaponsInfos {
     id: string;
     displayName: string;
@@ -192,9 +204,15 @@ export interface WeaponsInfos {
     icon: string;
     type: string;
     category: string | null;
-    season: number;
+    season: number | null;
+    unversioned: boolean;
     series: string;
     stats: WeaponsStats;
+    images: {
+        icon: string | null;
+        iconNoBackground: string | null;
+        largeIcon: string | null;
+    };
 }
 export interface GameplayTags {
     gameplayTags: Array<String>;
@@ -479,9 +497,98 @@ export interface PlayerEventData {
     percentile?: number;
     sessions?: Array<any>;
 }
+export interface RankRequirement {
+    raw: string;
+    trackId?: string;
+    minimumRank?: number;
+}
+export interface WindowRequirements {
+    mfa: boolean;
+    eula: string | null;
+    anticheat: string | null;
+    rankRequirements: RankRequirement[] | null;
+}
+export interface EligibilityWindow {
+    eventWindowId: string;
+    beginTime: string;
+    endTime: string;
+    round: number;
+    requireAllTokens: string[];
+    requireAnyTokens: string[];
+    requireNoneTokensCaller: string[];
+    teammateEligibility: string | null;
+    requirements: WindowRequirements;
+}
+export interface EligibilityRequirements {
+    minimumAccountLevel: number | null;
+    platforms: string[];
+    systemFeatures: string[];
+    tournamentType: string | null;
+    regionLockType: string | null;
+    accountLockType: string | null;
+    teamLockType: string | null;
+    disqualifyType: string | null;
+}
 export interface EligibilityStatus {
-    eligible: boolean;
-    reasons?: string[];
+    eventId: string;
+    region: string;
+    groupId: string;
+    name: string;
+    requirements: EligibilityRequirements;
+    windows: EligibilityWindow[];
+}
+export interface EligibilityCheck {
+    status: "pass" | "fail" | "unknown";
+    required?: any;
+    message?: string;
+    playerPlatform?: string;
+}
+export interface RankCheck {
+    status: "pass" | "fail" | "unknown";
+    type: "OR";
+    details: Array<{
+        trackId: string;
+        minimumRank: number;
+        playerDivision: number | null;
+        status: "pass" | "fail" | "unknown";
+    }>;
+}
+export interface PlayerEligibilityWindow {
+    eventWindowId: string;
+    checks: {
+        mfa?: EligibilityCheck;
+        eula?: EligibilityCheck;
+        rank?: RankCheck;
+        requireNoneTokensCaller?: EligibilityCheck;
+    };
+}
+export interface PlayerEligibilityResult {
+    eventId: string;
+    accountId: string;
+    region: string;
+    name: string;
+    checks: {
+        minimumAccountLevel?: EligibilityCheck;
+        platform?: EligibilityCheck;
+        systemFeatures?: EligibilityCheck;
+    };
+    windows: PlayerEligibilityWindow[];
+    playerRanks: Record<string, {
+        currentDivision: number | null;
+        highestDivision: number | null;
+        currentPlayerRanking: number | null;
+    }>;
+    checkedAt: string;
+}
+export interface OAuthExchangeCodeResponse {
+    success: boolean;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    tokenType: string;
+    scope: string;
+    accountId: string;
+    displayName: string | null;
 }
 export interface ArenaHype {
     accountId: string;

package/package.json

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