clashofclans.js 1.5.4 → 2.0.0-dev.2c5b083

package/dist/client/EventManager.d.ts

@@ -0,0 +1,86 @@
+import { Clan, ClanWar, Player } from '../struct';
+import { Client } from './Client';
+/** Represents Event Manager of the {@link Client}. */
+export declare class EventManager {
+    private readonly client;
+    private readonly _clanTags;
+    private readonly _playerTags;
+    private readonly _warTags;
+    private readonly _clans;
+    private readonly _players;
+    private readonly _wars;
+    private readonly _events;
+    private _inMaintenance;
+    private _maintenanceStartTime;
+    constructor(client: Client);
+    /** Initialize the Event Manager to start pulling. */
+    init(): Promise<string[]>;
+    /** Add clan tags to clan events. */
+    addClans(tags: string[] | string): this;
+    /** Delete clan tags from clan events. */
+    deleteClans(tags: string[] | string): this;
+    /** Add player tags for player events. */
+    addPlayers(tags: string[] | string): this;
+    /** Delete player tags from player events. */
+    deletePlayers(tags: string[] | string): this;
+    /** Add clan tags for war events. */
+    addWars(tags: string[] | string): this;
+    /** Delete clan tags from war events. */
+    deleteWars(tags: string[] | string): this;
+    /**
+     * Set your own custom clan event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     *
+     * @example
+     * ```js
+     * client.events.addClans(['#2PP', '#8QU8J9LP']);
+     *
+     * client.events.setClanEvent({
+     *   name: 'clanMemberUpdate',
+     *   filter: (oldClan, newClan) => {
+     *     return oldClan.memberCount !== newClan.memberCount;
+     *   }
+     * });
+     *
+     * client.on('clanMemberUpdate', (oldClan, newClan) => {
+     *   console.log(oldClan.memberCount, newClan.memberCount);
+     * });
+     *
+     * (async function () {
+     *   await client.events.init();
+     * })();
+     * ```
+     * @returns
+     */
+    setClanEvent(event: {
+        name: string;
+        filter: (oldClan: Clan, newClan: Clan) => boolean;
+    }): this;
+    /**
+     * Set your own custom war event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setWarEvent(event: {
+        name: string;
+        filter: (oldWar: ClanWar, newWar: ClanWar) => boolean;
+    }): this;
+    /**
+     * Set your own custom player event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setPlayerEvent(event: {
+        name: string;
+        filter: (oldPlayer: Player, newPlayer: Player) => boolean;
+    }): this;
+    private maintenanceHandler;
+    private seasonEndHandler;
+    private clanUpdateHandler;
+    private playerUpdateHandler;
+    private warUpdateHandler;
+    private runClanUpdate;
+    private runPlayerUpdate;
+    private runWarUpdate;
+}

package/dist/client/EventManager.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventManager = void 0;
+const HTTPError_1 = require("../rest/HTTPError");
+const Constants_1 = require("../util/Constants");
+const Util_1 = require("../util/Util");
+/** Represents Event Manager of the {@link Client}. */
+class EventManager {
+    constructor(client) {
+        this.client = client;
+        this._clanTags = new Set();
+        this._playerTags = new Set();
+        this._warTags = new Set();
+        this._clans = new Map();
+        this._players = new Map();
+        this._wars = new Map();
+        this._events = {
+            clans: [],
+            wars: [],
+            players: []
+        };
+        this._inMaintenance = Boolean(false);
+        this._maintenanceStartTime = null;
+    }
+    /** Initialize the Event Manager to start pulling. */
+    async init() {
+        this.seasonEndHandler();
+        this.maintenanceHandler();
+        this.clanUpdateHandler();
+        this.playerUpdateHandler();
+        this.warUpdateHandler();
+        return Promise.resolve(this.client.eventNames());
+    }
+    /** Add clan tags to clan events. */
+    addClans(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            this._clanTags.add(this.client.util.parseTag(tag));
+        }
+        return this;
+    }
+    /** Delete clan tags from clan events. */
+    deleteClans(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            const key = this.client.util.parseTag(tag);
+            this._clans.delete(key);
+            this._clanTags.delete(key);
+        }
+        return this;
+    }
+    /** Add player tags for player events. */
+    addPlayers(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            this._playerTags.add(this.client.util.parseTag(tag));
+        }
+        return this;
+    }
+    /** Delete player tags from player events. */
+    deletePlayers(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            const key = this.client.util.parseTag(tag);
+            this._players.delete(key);
+            this._playerTags.delete(key);
+        }
+        return this;
+    }
+    /** Add clan tags for war events. */
+    addWars(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            this._warTags.add(this.client.util.parseTag(tag));
+        }
+        return this;
+    }
+    /** Delete clan tags from war events. */
+    deleteWars(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            const key = this.client.util.parseTag(tag);
+            this._wars.delete(`${key}:${1}`);
+            this._wars.delete(`${key}:${2}`);
+            this._warTags.delete(key);
+        }
+        return this;
+    }
+    /**
+     * Set your own custom clan event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     *
+     * @example
+     * ```js
+     * client.events.addClans(['#2PP', '#8QU8J9LP']);
+     *
+     * client.events.setClanEvent({
+     *   name: 'clanMemberUpdate',
+     *   filter: (oldClan, newClan) => {
+     *     return oldClan.memberCount !== newClan.memberCount;
+     *   }
+     * });
+     *
+     * client.on('clanMemberUpdate', (oldClan, newClan) => {
+     *   console.log(oldClan.memberCount, newClan.memberCount);
+     * });
+     *
+     * (async function () {
+     *   await client.events.init();
+     * })();
+     * ```
+     * @returns
+     */
+    setClanEvent(event) {
+        if (!event.name)
+            throw new Error('Event name is required.');
+        if (typeof event.filter !== 'function')
+            throw new Error('Filter function is required.');
+        this._events.clans.push(event);
+        return this;
+    }
+    /**
+     * Set your own custom war event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setWarEvent(event) {
+        if (!event.name)
+            throw new Error('Event name is required.');
+        if (typeof event.filter !== 'function')
+            throw new Error('Filter function is required.');
+        this._events.wars.push(event);
+        return this;
+    }
+    /**
+     * Set your own custom player event.
+     *
+     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     */
+    setPlayerEvent(event) {
+        if (!event.name)
+            throw new Error('Event name is required.');
+        if (typeof event.filter !== 'function')
+            throw new Error('Filter function is required.');
+        this._events.players.push(event);
+        return this;
+    }
+    async maintenanceHandler() {
+        setTimeout(this.maintenanceHandler.bind(this), 10000).unref();
+        try {
+            const res = await this.client.rest.getClans({ maxMembers: Math.floor(Math.random() * 40) + 10, limit: 1 });
+            if (res.status === 200 && this._inMaintenance) {
+                this._inMaintenance = Boolean(false);
+                const duration = Date.now() - this._maintenanceStartTime.getTime();
+                this._maintenanceStartTime = null;
+                this.client.emit(Constants_1.EVENTS.MAINTENANCE_END, duration);
+            }
+        }
+        catch (error) {
+            if (error instanceof HTTPError_1.HTTPError && error.status === 503 && !this._inMaintenance) {
+                this._inMaintenance = Boolean(true);
+                this._maintenanceStartTime = new Date();
+                this.client.emit(Constants_1.EVENTS.MAINTENANCE_START);
+            }
+        }
+    }
+    seasonEndHandler() {
+        const end = Util_1.Util.getSeasonEndTime().getTime() - Date.now();
+        // Why this? setTimeout can be up to 24.8 days or 2147483647ms [(2^31 - 1) Max 32bit Integer]
+        if (end > 24 * 60 * 60 * 1000) {
+            setTimeout(this.seasonEndHandler.bind(this), 60 * 60 * 1000).unref();
+        }
+        else if (end > 0) {
+            setTimeout(() => {
+                this.client.emit(Constants_1.EVENTS.NEW_SEASON_START, Util_1.Util.getSeasonId());
+            }, end + 100).unref();
+        }
+    }
+    async clanUpdateHandler() {
+        this.client.emit(Constants_1.EVENTS.CLAN_LOOP_START);
+        for (const tag of this._clanTags)
+            await this.runClanUpdate(tag);
+        this.client.emit(Constants_1.EVENTS.CLAN_LOOP_END);
+        setTimeout(this.clanUpdateHandler.bind(this), 10000).unref();
+    }
+    async playerUpdateHandler() {
+        this.client.emit(Constants_1.EVENTS.PLAYER_LOOP_START);
+        for (const tag of this._playerTags)
+            await this.runPlayerUpdate(tag);
+        this.client.emit(Constants_1.EVENTS.PLAYER_LOOP_END);
+        setTimeout(this.playerUpdateHandler.bind(this), 10000).unref();
+    }
+    async warUpdateHandler() {
+        this.client.emit(Constants_1.EVENTS.WAR_LOOP_START);
+        for (const tag of this._warTags)
+            await this.runWarUpdate(tag);
+        this.client.emit(Constants_1.EVENTS.WAR_LOOP_END);
+        setTimeout(this.warUpdateHandler.bind(this), 10000).unref();
+    }
+    async runClanUpdate(tag) {
+        if (this._inMaintenance)
+            return null;
+        const clan = await this.client.getClan(tag).catch(() => null);
+        if (!clan)
+            return null;
+        const cached = this._clans.get(clan.tag);
+        if (!cached)
+            return this._clans.set(clan.tag, clan);
+        for (const { name, filter } of this._events.clans) {
+            try {
+                if (!filter(cached, clan))
+                    continue;
+                this.client.emit(name, cached, clan);
+            }
+            catch (error) {
+                this.client.emit(Constants_1.EVENTS.ERROR, error);
+            }
+        }
+        return this._clans.set(clan.tag, clan);
+    }
+    async runPlayerUpdate(tag) {
+        if (this._inMaintenance)
+            return null;
+        const player = await this.client.getPlayer(tag).catch(() => null);
+        if (!player)
+            return null;
+        const cached = this._players.get(player.tag);
+        if (!cached)
+            return this._players.set(player.tag, player);
+        for (const { name, filter } of this._events.players) {
+            try {
+                if (!filter(cached, player))
+                    continue;
+                this.client.emit(name, cached, player);
+            }
+            catch (error) {
+                this.client.emit(Constants_1.EVENTS.ERROR, error);
+            }
+        }
+        return this._players.set(player.tag, player);
+    }
+    async runWarUpdate(tag) {
+        if (this._inMaintenance)
+            return null;
+        // @ts-expect-error
+        const clanWars = await this.client._getClanWars(tag).catch(() => null);
+        if (!clanWars?.length)
+            return null;
+        clanWars.forEach(async (war, index) => {
+            const key = `${tag}:${index}`;
+            const cached = this._wars.get(key);
+            if (!cached)
+                return this._wars.set(key, war);
+            for (const { name, filter } of this._events.wars) {
+                try {
+                    if (!filter(cached, war))
+                        continue;
+                    this.client.emit(name, cached, war);
+                }
+                catch (error) {
+                    this.client.emit(Constants_1.EVENTS.ERROR, error);
+                }
+            }
+            // check for war end
+            if (index === 1 && cached.warTag !== war.warTag) {
+                const data = await this.client.getLeagueWar({ clanTag: tag, round: 'PREVIOUS_ROUND' }).catch(() => null);
+                if (data && data.warTag === cached.warTag) {
+                    for (const { name, filter } of this._events.wars) {
+                        try {
+                            if (!filter(cached, data))
+                                continue;
+                            this.client.emit(name, cached, data);
+                        }
+                        catch (error) {
+                            this.client.emit(Constants_1.EVENTS.ERROR, error);
+                        }
+                    }
+                }
+            }
+            return this._wars.set(key, war);
+        });
+    }
+}
+exports.EventManager = EventManager;

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './client/Client';
+export * from './rest/RESTManager';
+export * from './rest/RequestHandler';
+export * from './rest/HTTPError';
+export * from './client/EventManager';
+export * from './rest/Throttler';
+export * from './util/Util';
+export * from './struct';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client/Client"), exports);
+__exportStar(require("./rest/RESTManager"), exports);
+__exportStar(require("./rest/RequestHandler"), exports);
+__exportStar(require("./rest/HTTPError"), exports);
+__exportStar(require("./client/EventManager"), exports);
+__exportStar(require("./rest/Throttler"), exports);
+__exportStar(require("./util/Util"), exports);
+__exportStar(require("./struct"), exports);
+__exportStar(require("./types"), exports);

