@yaelouuu/fortnite-api 4.2.0 → 4.3.0

package/dist/client.d.ts

@@ -10,6 +10,9 @@ 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";
 export interface ClientOptions {
     apiKey: string;
     baseUrl?: string;
@@ -29,6 +32,9 @@ export declare class FortniteAPI {
     quests: QuestsResource;
     account: AccountResource;
     fn: FNResource;
+    friends: FriendsResource;
+    stats: StatsResource;
+    events: EventsResource;
     constructor(options: ClientOptions);
     /**
      * Internal method to make HTTP requests

package/dist/client.js

@@ -14,6 +14,9 @@ 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");
 class FortniteAPI {
     constructor(options) {
         this.apiKey = options.apiKey;
@@ -32,6 +35,9 @@ 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);
     }
     /**
      * Internal method to make HTTP requests

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/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,145 @@ 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;
+    }>;
+}

package/package.json

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