clashofclans.js 3.0.0-dev.392ca4c → 3.0.0-dev.ec60c82

package/dist/client/Client.d.ts

@@ -1,10 +1,33 @@
 /// <reference types="node" />
+import { EventEmitter } from 'node:events';
 import { ClanSearchOptions, SearchOptions, ClientOptions, LoginOptions, OverrideOptions } from '../types';
-import { CWLRounds } from '../util/Constants';
+import { CWLRounds, ClientEvents } from '../util/Constants';
 import { RESTManager } from '../rest/RESTManager';
-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';
+interface IClientEvents {
+    [ClientEvents.Error]: [error: unknown];
+    [ClientEvents.Debug]: [path: string, status: string, message: string];
+}
+export interface Client {
+    emit: (<K extends keyof IClientEvents>(event: K, ...args: IClientEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof IClientEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof IClientEvents>(event: K, listener: (...args: IClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IClientEvents>, listener: (...args: any[]) => void) => this);
+    on: (<K extends keyof IClientEvents>(event: K, listener: (...args: IClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IClientEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof IClientEvents>(event: K, listener: (...args: IClientEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IClientEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof IClientEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof IClientEvents>) => this);
+    /**
+     * Emitted for general debugging information.
+     * @public
+     * @event
+     */
+    debug: string;
+    /**
+     * Emitted when the client encounters an error.
+     * @public
+     * @event
+     */
+    error: string;
+}
 /**
  * Represents Clash of Clans API Client.
  * ```js
@@ -127,3 +150,4 @@ export declare class Client extends EventEmitter {
     /** Get info about gold pass season. */
     getGoldPassSeason(options?: OverrideOptions): Promise<GoldPassSeason>;
 }
+export {};

package/dist/client/Client.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
+const node_events_1 = require("node:events");
 const Constants_1 = require("../util/Constants");
 const HTTPError_1 = require("../rest/HTTPError");
 const RESTManager_1 = require("../rest/RESTManager");
-const events_1 = require("events");
 const Util_1 = require("../util/Util");
 const struct_1 = require("../struct");
 /**
@@ -14,10 +14,12 @@ const struct_1 = require("../struct");
  * const client = new Client({ keys: ['***'] });
  * ```
  */
-class Client extends events_1.EventEmitter {
+class Client extends node_events_1.EventEmitter {
     constructor(options) {
         super();
-        this.rest = new RESTManager_1.RESTManager({ ...options, rejectIfNotValid: true });
+        this.rest = new RESTManager_1.RESTManager({ ...options, rejectIfNotValid: true })
+            .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));
     }
     /** Contains various general-purpose utility methods. */
     get util() {
@@ -32,11 +34,11 @@ class Client extends events_1.EventEmitter {
      * ```
      */
     login(options) {
-        return this.rest.handler.init(options);
+        return this.rest.requestHandler.init(options);
     }
     /** Set Clash of Clans API keys. */
     setKeys(keys) {
-        this.rest.handler.setKeys(keys);
+        this.rest.requestHandler.setKeys(keys);
         return this;
     }
     /** Search clans by name and/or filtering parameters or get clans by their tags (fetches in parallel). */
@@ -140,7 +142,7 @@ class Client extends events_1.EventEmitter {
             return [await this.getClanWar(clanTag, options)];
         }
         try {
-            return this.getLeagueWars(clanTag, options);
+            return await this.getLeagueWars(clanTag, options);
         }
         catch (e) {
             if (e instanceof HTTPError_1.HTTPError && [404].includes(e.status)) {

package/dist/client/PollingClient.d.ts

@@ -2,7 +2,6 @@ import { Clan, ClanWar, Player } from '../struct';
 import { ClientOptions } from '../types';
 import { PollingEvents } from '../util/Constants';
 import { Client } from './Client';
-import { PollingEventManager } from './EventManager';
 /**
  * Represents Clash of Clans Polling Event Client.
  * ```js
@@ -11,11 +10,93 @@ import { PollingEventManager } from './EventManager';
  * ```
  */
 export declare class PollingClient extends Client {
-    /** Polling Event Manager for the client. */
-    pollingEvents: PollingEventManager;
+    private readonly _clanTags;
+    private readonly _playerTags;
+    private readonly _warTags;
+    private readonly _clans;
+    private readonly _players;
+    private readonly _wars;
+    private readonly _pollingEvents;
+    inMaintenance: boolean;
+    private _maintenanceStartTime;
     constructor(options?: ClientOptions);
-    /** Whether the API is in maintenance break. */
-    get inMaintenance(): any;
+    /** Initialize the PollingEvent Manager to start pulling the data by polling api. */
+    init(): Promise<string[]>;
+    /** Add clan tags to clan polling events. */
+    addClans(tags: string[] | string): this;
+    /** Delete clan tags from clan polling events. */
+    deleteClans(tags: string[] | string): this;
+    /** Add player tags for player polling events. */
+    addPlayers(tags: string[] | string): this;
+    /** Delete player tags from player polling events. */
+    deletePlayers(tags: string[] | string): this;
+    /** Add clan tags for war polling events. */
+    addWars(tags: string[] | string): this;
+    /** Delete clan tags from war polling events. */
+    deleteWars(tags: string[] | string): 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: {
+        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;
+}
+export interface PollingClient {
+    emit: (<K extends keyof IPollingEvents>(event: K, ...args: IPollingEvents[K]) => boolean) & (<S extends string | symbol>(event: Exclude<S, keyof IPollingEvents>, ...args: any[]) => boolean);
+    off: (<K extends keyof IPollingEvents>(event: K, listener: (...args: IPollingEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IPollingEvents>, listener: (...args: any[]) => void) => this);
+    on: (<K extends keyof IPollingEvents>(event: K, listener: (...args: IPollingEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IPollingEvents>, listener: (...args: any[]) => void) => this);
+    once: (<K extends keyof IPollingEvents>(event: K, listener: (...args: IPollingEvents[K]) => void) => this) & (<S extends string | symbol>(event: Exclude<S, keyof IPollingEvents>, listener: (...args: any[]) => void) => this);
+    removeAllListeners: (<K extends keyof IPollingEvents>(event?: K) => this) & (<S extends string | symbol>(event?: Exclude<S, keyof IPollingEvents>) => this);
     /**
      * Emits when a new season starts.
      *
@@ -27,13 +108,13 @@ export declare class PollingClient extends Client {
      * @public
      * @event
      */
-    private static newSeasonStart;
+    newSeasonStart: string;
     /**
      * Emits when maintenance break starts in the API.
      * @public
      * @event
      */
-    private static maintenanceStart;
+    maintenanceStart: string;
     /**
      * Emits when maintenance break ends in the API.
      *
@@ -45,39 +126,31 @@ export declare class PollingClient extends Client {
      * @public
      * @event
      */
-    private static maintenanceEnd;
-    /** @internal */
-    on<K extends keyof ClientPollingEvents>(event: K, listeners: (...args: ClientPollingEvents[K]) => void): this;
-    /** @internal */
-    on<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientPollingEvents>, listeners: (...args: CustomEvents[S]) => void): this;
-    /** @internal */ on<S extends string | symbol>(event: Exclude<S, keyof ClientPollingEvents>, listeners: (...args: any[]) => void): this;
-    /** @internal */
-    once<K extends keyof ClientPollingEvents>(event: K, listeners: (...args: ClientPollingEvents[K]) => void): this;
-    /** @internal */
-    once<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientPollingEvents>, listeners: (...args: CustomEvents[S]) => void): this;
-    /** @internal */ once<S extends string | symbol>(event: Exclude<S, keyof ClientPollingEvents>, listeners: (...args: any[]) => void): this;
-    /** @internal */
-    emit<K extends keyof ClientPollingEvents>(event: K, ...args: ClientPollingEvents[K]): boolean;
-    /** @internal */
-    emit<S extends keyof CustomEvents>(event: Exclude<S, keyof ClientPollingEvents>, ...args: CustomEvents[S]): this;
-    /** @internal */ emit<S extends string | symbol>(event: Exclude<S, keyof ClientPollingEvents>, ...args: any[]): boolean;
+    maintenanceEnd: string;
+    /**
+     * Emitted for general debugging information.
+     * @public
+     * @event
+     */
+    debug: string;
+    /**
+     * Emitted when the client encounters an error.
+     * @public
+     * @event
+     */
+    error: string;
 }
-interface ClientPollingEvents {
-    [PollingEvents.NewSeasonStart]: [id: string];
-    [PollingEvents.MaintenanceStart]: [];
-    [PollingEvents.MaintenanceEnd]: [duration: number];
+interface IPollingEvents {
     [PollingEvents.ClanLoopStart]: [];
     [PollingEvents.ClanLoopEnd]: [];
     [PollingEvents.PlayerLoopStart]: [];
     [PollingEvents.PlayerLoopEnd]: [];
     [PollingEvents.WarLoopStart]: [];
     [PollingEvents.WarLoopEnd]: [];
+    [PollingEvents.NewSeasonStart]: [id: string];
+    [PollingEvents.MaintenanceStart]: [];
+    [PollingEvents.MaintenanceEnd]: [duration: number];
     [PollingEvents.Error]: [error: unknown];
     [PollingEvents.Debug]: [path: string, status: string, message: string];
 }
-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/PollingClient.js

@@ -1,9 +1,9 @@
 "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.
  * ```js
@@ -14,12 +14,271 @@ const EventManager_1 = require("./EventManager");
 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();
+        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

@@ -20,6 +20,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;
@@ -43,7 +44,6 @@ 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 +52,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/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 { 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;