@yaelouuu/fortnite-api 4.1.0 → 4.3.0

package/dist/resources/account.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AccountResource = void 0;
+class AccountResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Lookup account by Account ID
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getById(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/${accountId}`, { headers }, "v1");
+    }
+    /**
+     * Bulk account lookup by Account IDs
+     * @param accountIds - Array of Epic Games account IDs (max 100)
+     */
+    async getBulk(accountIds) {
+        const queryString = accountIds
+            .map((id) => `accountId=${encodeURIComponent(id)}`)
+            .join("&");
+        return this.client.request(`/account/bulk?${queryString}`, {}, "v1");
+    }
+    /**
+     * Lookup account by Epic display name
+     * @param displayName - Epic Games display name
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getByDisplayName(displayName, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/displayName/${encodeURIComponent(displayName)}`, { headers }, "v1");
+    }
+    /**
+     * Cross-platform account lookup by external display name
+     * @param platform - Platform type (psn, xbl, steam, nintendo, twitch, github)
+     * @param displayName - Platform display name
+     * @param caseInsensitive - Case-insensitive search (default: false)
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getByExternalDisplayName(platform, displayName, caseInsensitive = false, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        const query = caseInsensitive ? "?caseInsensitive=true" : "";
+        return this.client.request(`/account/external/${platform}/displayName/${encodeURIComponent(displayName)}${query}`, { headers }, "v1");
+    }
+    /**
+     * Bulk external display name lookup
+     * @param payload - Array of platform/displayName pairs (max 100)
+     */
+    async getBulkExternalDisplayNames(payload) {
+        return this.client.request(`/account/external/displayNames/bulk`, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        }, "v1");
+    }
+    /**
+     * Bulk external ID lookup
+     * @param payload - Array of platform/externalId pairs (max 100)
+     */
+    async getBulkExternalIds(payload) {
+        return this.client.request(`/account/external/ids/bulk`, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        }, "v1");
+    }
+    /**
+     * Get all external authentications for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getExternalAuths(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/${accountId}/externalAuths`, { headers }, "v1");
+    }
+    /**
+     * Get specific external authentication for an account
+     * @param accountId - Epic Games account ID
+     * @param platform - Platform type (psn, xbl, steam, nintendo, twitch, github)
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getExternalAuth(accountId, platform, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/account/${accountId}/externalAuths/${platform}`, { headers }, "v1");
+    }
+}
+exports.AccountResource = AccountResource;

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/fn.d.ts

@@ -0,0 +1,56 @@
+import { FortniteAPI } from "../client";
+import { BRInventory, Keychain, Receipt, EnabledFeatures, VersionCheck, PrivacySettings, EntitlementCheck } from "../types";
+export declare class FNResource {
+    private client;
+    constructor(client: FortniteAPI);
+    /**
+     * Get Battle Royale inventory (V-Bucks and currency)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getBRInventory(accountId: string, fortniteToken?: string): Promise<BRInventory>;
+    /**
+     * Get storefront encryption keychain
+     */
+    getKeychain(): Promise<Keychain>;
+    /**
+     * Get purchase receipts for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    getReceipts(accountId: string, fortniteToken?: string): Promise<Receipt[]>;
+    /**
+     * Get currently enabled game features
+     */
+    getEnabledFeatures(): Promise<EnabledFeatures>;
+    /**
+     * Check game version
+     * @param platform - Platform name (Windows, Mac, etc.)
+     * @param version - Version string to check
+     */
+    checkVersion(platform: string, version: string): Promise<VersionCheck>;
+    /**
+     * Get privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    getPrivacySettings(accountId: string, fortniteToken: string): Promise<PrivacySettings>;
+    /**
+     * Update privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param settings - Privacy settings to update
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    updatePrivacySettings(accountId: string, settings: Partial<PrivacySettings>, fortniteToken: string): Promise<PrivacySettings>;
+    /**
+     * Check Fortnite entitlement (requires user token)
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    checkEntitlement(fortniteToken: string): Promise<EntitlementCheck>;
+    /**
+     * Request Fortnite entitlement access (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    requestEntitlement(accountId: string, fortniteToken: string): Promise<void>;
+}

package/dist/resources/fn.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FNResource = void 0;
+class FNResource {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get Battle Royale inventory (V-Bucks and currency)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getBRInventory(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/fn/br-inventory/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get storefront encryption keychain
+     */
+    async getKeychain() {
+        return this.client.request("/fn/keychain", {}, "v2");
+    }
+    /**
+     * Get purchase receipts for an account
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - Optional user Fortnite token
+     */
+    async getReceipts(accountId, fortniteToken) {
+        const headers = {};
+        if (fortniteToken) {
+            headers["x-fortnite-token"] = fortniteToken;
+        }
+        return this.client.request(`/fn/receipts/${accountId}`, { headers }, "v2");
+    }
+    /**
+     * Get currently enabled game features
+     */
+    async getEnabledFeatures() {
+        return this.client.request("/fn/enabled-features", {}, "v2");
+    }
+    /**
+     * Check game version
+     * @param platform - Platform name (Windows, Mac, etc.)
+     * @param version - Version string to check
+     */
+    async checkVersion(platform, version) {
+        return this.client.request(`/fn/version/${platform}?version=${encodeURIComponent(version)}`, {}, "v2");
+    }
+    /**
+     * Get privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async getPrivacySettings(accountId, fortniteToken) {
+        return this.client.request(`/fn/privacy/${accountId}`, {
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+        }, "v2");
+    }
+    /**
+     * Update privacy settings for an account (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param settings - Privacy settings to update
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async updatePrivacySettings(accountId, settings, fortniteToken) {
+        return this.client.request(`/fn/privacy/${accountId}`, {
+            method: "POST",
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+            body: JSON.stringify(settings),
+        }, "v2");
+    }
+    /**
+     * Check Fortnite entitlement (requires user token)
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async checkEntitlement(fortniteToken) {
+        return this.client.request("/fn/entitlement", {
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+        }, "v2");
+    }
+    /**
+     * Request Fortnite entitlement access (requires user token)
+     * @param accountId - Epic Games account ID
+     * @param fortniteToken - User Fortnite token (required)
+     */
+    async requestEntitlement(accountId, fortniteToken) {
+        await this.client.request(`/fn/entitlement/${accountId}`, {
+            method: "POST",
+            headers: {
+                "x-fortnite-token": fortniteToken,
+            },
+        }, "v2");
+    }
+}
+exports.FNResource = FNResource;

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;