clashofclans.js 3.0.0-dev.392ca4c → 3.0.0-dev.70cb1c7

package/dist/client/PollingClient.js

@@ -1,25 +1,286 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PollingClient = void 0;
+const HTTPError_1 = require("../rest/HTTPError");
 const Constants_1 = require("../util/Constants");
 const Client_1 = require("./Client");
-const EventManager_1 = require("./EventManager");
 /**
- * Represents Clash of Clans Polling Event Client.
+ * Represents a Polling Event Client.
  * ```js
  * const { PollingClient } = require('clashofclans.js');
- * const client = new PollingClient({ keys: ['***'] });
+ * const pollingClient = new PollingClient({ keys: ['***'] });
  * ```
  */
 class PollingClient extends Client_1.Client {
     constructor(options) {
         super(options);
-        this.pollingEvents = new EventManager_1.PollingEventManager(this);
+        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._pollingEvents = {
+            clans: [],
+            wars: [],
+            players: []
+        };
+        this.inMaintenance = Boolean(false);
+        this._maintenanceStartTime = null;
     }
-    /** Whether the API is in maintenance break. */
-    get inMaintenance() {
-        // @ts-expect-error
-        return this.events._inMaintenance;
+    /** Initialize the PollingEvent Manager to start pulling the data by polling api. */
+    async init() {
+        this.seasonEndHandler();
+        this.maintenanceHandler();
+        this.clanUpdateHandler();
+        this.playerUpdateHandler();
+        this.warUpdateHandler();
+        return Promise.resolve(this.eventNames());
+    }
+    /** Add clan tags to clan polling events. */
+    addClans(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            this._clanTags.add(this.util.formatTag(tag));
+        }
+        return this;
+    }
+    /** Delete clan tags from clan polling events. */
+    deleteClans(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            const key = this.util.formatTag(tag);
+            this._clans.delete(key);
+            this._clanTags.delete(key);
+        }
+        return this;
+    }
+    /** Add player tags for player polling events. */
+    addPlayers(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            this._playerTags.add(this.util.formatTag(tag));
+        }
+        return this;
+    }
+    /** Delete player tags from player polling events. */
+    deletePlayers(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            const key = this.util.formatTag(tag);
+            this._players.delete(key);
+            this._playerTags.delete(key);
+        }
+        return this;
+    }
+    /** Add clan tags for war polling events. */
+    addWars(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            this._warTags.add(this.util.formatTag(tag));
+        }
+        return this;
+    }
+    /** Delete clan tags from war polling events. */
+    deleteWars(tags) {
+        for (const tag of Array.isArray(tags) ? tags : [tags]) {
+            const key = this.util.formatTag(tag);
+            this._wars.delete(`${key}:${1}`);
+            this._wars.delete(`${key}:${2}`);
+            this._warTags.delete(key);
+        }
+        return this;
+    }
+    /**
+     * Set your own custom clan polling event.
+     *
+     * In order to emit the custom polling event, you must have this filter function that returns a boolean.
+     *
+     * @example
+     * ```js
+     * client.addClans(['#2PP', '#8QU8J9LP']);
+     *
+     * client.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.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._pollingEvents.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._pollingEvents.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._pollingEvents.players.push(event);
+        return this;
+    }
+    async maintenanceHandler() {
+        setTimeout(this.maintenanceHandler.bind(this), 10000).unref();
+        if (!(this.listenerCount(Constants_1.PollingEvents.MaintenanceStart) && this.listenerCount(Constants_1.PollingEvents.MaintenanceEnd)))
+            return;
+        try {
+            const res = await this.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.emit(Constants_1.PollingEvents.MaintenanceEnd, duration);
+            }
+        }
+        catch (error) {
+            if (error instanceof HTTPError_1.HTTPError && error.status === 503 && !this.inMaintenance) {
+                this.inMaintenance = Boolean(true);
+                this._maintenanceStartTime = new Date();
+                this.emit(Constants_1.PollingEvents.MaintenanceStart);
+            }
+        }
+    }
+    seasonEndHandler() {
+        const end = this.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);
+        }
+        else if (end > 0) {
+            setTimeout(() => {
+                this.emit(Constants_1.PollingEvents.NewSeasonStart, this.util.getSeasonId());
+            }, end + 100).unref();
+        }
+    }
+    async clanUpdateHandler() {
+        this.emit(Constants_1.PollingEvents.ClanLoopStart);
+        for (const tag of this._clanTags)
+            await this.runClanUpdate(tag);
+        this.emit(Constants_1.PollingEvents.ClanLoopEnd);
+        setTimeout(this.clanUpdateHandler.bind(this), 10000);
+    }
+    async playerUpdateHandler() {
+        this.emit(Constants_1.PollingEvents.PlayerLoopStart);
+        for (const tag of this._playerTags)
+            await this.runPlayerUpdate(tag);
+        this.emit(Constants_1.PollingEvents.PlayerLoopEnd);
+        setTimeout(this.playerUpdateHandler.bind(this), 10000);
+    }
+    async warUpdateHandler() {
+        this.emit(Constants_1.PollingEvents.WarLoopStart);
+        for (const tag of this._warTags)
+            await this.runWarUpdate(tag);
+        this.emit(Constants_1.PollingEvents.WarLoopEnd);
+        setTimeout(this.warUpdateHandler.bind(this), 10000);
+    }
+    async runClanUpdate(tag) {
+        if (this.inMaintenance)
+            return null;
+        const clan = await this.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._pollingEvents.clans) {
+            try {
+                if (!(await filter(cached, clan)))
+                    continue;
+                this.emit(name, cached, clan);
+            }
+            catch (error) {
+                this.emit(Constants_1.PollingEvents.Error, error);
+            }
+        }
+        return this._clans.set(clan.tag, clan);
+    }
+    async runPlayerUpdate(tag) {
+        if (this.inMaintenance)
+            return null;
+        const player = await this.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._pollingEvents.players) {
+            try {
+                if (!(await filter(cached, player)))
+                    continue;
+                this.emit(name, cached, player);
+            }
+            catch (error) {
+                this.emit(Constants_1.PollingEvents.Error, error);
+            }
+        }
+        return this._players.set(player.tag, player);
+    }
+    async runWarUpdate(tag) {
+        if (this.inMaintenance)
+            return null;
+        const clanWars = await this.getWars(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._pollingEvents.wars) {
+                try {
+                    if (!(await filter(cached, war)))
+                        continue;
+                    this.emit(name, cached, war);
+                }
+                catch (error) {
+                    this.emit(Constants_1.PollingEvents.Error, error);
+                }
+            }
+            // check for war end
+            if (index === 1 && cached.warTag !== war.warTag) {
+                const data = await this.getLeagueWar({ clanTag: tag, round: 'PreviousRound' }).catch(() => null);
+                if (data && data.warTag === cached.warTag) {
+                    for (const { name, filter } of this._pollingEvents.wars) {
+                        try {
+                            if (!(await filter(cached, data)))
+                                continue;
+                            this.emit(name, cached, data);
+                        }
+                        catch (error) {
+                            this.emit(Constants_1.PollingEvents.Error, error);
+                        }
+                    }
+                }
+            }
+            return this._wars.set(key, war);
+        });
     }
 }
 exports.PollingClient = PollingClient;

package/dist/index.d.ts

@@ -3,7 +3,6 @@ export * from './client/PollingClient';
 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';

package/dist/index.js

@@ -1,7 +1,11 @@
 "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]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -15,7 +19,6 @@ __exportStar(require("./client/PollingClient"), 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);

package/dist/index.mjs

@@ -8,8 +8,11 @@ export const BatchThrottler = mod.BatchThrottler;
 export const BuilderTroops = mod.BuilderTroops;
 export const CWLRounds = mod.CWLRounds;
 export const CacheStore = mod.CacheStore;
+export const CapitalRaidSeason = mod.CapitalRaidSeason;
+export const CapitalRaidSeasonMember = mod.CapitalRaidSeasonMember;
 export const ChatLanguage = mod.ChatLanguage;
 export const Clan = mod.Clan;
+export const ClanCapital = mod.ClanCapital;
 export const ClanMember = mod.ClanMember;
 export const ClanWar = mod.ClanWar;
 export const ClanWarAttack = mod.ClanWarAttack;
@@ -20,6 +23,7 @@ export const ClanWarLeagueRound = mod.ClanWarLeagueRound;
 export const ClanWarLog = mod.ClanWarLog;
 export const ClanWarMember = mod.ClanWarMember;
 export const Client = mod.Client;
+export const ClientEvents = mod.ClientEvents;
 export const DarkElixirSpells = mod.DarkElixirSpells;
 export const DarkElixirTroops = mod.DarkElixirTroops;
 export const DevSiteAPIBaseURL = mod.DevSiteAPIBaseURL;
@@ -39,11 +43,9 @@ export const Leagues = mod.Leagues;
 export const LegendLeagueId = mod.LegendLeagueId;
 export const LegendStatistics = mod.LegendStatistics;
 export const Location = mod.Location;
-export const NotInWarError = mod.NotInWarError;
 export const Player = mod.Player;
 export const PlayerClan = mod.PlayerClan;
 export const PollingClient = mod.PollingClient;
-export const PollingEventManager = mod.PollingEventManager;
 export const PollingEvents = mod.PollingEvents;
 export const PrivateWarLogError = mod.PrivateWarLogError;
 export const QueueThrottler = mod.QueueThrottler;
@@ -52,6 +54,7 @@ export const RankedClan = mod.RankedClan;
 export const RankedPlayer = mod.RankedPlayer;
 export const RawData = mod.RawData;
 export const RequestHandler = mod.RequestHandler;
+export const RestEvents = mod.RestEvents;
 export const Season = mod.Season;
 export const SeasonRankedPlayer = mod.SeasonRankedPlayer;
 export const SiegeMachines = mod.SiegeMachines;

package/dist/rest/HTTPError.d.ts

@@ -19,10 +19,6 @@ export declare class HTTPError extends Error {
     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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PrivateWarLogError = exports.NotInWarError = exports.HTTPError = void 0;
+exports.PrivateWarLogError = exports.HTTPError = void 0;
 const messages = {
     500: 'Unknown error happened when handling the request.',
     504: 'The user aborted this request.',
@@ -32,10 +32,6 @@ class HTTPError extends Error {
     }
 }
 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

@@ -1,10 +1,43 @@
-import { RequestHandler } from './RequestHandler';
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
 import { Util } from '../util/Util';
-import { APIClan, APIClanList, APIClanMemberList, APIClanRankingList, APIClanVersusRankingList, APIClanWar, APIClanWarLeagueGroup, APIClanWarLog, APIGoldPassSeason, APILabelList, APILeague, APILeagueList, APILeagueSeasonList, APILocation, APILocationList, APIPlayer, APIPlayerRankingList, APIPlayerSeasonRankingList, APIPlayerVersusRankingList, APIVerifyToken, APIWarLeague, APIWarLeagueList, SearchOptions, ClanSearchOptions, RESTOptions, OverrideOptions, LoginOptions } from '../types';
+import { APIClan, APIClanList, APIClanMemberList, APICapitalRaidSeasons, APIClanRankingList, APIClanVersusRankingList, APIClanWar, APIClanWarLeagueGroup, APIClanWarLog, APIGoldPassSeason, APILabelList, APILeague, APILeagueList, APILeagueSeasonList, APILocation, APILocationList, APIPlayer, APIPlayerRankingList, APIPlayerSeasonRankingList, APIPlayerVersusRankingList, APIVerifyToken, APIWarLeague, APIWarLeagueList, SearchOptions, ClanSearchOptions, RESTOptions, OverrideOptions, LoginOptions } from '../types';
+import { RestEvents } from '../util/Constants';
+import { RequestHandler } from './RequestHandler';
+export interface IRestEvents {
+    [RestEvents.Error]: [error: unknown];
+    [RestEvents.Debug]: [path: string, status: number, message: string];
+    [RestEvents.RateLimited]: [path: string, status: number, message: string];
+}
+export interface RESTManager {
+    emit: (<K extends keyof IRestEvents>(event: K, ...args: IRestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    on: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof IRestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof IRestEvents>) => this);
+    /**
+     * Emitted for general debugging information.
+     * @public
+     * @event
+     */
+    debug: string;
+    /**
+     * Emitted when the client encounters an error.
+     * @public
+     * @event
+     */
+    error: string;
+    /**
+     * Emitted when the client is rate limited.
+     * @public
+     * @event
+     */
+    rateLimited: string;
+}
 /** Represents a REST Manager of the client. */
