clashofclans.js 2.7.0 → 2.8.0-dev.41c401c

package/CHANGELOG.md

@@ -2,11 +2,19 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## 2.8.0 (2022-07-22)
+
+### Features
+
+-   Better Throttler with JS generator function. ([#111](https://github.com/clashperk/clashofclans.js/pull/111))
+-   Updated raw data from game files. ([#111](https://github.com/clashperk/clashofclans.js/pull/111))
+-   New method Util#parseArmyLink has been added. ([#110](https://github.com/clashperk/clashofclans.js/pull/110))
+
 ## 2.7.0 (2022-05-22)
 
 ### Features
 
-- Some useful QOL methods have been added. ([#106](https://github.com/clashperk/clashofclans.js/pull/106))
+-   Some useful QOL methods have been added. ([#106](https://github.com/clashperk/clashofclans.js/pull/106))
 
 ## 2.6.1 (2022-02-03)
 

package/dist/client/Client.d.ts

@@ -1,8 +1,7 @@
 /// <reference types="node" />
 import { ClanSearchOptions, SearchOptions, ClientOptions, LoginOptions, OverrideOptions } from '../types';
-import { EVENTS, CWL_ROUNDS } from '../util/Constants';
+import { CWLRounds } from '../util/Constants';
 import { RESTManager } from '../rest/RESTManager';
-import { EventManager } from './EventManager';
 import { EventEmitter } from 'events';
 import { Util } from '../util/Util';
 import { Clan, ClanMember, ClanWar, ClanWarLog, League, Location, Player, WarLeague, RankedClan, RankedPlayer, Label, SeasonRankedPlayer, GoldPassSeason, ClanWarLeagueGroup } from '../struct';
@@ -14,15 +13,11 @@ import { Clan, ClanMember, ClanWar, ClanWarLog, League, Location, Player, WarLea
  * ```
  */
 export declare class Client extends EventEmitter {
-    /** Event Manager for the client. */
-    readonly events: EventManager;
     /** REST Handler of the client. */
-    readonly rest: RESTManager;
+    rest: RESTManager;
     constructor(options?: ClientOptions);
     /** Contains various general-purpose utility methods. */
     get util(): typeof Util;
-    /** Whether the API is in maintenance break. */
-    get inMaintenance(): boolean;
     /**
      * Initialize the client to create keys.
      * @example
@@ -57,7 +52,7 @@ export declare class Client extends EventEmitter {
      */
     getCurrentWar(clanTag: string | {
         clanTag: string;
-        round?: keyof typeof CWL_ROUNDS;
+        round?: keyof typeof CWLRounds;
     }, options?: OverrideOptions): Promise<ClanWar | null>;
     /**
      * Get info about currently running CWL round.
@@ -72,10 +67,12 @@ export declare class Client extends EventEmitter {
      */
     getLeagueWar(clanTag: string | {
         clanTag: string;
-        round?: keyof typeof CWL_ROUNDS;
+        round?: keyof typeof CWLRounds;
     }, options?: OverrideOptions): Promise<ClanWar | null>;
-    private _getCurrentLeagueWars;
-    private _getClanWars;
+    /** Returns active wars (last 2) of the CWL group. */
+    getLeagueWars(clanTag: string, options?: OverrideOptions): Promise<ClanWar[]>;
+    /** Returns active wars (last 2 for CWL) of the clan. */
+    getWars(clanTag: string, options?: OverrideOptions): Promise<ClanWar[]>;
     /** Get info about clan war league. */
     getClanWarLeagueGroup(clanTag: string, options?: OverrideOptions): Promise<ClanWarLeagueGroup>;
     /** Get info about a CWL round by WarTag. */
@@ -129,67 +126,4 @@ export declare class Client extends EventEmitter {
     getPlayerLabels(options?: SearchOptions): Promise<Label[]>;
     /** Get info about gold pass season. */
     getGoldPassSeason(options?: OverrideOptions): Promise<GoldPassSeason>;
-    /**
-     * Emits when a new season starts.
-     *
-     * **Parameters**
-     *
-     * | Name |   Type   | Description           |
-     * | :--: | :------: | :-------------------: |
-     * | `id` | `string` | Id of the new season. |
-     * @public
-     * @event
-     */
-    private static newSeasonStart;
-    /**
-     * Emits when maintenance break starts in the API.
-     * @public
-     * @event
-     */
-    private static maintenanceStart;
-    /**
-     * Emits when maintenance break ends in the API.
-     *
-     * **Parameters**
-     *
-     * |    Name    |   Type   |                    Description                     |
-     * | :--------: | :------: | :------------------------------------------------: |
-     * | `duration` | `number` | Duration of the maintenance break in milliseconds. |
-     * @public
-     * @event
-     */
-    private static maintenanceEnd;
-    /** @internal */
-    on<K extends keyof ClientEvents>(event: K, listeners: (...args: ClientEvents[K]) => void): this;
-    /** @internal */
-    on<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: CustomEvents[S]) => void): this;
-    /** @internal */ on<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: any[]) => void): this;
-    /** @internal */
-    once<K extends keyof ClientEvents>(event: K, listeners: (...args: ClientEvents[K]) => void): this;
-    /** @internal */
-    once<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: CustomEvents[S]) => void): this;
-    /** @internal */ once<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, listeners: (...args: any[]) => void): this;
-    /** @internal */
-    emit<K extends keyof ClientEvents>(event: K, ...args: ClientEvents[K]): boolean;
-    /** @internal */
-    emit<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientEvents>, ...args: CustomEvents[S]): this;
-    /** @internal */ emit<S extends string | symbol>(event: Exclude<S, keyof ClientEvents>, ...args: any[]): boolean;
-}
-interface ClientEvents {
-    [EVENTS.NEW_SEASON_START]: [id: string];
-    [EVENTS.MAINTENANCE_START]: [];
-    [EVENTS.MAINTENANCE_END]: [duration: number];
-    [EVENTS.CLAN_LOOP_START]: [];
-    [EVENTS.CLAN_LOOP_END]: [];
-    [EVENTS.PLAYER_LOOP_START]: [];
-    [EVENTS.PLAYER_LOOP_END]: [];
-    [EVENTS.WAR_LOOP_START]: [];
-    [EVENTS.WAR_LOOP_END]: [];
-    [EVENTS.ERROR]: [error: unknown];
-}
-interface CustomEvents {
-    [key: `clan${string}`]: [oldClan: Clan, newClan: Clan];
-    [key: `war${string}`]: [oldWar: ClanWar, newWar: ClanWar];
-    [key: `player${string}`]: [oldPlayer: Player, newPlayer: Player];
 }
-export {};

package/dist/client/Client.js

@@ -4,7 +4,6 @@ exports.Client = void 0;
 const Constants_1 = require("../util/Constants");
 const HTTPError_1 = require("../rest/HTTPError");
 const RESTManager_1 = require("../rest/RESTManager");
-const EventManager_1 = require("./EventManager");
 const events_1 = require("events");
 const Util_1 = require("../util/Util");
 const struct_1 = require("../struct");
@@ -19,17 +18,11 @@ class Client extends events_1.EventEmitter {
     constructor(options) {
         super();
         this.rest = new RESTManager_1.RESTManager({ ...options, rejectIfNotValid: true });
-        this.events = new EventManager_1.EventManager(this);
     }
     /** Contains various general-purpose utility methods. */
     get util() {
         return Util_1.Util;
     }
-    /** Whether the API is in maintenance break. */
-    get inMaintenance() {
-        // @ts-expect-error
-        return this.events._inMaintenance;
-    }
     /**
      * Initialize the client to create keys.
      * @example
@@ -116,7 +109,7 @@ class Client extends events_1.EventEmitter {
      */
     async getLeagueWar(clanTag, options) {
         const args = typeof clanTag === 'string' ? { clanTag } : { clanTag: clanTag.clanTag, round: clanTag.round };
-        const state = (args.round && Constants_1.CWL_ROUNDS[args.round]) ?? 'inWar'; // eslint-disable-line
+        const state = (args.round && Constants_1.CWLRounds[args.round]) ?? 'inWar'; // eslint-disable-line
         const data = await this.getClanWarLeagueGroup(args.clanTag, options);
         const rounds = data.rounds.filter((round) => !round.warTags.includes('#0'));
         if (!rounds.length)
@@ -128,23 +121,26 @@ class Client extends events_1.EventEmitter {
             .flat()
             .reverse();
         const wars = await this.util.allSettled(warTags.map((warTag) => this.getClanWarLeagueRound({ warTag, clanTag: args.clanTag }, { ...options, ignoreRateLimit: true })));
-        if (args.round && args.round in Constants_1.CWL_ROUNDS) {
-            return wars.find((war) => war.state === state) ?? null;
+        if (args.round && args.round in Constants_1.CWLRounds) {
+            return wars.find((war) => war.clan.tag === args.clanTag && war.state === state) ?? null;
         }
-        return wars.find((war) => war.state === state) ?? wars.at(0) ?? null;
+        return (wars.find((war) => war.clan.tag === args.clanTag && war.state === state) ??
+            wars.find((war) => war.clan.tag === args.clanTag) ??
+            null);
     }
-    async _getCurrentLeagueWars(clanTag, options) {
+    /** Returns active wars (last 2) of the CWL group. */
+    async getLeagueWars(clanTag, options) {
         const data = await this.getClanWarLeagueGroup(clanTag, options);
-        // @ts-expect-error
-        return data._getCurrentWars(clanTag, options);
+        return data.getCurrentWars(clanTag, options);
     }
-    async _getClanWars(clanTag, options) {
+    /** Returns active wars (last 2 for CWL) of the clan. */
+    async getWars(clanTag, options) {
         const date = new Date().getUTCDate();
         if (!(date >= 1 && date <= 10)) {
             return [await this.getClanWar(clanTag, options)];
         }
         try {
-            return this._getCurrentLeagueWars(clanTag, options);
+            return this.getLeagueWars(clanTag, options);
         }
         catch (e) {
             if (e instanceof HTTPError_1.HTTPError && [404].includes(e.status)) {
@@ -193,12 +189,12 @@ class Client extends events_1.EventEmitter {
     }
     /** Get Legend League season Ids. */
     async getLeagueSeasons(options) {
-        const { data } = await this.rest.getLeagueSeasons(Constants_1.LEGEND_LEAGUE_ID, options);
+        const { data } = await this.rest.getLeagueSeasons(Constants_1.LegendLeagueId, options);
         return data.items.map((league) => league.id);
     }
     /** Get Legend League season rankings by season Id. */
     async getSeasonRankings(seasonId, options) {
-        const { data } = await this.rest.getSeasonRankings(Constants_1.LEGEND_LEAGUE_ID, seasonId, options);
+        const { data } = await this.rest.getSeasonRankings(Constants_1.LegendLeagueId, seasonId, options);
         return data.items.map((entry) => new struct_1.SeasonRankedPlayer(this, entry));
     }
     /** Get list of Clan War Leagues. */

package/dist/client/EventManager.d.ts

@@ -1,42 +1,42 @@
 import { Clan, ClanWar, Player } from '../struct';
-import { Client } from './Client';
-/** Represents Event Manager of the {@link Client}. */
-export declare class EventManager {
-    private readonly client;
+import { PollingClient } from './PollingClient';
+/** Represents PollingEvent Manager of the {@link PollingClient}. */
+export declare class PollingEventManager {
+    private readonly pollingClient;
     private readonly _clanTags;
     private readonly _playerTags;
     private readonly _warTags;
     private readonly _clans;
     private readonly _players;
     private readonly _wars;
-    private readonly _events;
+    private readonly _pollingEvents;
     private _inMaintenance;
     private _maintenanceStartTime;
-    constructor(client: Client);
-    /** Initialize the Event Manager to start pulling. */
+    constructor(pollingClient: PollingClient);
+    /** Initialize the PollingEvent Manager to start pulling the data by polling api. */
     init(): Promise<string[]>;
-    /** Add clan tags to clan events. */
+    /** Add clan tags to clan polling events. */
     addClans(tags: string[] | string): this;
-    /** Delete clan tags from clan events. */
+    /** Delete clan tags from clan polling events. */
     deleteClans(tags: string[] | string): this;
-    /** Add player tags for player events. */
+    /** Add player tags for player polling events. */
     addPlayers(tags: string[] | string): this;
-    /** Delete player tags from player events. */
+    /** Delete player tags from player polling events. */
     deletePlayers(tags: string[] | string): this;
-    /** Add clan tags for war events. */
+    /** Add clan tags for war polling events. */
     addWars(tags: string[] | string): this;
-    /** Delete clan tags from war events. */
+    /** Delete clan tags from war polling events. */
     deleteWars(tags: string[] | string): this;
     /**
-     * Set your own custom clan event.
+     * Set your own custom clan polling event.
      *
-     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     * In order to emit the custom polling event, you must have this filter function that returns a boolean.
      *
      * @example
      * ```js
-     * client.events.addClans(['#2PP', '#8QU8J9LP']);
+     * client.pollingEvents.addClans(['#2PP', '#8QU8J9LP']);
      *
-     * client.events.setClanEvent({
+     * client.pollingEvents.setClanEvent({
      *   name: 'clanMemberUpdate',
      *   filter: (oldClan, newClan) => {
      *     return oldClan.memberCount !== newClan.memberCount;
@@ -48,7 +48,7 @@ export declare class EventManager {
      * });
      *
      * (async function () {
-     *   await client.events.init();
+     *   await client.pollingEvents.init();
      * })();
      * ```
      * @returns

package/dist/client/EventManager.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventManager = void 0;
+exports.PollingEventManager = 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;
+/** Represents PollingEvent Manager of the {@link PollingClient}. */
+class PollingEventManager {
+    constructor(pollingClient) {
+        this.pollingClient = pollingClient;
         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 = {
+        this._pollingEvents = {
             clans: [],
             wars: [],
             players: []
@@ -22,58 +22,58 @@ class EventManager {
         this._inMaintenance = Boolean(false);
         this._maintenanceStartTime = null;
     }
-    /** Initialize the Event Manager to start pulling. */
+    /** 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.client.eventNames());
+        return Promise.resolve(this.pollingClient.eventNames());
     }
-    /** Add clan tags to clan events. */
+    /** Add clan tags to clan polling events. */
     addClans(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            this._clanTags.add(this.client.util.formatTag(tag));
+            this._clanTags.add(this.pollingClient.util.formatTag(tag));
         }
         return this;
     }
-    /** Delete clan tags from clan events. */
+    /** Delete clan tags from clan polling events. */
     deleteClans(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            const key = this.client.util.formatTag(tag);
+            const key = this.pollingClient.util.formatTag(tag);
             this._clans.delete(key);
             this._clanTags.delete(key);
         }
         return this;
     }
-    /** Add player tags for player events. */
+    /** Add player tags for player polling events. */
     addPlayers(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            this._playerTags.add(this.client.util.formatTag(tag));
+            this._playerTags.add(this.pollingClient.util.formatTag(tag));
         }
         return this;
     }
-    /** Delete player tags from player events. */
+    /** Delete player tags from player polling events. */
     deletePlayers(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            const key = this.client.util.formatTag(tag);
+            const key = this.pollingClient.util.formatTag(tag);
             this._players.delete(key);
             this._playerTags.delete(key);
         }
         return this;
     }
-    /** Add clan tags for war events. */
+    /** Add clan tags for war polling events. */
     addWars(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            this._warTags.add(this.client.util.formatTag(tag));
+            this._warTags.add(this.pollingClient.util.formatTag(tag));
         }
         return this;
     }
-    /** Delete clan tags from war events. */
+    /** Delete clan tags from war polling events. */
     deleteWars(tags) {
         for (const tag of Array.isArray(tags) ? tags : [tags]) {
-            const key = this.client.util.formatTag(tag);
+            const key = this.pollingClient.util.formatTag(tag);
             this._wars.delete(`${key}:${1}`);
             this._wars.delete(`${key}:${2}`);
             this._warTags.delete(key);
@@ -81,15 +81,15 @@ class EventManager {
         return this;
     }
     /**
-     * Set your own custom clan event.
+     * Set your own custom clan polling event.
      *
-     * In order to emit the custom event, you must have this filter function that returns a boolean.
+     * In order to emit the custom polling event, you must have this filter function that returns a boolean.
      *
      * @example
      * ```js
-     * client.events.addClans(['#2PP', '#8QU8J9LP']);
+     * client.pollingEvents.addClans(['#2PP', '#8QU8J9LP']);
      *
-     * client.events.setClanEvent({
+     * client.pollingEvents.setClanEvent({
      *   name: 'clanMemberUpdate',
      *   filter: (oldClan, newClan) => {
      *     return oldClan.memberCount !== newClan.memberCount;
@@ -101,7 +101,7 @@ class EventManager {
      * });
      *
      * (async function () {
-     *   await client.events.init();
+     *   await client.pollingEvents.init();
      * })();
      * ```
      * @returns
@@ -111,7 +111,7 @@ class EventManager {
             throw new Error('Event name is required.');
         if (typeof event.filter !== 'function')
             throw new Error('Filter function is required.');
-        this._events.clans.push(event);
+        this._pollingEvents.clans.push(event);
         return this;
     }
     /**
@@ -124,7 +124,7 @@ class EventManager {
             throw new Error('Event name is required.');
         if (typeof event.filter !== 'function')
             throw new Error('Filter function is required.');
-        this._events.wars.push(event);
+        this._pollingEvents.wars.push(event);
         return this;
     }
     /**
@@ -137,25 +137,25 @@ class EventManager {
             throw new Error('Event name is required.');
         if (typeof event.filter !== 'function')
             throw new Error('Filter function is required.');
-        this._events.players.push(event);
+        this._pollingEvents.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 });
+            const res = await this.pollingClient.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);
+                this.pollingClient.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.client.emit(Constants_1.EVENTS.MAINTENANCE_START);
+                this.pollingClient.emit(Constants_1.PollingEvents.MaintenanceStart);
             }
         }
     }
@@ -167,48 +167,48 @@ class EventManager {
         }
         else if (end > 0) {
             setTimeout(() => {
-                this.client.emit(Constants_1.EVENTS.NEW_SEASON_START, Util_1.Util.getSeasonId());
+                this.pollingClient.emit(Constants_1.PollingEvents.NewSeasonStart, Util_1.Util.getSeasonId());
             }, end + 100).unref();
         }
     }
     async clanUpdateHandler() {
-        this.client.emit(Constants_1.EVENTS.CLAN_LOOP_START);
+        this.pollingClient.emit(Constants_1.PollingEvents.ClanLoopStart);
         for (const tag of this._clanTags)
             await this.runClanUpdate(tag);
-        this.client.emit(Constants_1.EVENTS.CLAN_LOOP_END);
+        this.pollingClient.emit(Constants_1.PollingEvents.ClanLoopEnd);
         setTimeout(this.clanUpdateHandler.bind(this), 10000);
     }
     async playerUpdateHandler() {
-        this.client.emit(Constants_1.EVENTS.PLAYER_LOOP_START);
+        this.pollingClient.emit(Constants_1.PollingEvents.PlayerLoopStart);
         for (const tag of this._playerTags)
             await this.runPlayerUpdate(tag);
-        this.client.emit(Constants_1.EVENTS.PLAYER_LOOP_END);
+        this.pollingClient.emit(Constants_1.PollingEvents.PlayerLoopEnd);
         setTimeout(this.playerUpdateHandler.bind(this), 10000);
     }
     async warUpdateHandler() {
-        this.client.emit(Constants_1.EVENTS.WAR_LOOP_START);
+        this.pollingClient.emit(Constants_1.PollingEvents.WarLoopStart);
         for (const tag of this._warTags)
             await this.runWarUpdate(tag);
-        this.client.emit(Constants_1.EVENTS.WAR_LOOP_END);
+        this.pollingClient.emit(Constants_1.PollingEvents.WarLoopEnd);
         setTimeout(this.warUpdateHandler.bind(this), 10000);
     }
     async runClanUpdate(tag) {
         if (this._inMaintenance)
             return null;
-        const clan = await this.client.getClan(tag).catch(() => null);
+        const clan = await this.pollingClient.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) {
+        for (const { name, filter } of this._pollingEvents.clans) {
             try {
                 if (!(await filter(cached, clan)))
                     continue;
-                this.client.emit(name, cached, clan);
+                this.pollingClient.emit(name, cached, clan);
             }
             catch (error) {
-                this.client.emit(Constants_1.EVENTS.ERROR, error);
+                this.pollingClient.emit(Constants_1.PollingEvents.Error, error);
             }
         }
         return this._clans.set(clan.tag, clan);
@@ -216,20 +216,20 @@ class EventManager {
     async runPlayerUpdate(tag) {
         if (this._inMaintenance)
             return null;
-        const player = await this.client.getPlayer(tag).catch(() => null);
+        const player = await this.pollingClient.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) {
+        for (const { name, filter } of this._pollingEvents.players) {
             try {
                 if (!(await filter(cached, player)))
                     continue;
-                this.client.emit(name, cached, player);
+                this.pollingClient.emit(name, cached, player);
             }
             catch (error) {
-                this.client.emit(Constants_1.EVENTS.ERROR, error);
+                this.pollingClient.emit(Constants_1.PollingEvents.Error, error);
             }
         }
         return this._players.set(player.tag, player);
@@ -237,8 +237,7 @@ class EventManager {
     async runWarUpdate(tag) {
         if (this._inMaintenance)
             return null;
-        // @ts-expect-error
-        const clanWars = await this.client._getClanWars(tag).catch(() => null);
+        const clanWars = await this.pollingClient.getWars(tag).catch(() => null);
         if (!clanWars?.length)
             return null;
         clanWars.forEach(async (war, index) => {
@@ -246,28 +245,28 @@ class EventManager {
             const cached = this._wars.get(key);
             if (!cached)
                 return this._wars.set(key, war);
-            for (const { name, filter } of this._events.wars) {
+            for (const { name, filter } of this._pollingEvents.wars) {
                 try {
                     if (!(await filter(cached, war)))
                         continue;
-                    this.client.emit(name, cached, war);
+                    this.pollingClient.emit(name, cached, war);
                 }
                 catch (error) {
-                    this.client.emit(Constants_1.EVENTS.ERROR, error);
+                    this.pollingClient.emit(Constants_1.PollingEvents.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);
+                const data = await this.pollingClient.getLeagueWar({ clanTag: tag, round: 'PreviousRound' }).catch(() => null);
                 if (data && data.warTag === cached.warTag) {
-                    for (const { name, filter } of this._events.wars) {
+                    for (const { name, filter } of this._pollingEvents.wars) {
                         try {
                             if (!(await filter(cached, data)))
                                 continue;
-                            this.client.emit(name, cached, data);
+                            this.pollingClient.emit(name, cached, data);
                         }
                         catch (error) {
-                            this.client.emit(Constants_1.EVENTS.ERROR, error);
+                            this.pollingClient.emit(Constants_1.PollingEvents.Error, error);
                         }
                     }
                 }
@@ -276,4 +275,4 @@ class EventManager {
         });
     }
 }
-exports.EventManager = EventManager;
+exports.PollingEventManager = PollingEventManager;