clashofclans.js 2.0.0-dev.ba3ae68 → 2.0.0

package/dist/rest/RequestHandler.d.ts

@@ -11,18 +11,14 @@ export declare class RequestHandler {
     private keys;
     private readonly baseURL;
     private readonly retryLimit;
-    private readonly cached;
     private readonly restRequestTimeout;
     private readonly throttler?;
+    private readonly cached;
     constructor(options?: ClientOptions);
     private get _keys();
     private get _key();
     setKeys(keys: string[]): this;
-    request<T>(path: string, options?: RequestOptions): Promise<{
-        data: T;
-        maxAge: number;
-        status: number;
-    }>;
+    request<T>(path: string, options?: RequestOptions): Promise<Response<T>>;
     private exec;
     init(options: InitOptions): Promise<string[]>;
     private reValidateKeys;
@@ -32,47 +28,135 @@ export declare class RequestHandler {
     private createKey;
     private getIp;
 }
+/** Options for a client. */
 export interface ClientOptions {
+    /** Keys from Clash of Clans API developer site. */
     keys?: string[];
+    /** Base URL of the Clash of Clans API. */
     baseURL?: string;
+    /**
+     * How many times to retry on 5XX errors.
+     */
     retryLimit?: number;
+    /**
+     * Whether enable or disable internal caching.
+     * @example
+     * ```ts
+     * const client = new Client({ cache: true });
+     * ```
+     */
     cache?: boolean | Keyv;
+    /** Time to wait before cancelling a REST request, in milliseconds. */
     restRequestTimeout?: number;
+    /**
+     * Throttler class which handles rate-limit
+     * @example
+     * ```ts
+     * const client = new Client({ throttler: new QueueThrottler(1000 / 10) });
+     * ```
+     * @example
+     * ```ts
+     * const client = new Client({ throttler: new BatchThrottler(30) });
+     * ```
+     */
     throttler?: QueueThrottler | BatchThrottler;
 }
+/** Search options for request. */
 export interface SearchOptions extends OverrideOptions {
+    /** Limit the number of items returned in the response. */
     limit?: number;
+    /**
+     * Return only items that occur after this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     after?: string;
+    /**
+     * Return only items that occur before this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     before?: string;
 }
+/** Override options for a request. */
 export interface OverrideOptions {
+    /** Whether to cache this response. */
     cache?: boolean;
+    /** Whether to skip the cache check and request the API. */
     force?: boolean;
+    /** How many times to retry on 5XX errors. */
     retryLimit?: string;
+    /** Whether to ignore throttlers. */
     ignoreRateLimit?: boolean;
+    /** Time to wait before cancelling a REST request, in milliseconds. */
     restRequestTimeout?: number;
 }
 export interface RequestOptions extends OverrideOptions {
+    /** The request body. */
     body?: string;
+    /** The request method. */
     method?: string;
 }
+export interface Response<T> {
+    /** The response body. */
+    data: T;
+    /** Path of the request for this response. */
+    path: string;
+    /** HTTP status code of this response. */
+    status: number;
+    /** The maxAge of this response. */
+    maxAge: number;
+}
+/**
+ * Clan search options for a request.
+ *
+ * ::info
+ * If name is used as part of search query, it needs to be at least three characters long.
+ * Name search parameter is interpreted as wild card search, so it may appear anywhere in the clan name.
+ * :::
+ */
 export interface ClanSearchOptions {
+    /** Search clans by name. */
     name?: string;
+    /** Filter by minimum number of clan members. */
     minMembers?: number;
+    /** Filter by maximum number of clan members. */
     maxMembers?: number;
+    /** Filter by minimum amount of clan points. */
     minClanPoints?: number;
+    /** Filter by minimum clan level. */
     minClanLevel?: number;
+    /** Filter by clan war frequency. */
     warFrequency?: string;
+    /** Filter by clan location identifier. For list of available locations, refer to getLocations operation. */
     locationId?: string;
+    /** Comma separated list of label IDs to use for filtering results. */
     labelIds?: string;
+    /** Limit the number of items returned in the response. */
     limit?: number;
+    /**
+     * Return only items that occur after this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     after?: string;
+    /**
+     * Return only items that occur before this marker.
+     * Before marker can be found from the response, inside the 'paging' property.
+     * Note that only after or before can be specified for a request, not both.
+     */
     before?: string;
 }
+/** Login options for a client. */
 export interface InitOptions {
+    /** Developer site email address. */
     email: string;
+    /** Developer site password. */
     password: string;
+    /** Name of API key(s). */
     keyName?: string;
+    /** Number of allowed API keys. */
     keyCount?: number;
+    /** Description of API key(s). */
     keyDescription?: string;
 }

package/dist/rest/RequestHandler.js

@@ -50,8 +50,9 @@ class RequestHandler {
     }
     async request(path, options = {}) {
         const cached = (await this.cached?.get(path)) ?? null;
-        if (cached && options.force !== true)
-            return { data: cached, maxAge: 0, status: 200 };
+        if (cached && options.force !== true) {
+            return { data: cached.data, maxAge: cached.ttl - Date.now(), status: 200, path };
+        }
         if (!this.throttler || options.ignoreRateLimit)
             return this.exec(path, options);
         await this.throttler.wait();
@@ -74,15 +75,19 @@ class RequestHandler {
         if (!res && retries < (options.retryLimit ?? this.retryLimit))
             return this.exec(path, options, ++retries);
         if (res?.status === 403 && data?.reason === 'accessDenied.invalidIp' && this.email && this.password) {
-            await this.login();
-            return this.exec(path, options, ++retries);
+            const keys = await this.reValidateKeys().then(() => this.login());
+            if (keys.length)
+                return this.exec(path, options, ++retries);
         }
+        const maxAge = Number(res?.headers.get('cache-control')?.split('=')?.[1] ?? 0) * 1000;
+        if (res?.status === 403 && !data?.message)
+            throw new HTTPError_1.HTTPError(HTTPError_1.PrivateWarLogError, res.status, path, maxAge);
         if (!res?.ok)
-            throw new HTTPError_1.HTTPError(data, res?.status ?? 504, path, options.method);
-        const maxAge = Number(res.headers.get('cache-control')?.split('=')?.[1] ?? 0) * 1000;
-        if (this.cached && maxAge > 0 && options.cache !== false)
-            await this.cached.set(path, data, maxAge);
-        return { data, maxAge, status: res.status };
+            throw new HTTPError_1.HTTPError(data, res?.status ?? 504, path, maxAge, options.method);
+        if (this.cached && maxAge > 0 && options.cache !== false) {
+            await this.cached.set(path, { data, ttl: Date.now() + maxAge }, maxAge);
+        }
+        return { data, maxAge, status: res.status, path };
     }
     async init(options) {
         if (!(options.email && options.password))
@@ -97,11 +102,12 @@ class RequestHandler {
     }
     async reValidateKeys() {
         for (const key of this.keys) {
-            const res = await (0, node_fetch_1.default)(`${this.baseURL}/locations`, {
+            const res = await (0, node_fetch_1.default)(`${this.baseURL}/locations?limit=1`, {
                 method: 'GET',
+                timeout: 10000,
                 headers: { 'Authorization': `Bearer ${key}`, 'Content-Type': 'application/json' }
-            });
-            if (res.status === 403) {
+            }).catch(() => null);
+            if (res?.status === 403) {
                 const index = this.keys.indexOf(key);
                 this.keys.splice(index, 1);
                 console.warn(`[WARN] Pre-defined key #${index + 1} is no longer valid. Removed from the key list.`);
@@ -111,6 +117,7 @@ class RequestHandler {
     async login() {
         const res = await (0, node_fetch_1.default)(`${Constants_1.DEV_SITE_API_BASE_URL}/login`, {
             method: 'POST',
+            timeout: 10000,
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({ email: this.email, password: this.password })
         });
@@ -123,14 +130,14 @@ class RequestHandler {
         const ip = await this.getIp();
         const res = await (0, node_fetch_1.default)(`${Constants_1.DEV_SITE_API_BASE_URL}/apikey/list`, {
             method: 'POST',
+            timeout: 10000,
             headers: { 'Content-Type': 'application/json', cookie }
         });
         const data = await res.json();
         // Get all available keys from the developer site.
         const keys = (data.keys ?? []);
         // Revoke keys for specified key name but not matching current IP address.
-        const expiredKeys = keys.filter((key) => key.name === this.keyName && !key.cidrRanges.includes(ip));
-        for (const key of expiredKeys) {
+        for (const key of keys.filter((key) => key.name === this.keyName && !key.cidrRanges.includes(ip))) {
             if (!(await this.revokeKey(key.id, cookie)))
                 continue;
             const index = keys.findIndex(({ id }) => id === key.id);
@@ -163,6 +170,7 @@ class RequestHandler {
     async revokeKey(keyId, cookie) {
         const res = await (0, node_fetch_1.default)(`${Constants_1.DEV_SITE_API_BASE_URL}/apikey/revoke`, {
             method: 'POST',
+            timeout: 10000,
             body: JSON.stringify({ id: keyId }),
             headers: { 'Content-Type': 'application/json', cookie }
         });
@@ -171,6 +179,7 @@ class RequestHandler {
     async createKey(cookie, ip) {
         const res = await (0, node_fetch_1.default)(`${Constants_1.DEV_SITE_API_BASE_URL}/apikey/create`, {
             method: 'POST',
+            timeout: 10000,
             headers: { 'Content-Type': 'application/json', cookie },
             body: JSON.stringify({
                 cidrRanges: [ip],
@@ -182,7 +191,7 @@ class RequestHandler {
         return data.key;
     }
     async getIp() {
-        return (0, node_fetch_1.default)('https://api.ipify.org/').then((res) => res.text());
+        return (0, node_fetch_1.default)('https://api.ipify.org/', { timeout: 10000 }).then((res) => res.text());
     }
 }
 exports.RequestHandler = RequestHandler;

package/dist/rest/Throttler.d.ts

@@ -29,7 +29,3 @@ export declare class BatchThrottler {
     wait(): Promise<void>;
     throttle(): Promise<void>;
 }
-export interface DeferredPromise {
-    resolve(): void;
-    promise: Promise<void>;
-}

package/dist/struct/Clan.d.ts

@@ -1,3 +1,4 @@
+import { OverrideOptions } from '../rest/RequestHandler';
 import { ChatLanguage } from './ChatLanguage';
 import { ClanMember } from './ClanMember';
 import { Client } from '../client/Client';
@@ -59,5 +60,5 @@ export declare class Clan {
     members: ClanMember[];
     constructor(client: Client, data: APIClan);
     /** Get {@link Player} information for every Player in the clan. */
-    fetchMembers(): Promise<Player[]>;
+    fetchMembers(options?: OverrideOptions): Promise<Player[]>;
 }

package/dist/struct/Clan.js

@@ -35,8 +35,8 @@ class Clan {
         this.members = data.memberList?.map((mem) => new ClanMember_1.ClanMember(this.client, mem)) ?? []; // eslint-disable-line
     }
     /** Get {@link Player} information for every Player in the clan. */
-    async fetchMembers() {
-        return (await Promise.allSettled(this.members.map((m) => this.client.getPlayer(m.tag, { ignoreRateLimit: true }))))
+    async fetchMembers(options) {
+        return (await Promise.allSettled(this.members.map((m) => this.client.getPlayer(m.tag, { ...options, ignoreRateLimit: true }))))
             .filter((res) => res.status === 'fulfilled')
             .map((res) => res.value);
     }

package/dist/struct/ClanMember.d.ts

@@ -1,3 +1,4 @@
+import { OverrideOptions } from '../rest/RequestHandler';
 import { Client } from '../client/Client';
 import { APIClanMember } from '../types';
 import { League } from './League';
@@ -27,5 +28,5 @@ export declare class ClanMember {
     received: number;
     constructor(client: Client, data: APIClanMember);
     /** Fetch detailed clan info for the member's clan. */
-    fetch(): Promise<import("./Player").Player>;
+    fetch(options?: OverrideOptions): Promise<import("./Player").Player>;
 }

package/dist/struct/ClanMember.js

@@ -21,8 +21,8 @@ class ClanMember {
         this.received = data.donationsReceived;
     }
     /** Fetch detailed clan info for the member's clan. */
-    async fetch() {
-        return this.client.getPlayer(this.tag);
+    async fetch(options) {
+        return this.client.getPlayer(this.tag, options);
     }
 }
 exports.ClanMember = ClanMember;

package/dist/struct/ClanWar.d.ts

@@ -116,12 +116,12 @@ export declare class ClanWar {
     opponent: WarClan;
     /** The war's unique tag. This is `null` unless this is a CWL.  */
     warTag: string | null;
-    /** The timestamp when a fresh version of this data will be available again. */
+    /** Maximum number of milliseconds the results can be cached. */
     maxAge: number;
     constructor(client: Client, data: APIClanWar, extra: {
         clanTag?: string;
         warTag?: string;
-        maxAge?: number;
+        maxAge: number;
     });
     /** Return a {@link ClanWarMember} with the tag provided. */
     getMember(tag: string): ClanWarMember | null;
@@ -129,7 +129,9 @@ export declare class ClanWar {
     getAttack(attackerTag: string, defenderTag: string): ClanWarAttack | null;
     /** Return a list of {@link ClanWarAttack} for the defenderTag provided. */
     getDefenses(defenderTag: string): ClanWarAttack[];
-    /** Returns either `friendly`, `cwl` or `regular`. */
-    get type(): 'friendly' | 'cwl' | 'regular';
+    /** Returns either `friendly`, `cwl` or `normal`. */
+    get type(): "friendly" | "cwl" | "normal";
     private get _isFriendly();
+    /** Returns the war status, based off the home clan. */
+    get status(): "win" | "lose" | "tie" | "pending";
 }

package/dist/struct/ClanWar.js

@@ -147,7 +147,7 @@ class ClanWar {
         }
         this.clan = new WarClan(this, clan);
         this.opponent = new WarClan(this, opponent);
-        this.maxAge = Date.now() + (extra.maxAge ?? 0);
+        this.maxAge = extra.maxAge;
     }
     /** Return a {@link ClanWarMember} with the tag provided. */
     getMember(tag) {
@@ -168,17 +168,31 @@ class ClanWar {
         }
         return this.opponent.attacks.filter((atk) => atk.defenderTag === defenderTag);
     }
-    /** Returns either `friendly`, `cwl` or `regular`. */
+    /** Returns either `friendly`, `cwl` or `normal`. */
     get type() {
         if (this._isFriendly)
             return 'friendly';
         if (this.warTag)
             return 'cwl';
-        return 'regular';
+        return 'normal';
     }
     get _isFriendly() {
         const preparationTime = this.startTime.getTime() - this.preparationStartTime.getTime();
         return Constants_1.FRIENDLY_WAR_PREPARATION_TIMES.includes(preparationTime);
     }
+    /** Returns the war status, based off the home clan. */
+    get status() {
+        if (this.state === 'preparation')
+            return 'pending';
+        if (this.clan.stars > this.opponent.stars)
+            return 'win';
+        if (this.clan.stars === this.opponent.stars) {
+            if (this.clan.destruction > this.opponent.destruction)
+                return 'win';
+            if (this.clan.destruction === this.opponent.destruction)
+                return 'tie';
+        }
+        return 'lose';
+    }
 }
 exports.ClanWar = ClanWar;

package/dist/struct/ClanWarLeagueGroup.d.ts

@@ -1,4 +1,5 @@
 import { APIClanWarLeagueClan, APIClanWarLeagueClanMember, APIClanWarLeagueGroup, APIClanWarLeagueRound } from '../types';
+import { OverrideOptions } from '../rest/RequestHandler';
 import { Client } from '../client/Client';
 import { ClanWar } from './ClanWar';
 import { Player } from './Player';
@@ -28,7 +29,7 @@ export declare class ClanWarLeagueClan {
     members: ClanWarLeagueClanMember[];
     constructor(client: Client, data: APIClanWarLeagueClan);
     /** Get {@link Player} information for every members that are in the CWL group. */
-    fetchMembers(): Promise<Player[]>;
+    fetchMembers(options?: OverrideOptions): Promise<Player[]>;
 }
 /** Represents a Round of CWL Group. */
 export declare class ClanWarLeagueRound {
@@ -53,9 +54,10 @@ export declare class ClanWarLeagueGroup {
     /**
      * This returns an array of {@link ClanWar} which fetches all wars in parallel.
      * @param clanTag Optional clan tag. If present, this will only return wars which belong to this clan.
+     * @param options Override options for the request.
      */
-    getWars(clanTag?: string): Promise<ClanWar[]>;
+    getWars(clanTag?: string, options?: OverrideOptions): Promise<ClanWar[]>;
     private _getCurrentWars;
-    /** Returns # (1-7) of the round for the specified warTag. */
+    /** Returns the index of the round for this specified warTag. */
     getRoundIndex(warTag: string): number | null;
 }

package/dist/struct/ClanWarLeagueGroup.js

@@ -22,8 +22,8 @@ class ClanWarLeagueClan {
         this.members = data.members.map((mem) => new ClanWarLeagueClanMember(mem));
     }
     /** Get {@link Player} information for every members that are in the CWL group. */
-    async fetchMembers() {
-        return (await Promise.allSettled(this.members.map((m) => this.client.getPlayer(m.tag, { ignoreRateLimit: true }))))
+    async fetchMembers(options) {
+        return (await Promise.allSettled(this.members.map((m) => this.client.getPlayer(m.tag, { ...options, ignoreRateLimit: true }))))
             .filter((res) => res.status === 'fulfilled')
             .map((res) => res.value);
     }
@@ -49,33 +49,35 @@ class ClanWarLeagueGroup {
     /**
      * This returns an array of {@link ClanWar} which fetches all wars in parallel.
      * @param clanTag Optional clan tag. If present, this will only return wars which belong to this clan.
+     * @param options Override options for the request.
      */
-    async getWars(clanTag) {
+    async getWars(clanTag, options) {
         const rounds = this.rounds.filter((round) => !round.warTags.includes('#0'));
         if (!rounds.length)
             return [];
         const warTags = rounds.map((round) => round.warTags).flat();
-        const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ignoreRateLimit: true })));
+        const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ...options, ignoreRateLimit: true })));
         return wars
-            .filter((res) => res.status === 'fulfilled' && res.value)
+            .filter((res) => res.status === 'fulfilled')
             .map((res) => res.value)
             .filter((war) => (clanTag ? war.clan.tag === clanTag : true));
     }
-    async _getCurrentWars(clanTag) {
+    async _getCurrentWars(clanTag, options) {
         const rounds = this.rounds.filter((round) => !round.warTags.includes('#0'));
         if (!rounds.length)
             return [];
         const warTags = rounds
             .slice(-2)
             .map((round) => round.warTags)
-            .flat();
-        const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ignoreRateLimit: true })));
+            .flat()
+            .reverse();
+        const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ...options, ignoreRateLimit: true })));
         return wars
-            .filter((res) => res.status === 'fulfilled' && res.value)
+            .filter((res) => res.status === 'fulfilled')
             .map((res) => res.value)
             .filter((war) => war.clan.tag === clanTag);
     }
-    /** Returns # (1-7) of the round for the specified warTag. */
+    /** Returns the index of the round for this specified warTag. */
     getRoundIndex(warTag) {
         return this.rounds.find((round) => round.warTags.includes(warTag))?.round ?? null;
     }

package/dist/struct/ClanWarLog.d.ts

@@ -49,6 +49,6 @@ export declare class ClanWarLog {
     /** The opposition clan. */
     opponent: WarLogClan;
     constructor(client: Client, data: APIClanWarLogEntry);
-    /** Returns either `friendly`, `cwl` or `regular`. */
-    get type(): "friendly" | "cwl" | "regular";
+    /** Returns either `friendly`, `cwl` or `normal`. */
+    get type(): "friendly" | "cwl" | "normal";
 }

package/dist/struct/ClanWarLog.js

@@ -34,13 +34,13 @@ class ClanWarLog {
         this.clan = new WarLogClan(data.clan);
         this.opponent = new WarLogClan(data.opponent);
     }
-    /** Returns either `friendly`, `cwl` or `regular`. */
+    /** Returns either `friendly`, `cwl` or `normal`. */
     get type() {
         if (!this.clan.expEarned)
             return 'friendly';
         if (!this.opponent.tag)
             return 'cwl';
-        return 'regular';
+        return 'normal';
     }
 }
 exports.ClanWarLog = ClanWarLog;

package/dist/struct/Player.d.ts

@@ -1,3 +1,4 @@
+import { OverrideOptions } from '../rest/RequestHandler';
 import { LegendStatistics } from './LegendStatistics';
 import { Achievement } from './Achievement';
 import { Hero, Spell, Troop } from './Unit';
@@ -63,7 +64,7 @@ export declare class Player {
     heroes: Hero[];
     constructor(client: Client, data: APIPlayer);
     /** Fetch detailed clan info for the player's clan. */
-    fetchClan(): Promise<import("./Clan").Clan | null>;
+    fetchClan(options?: OverrideOptions): Promise<import("./Clan").Clan | null>;
     /** An array of the player's home base troops. */
     get homeTroops(): Troop[];
     /** An array of the player's builder base troops. */

package/dist/struct/Player.js

@@ -2,12 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Player = void 0;
 const Constants_1 = require("../util/Constants");
+const raw_json_1 = require("../util/raw.json");
 const LegendStatistics_1 = require("./LegendStatistics");
 const Achievement_1 = require("./Achievement");
 const Unit_1 = require("./Unit");
 const PlayerClan_1 = require("./PlayerClan");
 const League_1 = require("./League");
 const Label_1 = require("./Label");
+const UNIT_NAMES = [...raw_json_1.RAW_UNITS.map((unit) => unit.name), ...raw_json_1.RAW_SUPER_UNITS.map((unit) => unit.name)];
 /** Represents a Clash of Clans Player. */
 class Player {
     constructor(client, data) {
@@ -36,15 +38,15 @@ class Player {
         this.legendStatistics = data.legendStatistics ? new LegendStatistics_1.LegendStatistics(data.legendStatistics) : null;
         this.achievements = data.achievements.map((data) => new Achievement_1.Achievement(data));
         this.labels = data.labels.map((data) => new Label_1.Label(data));
-        this.troops = data.troops.map((data) => new Unit_1.Troop(data));
-        this.spells = data.spells.map((data) => new Unit_1.Spell(data));
-        this.heroes = data.heroes.map((data) => new Unit_1.Hero(data));
+        this.troops = data.troops.filter((unit) => UNIT_NAMES.includes(unit.name)).map((unit) => new Unit_1.Troop(data, unit));
+        this.spells = data.spells.filter((unit) => UNIT_NAMES.includes(unit.name)).map((unit) => new Unit_1.Spell(data, unit));
+        this.heroes = data.heroes.filter((unit) => UNIT_NAMES.includes(unit.name)).map((unit) => new Unit_1.Hero(data, unit));
     }
     /** Fetch detailed clan info for the player's clan. */
-    async fetchClan() {
+    async fetchClan(options) {
         if (!this.clan)
             return null;
-        return this.client.getClan(this.clan.tag);
+        return this.client.getClan(this.clan.tag, options);
     }
     /** An array of the player's home base troops. */
     get homeTroops() {

package/dist/struct/PlayerClan.d.ts

@@ -1,3 +1,4 @@
+import { OverrideOptions } from '../rest/RequestHandler';
 import { Client } from '../client/Client';
 import { APIPlayerClan } from '../types';
 import { Badge } from './Badge';
@@ -14,5 +15,5 @@ export declare class PlayerClan {
     badge: Badge;
     constructor(_client: Client, data: APIPlayerClan);
     /** Fetch detailed clan info for the player's clan. */
-    fetch(): Promise<import("./Clan").Clan>;
+    fetch(options?: OverrideOptions): Promise<import("./Clan").Clan>;
 }

package/dist/struct/PlayerClan.js

@@ -12,8 +12,8 @@ class PlayerClan {
         this.badge = new Badge_1.Badge(data.badgeUrls);
     }
     /** Fetch detailed clan info for the player's clan. */
-    fetch() {
-        return this._client.getClan(this.tag);
+    fetch(options) {
+        return this._client.getClan(this.tag, options);
     }
 }
 exports.PlayerClan = PlayerClan;

package/dist/struct/Unit.d.ts

@@ -1,4 +1,4 @@
-import { APIPlayerItem } from '../types';
+import { APIPlayerItem, APIPlayer } from '../types';
 /** Represents a player's unit. */
 export declare class Unit {
     /** The name of this unit. */
@@ -9,7 +9,35 @@ export declare class Unit {
     maxLevel: number;
     /** The village type of this unit. */
     village: 'home' | 'builderBase';
-    constructor(data: APIPlayerItem);
+    /** Id of this unit. */
+    id: number;
+    /** Housing space of this unit. */
+    housingSpace: number;
+    /** Town/Builder hall's max level of this unit. */
+    hallMaxLevel: number;
+    /** Unlock Town/Builder Hall level of this unit. */
+    unlockHallLevel: number;
+    /** Unlock cost of this unit. */
+    unlockCost: number;
+    /** Unlock time of this unit. */
+    unlockTime: number;
+    /** Unlock resource of this unit. */
+    unlockResource: string;
+    /** Unlock building of this unit. */
+    unlockBuilding: string;
+    /** Unlock building level of this unit. */
+    unlockBuildingLevel: number;
+    /** Upgrade cost of this unit. */
+    upgradeCost: number;
+    /** Upgrade resource of this unit. */
+    upgradeResource: string;
+    /** Upgrade time of this unit. */
+    upgradeTime: number;
+    /** @internal */
+    minOriginalLevel: number | null;
+    /** @internal */
+    originalName: string | null;
+    constructor(data: APIPlayer, unit: APIPlayerItem);
     /** Whether the unit belongs to the home base. */
     get isHomeBase(): boolean;
     /** Whether the unit belongs to the builder base. */
@@ -22,8 +50,13 @@ export declare class Unit {
 /** Represents a player's troop. */
 export declare class Troop extends Unit {
     name: string;
-    superTroopIsActive: boolean;
-    constructor(data: APIPlayerItem);
+    /** Whether this troop is currently active of boosted. */
+    isActive: boolean;
+    /** Origin troop's minimum level of this super troop. */
+    minOriginalLevel: number | null;
+    /** Origin troop's name of this super troop. */
+    originalName: string | null;
+    constructor(data: APIPlayer, unit: APIPlayerItem);
     /** Whether this troop is a Super Troop. */
     get isSuperTroop(): boolean;
 }