-export declare class RESTManager {
+export declare class RESTManager extends EventEmitter {
     /** Request Handler for the RESTManager. */
-    handler: RequestHandler;
+    requestHandler: RequestHandler;
     constructor(options?: RESTOptions);
     /** Contains various general-purpose utility methods. */
     get util(): typeof Util;
@@ -33,6 +66,8 @@ export declare class RESTManager {
     getClanWarLeagueGroup(clanTag: string, options?: OverrideOptions): Promise<import("../types").Response<APIClanWarLeagueGroup>>;
     /** Get info about a CWL round by WarTag. */
     getClanWarLeagueRound(warTag: string, options?: OverrideOptions): Promise<import("../types").Response<APIClanWar>>;
+    /** Retrieve clan's capital raid seasons. */
+    getCapitalRaidSeasons(tag: string, options?: OverrideOptions): Promise<import("../types").Response<APICapitalRaidSeasons>>;
     /** Get info about a player by tag. */
     getPlayer(playerTag: string, options?: OverrideOptions): Promise<import("../types").Response<APIPlayer>>;
     /** Verify Player API token that can be found from the Game settings. */

package/dist/rest/RESTManager.js

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RESTManager = void 0;
-const RequestHandler_1 = require("./RequestHandler");
+const node_events_1 = require("node:events");
 const Util_1 = require("../util/Util");
+const Constants_1 = require("../util/Constants");
+const RequestHandler_1 = require("./RequestHandler");
 /** Represents a REST Manager of the client. */
-class RESTManager {
+class RESTManager extends node_events_1.EventEmitter {
     constructor(options) {
-        this.handler = new RequestHandler_1.RequestHandler(options);
+        super();
+        this.requestHandler = new RequestHandler_1.RequestHandler(options)
+            .on(Constants_1.RestEvents.Debug, this.emit.bind(this, Constants_1.RestEvents.Debug))
+            .on(Constants_1.RestEvents.Error, this.emit.bind(this, Constants_1.RestEvents.Error))
+            .on(Constants_1.RestEvents.RateLimited, this.emit.bind(this, Constants_1.RestEvents.RateLimited));
     }
     /** Contains various general-purpose utility methods. */
     get util() {
@@ -21,122 +27,127 @@ class RESTManager {
      * ```
      */
     login(options) {
-        return this.handler.init(options);
+        return this.requestHandler.init(options);
     }
     /** Set Clash of Clans API keys. */
     setKeys(keys) {
-        this.handler.setKeys(keys);
+        this.requestHandler.setKeys(keys);
         return this;
     }
     /** Search all clans by name and/or filtering the results using various criteria. */
     getClans(query, options) {
-        return this.handler.request(`/clans${Util_1.Util.queryString(query)}`, options);
+        return this.requestHandler.request(`/clans${Util_1.Util.queryString(query)}`, options);
     }
     /** Get info about a clan. */
     getClan(clanTag, options) {
-        return this.handler.request(`/clans/${Util_1.Util.encodeURI(clanTag)}`, options);
+        return this.requestHandler.request(`/clans/${Util_1.Util.encodeURI(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.encodeURI(clanTag)}/members${query}`, options);
+        return this.requestHandler.request(`/clans/${Util_1.Util.encodeURI(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.encodeURI(clanTag)}/warlog${query}`, options);
+        return this.requestHandler.request(`/clans/${Util_1.Util.encodeURI(clanTag)}/warlog${query}`, options);
     }
     /** Get info about currently running war in the clan. */
     getCurrentWar(clanTag, options) {
-        return this.handler.request(`/clans/${Util_1.Util.encodeURI(clanTag)}/currentwar`, options);
+        return this.requestHandler.request(`/clans/${Util_1.Util.encodeURI(clanTag)}/currentwar`, options);
     }
     /** Get info about clan war league. */
     getClanWarLeagueGroup(clanTag, options) {
-        return this.handler.request(`/clans/${Util_1.Util.encodeURI(clanTag)}/currentwar/leaguegroup`, options);
+        return this.requestHandler.request(`/clans/${Util_1.Util.encodeURI(clanTag)}/currentwar/leaguegroup`, options);
     }
     /** Get info about a CWL round by WarTag. */
     getClanWarLeagueRound(warTag, options) {
-        return this.handler.request(`/clanwarleagues/wars/${Util_1.Util.encodeURI(warTag)}`, options);
+        return this.requestHandler.request(`/clanwarleagues/wars/${Util_1.Util.encodeURI(warTag)}`, options);
+    }
+    /** Retrieve clan's capital raid seasons. */
+    getCapitalRaidSeasons(tag, options) {
+        const query = Util_1.Util.queryString(options);
+        return this.requestHandler.request(`/clans/${Util_1.Util.encodeURI(tag)}/capitalraidseasons${query}`, options);
     }
     /** Get info about a player by tag. */
     getPlayer(playerTag, options) {
-        return this.handler.request(`/players/${Util_1.Util.encodeURI(playerTag)}`, options);
+        return this.requestHandler.request(`/players/${Util_1.Util.encodeURI(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.encodeURI(playerTag)}/verifytoken`, opts);
+        return this.requestHandler.request(`/players/${Util_1.Util.encodeURI(playerTag)}/verifytoken`, opts);
     }
     /** Get list of Leagues. */
     getLeagues(options) {
         const query = Util_1.Util.queryString(options);
-        return this.handler.request(`/leagues${query}`, options);
+        return this.requestHandler.request(`/leagues${query}`, options);
     }
     /** Get a League info. */
     getLeague(leagueId, options) {
-        return this.handler.request(`/leagues/${leagueId}`, options);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.request(`/warleagues${query}`, options);
     }
     /** Get info about a Clan War League. */
     getWarLeague(leagueId, options) {
-        return this.handler.request(`/warleagues/${leagueId}`, options);
+        return this.requestHandler.request(`/warleagues/${leagueId}`, options);
     }
     /** Get list of Locations. */
     getLocations(options) {
         const query = Util_1.Util.queryString(options);
-        return this.handler.request(`/locations${query}`, options);
+        return this.requestHandler.request(`/locations${query}`, options);
     }
     /** Get info about a Location. */
     getLocation(locationId, options) {
-        return this.handler.request(`/locations/${locationId}`, options);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.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);
+        return this.requestHandler.request(`/labels/players${query}`, options);
     }
     /** Get info about gold pass season. */
     getGoldPassSeason(options) {
-        return this.handler.request('/goldpass/seasons/current', options);
+        return this.requestHandler.request('/goldpass/seasons/current', options);
     }
 }
 exports.RESTManager = RESTManager;

package/dist/rest/RequestHandler.d.ts

@@ -1,6 +1,34 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
 import { Response, RequestOptions, LoginOptions, RequestHandlerOptions } from '../types';
-/** Represents a Request Handler. */
-export declare class RequestHandler {
+import { IRestEvents } from './RESTManager';
+export interface RequestHandler {
+    emit: (<K extends keyof IRestEvents>(event: K, ...args: IRestEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    on: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof IRestEvents>(event: K, listener: (...args: IRestEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IRestEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof IRestEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof IRestEvents>) => this);
+    /**
+     * Emitted for general debugging information.
+     * @public
+     * @event
+     */
+    debug: string;
+    /**
+     * Emitted when the client encounters an error.
+     * @public
+     * @event
+     */
+    error: string;
+    /**
+     * Emitted when the client is rate limited.
+     * @public
+     * @event
+     */
+    rateLimited: string;
+}
+/** Represents the class that manages handlers for endpoints. */
+export declare class RequestHandler extends EventEmitter {
     #private;
     private email;
     private password;