clashofclans.js 1.5.4 → 2.0.0-dev.2c5b083

package/dist/rest/RequestHandler.d.ts

@@ -0,0 +1,162 @@
+import { QueueThrottler, BatchThrottler } from './Throttler';
+import Keyv from 'keyv';
+/** Represents a Request Handler. */
+export declare class RequestHandler {
+    #private;
+    private email;
+    private password;
+    private keyCount;
+    private keyName;
+    private keyDescription?;
+    private keys;
+    private readonly baseURL;
+    private readonly retryLimit;
+    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<Response<T>>;
+    private exec;
+    init(options: InitOptions): Promise<string[]>;
+    private reValidateKeys;
+    private login;
+    private getKeys;
+    private revokeKey;
+    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

@@ -0,0 +1,198 @@
+"use strict";
+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");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _RequestHandler_keyIndex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestHandler = void 0;
+const Constants_1 = require("../util/Constants");
+const HTTPError_1 = require("./HTTPError");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const https_1 = __importDefault(require("https"));
+const keyv_1 = __importDefault(require("keyv"));
+const agent = new https_1.default.Agent({ keepAlive: true });
+/** Represents a Request Handler. */
+class RequestHandler {
+    constructor(options) {
+        _RequestHandler_keyIndex.set(this, 0); // eslint-disable-line
+        this.keys = options?.keys ?? [];
+        this.retryLimit = options?.retryLimit ?? 0;
+        this.throttler = options?.throttler ?? null;
+        this.baseURL = options?.baseURL ?? Constants_1.API_BASE_URL;
+        this.restRequestTimeout = options?.restRequestTimeout ?? 0;
+        if (options?.cache instanceof keyv_1.default)
+            this.cached = options.cache;
+        else
+            this.cached = options?.cache ? new keyv_1.default() : null;
+    }
+    get _keys() {
+        return Array.isArray(this.keys) ? this.keys : [this.keys];
+    }
+    get _key() {
+        const key = this._keys[__classPrivateFieldGet(this, _RequestHandler_keyIndex, "f")];
+        __classPrivateFieldSet(this, _RequestHandler_keyIndex, __classPrivateFieldGet(this, _RequestHandler_keyIndex, "f") + 1 >= this._keys.length ? 0 : __classPrivateFieldGet(this, _RequestHandler_keyIndex, "f") + 1, "f");
+        return key;
+    }
+    setKeys(keys) {
+        this.keys = keys;
+        return this;
+    }
+    async request(path, options = {}) {
+        const cached = (await this.cached?.get(path)) ?? null;
+        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();
+        try {
+            return await this.exec(path, options);
+        }
+        finally {
+            await this.throttler.throttle();
+        }
+    }
+    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 (res?.status === 403 && data?.reason === 'accessDenied.invalidIp' && this.email && this.password) {
+            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, 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))
+            throw ReferenceError('Missing email and password.');
+        this.keyDescription = options.keyDescription;
+        this.keyName = options.keyName ?? 'clashofclans.js.keys';
+        this.keyCount = Math.min(options.keyCount ?? 1, 10);
+        this.password = options.password;
+        this.email = options.email;
+        await this.reValidateKeys();
+        return this.login();
+    }
+    async reValidateKeys() {
+        for (const key of this.keys) {
+            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' }
+            }).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.`);
+            }
+        }
+    }
+    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 })
+        });
+        if (res.ok) {
+            return this.getKeys(res.headers.get('set-cookie'));
+        }
+        throw new ReferenceError('Invalid email or password.');
+    }
+    async getKeys(cookie) {
+        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.
+        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);
+            keys.splice(index, 1);
+        }
+        // Filter keys for current IP address and specified key name.
+        for (const key of keys.filter((key) => key.name === this.keyName && key.cidrRanges.includes(ip))) {
+            if (this.keys.length >= this.keyCount)
+                break;
+            if (!this.keys.includes(key.key))
+                this.keys.push(key.key);
+        }
+        // Create keys within limits (maximum of 10 keys per account)
+        while (this.keys.length < this.keyCount && keys.length < 10) {
+            const key = await this.createKey(cookie, ip);
+            this.keys.push(key.key);
+            keys.push(key);
+        }
+        if (this.keys.length < this.keyCount && keys.length === 10) {
+            console.warn(`[WARN] ${this.keyCount} key(s) were requested but failed to create ${this.keyCount - this.keys.length} more key(s).`);
+        }
+        if (!this.keys.length) {
+            throw new Error([
+                `${keys.length} API keys were created but none match a key name of "${this.keyName}" and IP "${ip}".`,
+                `Specify a key name or go to "https://developer.clashofclans.com" to delete unused keys.`
+            ].join(' '));
+        }
+        return this.keys;
+    }
+    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 }
+        });
+        return res.ok;
+    }
+    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],
+                name: this.keyName,
+                description: this.keyDescription ?? new Date().toUTCString()
+            })
+        });
+        const data = await res.json();
+        return data.key;
+    }
+    async getIp() {
+        return (0, node_fetch_1.default)('https://api.ipify.org/', { timeout: 10000 }).then((res) => res.text());
+    }
+}
+exports.RequestHandler = RequestHandler;
+_RequestHandler_keyIndex = new WeakMap();

package/dist/rest/Throttler.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Represents a throttler that sleeps for x ms between each request.
+ * ```js
+ * const throttler = new QueueThrottler(1000 / 10);
+ * // 10 requests per second or sleep for 100ms between each request.
+ * ```
+ */
+export declare class QueueThrottler {
+    private lastRun?;
+    private readonly sleepTime;
+    private readonly promises;
+    constructor(sleepTime?: number);
+    get remaining(): number;
+    throttle(): Promise<void>;
+    wait(): Promise<void>;
+    private shift;
+}
+/**
+ * Represents a throttler that allows x requests per second before sleeping until the next second.
+ * ```js
+ * const throttler = new BatchThrottler(30);
+ * // 30 requests every second.
+ * ```
+ */
+export declare class BatchThrottler {
+    #private;
+    private readonly rateLimit;
+    constructor(rateLimit?: number);
+    wait(): Promise<void>;
+    throttle(): Promise<void>;
+}

package/dist/rest/Throttler.js

@@ -0,0 +1,86 @@
+"use strict";
+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");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _BatchThrottler_taskLogs;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchThrottler = exports.QueueThrottler = void 0;
+const Util_1 = require("../util/Util");
+/**
+ * Represents a throttler that sleeps for x ms between each request.
+ * ```js
+ * const throttler = new QueueThrottler(1000 / 10);
+ * // 10 requests per second or sleep for 100ms between each request.
+ * ```
+ */
+class QueueThrottler {
+    constructor(sleepTime = 100) {
+        this.promises = [];
+        this.sleepTime = sleepTime;
+    }
+    get remaining() {
+        return this.promises.length;
+    }
+    async throttle() {
+        if (this.lastRun) {
+            const difference = Date.now() - this.lastRun;
+            const needToSleep = this.sleepTime - difference;
+            if (needToSleep > 0)
+                await Util_1.Util.delay(needToSleep);
+        }
+        this.lastRun = Date.now();
+        return this.shift();
+    }
+    wait() {
+        const next = this.promises.length ? this.promises[this.promises.length - 1].promise : Promise.resolve();
+        let resolve;
+        const promise = new Promise((res) => {
+            resolve = res;
+        });
+        this.promises.push({ resolve: resolve, promise });
+        return next;
+    }
+    shift() {
+        const deferred = this.promises.shift();
+        if (typeof deferred !== 'undefined')
+            deferred.resolve();
+    }
+}
+exports.QueueThrottler = QueueThrottler;
+/**
+ * Represents a throttler that allows x requests per second before sleeping until the next second.
+ * ```js
+ * const throttler = new BatchThrottler(30);
+ * // 30 requests every second.
+ * ```
+ */
+class BatchThrottler {
+    constructor(rateLimit = 10) {
+        _BatchThrottler_taskLogs.set(this, []); // eslint-disable-line
+        this.rateLimit = rateLimit;
+    }
+    async wait() {
+        return Promise.resolve();
+    }
+    async throttle() {
+        while (true) { // eslint-disable-line
+            const now = Date.now();
+            while (__classPrivateFieldGet(this, _BatchThrottler_taskLogs, "f").length) {
+                if (now - __classPrivateFieldGet(this, _BatchThrottler_taskLogs, "f")[0] > 1000) {
+                    __classPrivateFieldGet(this, _BatchThrottler_taskLogs, "f").shift();
+                }
+                else {
+                    break;
+                }
+            }
+            if (__classPrivateFieldGet(this, _BatchThrottler_taskLogs, "f").length < this.rateLimit)
+                break;
+            await Util_1.Util.delay(1000);
+        }
+        __classPrivateFieldGet(this, _BatchThrottler_taskLogs, "f").push(Date.now());
+    }
+}
+exports.BatchThrottler = BatchThrottler;
+_BatchThrottler_taskLogs = new WeakMap();

package/dist/struct/Achievement.d.ts

@@ -0,0 +1,25 @@
+import { APIPlayerAchievement } from '../types';
+/** Represents a Clash of Clans Achievement. */
+export declare class Achievement {
+    /** The name of the achievement. */
+    name: string;
+    /** The current stars achieved for the achievement. */
+    stars: number;
+    /** The number of X things attained for this achievement. */
+    value: number;
+    /** The number of X things required to complete this achievement. */
+    target: number;
+    /** Information regarding the achievement. */
+    info: string;
+    /** The village this achievement belongs to.  */
+    village: 'home' | 'builderBase';
+    /** Information regarding completion of the achievement. */
+    completionInfo: string | null;
+    constructor(data: APIPlayerAchievement);
+    /** Whether achievement belongs to the home base. */
+    get isHomeBase(): boolean;
+    /** Whether the achievement belongs to the builder base. */
+    get isBuilderBase(): boolean;
+    /** Whether the achievement is completed. */
+    get isCompleted(): boolean;
+}

package/dist/struct/Achievement.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Achievement = void 0;
+/** Represents a Clash of Clans Achievement. */
+class Achievement {
+    constructor(data) {
+        this.name = data.name;
+        this.stars = data.stars;
+        this.value = data.value;
+        this.target = data.target;
+        this.info = data.info;
+        this.village = data.village;
+        this.completionInfo = data.completionInfo ?? null;
+    }
+    /** Whether achievement belongs to the home base. */
+    get isHomeBase() {
+        return this.village === 'home';
+    }
+    /** Whether the achievement belongs to the builder base. */
+    get isBuilderBase() {
+        return this.village === 'builderBase';
+    }
+    /** Whether the achievement is completed. */
+    get isCompleted() {
+        return this.stars === 3;
+    }
+}
+exports.Achievement = Achievement;

package/dist/struct/Badge.d.ts

@@ -0,0 +1,16 @@
+import { APIBadge } from '../types';
+/** Represents a Clash of Clans Badge. */
+export declare class Badge {
+    private readonly _data;
+    /** The default badge URL. */
+    url: string;
+    constructor(data: APIBadge);
+    /** The large badge URL. */
+    get large(): string;
+    /** The medium badge URL. */
+    get medium(): string;
+    /** The small badge URL. */
+    get small(): string;
+    /** Get unique hash of this Badge. */
+    get hash(): string;
+}

package/dist/struct/Badge.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Badge = void 0;
+/** Represents a Clash of Clans Badge. */
+class Badge {
+    constructor(data) {
+        Object.defineProperty(this, '_data', { value: data });
+        this.url = data.large;
+    }
+    /** The large badge URL. */
+    get large() {
+        return this._data.large;
+    }
+    /** The medium badge URL. */
+    get medium() {
+        return this._data.medium;
+    }
+    /** The small badge URL. */
+    get small() {
+        return this._data.small;
+    }
+    /** Get unique hash of this Badge. */
+    get hash() {
+        return this.url.split('/').pop();
+    }
+}
+exports.Badge = Badge;

package/dist/struct/ChatLanguage.d.ts

@@ -0,0 +1,11 @@
+import { APIChatLanguage } from '../types';
+/** Represents a Clan's Chat Language. */
+export declare class ChatLanguage {
+    /** The language's unique Id. */
+    id: number;
+    /** The language's full name. */
+    name: string;
+    /** The language's code. */
+    code: string;
+    constructor(data: APIChatLanguage);
+}

package/dist/struct/ChatLanguage.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatLanguage = void 0;
+/** Represents a Clan's Chat Language. */
+class ChatLanguage {
+    constructor(data) {
+        this.id = data.id;
+        this.name = data.name;
+        this.code = data.languageCode;
+    }
+}
+exports.ChatLanguage = ChatLanguage;

package/dist/struct/Clan.d.ts

@@ -0,0 +1,64 @@
+import { OverrideOptions } from '../rest/RequestHandler';
+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';
+import { APIClan } from '../types';
+import { Label } from './Label';
+import { Badge } from './Badge';
+/** Represents a Clan. */
+export declare class Clan {
+    client: Client;
+    /** Name of the clan. */
+    name: string;
+    /** Tag of the clan. */
+    tag: string;
+    /** The clan's type for accepting members. */
+    type: 'open' | 'inviteOnly' | 'closed';
+    /** The clan's description. */
+    description: string;
+    /** The location of this clan. */
+    location: Location | null;
+    /** The clan's trophy count. */
+    chatLanguage: ChatLanguage | null;
+    /** The clan's Badge. */
+    badge: Badge;
+    /** The clan's level. */
+    level: number;
+    /** The clan's trophy count. */
+    points: number;
+    /** The clan's versus trophy count. */
+    versusPoints: number;
+    /** The minimum trophies required to apply to this clan. */
+    requiredTrophies: number;
+    /** The minimum hall level required to apply to this clan. */
+    requiredTownHallLevel: number | null;
+    /** The frequency for when this clan goes to war. */
+    warFrequency: 'always' | 'moreThanOncePerWeek' | 'oncePerWeek' | 'lessThanOncePerWeek' | 'never' | 'unknown';
+    /** The clan's current war winning streak. */
+    warWinStreak: number;
+    /** The number of wars the clan has won. */
+    warWins: number;
+    /** The number of wars the clan has tied. */
+    warTies: number | null;
+    /** The number of wars the clan has lost. */
+    warLosses: number | null;
+    /** Indicates if the clan has a public war log. */
+    isWarLogPublic: boolean;
+    /** The clan's CWL league. */
+    warLeague: WarLeague | null;
+    /** The number of members in the clan. */
+    memberCount: number;
+    /** An array of {@link Label} that the clan has. */
+    labels: Label[];
+    /**
+     * List of clan members.
+     * - This property returns empty array for {@link Client.getClans} method.
+     */
+    members: ClanMember[];
+    constructor(client: Client, data: APIClan);
+    /** Get {@link Player} information for every Player in the clan. */
+    fetchMembers(options?: OverrideOptions): Promise<Player[]>;
+}