clashofclans.js 1.5.4 → 2.0.0-dev.2c5b083

package/dist/struct/Clan.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Clan = void 0;
+const ChatLanguage_1 = require("./ChatLanguage");
+const ClanMember_1 = require("./ClanMember");
+const WarLeague_1 = require("./WarLeague");
+const Location_1 = require("./Location");
+const Label_1 = require("./Label");
+const Badge_1 = require("./Badge");
+/** Represents a Clan. */
+class Clan {
+    constructor(client, data) {
+        this.client = client;
+        this.name = data.name;
+        this.tag = data.tag;
+        this.type = data.type;
+        this.description = data.description;
+        this.location = data.location ? new Location_1.Location(data.location) : null;
+        this.chatLanguage = data.chatLanguage ? new ChatLanguage_1.ChatLanguage(data.chatLanguage) : null;
+        this.badge = new Badge_1.Badge(data.badgeUrls);
+        this.level = data.clanLevel;
+        this.points = data.clanPoints;
+        this.versusPoints = data.clanVersusPoints;
+        this.requiredTrophies = data.requiredTrophies;
+        this.requiredTownHallLevel = data.requiredTownhallLevel ?? null;
+        this.warFrequency = data.warFrequency;
+        this.warWinStreak = data.warWinStreak;
+        this.warWins = data.warWins;
+        this.warTies = data.warTies ?? null;
+        this.warLosses = data.warLosses ?? null;
+        this.isWarLogPublic = data.isWarLogPublic;
+        this.warLeague = data.warLeague ? new WarLeague_1.WarLeague(data.warLeague) : null;
+        this.memberCount = data.members;
+        this.labels = data.labels.map((label) => new Label_1.Label(label));
+        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(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.Clan = Clan;

package/dist/struct/ClanMember.d.ts

@@ -0,0 +1,32 @@
+import { OverrideOptions } from '../rest/RequestHandler';
+import { Client } from '../client/Client';
+import { APIClanMember } from '../types';
+import { League } from './League';
+export declare class ClanMember {
+    client: Client;
+    /** The member's name. */
+    name: string;
+    /** The member's tag. */
+    tag: string;
+    /** The member's role in the clan. */
+    role: 'member' | 'elder' | 'coLeader' | 'leader';
+    /** The member's experience level. */
+    expLevel: number;
+    /** The member's current League. */
+    league: League;
+    /** The member's trophy count. */
+    trophies: number;
+    /** The member's versus trophy count. */
+    versusTrophies: number | null;
+    /** The member's rank in the clan. */
+    clanRank: number;
+    /** The member's rank before the last leader-board change. */
+    previousClanRank: number;
+    /** The member's donation count for this season. */
+    donations: number;
+    /** The member's donation received count for this season. */
+    received: number;
+    constructor(client: Client, data: APIClanMember);
+    /** Fetch detailed clan info for the member's clan. */
+    fetch(options?: OverrideOptions): Promise<import("./Player").Player>;
+}

package/dist/struct/ClanMember.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClanMember = void 0;
+const Constants_1 = require("../util/Constants");
+const League_1 = require("./League");
+class ClanMember {
+    constructor(client, data) {
+        this.client = client;
+        this.name = data.name;
+        this.tag = data.tag;
+        // @ts-expect-error
+        this.role = data.role.replace('admin', 'elder');
+        this.expLevel = data.expLevel;
+        // eslint-disable-next-line
+        this.league = new League_1.League(data.league ?? Constants_1.UNRANKED_LEAGUE_DATA);
+        this.trophies = data.trophies;
+        this.versusTrophies = data.versusTrophies ?? null;
+        this.clanRank = data.clanRank;
+        this.previousClanRank = data.previousClanRank;
+        this.donations = data.donations;
+        this.received = data.donationsReceived;
+    }
+    /** Fetch detailed clan info for the member's clan. */
+    async fetch(options) {
+        return this.client.getPlayer(this.tag, options);
+    }
+}
+exports.ClanMember = ClanMember;

package/dist/struct/ClanWar.d.ts

@@ -0,0 +1,137 @@
+import { APIClanWar, APIClanWarAttack, APIClanWarMember, APIWarClan } from '../types';
+import { Client } from '../client/Client';
+import { Badge } from './Badge';
+/** Represents a Clash of Clans War Attack. */
+export declare class ClanWarAttack {
+    /** The war this attack belongs to. */
+    war: ClanWar;
+    /** The clan this attack belongs to. */
+    clan: WarClan;
+    /** The stars achieved. */
+    stars: number;
+    /** The destruction achieved as a percentage. */
+    destruction: number;
+    /** The attack order in this war. */
+    order: number;
+    /** Duration of attack in seconds. */
+    duration: number;
+    /** The attacker tag. */
+    attackerTag: string;
+    /** The defender tag. */
+    defenderTag: string;
+    constructor(clan: WarClan, war: ClanWar, data: APIClanWarAttack);
+    /** Returns the defending player. */
+    get defender(): ClanWarMember;
+    /** Returns the attacking player. */
+    get attacker(): ClanWarMember;
+    /** Returns whether the attack is a fresh or first attack on the defender. */
+    get isFresh(): boolean;
+    /**
+     * Returns the previous best attack on this opponent village.
+     * This is useful for calculating the new stars or destruction for new attacks.
+     */
+    previousBestAttack(): ClanWarAttack | null;
+}
+/** Represents a Clash of Clans War Member. */
+export declare class ClanWarMember {
+    private readonly _bestOpponentAttackerTag?;
+    /** The current war this member is in. */
+    war: ClanWar;
+    /** The member's clan. */
+    clan: WarClan;
+    /** The member's name. */
+    name: string;
+    /** The member's tag. */
+    tag: string;
+    /** The member's map position in the war. */
+    mapPosition: number;
+    /** The member's town hall level. */
+    townHallLevel: number;
+    /** The member's attacks this war. */
+    attacks: ClanWarAttack[];
+    /** The number of times this member has been attacked. */
+    defenseCount: number;
+    constructor(clan: WarClan, war: ClanWar, data: APIClanWarMember);
+    /** Whether the member is from the opponent clan. */
+    get isOpponent(): boolean;
+    /** The member's defenses this war. */
+    get defenses(): ClanWarAttack[];
+    /** Best opponent attack on this base. */
+    get bestOpponentAttack(): ClanWarAttack | null;
+    /**
+     * Returns the previous best opponent attack on this village.
+     * This is useful for calculating the new stars or destruction for new attacks.
+     */
+    previousBestOpponentAttack(): ClanWarAttack | null;
+}
+/** Represents a War Clan. */
+export declare class WarClan {
+    private readonly war;
+    /** The clan's name. */
+    name: string;
+    /** The clan's tag. */
+    tag: string;
+    /** The clan's badge. */
+    badge: Badge;
+    /** The clan's level. */
+    level: number;
+    /** Number of stars achieved by this clan. */
+    stars: number;
+    /** The destruction achieved as a percentage. */
+    destruction: number;
+    /** An array of members that are in the war. */
+    members: ClanWarMember[];
+    /** Total attacks used by this clan. */
+    attackCount: number;
+    constructor(war: ClanWar, data: APIWarClan);
+    /** Whether the clan is the opponent clan. */
+    get isOpponent(): boolean;
+    /** Average duration of all clan member's attacks. */
+    get averageAttackDuration(): number;
+    /** Returns all clan member's attacks. */
+    get attacks(): ClanWarAttack[];
+    /** Returns all clan member's defenses. */
+    get defenses(): ClanWarAttack[];
+    /** Get a member of the clan for the given tag, or `null` if not found. */
+    getMember(tag: string): ClanWarMember | null;
+}
+/** Represents a Clan War in Clash of Clans. */
+export declare class ClanWar {
+    client: Client;
+    /** The clan's current war state. */
+    state: 'preparation' | 'inWar' | 'warEnded';
+    /** The number of players on each side. */
+    teamSize: number;
+    /** The number of attacks each member has. */
+    attacksPerMember: number;
+    /** The Date that preparation day started at. */
+    preparationStartTime: Date;
+    /** The Date that battle day starts at. */
+    startTime: Date;
+    /** The Date that battle day ends at. */
+    endTime: Date;
+    /** The home clan. */
+    clan: WarClan;
+    /** The opposition clan. */
+    opponent: WarClan;
+    /** The war's unique tag. This is `null` unless this is a CWL.  */
+    warTag: string | null;
+    /** Maximum number of milliseconds the results can be cached. */
+    maxAge: number;
+    constructor(client: Client, data: APIClanWar, extra: {
+        clanTag?: string;
+        warTag?: string;
+        maxAge: number;
+    });
+    /** Return a {@link ClanWarMember} with the tag provided. */
+    getMember(tag: string): ClanWarMember | null;
+    /** Return a list of {@link ClanWarAttack} for the attackerTag and defenderTag provided. */
+    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 `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

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClanWar = exports.WarClan = exports.ClanWarMember = exports.ClanWarAttack = void 0;
+const Constants_1 = require("../util/Constants");
+const Badge_1 = require("./Badge");
+/** Represents a Clash of Clans War Attack. */
+class ClanWarAttack {
+    constructor(clan, war, data) {
+        Object.defineProperty(this, 'clan', { value: clan });
+        Object.defineProperty(this, 'war', { value: war });
+        this.stars = data.stars;
+        this.destruction = data.destructionPercentage;
+        this.order = data.order;
+        this.duration = data.duration;
+        this.attackerTag = data.attackerTag;
+        this.defenderTag = data.defenderTag;
+    }
+    /** Returns the defending player. */
+    get defender() {
+        return this.war.getMember(this.defenderTag);
+    }
+    /** Returns the attacking player. */
+    get attacker() {
+        return this.war.getMember(this.attackerTag);
+    }
+    /** Returns whether the attack is a fresh or first attack on the defender. */
+    get isFresh() {
+        if (this.defender.defenses.length === 1)
+            return true;
+        return this.order === Math.min(...this.defender.defenses.map((def) => def.order));
+    }
+    /**
+     * Returns the previous best attack on this opponent village.
+     * This is useful for calculating the new stars or destruction for new attacks.
+     */
+    previousBestAttack() {
+        if (this.isFresh)
+            return null;
+        return (
+        // Let's not change the original array
+        [...this.clan.attacks]
+            .filter((atk) => atk.defenderTag === this.defenderTag && atk.order < this.order && atk.attackerTag !== this.attackerTag)
+            .sort((a, b) => b.destruction ** b.stars - a.destruction ** a.stars)
+            .at(0) ?? null);
+    }
+}
+exports.ClanWarAttack = ClanWarAttack;
+/** Represents a Clash of Clans War Member. */
+class ClanWarMember {
+    constructor(clan, war, data) {
+        Object.defineProperty(this, 'clan', { value: clan });
+        Object.defineProperty(this, 'war', { value: war });
+        this.name = data.name;
+        this.tag = data.tag;
+        this.mapPosition = data.mapPosition;
+        this.townHallLevel = data.townhallLevel;
+        this.attacks = data.attacks?.map((atk) => new ClanWarAttack(clan, war, atk)) ?? [];
+        this.defenseCount = data.opponentAttacks;
+        this._bestOpponentAttackerTag = data.bestOpponentAttack?.attackerTag;
+    }
+    /** Whether the member is from the opponent clan. */
+    get isOpponent() {
+        return this.clan.tag === this.war.opponent.tag;
+    }
+    /** The member's defenses this war. */
+    get defenses() {
+        return this.war.getDefenses(this.tag);
+    }
+    /** Best opponent attack on this base. */
+    get bestOpponentAttack() {
+        if (!this._bestOpponentAttackerTag)
+            return null;
+        return this.war.getAttack(this._bestOpponentAttackerTag, this.tag);
+    }
+    /**
+     * Returns the previous best opponent attack on this village.
+     * This is useful for calculating the new stars or destruction for new attacks.
+     */
+    previousBestOpponentAttack() {
+        return (
+        // Let's not change the original array
+        [...this.defenses]
+            .filter((def) => def.defenderTag === this.tag && def.attackerTag !== this.bestOpponentAttack?.attackerTag)
+            .sort((a, b) => b.destruction ** b.stars - a.destruction ** a.stars)
+            .at(0) ?? null);
+    }
+}
+exports.ClanWarMember = ClanWarMember;
+/** Represents a War Clan. */
+class WarClan {
+    constructor(war, data) {
+        Object.defineProperty(this, 'war', { value: war });
+        this.name = data.name;
+        this.tag = data.tag;
+        this.badge = new Badge_1.Badge(data.badgeUrls);
+        this.level = data.clanLevel;
+        this.stars = data.stars;
+        this.attackCount = data.attacks;
+        this.destruction = data.destructionPercentage;
+        this.members = data.members.map((mem) => new ClanWarMember(this, war, mem));
+    }
+    /** Whether the clan is the opponent clan. */
+    get isOpponent() {
+        return this.tag === this.war.opponent.tag;
+    }
+    /** Average duration of all clan member's attacks. */
+    get averageAttackDuration() {
+        if (!this.attackCount)
+            return 0;
+        return this.attacks.reduce((prev, curr) => prev + curr.duration, 0) / this.attackCount;
+    }
+    /** Returns all clan member's attacks. */
+    get attacks() {
+        return this.members
+            .filter((m) => m.attacks.length)
+            .map((m) => m.attacks)
+            .flat()
+            .sort((a, b) => a.order - b.order);
+    }
+    /** Returns all clan member's defenses. */
+    get defenses() {
+        return this.isOpponent ? this.war.clan.attacks : this.war.opponent.attacks;
+    }
+    /** Get a member of the clan for the given tag, or `null` if not found. */
+    getMember(tag) {
+        return this.members.find((m) => m.tag === tag) ?? null;
+    }
+}
+exports.WarClan = WarClan;
+/** Represents a Clan War in Clash of Clans. */
+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;
+        this.preparationStartTime = client.util.parseDate(data.preparationStartTime);
+        this.startTime = client.util.parseDate(data.startTime);
+        this.endTime = client.util.parseDate(data.endTime);
+        this.warTag = extra.warTag ?? null;
+        let [clan, opponent] = [data.clan, data.opponent];
+        const clanTag = extra.clanTag && client.util.parseTag(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.maxAge = extra.maxAge;
+    }
+    /** Return a {@link ClanWarMember} with the tag provided. */
+    getMember(tag) {
+        return this.clan.getMember(tag) ?? this.opponent.getMember(tag) ?? null;
+    }
+    /** Return a list of {@link ClanWarAttack} for the attackerTag and defenderTag provided. */
+    getAttack(attackerTag, defenderTag) {
+        const attacker = this.getMember(attackerTag);
+        if (!attacker?.attacks.length)
+            return null;
+        return attacker.attacks.find((atk) => atk.defenderTag === defenderTag) ?? null;
+    }
+    /** Return a list of {@link ClanWarAttack} for the defenderTag provided. */
+    getDefenses(defenderTag) {
+        const defender = this.getMember(defenderTag);
+        if (defender.isOpponent) {
+            return this.clan.attacks.filter((atk) => atk.defenderTag === defenderTag);
+        }
+        return this.opponent.attacks.filter((atk) => atk.defenderTag === defenderTag);
+    }
+    /** Returns either `friendly`, `cwl` or `normal`. */
+    get type() {
+        if (this._isFriendly)
+            return 'friendly';
+        if (this.warTag)
+            return 'cwl';
+        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

@@ -0,0 +1,63 @@
+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';
+import { Badge } from './Badge';
+/** Represents a Clan War League member.  */
+export declare class ClanWarLeagueClanMember {
+    /** The member's name. */
+    name: string;
+    /** The member's tag. */
+    tag: string;
+    /** The member's town hall level. */
+    townHallLevel: number;
+    constructor(data: APIClanWarLeagueClanMember);
+}
+/** Represents a Clan of CWL Group. */
+export declare class ClanWarLeagueClan {
+    private readonly client;
+    /** The clan's name. */
+    name: string;
+    /** The clan's tag. */
+    tag: string;
+    /** The clan's level. */
+    level: number;
+    /** The clan's badge. */
+    badge: Badge;
+    /** An array of members that are in the CWL group. */
+    members: ClanWarLeagueClanMember[];
+    constructor(client: Client, data: APIClanWarLeagueClan);
+    /** Get {@link Player} information for every members that are in the CWL group. */
+    fetchMembers(options?: OverrideOptions): Promise<Player[]>;
+}
+/** Represents a Round of CWL Group. */
+export declare class ClanWarLeagueRound {
+    /** War Tags for this round. */
+    warTags: string[];
+    /** The # (1-7) of this round. */
+    round: number;
+    constructor(data: APIClanWarLeagueRound, round: number);
+}
+/** Represents a CWL Group. */
+export declare class ClanWarLeagueGroup {
+    private readonly client;
+    /** The CWL group's current war state. */
+    state: 'preparation' | 'inWar' | 'warEnded';
+    /** Season Id of this CWL group. */
+    season: string;
+    /** Returns all participating clans. */
+    clans: ClanWarLeagueClan[];
+    /** An array containing all war tags for each round. */
+    rounds: ClanWarLeagueRound[];
+    constructor(client: Client, data: APIClanWarLeagueGroup);
+    /**
+     * 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, options?: OverrideOptions): Promise<ClanWar[]>;
+    private _getCurrentWars;
+    /** Returns the index of the round for this specified warTag. */
+    getRoundIndex(warTag: string): number | null;
+}

package/dist/struct/ClanWarLeagueGroup.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClanWarLeagueGroup = exports.ClanWarLeagueRound = exports.ClanWarLeagueClan = exports.ClanWarLeagueClanMember = void 0;
+const Badge_1 = require("./Badge");
+/** Represents a Clan War League member.  */
+class ClanWarLeagueClanMember {
+    constructor(data) {
+        this.name = data.name;
+        this.tag = data.tag;
+        this.townHallLevel = data.townHallLevel;
+    }
+}
+exports.ClanWarLeagueClanMember = ClanWarLeagueClanMember;
+/** Represents a Clan of CWL Group. */
+class ClanWarLeagueClan {
+    constructor(client, data) {
+        this.client = client;
+        this.name = data.name;
+        this.tag = data.tag;
+        this.level = data.clanLevel;
+        this.badge = new Badge_1.Badge(data.badgeUrls);
+        this.members = data.members.map((mem) => new ClanWarLeagueClanMember(mem));
+    }
+    /** Get {@link Player} information for every members that are in the CWL group. */
+    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.ClanWarLeagueClan = ClanWarLeagueClan;
+/** Represents a Round of CWL Group. */
+class ClanWarLeagueRound {
+    constructor(data, round) {
+        this.warTags = data.warTags;
+        this.round = round + 1;
+    }
+}
+exports.ClanWarLeagueRound = ClanWarLeagueRound;
+/** Represents a CWL Group. */
+class ClanWarLeagueGroup {
+    constructor(client, data) {
+        this.client = client;
+        this.state = data.state;
+        this.season = data.season;
+        this.clans = data.clans.map((clan) => new ClanWarLeagueClan(client, clan));
+        this.rounds = data.rounds.map((round, i) => new ClanWarLeagueRound(round, i));
+    }
+    /**
+     * 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, 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 }, { ...options, ignoreRateLimit: true })));
+        return wars
+            .filter((res) => res.status === 'fulfilled')
+            .map((res) => res.value)
+            .filter((war) => (clanTag ? war.clan.tag === clanTag : true));
+    }
+    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()
+            .reverse();
+        const wars = await Promise.allSettled(warTags.map((warTag) => this.client.getClanWarLeagueRound({ warTag, clanTag }, { ...options, ignoreRateLimit: true })));
+        return wars
+            .filter((res) => res.status === 'fulfilled')
+            .map((res) => res.value)
+            .filter((war) => war.clan.tag === clanTag);
+    }
+    /** Returns the index of the round for this specified warTag. */
+    getRoundIndex(warTag) {
+        return this.rounds.find((round) => round.warTags.includes(warTag))?.round ?? null;
+    }
+}
+exports.ClanWarLeagueGroup = ClanWarLeagueGroup;

package/dist/struct/ClanWarLog.d.ts

@@ -0,0 +1,54 @@
+import { APIClanWarLogEntry, APIWarLogClan } from '../types';
+import { Client } from '../client/Client';
+import { Badge } from './Badge';
+/**
+ * Represents War Log Clan.
+ *
+ * :::caution
+ * If this is called via {@link ClanWarLog.opponent}, then {@link WarLogClan.attackCount} and {@link WarLogClan.expEarned} will be `null`.
+ * For CWL entries {@link WarLogClan.name} and {@link WarLogClan.tag} are `null`.
+ * :::
+ */
+export declare class WarLogClan {
+    /** The clan's name. This property is `null` CWL entries. */
+    name: string | null;
+    /** The clan's tag. This property is `null` CWL entries. */
+    tag: string | null;
+    /** The clan's badge. */
+    badge: Badge;
+    /** The clan's level. */
+    level: number;
+    /** Number of stars achieved by this clan. */
+    stars: number;
+    /** The destruction achieved as a percentage. */
+    destruction: number;
+    /**
+     * Total XP earned by clan this war.
+     * This property is `null` for the opponent.
+     */
+    expEarned: number | null;
+    /**
+     * Total attacks used by this clan.
+     * This property is `null` for the opponent.
+     */
+    attackCount: number | null;
+    constructor(data: APIWarLogClan);
+}
+export declare class ClanWarLog {
+    client: Client;
+    /** The result of the war. */
+    result: 'win' | 'lose' | 'tie' | null;
+    /** The Date that battle day ends at. */
+    endTime: Date;
+    /** The number of players on each side. */
+    teamSize: number;
+    /** The number of attacks each member has. */
+    attacksPerMember: number | null;
+    /** The home clan. */
+    clan: WarLogClan;
+    /** The opposition clan. */
+    opponent: WarLogClan;
+    constructor(client: Client, data: APIClanWarLogEntry);
+    /** Returns either `friendly`, `cwl` or `normal`. */
+    get type(): "friendly" | "cwl" | "normal";
+}