package/dist/rest/HTTPError.d.ts

@@ -0,0 +1,24 @@
+/** Represents an HTTP Error. */
+export declare class HTTPError extends Error {
+    /** The message of this error. */
+    message: string;
+    /** The HTTP method of this request. */
+    method: string;
+    /** The reason of this error. */
+    reason: string;
+    /** The HTTP status code of this request. */
+    status: number;
+    /** The path of this request. */
+    path: string;
+    /** Maximum number of milliseconds the results can be cached. */
+    maxAge: number;
+    constructor(error: any, status: number, path: string, maxAge: number, method?: string);
+}
+export declare const NotInWarError: {
+    message: string;
+    reason: string;
+};
+export declare const PrivateWarLogError: {
+    message: string;
+    reason: string;
+};

package/dist/rest/HTTPError.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateWarLogError = exports.NotInWarError = exports.HTTPError = void 0;
+const messages = {
+    500: 'Unknown error happened when handling the request.',
+    504: 'The user aborted this request.',
+    404: 'Requested resource was not found.',
+    400: 'Client provided incorrect parameters for the request.',
+    503: 'Service is temporarily unavailable because of maintenance.',
+    429: 'Request was throttled, because amount of requests was above the threshold defined for the used API token.',
+    403: 'Access denied, either because of missing/incorrect credentials or used API token does not grant access to the requested resource.'
+};
+const reasons = {
+    503: 'serviceUnavailable',
+    429: 'tooManyRequests',
+    400: 'badRequest',
+    403: 'forbidden',
+    500: 'unknownError',
+    404: 'notFound',
+    504: 'requestAborted'
+};
+/** Represents an HTTP Error. */
+class HTTPError extends Error {
+    constructor(error, status, path, maxAge, method) {
+        super();
+        this.message = error?.message ?? messages[status];
+        this.reason = error?.reason ?? reasons[status];
+        this.path = path;
+        this.method = method ?? 'GET';
+        this.status = status;
+        this.maxAge = maxAge;
+    }
+}
+exports.HTTPError = HTTPError;
+exports.NotInWarError = {
+    message: 'Clan is not in war at this moment.',
+    reason: 'notInWar'
+};
+exports.PrivateWarLogError = {
+    message: 'Access denied, clan war log is private.',
+    reason: 'privateWarLog'
+};

