clashofclans.js 3.0.0-dev.392ca4c → 3.0.0-dev.577f128

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;

package/dist/rest/RequestHandler.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -16,16 +39,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 var _RequestHandler_keyIndex;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestHandler = void 0;
+const node_https_1 = __importDefault(require("node:https"));
+const node_events_1 = require("node:events");
+const node_fetch_1 = __importStar(require("node-fetch"));
 const Constants_1 = require("../util/Constants");
-const HTTPError_1 = require("./HTTPError");
 const Store_1 = require("../util/Store");
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const https_1 = __importDefault(require("https"));
+const HTTPError_1 = require("./HTTPError");
 const IP_REGEX = /\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}/g;
-const agent = new https_1.default.Agent({ keepAlive: true });
-/** Represents a Request Handler. */
-class RequestHandler {
+const agent = new node_https_1.default.Agent({ keepAlive: true });
+/** Represents the class that manages handlers for endpoints. */
+class RequestHandler extends node_events_1.EventEmitter {
     constructor(options) {
+        super();
         _RequestHandler_keyIndex.set(this, 0); // eslint-disable-line
         this.keys = options?.keys ?? [];
         this.retryLimit = options?.retryLimit ?? 0;
@@ -64,35 +89,46 @@ class RequestHandler {
         return this.exec(path, options);
     }
     async exec(path, options = {}, retries = 0) {
-        const res = await (0, node_fetch_1.default)(`${this.baseURL}${path}`, {
-            agent,
-            body: options.body,
-            method: options.method,
-            timeout: options.restRequestTimeout ?? this.restRequestTimeout,
-            headers: { 'Authorization': `Bearer ${this._key}`, 'Content-Type': 'application/json' }
-        }).catch(() => null);
-        const data = await res?.json().catch(() => null);
-        if (!res && retries < (options.retryLimit ?? this.retryLimit))
-            return this.exec(path, options, ++retries);
-        if (this.creds &&
-            res?.status === 403 &&
-            data?.reason === 'accessDenied.invalidIp' &&
-            retries < (options.retryLimit ?? this.retryLimit)) {
-            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 && this.rejectIfNotValid) {
-            throw new HTTPError_1.HTTPError(HTTPError_1.PrivateWarLogError, res.status, path, maxAge);
-        }
-        if (!res?.ok && this.rejectIfNotValid) {
-            throw new HTTPError_1.HTTPError(data, res?.status ?? 504, path, maxAge, options.method);
+        try {
+            const res = await (0, node_fetch_1.default)(`${this.baseURL}${path}`, {
+                agent,
+                body: options.body,
+                method: options.method,
+                timeout: options.restRequestTimeout ?? this.restRequestTimeout,
+                headers: { 'Authorization': `Bearer ${this._key}`, 'Content-Type': 'application/json' }
+            });
+            if (res.status === 504 && retries < (options.retryLimit ?? this.retryLimit)) {
+                return await this.exec(path, options, ++retries);
+            }
+            const data = await res.json();
+            if (this.creds &&
+                res.status === 403 &&
+                data.reason === 'accessDenied.invalidIp' &&
+                retries < (options.retryLimit ?? this.retryLimit)) {
+                const keys = await this.reValidateKeys().then(() => () => this.login());
+                if (keys.length)
+                    return await this.exec(path, options, ++retries);
+            }
+            const maxAge = Number(res.headers.get('cache-control')?.split('=')?.[1] ?? 0) * 1000;
+            if (res.status === 403 && !data?.message && this.rejectIfNotValid) {
+                throw new HTTPError_1.HTTPError(HTTPError_1.PrivateWarLogError, res.status, path, maxAge);
+            }
+            if (!res.ok && this.rejectIfNotValid) {
+                throw new HTTPError_1.HTTPError(data, res.status, path, maxAge, options.method);
+            }
+            if (this.cached && maxAge > 0 && options.cache !== false && res.ok) {
+                await this.cached.set(path, { data, ttl: Date.now() + maxAge, status: res.status }, maxAge);
+            }
+            return { data, maxAge, status: res.status, path, ok: res.status === 200 };
         }
-        if (this.cached && maxAge > 0 && options.cache !== false && res?.ok) {
-            await this.cached.set(path, { data, ttl: Date.now() + maxAge, status: res.status }, maxAge);
+        catch (error) {
+            if (error instanceof node_fetch_1.FetchError && error.type === 'request-timeout' && retries < (options.retryLimit ?? this.retryLimit)) {
+                return this.exec(path, options, ++retries);
+            }
+            if (this.rejectIfNotValid)
+                throw error;
+            return { data: { message: error.message }, maxAge: 0, status: 500, path, ok: false };
         }
-        return { data, maxAge, status: res?.status ?? 504, path, ok: res?.status === 200 };
     }
     async init(options) {
         if (!(options.email && options.password))

package/dist/struct/CapitalRaidSeason.d.ts

@@ -0,0 +1,49 @@
+import { Client } from '../client/Client';
+import { APICapitalRaidSeason, APICapitalRaidSeasonAttackLog, APICapitalRaidSeasonDefenseLog, APICapitalRaidSeasonMember, OverrideOptions } from '../types';
+import { Player } from './Player';
+export declare class CapitalRaidSeasonMember {
+    /** The player's tag. */
+    name: string;
+    /** The player's name. */
+    tag: string;
+    /** The number of attacks the player has made. */
+    attacks: number;
+    /** The number of attacks the player can make. */
+    attackLimit: number;
+    /** The number of bonus attacks the player can make. */
+    bonusAttackLimit: number;
+    /** The number of capital resources the player has looted. */
+    capitalResourcesLooted: number;
+    constructor(data: APICapitalRaidSeasonMember);
+}
+/** Represents a Capital Raid Season. */
+export declare class CapitalRaidSeason {
+    private readonly client;
+    /** The state of the raid season. */
+    state: 'ongoing' | 'ended';
+    /** The start time of the raid season. */
+    startTime: Date;
+    /** The end time of the raid season. */
+    endTime: Date;
+    /** The total loot collected from the capital. */
+    capitalTotalLoot: number;
+    /** The number of raids completed. */
+    raidsCompleted: number;
+    /** The total number of attacks. */
+    totalAttacks: number;
+    /** The number of enemy districts destroyed. */
+    enemyDistrictsDestroyed: number;
+    /** The offensive reward. */
+    offensiveReward: number;
+    /** The defensive reward. */
+    defensiveReward: number;
+    /** The members of the raid season. */
+    members: APICapitalRaidSeasonMember[];
+    /** The attack log of the raid season. */
+    attackLog: APICapitalRaidSeasonAttackLog[];
+    /** The defense log of the raid season. */
+    defenseLog: APICapitalRaidSeasonDefenseLog[];
+    constructor(client: Client, data: APICapitalRaidSeason);
+    /** Get {@link Player} info for every Player in the clan. */
+    fetchMembers(options?: OverrideOptions): Promise<Player[]>;
+}

package/dist/struct/CapitalRaidSeason.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CapitalRaidSeason = exports.CapitalRaidSeasonMember = void 0;
+const Util_1 = require("../util/Util");
+class CapitalRaidSeasonMember {
+    constructor(data) {
+        this.tag = data.tag;
+        this.name = data.name;
+        this.attacks = data.attacks;
+        this.attackLimit = data.attackLimit;
+        this.bonusAttackLimit = data.bonusAttackLimit;
+        this.capitalResourcesLooted = data.capitalResourcesLooted;
+    }
+}
+exports.CapitalRaidSeasonMember = CapitalRaidSeasonMember;
+/** Represents a Capital Raid Season. */
+class CapitalRaidSeason {
+    constructor(client, data) {
+        this.client = client;
+        this.state = data.state;
+        this.startTime = Util_1.Util.formatDate(data.startTime);
+        this.endTime = Util_1.Util.formatDate(data.endTime);
+        this.capitalTotalLoot = data.capitalTotalLoot;
+        this.raidsCompleted = data.raidsCompleted;
+        this.totalAttacks = data.totalAttacks;
+        this.enemyDistrictsDestroyed = data.enemyDistrictsDestroyed;
+        this.offensiveReward = data.offensiveReward;
+        this.defensiveReward = data.defensiveReward;
+        this.attackLog = data.attackLog;
+        this.defenseLog = data.defenseLog;
+        this.members = (data.members ?? []).map((member) => new CapitalRaidSeasonMember(member));
+    }
+    /** Get {@link Player} info for every Player in the clan. */
+    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);
+    }
+}
+exports.CapitalRaidSeason = CapitalRaidSeason;

package/dist/struct/Clan.d.ts

@@ -1,7 +1,7 @@
-import { APIClan, OverrideOptions } from '../types';
+import { APICapitalLeague, APIClan, OverrideOptions } from '../types';
+import { Client } from '../client/Client';
 import { ChatLanguage } from './ChatLanguage';
 import { ClanMember } from './ClanMember';
-import { Client } from '../client/Client';
 import { WarLeague } from './WarLeague';
 import type { Player } from './Player';
 import { Location } from './Location';
@@ -29,6 +29,8 @@ export declare class Clan {
     level: number;
     /** The clan's trophy count. */
     points: number;
+    /** The clan's capital points. */
+    capitalPoints: number;
     /** The clan's versus trophy count. */
     versusPoints: number;
     /** The minimum trophies required to apply to this clan. */
@@ -57,6 +59,10 @@ export declare class Clan {
     labels: Label[];
     /** The clan's Clan Capital information */
     clanCapital: ClanCapital | null;
+    /** The clan's capital league. */
+    capitalLeague?: APICapitalLeague;
+    /** Whether the clan is family friendly. */
+    isFamilyFriendly: boolean;
     /**
      * List of clan members.
      * - This property returns empty array for {@link Client.getClans} method.

package/dist/struct/Clan.js

@@ -35,6 +35,9 @@ class Clan {
         this.memberCount = data.members;
         this.labels = data.labels.map((label) => new Label_1.Label(label));
         this.clanCapital = Object.keys(data.clanCapital).length > 0 ? new ClanCapital_1.ClanCapital(data.clanCapital) : null;
+        this.isFamilyFriendly = data.isFamilyFriendly;
+        this.capitalPoints = data.clanCapitalPoints;
+        this.capitalLeague = data.capitalLeague;
         this.members = data.memberList?.map((mem) => new ClanMember_1.ClanMember(this.client, mem)) ?? []; // eslint-disable-line
     }
     /** Get {@link Player} info for every Player in the clan. */

package/dist/struct/ClanCapital.js

@@ -4,7 +4,7 @@ exports.ClanCapital = void 0;
 class ClanCapital {
     constructor(data) {
         this.capitalHallLevel = data.capitalHallLevel ?? null;
-        this.districts = data.districts ? data.districts : null;
+        this.districts = data.districts ?? null;
     }
 }
 exports.ClanCapital = ClanCapital;

package/dist/struct/ClanMember.d.ts

@@ -1,4 +1,4 @@
-import { APIClanMember, OverrideOptions } from '../types';
+import { APIClanMember, APIPlayerHouse, OverrideOptions } from '../types';
 import { Client } from '../client/Client';
 import { League } from './League';
 export declare class ClanMember {
@@ -25,6 +25,8 @@ export declare class ClanMember {
     donations: number;
     /** The member's donation received count for this season. */
     received: number;
+    /** The member's player house details. */
+    playerHouse?: APIPlayerHouse | null;
     constructor(client: Client, data: APIClanMember);
     /** Whether this clan member is in the clan. */
     get isMember(): boolean;

package/dist/struct/ClanMember.js

@@ -18,6 +18,7 @@ class ClanMember {
         this.clanRank = data.clanRank;
         this.previousClanRank = data.previousClanRank;
         this.donations = data.donations;
+        this.playerHouse = data.playerHouse ?? null;
         this.received = data.donationsReceived;
     }
     /** Whether this clan member is in the clan. */

package/dist/struct/ClanWar.d.ts

@@ -101,11 +101,21 @@ export declare class WarClan {
     /** Get clan's formatted link to open clan in-game. */
     get shareLink(): string;
 }
-/** Represents a Clan War in Clash of Clans. */
+/**
+ * Represents a Clan War in Clash of Clans.
+ *
+ * :::caution
+ * It's recommended to see if ClanWar#state is `notInWar` available before performing operations or reading data from it. You can check this with data.ok property.
+ * :::
+ */
 export declare class ClanWar {
     client: Client;
-    /** The clan's current war state. */
-    state: 'preparation' | 'inWar' | 'warEnded';
+    /**
+     * The clan's current war state.
+     *
+     * :warning: Other properties won't be available if the state is `notInWar`.
+     */
+    state: 'preparation' | 'inWar' | 'warEnded' | 'notInWar';
     /** The number of players on each side. */
     teamSize: number;
     /** The number of attacks each member has. */
@@ -135,6 +145,8 @@ 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[];
+    /** Whether the clan is not in war. */
+    get isNotInWar(): boolean;
     /** Whether this is a Battle Day. */
     get isBattleDay(): boolean;
     /** Whether this is a Preparation Day. */

package/dist/struct/ClanWar.js

@@ -137,26 +137,33 @@ class WarClan {
     }
 }
 exports.WarClan = WarClan;
-/** Represents a Clan War in Clash of Clans. */
+/**
+ * Represents a Clan War in Clash of Clans.
+ *
+ * :::caution
+ * It's recommended to see if ClanWar#state is `notInWar` available before performing operations or reading data from it. You can check this with data.ok property.
+ * :::
+ */
 class ClanWar {
     constructor(client, data, extra) {
         Object.defineProperty(this, 'client', { value: client });
-        // @ts-expect-error
         this.state = data.state;
-        this.teamSize = data.teamSize;
-        this.attacksPerMember = data.attacksPerMember ?? (extra.warTag ? 1 : 2);
-        this.preparationStartTime = client.util.formatDate(data.preparationStartTime);
-        this.startTime = client.util.formatDate(data.startTime);
-        this.endTime = client.util.formatDate(data.endTime);
-        this.warTag = extra.warTag ?? null;
-        let [clan, opponent] = [data.clan, data.opponent];
-        const clanTag = extra.clanTag && client.util.formatTag(extra.clanTag);
-        if (clanTag && [data.clan.tag, data.opponent.tag].includes(clanTag)) {
-            clan = data.clan.tag === clanTag ? data.clan : data.opponent;
-            opponent = data.clan.tag === clan.tag ? data.opponent : data.clan;
+        if (this.state !== 'notInWar') {
+            this.teamSize = data.teamSize;
+            this.attacksPerMember = data.attacksPerMember ?? (extra.warTag ? 1 : 2);
+            this.preparationStartTime = client.util.formatDate(data.preparationStartTime);
+            this.startTime = client.util.formatDate(data.startTime);
+            this.endTime = client.util.formatDate(data.endTime);
+            this.warTag = extra.warTag ?? null;
+            let [clan, opponent] = [data.clan, data.opponent];
+            const clanTag = extra.clanTag && client.util.formatTag(extra.clanTag);
+            if (clanTag && [data.clan.tag, data.opponent.tag].includes(clanTag)) {
+                clan = data.clan.tag === clanTag ? data.clan : data.opponent;
+                opponent = data.clan.tag === clan.tag ? data.opponent : data.clan;
+            }
+            this.clan = new WarClan(this, clan);
+            this.opponent = new WarClan(this, opponent);
         }
-        this.clan = new WarClan(this, clan);
-        this.opponent = new WarClan(this, opponent);
         this.maxAge = extra.maxAge;
     }
     /** Return a {@link ClanWarMember} with the tag provided. */
@@ -178,6 +185,10 @@ class ClanWar {
         }
         return this.opponent.attacks.filter((atk) => atk.defenderTag === defenderTag);
     }
+    /** Whether the clan is not in war. */
+    get isNotInWar() {
+        return this.state === 'notInWar';
+    }
     /** Whether this is a Battle Day. */
     get isBattleDay() {
         return this.state === 'inWar';

package/dist/struct/Player.d.ts

@@ -1,9 +1,9 @@
-import { APIPlayer, OverrideOptions } from '../types';
+import { APIPlayer, APIPlayerHouse, OverrideOptions } from '../types';
+import { Client } from '../client/Client';
 import { LegendStatistics } from './LegendStatistics';
 import { Achievement } from './Achievement';
 import { Hero, Spell, Troop } from './Unit';
 import { PlayerClan } from './PlayerClan';
-import { Client } from '../client/Client';
 import { League } from './League';
 import { Label } from './Label';
 /** Represents a Clash of Clans Player. */
@@ -63,6 +63,8 @@ export declare class Player {
     spells: Spell[];
     /** An array of player's heroes (both home base and build base). */
     heroes: Hero[];
+    /** The player's clan capital house details. */
+    playerHouse?: APIPlayerHouse | null;
     constructor(client: Client, data: APIPlayer);
     /** Whether this clan member is in the clan. */
     get inClan(): boolean;

package/dist/struct/Player.js

@@ -40,6 +40,7 @@ class Player {
         this.troops = data.troops.map((unit) => new Unit_1.Troop(data, unit));
         this.spells = data.spells.map((unit) => new Unit_1.Spell(data, unit));
         this.heroes = data.heroes.map((unit) => new Unit_1.Hero(data, unit));
+        this.playerHouse = data.playerHouse ?? null;
     }
     /** Whether this clan member is in the clan. */
     get inClan() {

package/dist/struct/Ranking.d.ts

@@ -1,6 +1,6 @@
 import { APIClanRanking, APIClanVersusRanking, APIPlayerRanking, APIPlayerVersusRanking } from '../types';
-import { PlayerClan } from './PlayerClan';
 import { Client } from '../client/Client';
+import { PlayerClan } from './PlayerClan';
 import { Location } from './Location';
 import { League } from './League';
 import { Badge } from './Badge';

package/dist/struct/Unit.d.ts

@@ -39,8 +39,6 @@ export declare class Unit {
     seasonal: boolean;
     /** Damage per second of this unit. */
     dps: number;
-    /** Resource type of this unit. */
-    resourceType: string;
     /** Training time of this unit. */
     trainingTime: number;
     /** @internal */

package/dist/struct/Unit.js

@@ -25,7 +25,6 @@ class Unit {
             this.unlockBuilding = original.unlock.building;
             this.unlockBuildingLevel = original.unlock.buildingLevel;
             this.dps = rawUnit.dps[this.level - 1];
-            this.resourceType = rawSuperUnit.resource;
             this.trainingTime = rawUnit.trainingTime;
             const origin = data.troops.find((troop) => troop.village === 'home' && troop.name === original.name);
             this.level = origin.level;
@@ -49,7 +48,6 @@ class Unit {
             this.upgradeCost = rawUnit.upgrade.cost[this.level - 1] ?? 0;
             this.upgradeTime = rawUnit.upgrade.time[this.level - 1] ?? 0;
             this.dps = rawUnit.dps[this.level - 1];
-            this.resourceType = rawUnit.resourceType;
             this.trainingTime = rawUnit.trainingTime;
             if (rawUnit.category === 'hero')
                 this.regenerationTime = rawUnit.regenerationTimes[this.level - 1];

package/dist/struct/index.d.ts

@@ -17,3 +17,5 @@ export * from './Ranking';
 export * from './Season';
 export * from './Unit';
 export * from './WarLeague';
+export * from './ClanCapital';
+export * from './CapitalRaidSeason';

package/dist/struct/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];
@@ -29,3 +33,5 @@ __exportStar(require("./Ranking"), exports);
 __exportStar(require("./Season"), exports);
 __exportStar(require("./Unit"), exports);
 __exportStar(require("./WarLeague"), exports);
+__exportStar(require("./ClanCapital"), exports);
+__exportStar(require("./CapitalRaidSeason"), exports);

package/dist/types/api.d.ts

@@ -58,6 +58,9 @@ export interface APIClan {
     labels: APILabel[];
     memberList: APIClanMember[];
     clanCapital: APIClanCapital;
+    isFamilyFriendly: boolean;
+    clanCapitalPoints: number;
+    capitalLeague?: APICapitalLeague;
 }
 export interface APIClanMember {
     name: string;
@@ -71,6 +74,13 @@ export interface APIClanMember {
     previousClanRank: number;
     donations: number;
     donationsReceived: number;
+    playerHouse?: APIPlayerHouse;
+}
+export interface APIPlayerHouse {
+    elements: {
+        type: string;
+        id: number;
+    }[];
 }
 export interface APIClanCapital {
     capitalHallLevel?: number;
@@ -169,6 +179,64 @@ export interface APIClanWarLeagueClanMember {
 export interface APIClanWarLeagueRound {
     warTags: string[];
 }
+export interface APICapitalRaidSeason {
+    state: 'ongoing' | 'ended';
+    startTime: string;
+    endTime: string;
+    capitalTotalLoot: number;
+    raidsCompleted: number;
+    totalAttacks: number;
+    enemyDistrictsDestroyed: number;
+    offensiveReward: number;
+    defensiveReward: number;
+    members?: APICapitalRaidSeasonMember[];
+    attackLog: APICapitalRaidSeasonAttackLog[];
+    defenseLog: APICapitalRaidSeasonDefenseLog[];
+}
+export interface APICapitalRaidSeasonMember {
+    tag: string;
+    name: string;
+    attacks: number;
+    attackLimit: number;
+    bonusAttackLimit: number;
+    capitalResourcesLooted: number;
+}
+export interface APICapitalRaidSeasonClan {
+    tag: string;
+    name: string;
+    level: number;
+    badgeUrls: {
+        small: string;
+        large: string;
+        medium: string;
+    };
+}
+export interface APICapitalRaidSeasonDistrict {
+    id: number;
+    name: string;
+    districtHallLevel: number;
+    destructionPercent: number;
+    attackCount: number;
+    totalLooted: number;
+}
+export interface APICapitalRaidSeasonAttackLog {
+    defender: APICapitalRaidSeasonClan;
+    attackCount: number;
+    districtCount: number;
+    districtsDestroyed: number;
+    districts: APICapitalRaidSeasonDistrict[];
+}
+export interface APICapitalRaidSeasonDefenseLog {
+    attacker: APICapitalRaidSeasonClan;
+    attackCount: number;
+    districtCount: number;
+    districtsDestroyed: number;
+    districts: APICapitalRaidSeasonDistrict[];
+}
+export interface APICapitalRaidSeasons {
+    items: APICapitalRaidSeason[];
+    paging: APIPaging;
+}
 /** /players/{playerTag} */
 export interface APIPlayer {
     name: string;
@@ -199,6 +267,7 @@ export interface APIPlayer {
     heroes: APIPlayerItem[];
     spells: APIPlayerItem[];
     labels: APILabel[];
+    playerHouse?: APIPlayerHouse;
 }
 export interface APILegendStatistics {
     previousSeason?: APISeason;
@@ -313,6 +382,22 @@ export interface APIPlayerVersusRanking {
     previousRank: number;
     clan?: APIPlayerClan;
 }
+export interface APIClanCapitalRanking {
+    clanLevel: number;
+    clanPoints: number;
+    location: APILocation;
+    members: number;
+    tag: string;
+    name: string;
+    rank: number;
+    previousRank: number;
+    badgeUrls: APIBadge;
+    clanCapitalPoints: number;
+}
+export interface APIClanCapitalRankingList {
+    items: APIClanCapitalRanking[];
+    paging: APIPaging;
+}
 /** /leagues */
 export interface APILeagueList {
     items: APILeague[];
@@ -346,6 +431,14 @@ export interface APIWarLeague {
     id: number;
     name: string;
 }
+export interface APICapitalLeague {
+    id: number;
+    name: string;
+}
+export interface APICapitalLeagueList {
+    items: APICapitalLeague[];
+    paging: APIPaging;
+}
 export interface APILabel {
     id: number;
     name: string;