package/dist/rest/RESTManager.d.ts

@@ -0,0 +1,56 @@
+import { RequestHandler, SearchOptions, ClanSearchOptions, ClientOptions, OverrideOptions } from './RequestHandler';
+import { APIClan, APIClanList, APIClanMemberList, APIClanRankingList, APIClanVersusRankingList, APIClanWar, APIClanWarLeagueGroup, APIClanWarLog, APIGoldPassSeason, APILabelList, APILeague, APILeagueList, APILeagueSeasonList, APILocation, APILocationList, APIPlayer, APIPlayerRankingList, APIPlayerSeasonRankingList, APIPlayerVersusRankingList, APIVerifyToken, APIWarLeague, APIWarLeagueList } from '../types';
+/** Represents a REST Manager of the client. */
+export declare class RESTManager {
+    /** Request Handler for the RESTManager. */
+    readonly handler: RequestHandler;
+    constructor(options?: ClientOptions);
+    /** Search all clans by name and/or filtering the results using various criteria. */
+    getClans(options: ClanSearchOptions): Promise<import("./RequestHandler").Response<APIClanList>>;
+    /** Get information about a clan. */
+    getClan(clanTag: string, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIClan>>;
+    /** Get list of clan members. */
+    getClanMembers(clanTag: string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIClanMemberList>>;
+    /** Get clan war log. */
+    getClanWarLog(clanTag: string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIClanWarLog>>;
+    /** Get info about currently running war in the clan. */
+    getCurrentWar(clanTag: string, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIClanWar>>;
+    /** Get information about clan war league. */
+    getClanWarLeagueGroup(clanTag: string, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIClanWarLeagueGroup>>;
+    /** Get info about a CWL round by WarTag. */
+    getClanWarLeagueRound(warTag: string, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIClanWar>>;
+    /** Get information about a player by tag. */
+    getPlayer(playerTag: string, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIPlayer>>;
+    /** Verify Player API token that can be found from the Game settings. */
+    verifyPlayerToken(playerTag: string, token: string, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIVerifyToken>>;
+    /** Get list of Leagues. */
+    getLeagues(options?: SearchOptions): Promise<import("./RequestHandler").Response<APILeagueList>>;
+    /** Get a League info. */
+    getLeague(leagueId: string | number, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APILeague>>;
+    /** Get Legend League season Ids. */
+    getLeagueSeasons(leagueId: number, options?: SearchOptions): Promise<import("./RequestHandler").Response<APILeagueSeasonList>>;
+    /** Get Legend League season rankings by season Id. */
+    getSeasonRankings(leagueId: number, seasonId: string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIPlayerSeasonRankingList>>;
+    /** Get list of Clan War Leagues. */
+    getWarLeagues(options?: SearchOptions): Promise<import("./RequestHandler").Response<APIWarLeagueList>>;
+    /** Get info about a Clan War League. */
+    getWarLeague(leagueId: number, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIWarLeague>>;
+    /** Get list of Locations. */
+    getLocations(options?: SearchOptions): Promise<import("./RequestHandler").Response<APILocationList>>;
+    /** Get info about a Location. */
+    getLocation(locationId: number, options?: OverrideOptions): Promise<import("./RequestHandler").Response<APILocation>>;
+    /** Get clan rankings for a specific location. */
+    getClanRanks(locationId: number | string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIClanRankingList>>;
+    /** Get player rankings for a specific location. */
+    getPlayerRanks(locationId: number | string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIPlayerRankingList>>;
+    /** Get clan versus rankings for a specific location. */
+    getVersusClanRanks(locationId: number | string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIClanVersusRankingList>>;
+    /** Get player versus rankings for a specific location. */
+    getVersusPlayerRanks(locationId: number | string, options?: SearchOptions): Promise<import("./RequestHandler").Response<APIPlayerVersusRankingList>>;
+    /** Get list of clan labels. */
+    getClanLabels(options?: SearchOptions): Promise<import("./RequestHandler").Response<APILabelList>>;
+    /** Get list of player labels. */
+    getPlayerLabels(options?: SearchOptions): Promise<import("./RequestHandler").Response<APILabelList>>;
+    /** Get info about gold pass season. */
+    getGoldPassSeason(options?: OverrideOptions): Promise<import("./RequestHandler").Response<APIGoldPassSeason>>;
+}

package/dist/rest/RESTManager.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESTManager = void 0;
+const RequestHandler_1 = require("./RequestHandler");
+const Util_1 = require("../util/Util");
+/** Represents a REST Manager of the client. */
+class RESTManager {
+    constructor(options) {
+        this.handler = new RequestHandler_1.RequestHandler(options);
+    }
+    /** Search all clans by name and/or filtering the results using various criteria. */
+    getClans(options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/clans?${query}`);
+    }
+    /** Get information about a clan. */
+    getClan(clanTag, options) {
+        return this.handler.request(`/clans/${Util_1.Util.encodeTag(clanTag)}`, options);
+    }
+    /** Get list of clan members. */
+    getClanMembers(clanTag, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/clans/${Util_1.Util.encodeTag(clanTag)}/members?${query}`, options);
+    }
+    /** Get clan war log. */
+    getClanWarLog(clanTag, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/clans/${Util_1.Util.encodeTag(clanTag)}/warlog?${query}`, options);
+    }
+    /** Get info about currently running war in the clan. */
+    getCurrentWar(clanTag, options) {
+        return this.handler.request(`/clans/${Util_1.Util.encodeTag(clanTag)}/currentwar`, options);
+    }
+    /** Get information about clan war league. */
+    getClanWarLeagueGroup(clanTag, options) {
+        return this.handler.request(`/clans/${Util_1.Util.encodeTag(clanTag)}/currentwar/leaguegroup`, options);
+    }
+    /** Get info about a CWL round by WarTag. */
+    getClanWarLeagueRound(warTag, options) {
+        return this.handler.request(`/clanwarleagues/wars/${Util_1.Util.encodeTag(warTag)}`, options);
+    }
+    /** Get information about a player by tag. */
+    getPlayer(playerTag, options) {
+        return this.handler.request(`/players/${Util_1.Util.encodeTag(playerTag)}`, options);
+    }
+    /** Verify Player API token that can be found from the Game settings. */
+    verifyPlayerToken(playerTag, token, options) {
+        const opts = { method: 'POST', body: JSON.stringify({ token }), ...options };
+        return this.handler.request(`/players/${Util_1.Util.encodeTag(playerTag)}/verifytoken`, opts);
+    }
+    /** Get list of Leagues. */
+    getLeagues(options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/leagues?${query}`, options);
+    }
+    /** Get a League info. */
+    getLeague(leagueId, options) {
+        return this.handler.request(`/leagues/${leagueId}`, options);
+    }
+    /** Get Legend League season Ids. */
+    getLeagueSeasons(leagueId, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/leagues/${leagueId}/seasons?${query}`, options);
+    }
+    /** Get Legend League season rankings by season Id. */
+    getSeasonRankings(leagueId, seasonId, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/leagues/${leagueId}/seasons/${seasonId}?${query}`, options);
+    }
+    /** Get list of Clan War Leagues. */
+    getWarLeagues(options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/warleagues?${query}`, options);
+    }
+    /** Get info about a Clan War League. */
+    getWarLeague(leagueId, options) {
+        return this.handler.request(`/warleagues/${leagueId}`, options);
+    }
+    /** Get list of Locations. */
+    getLocations(options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/locations?${query}`, options);
+    }
+    /** Get info about a Location. */
+    getLocation(locationId, options) {
+        return this.handler.request(`/locations/${locationId}`, options);
+    }
+    /** Get clan rankings for a specific location. */
+    getClanRanks(locationId, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/locations/${locationId}/rankings/clans?${query}`, options);
+    }
+    /** Get player rankings for a specific location. */
+    getPlayerRanks(locationId, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/locations/${locationId}/rankings/players?${query}`, options);
+    }
+    /** Get clan versus rankings for a specific location. */
+    getVersusClanRanks(locationId, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/locations/${locationId}/rankings/clans-versus?${query}`, options);
+    }
+    /** Get player versus rankings for a specific location. */
+    getVersusPlayerRanks(locationId, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/locations/${locationId}/rankings/players-versus?${query}`, options);
+    }
+    /** Get list of clan labels. */
+    getClanLabels(options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/labels/clans?${query}`, options);
+    }
+    /** Get list of player labels. */
+    getPlayerLabels(options) {
+        const query = Util_1.Util.queryString(options);
+        return this.handler.request(`/labels/players?${query}`, options);
+    }
+    /** Get info about gold pass season. */
+    getGoldPassSeason(options) {
+        return this.handler.request('/goldpass/seasons/current', options);
+    }
+}
+exports.RESTManager = RESTManager;