@wise-old-man/utils 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/index.js

@@ -97,6 +97,32 @@ function sendPostRequest(path, body) {
         });
     });
 }
+function sendPutRequest(path, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestURL = `${config.apiBaseUrl}${path}`;
+        return axios__default["default"]
+            .put(requestURL, body || {})
+            .then(response => transformDates(response.data))
+            .catch(e => {
+            if (axios__default["default"].isAxiosError(e))
+                handleError(requestURL, e);
+            throw e;
+        });
+    });
+}
+function sendDeleteRequest(path, body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestURL = `${config.apiBaseUrl}${path}`;
+        return axios__default["default"]
+            .delete(requestURL, { data: body })
+            .then(response => transformDates(response.data))
+            .catch(e => {
+            if (axios__default["default"].isAxiosError(e))
+                handleError(requestURL, e);
+            throw e;
+        });
+    });
+}
 function sendGetRequest(path, params) {
     return __awaiter(this, void 0, void 0, function* () {
         const requestURL = `${config.apiBaseUrl}${path}`;
@@ -152,72 +178,262 @@ class InternalServerError extends Error {
     }
 }
 
-function getPlayerURL(player) {
-    if (typeof player === 'string') {
-        return `/players/${player}`;
+class DeltasClient {
+    /**
+     * Fetches the current top leaderboard for a specific metric, period, playerType, playerBuild and country.
+     * @returns A list of deltas, with their respective players, values and dates included.
+     */
+    getDeltaLeaderboard(filter) {
+        return sendGetRequest('/deltas/leaderboard', filter);
     }
-    if (player.id) {
-        return `/players/id/${player.id}`;
+}
+
+class GroupsClient {
+    /**
+     * Searches for groups that match a partial name.
+     * @returns A list of groups.
+     */
+    searchGroups(name, pagination) {
+        return sendGetRequest('/groups', Object.assign({ name }, pagination));
+    }
+    /**
+     * Fetches a group's details.
+     * @returns A group details object.
+     */
+    getGroupDetails(id) {
+        return sendGetRequest(`/groups/${id}`);
+    }
+    /**
+     * Fetches a group's entire members list.
+     * @returns A list of memberships, with players included.
+     */
+    getGroupMembers(id) {
+        return sendGetRequest(`/groups/${id}/members`);
+    }
+    /**
+     * Creates a new group.
+     * @returns The newly created group, and the verification code that authorizes future changes to it.
+     */
+    createGroup(payload) {
+        return sendPostRequest('/groups', payload);
+    }
+    /**
+     * Edits an existing group.
+     * @returns The updated group.
+     */
+    editGroup(id, payload, verificationCode) {
+        return sendPutRequest(`/groups/${id}`, Object.assign(Object.assign({}, payload), { verificationCode }));
+    }
+    /**
+     * Deletes an existing group.
+     * @returns A confirmation message.
+     */
+    deleteGroup(id, verificationCode) {
+        return sendDeleteRequest(`/groups/${id}`, { verificationCode });
+    }
+    /**
+     * Adds all (valid) given usernames (and roles) to a group, ignoring duplicates.
+     * @returns The number of members added and a confirmation message.
+     */
+    addMembers(id, members, verificationCode) {
+        return sendPostRequest(`/groups/${id}/members`, {
+            verificationCode,
+            members
+        });
+    }
+    /**
+     * Remove all given usernames from a group, ignoring usernames that aren't members.
+     * @returns The number of members removed and a confirmation message.
+     */
+    removeMembers(id, usernames, verificationCode) {
+        return sendDeleteRequest(`/groups/${id}/members`, {
+            verificationCode,
+            members: usernames
+        });
+    }
+    /**
+     * Changes a player's role in a given group.
+     * @returns The updated membership, with player included.
+     */
+    changeRole(id, payload, verificationCode) {
+        return sendPutRequest(`/groups/${id}/role`, Object.assign(Object.assign({}, payload), { verificationCode }));
+    }
+    /**
+     * Adds an "update" request to the queue, for each outdated group member.
+     * @returns The number of players to be updated and a confirmation message.
+     */
+    updateAll(id, verificationCode) {
+        return sendPostRequest(`/groups/${id}/update-all`, {
+            verificationCode
+        });
+    }
+    /**
+     * Fetches all of the groups's competitions
+     * @returns A list of competitions.
+     */
+    getGroupCompetitions(id, pagination) {
+        return sendGetRequest(`/groups/${id}/competitions`, Object.assign({}, pagination));
+    }
+    getGroupGains(id, filter, pagination) {
+        return sendGetRequest(`/groups/${id}/gained`, Object.assign(Object.assign({}, pagination), filter));
+    }
+    /**
+     * Fetches a group members' latest achievements.
+     * @returns A list of achievements.
+     */
+    getGroupAchievements(id, pagination) {
+        return sendGetRequest(`/groups/${id}/achievements`, Object.assign({}, pagination));
+    }
+    /**
+     * Fetches a group's record leaderboard for a specific metric and period.
+     * @returns A list of records, including their respective players.
+     */
+    getGroupRecords(id, filter, pagination) {
+        return sendGetRequest(`/groups/${id}/records`, Object.assign(Object.assign({}, pagination), filter));
+    }
+    /**
+     * Fetches a group's hiscores for a specific metric.
+     * @returns A list of hiscores entries (value, rank), including their respective players.
+     */
+    getGroupHiscores(id, metric, pagination) {
+        return sendGetRequest(`/groups/${id}/hiscores`, Object.assign(Object.assign({}, pagination), { metric }));
+    }
+    /**
+     * Fetches a group members' latest name changes.
+     * @returns A list of name change (approved) requests.
+     */
+    getGroupNameChanges(id, pagination) {
+        return sendGetRequest(`/groups/${id}/name-changes`, Object.assign({}, pagination));
+    }
+    /**
+     * Fetches a group's general statistics.
+     * @returns An object with a few statistic values and an average stats snapshot.
+     */
+    getGroupStatistics(id) {
+        return sendGetRequest(`/groups/${id}/statistics`);
     }
-    return `/players/${player.username}`;
 }
+
 class PlayersClient {
+    /**
+     * Searches players by partial username.
+     * @returns A list of players.
+     */
     searchPlayers(partialUsername, pagination) {
         return sendGetRequest('/players/search', Object.assign({ username: partialUsername }, pagination));
     }
+    /**
+     * Updates/tracks a player.
+     * @returns The player's new details, including the latest snapshot.
+     */
     updatePlayer(player) {
         return sendPostRequest(getPlayerURL(player));
     }
+    /**
+     * Asserts (and attempts to fix, if necessary) a player's game-mode type.
+     * @returns The updated player, and an indication of whether the type was changed.
+     */
     assertPlayerType(player) {
         return sendPostRequest(`${getPlayerURL(player)}/assert-type`);
     }
+    /**
+     * Attempts to import a player's snapshot history from CrystalMathLabs.
+     * @returns The number of snapshots that were imported.
+     */
     importPlayer(player) {
         return sendPostRequest(`${getPlayerURL(player)}/import-history`);
     }
+    /**
+     * Fetches a player's details.
+     * @returns The player's details, including the latest snapshot.
+     */
     getPlayerDetails(player) {
         return sendGetRequest(getPlayerURL(player));
     }
+    /**
+     * Fetches a player's current achievements.
+     * @returns A list of achievements.
+     */
     getPlayerAchievements(player) {
         return sendGetRequest(`${getPlayerURL(player)}/achievements`);
     }
+    /**
+     * Fetches a player's current achievement progress.
+     * @returns A list of achievements (completed or otherwise), with their respective relative/absolute progress percentage.
+     */
     getPlayerAchievementProgress(player) {
         return sendGetRequest(`${getPlayerURL(player)}/achievements/progress`);
     }
+    /**
+     * Fetches all of the player's competition participations.
+     * @returns A list of participations, with the respective competition included.
+     */
     getPlayerCompetitions(player, pagination) {
         return sendGetRequest(`${getPlayerURL(player)}/competitions`, pagination);
     }
+    /**
+     * Fetches all of the player's group memberships.
+     * @returns A list of memberships, with the respective group included.
+     */
     getPlayerGroups(player, pagination) {
         return sendGetRequest(`${getPlayerURL(player)}/groups`, pagination);
     }
+    /**
+     * Fetches a player's gains, for a specific period or time range, as a [metric: data] map.
+     * @returns A map of each metric's gained data.
+     */
     getPlayerGains(player, options) {
         return sendGetRequest(`${getPlayerURL(player)}/gained`, options);
     }
+    /**
+     * Fetches a player's gains, for a specific period or time range, as an array.
+     * @returns An array of each metric's gained data.
+     */
     getPlayerGainsAsArray(player, options) {
         return sendGetRequest(`${getPlayerURL(player)}/gained`, Object.assign(Object.assign({}, options), { formatting: 'array' }));
     }
+    /**
+     * Fetches all of the player's records.
+     * @returns A list of records.
+     */
     getPlayerRecords(player, options) {
         return sendGetRequest(`${getPlayerURL(player)}/records`, options);
     }
+    /**
+     * Fetches all of the player's past snapshots.
+     * @returns A list of snapshots.
+     */
     getPlayerSnapshots(player, options) {
         return sendGetRequest(`${getPlayerURL(player)}/snapshots`, options);
     }
+    /**
+     * Fetches all of the player's approved name changes.
+     * @returns A list of name changes.
+     */
     getPlayerNames(player) {
         return sendGetRequest(`${getPlayerURL(player)}/names`);
     }
 }
+function getPlayerURL(player) {
+    if (typeof player === 'string') {
+        return `/players/${player}`;
+    }
+    if (player.id) {
+        return `/players/id/${player.id}`;
+    }
+    return `/players/${player.username}`;
+}
 
 class RecordsClient {
+    /**
+     * Fetches the current records leaderboard for a specific metric, period, playerType, playerBuild and country.
+     * @returns A list of records, with their respective players, dates and values included.
+     */
     getRecordLeaderboard(filter) {
         return sendGetRequest('/records/leaderboard', filter);
     }
 }
 
-class DeltasClient {
-    getDeltaLeaderboard(filter) {
-        return sendGetRequest('/deltas/leaderboard', filter);
-    }
-}
-
 /**
  * Prisma currently seems to ignore the @map() in enum declarations.
  *
@@ -342,6 +558,8 @@ const Boss = {
     THEATRE_OF_BLOOD: 'theatre_of_blood',
     THEATRE_OF_BLOOD_HARD_MODE: 'theatre_of_blood_hard_mode',
     THERMONUCLEAR_SMOKE_DEVIL: 'thermonuclear_smoke_devil',
+    TOMBS_OF_AMASCUT: 'tombs_of_amascut',
+    TOMBS_OF_AMASCUT_EXPERT: 'tombs_of_amascut_expert',
     TZKAL_ZUK: 'tzkal_zuk',
     TZTOK_JAD: 'tztok_jad',
     VENENATIS: 'venenatis',
@@ -351,11 +569,11 @@ const Boss = {
     ZALCANO: 'zalcano',
     ZULRAH: 'zulrah'
 };
-const Virtual = {
+const ComputedMetric = {
     EHP: 'ehp',
     EHB: 'ehb'
 };
-const Metric = Object.assign(Object.assign(Object.assign(Object.assign({}, Skill), Activity), Boss), Virtual);
+const Metric = Object.assign(Object.assign(Object.assign(Object.assign({}, Skill), Activity), Boss), ComputedMetric);
 const NameChangeStatus = {
     PENDING: 'pending',
     DENIED: 'denied',
@@ -927,19 +1145,11 @@ const CompetitionStatusProps = {
 };
 const COMPETITION_TYPES = Object.values(CompetitionType);
 const COMPETITION_STATUSES = Object.values(exports.CompetitionStatus);
-function findCompetitionType(typeName) {
-    for (const [key, value] of Object.entries(CompetitionTypeProps)) {
-        if (value.name === typeName)
-            return key;
-    }
-    return null;
+function isCompetitionType(typeString) {
+    return typeString in CompetitionTypeProps;
 }
-function findCompetitionStatus(statusName) {
-    for (const [key, value] of Object.entries(CompetitionStatusProps)) {
-        if (value.name === statusName)
-            return key;
-    }
-    return null;
+function isCompetitionStatus(statusString) {
+    return statusString in CompetitionStatusProps;
 }
 
 const CountryProps = {
@@ -1198,6 +1408,9 @@ const COMMON_ALIASES = [
     { commonIdentifier: 'UK', trueIdentifier: 'GB' },
     { commonIdentifier: 'USA', trueIdentifier: 'US' }
 ];
+function isCountry(countryCodeString) {
+    return countryCodeString in CountryProps;
+}
 function findCountry(countryIdentifier) {
     return findCountryByCode(countryIdentifier) || findCountryByName(countryIdentifier);
 }
@@ -1214,485 +1427,61 @@ function replaceCommonAliases(countryCode) {
     return ((_a = COMMON_ALIASES.find(ca => ca.commonIdentifier === countryCode)) === null || _a === void 0 ? void 0 : _a.trueIdentifier) || countryCode;
 }
 
-exports.MetricType = void 0;
-(function (MetricType) {
-    MetricType["SKILL"] = "skill";
-    MetricType["BOSS"] = "boss";
-    MetricType["ACTIVITY"] = "activity";
-    MetricType["VIRTUAL"] = "virtual";
-})(exports.MetricType || (exports.MetricType = {}));
-exports.MetricMeasure = void 0;
-(function (MetricMeasure) {
-    MetricMeasure["EXPERIENCE"] = "experience";
-    MetricMeasure["KILLS"] = "kills";
-    MetricMeasure["SCORE"] = "score";
-    MetricMeasure["VALUE"] = "value";
-})(exports.MetricMeasure || (exports.MetricMeasure = {}));
-const SkillProps = lodash.mapValues({
-    [Skill.OVERALL]: { name: 'Overall', isCombat: false, isMembers: false },
-    [Skill.ATTACK]: { name: 'Attack', isCombat: true, isMembers: false },
-    [Skill.DEFENCE]: { name: 'Defence', isCombat: true, isMembers: false },
-    [Skill.STRENGTH]: { name: 'Strength', isCombat: true, isMembers: false },
-    [Skill.HITPOINTS]: { name: 'Hitpoints', isCombat: true, isMembers: false },
-    [Skill.RANGED]: { name: 'Ranged', isCombat: true, isMembers: false },
-    [Skill.PRAYER]: { name: 'Prayer', isCombat: true, isMembers: false },
-    [Skill.MAGIC]: { name: 'Magic', isCombat: true, isMembers: false },
-    [Skill.COOKING]: { name: 'Cooking', isCombat: false, isMembers: false },
-    [Skill.WOODCUTTING]: { name: 'Woodcutting', isCombat: false, isMembers: false },
-    [Skill.FLETCHING]: { name: 'Fletching', isCombat: false, isMembers: true },
-    [Skill.FISHING]: { name: 'Fishing', isCombat: false, isMembers: false },
-    [Skill.FIREMAKING]: { name: 'Firemaking', isCombat: false, isMembers: false },
-    [Skill.CRAFTING]: { name: 'Crafting', isCombat: false, isMembers: false },
-    [Skill.SMITHING]: { name: 'Smithing', isCombat: false, isMembers: false },
-    [Skill.MINING]: { name: 'Mining', isCombat: false, isMembers: false },
-    [Skill.HERBLORE]: { name: 'Herblore', isCombat: false, isMembers: true },
-    [Skill.AGILITY]: { name: 'Agility', isCombat: false, isMembers: true },
-    [Skill.THIEVING]: { name: 'Thieving', isCombat: false, isMembers: true },
-    [Skill.SLAYER]: { name: 'Slayer', isCombat: false, isMembers: true },
-    [Skill.FARMING]: { name: 'Farming', isCombat: false, isMembers: true },
-    [Skill.RUNECRAFTING]: { name: 'Runecrafting', isCombat: false, isMembers: false },
-    [Skill.HUNTER]: { name: 'Hunter', isCombat: false, isMembers: true },
-    [Skill.CONSTRUCTION]: { name: 'Construction', isCombat: false, isMembers: false }
-}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.SKILL, measure: exports.MetricMeasure.EXPERIENCE })));
-const BossProps = lodash.mapValues({
-    [Boss.ABYSSAL_SIRE]: { name: 'Abyssal Sire', minimumKc: 50, isMembers: true },
-    [Boss.ALCHEMICAL_HYDRA]: { name: 'Alchemical Hydra', minimumKc: 50, isMembers: true },
-    [Boss.BARROWS_CHESTS]: { name: 'Barrows Chests', minimumKc: 50, isMembers: true },
-    [Boss.BRYOPHYTA]: { name: 'Bryophyta', minimumKc: 5, isMembers: false },
-    [Boss.CALLISTO]: { name: 'Callisto', minimumKc: 50, isMembers: true },
-    [Boss.CERBERUS]: { name: 'Cerberus', minimumKc: 50, isMembers: true },
-    [Boss.CHAMBERS_OF_XERIC]: { name: 'Chambers Of Xeric', minimumKc: 50, isMembers: true },
-    [Boss.CHAMBERS_OF_XERIC_CM]: { name: 'Chambers Of Xeric (CM)', minimumKc: 5, isMembers: true },
-    [Boss.CHAOS_ELEMENTAL]: { name: 'Chaos Elemental', minimumKc: 50, isMembers: true },
-    [Boss.CHAOS_FANATIC]: { name: 'Chaos Fanatic', minimumKc: 50, isMembers: true },
-    [Boss.COMMANDER_ZILYANA]: { name: 'Commander Zilyana', minimumKc: 50, isMembers: true },
-    [Boss.CORPOREAL_BEAST]: { name: 'Corporeal Beast', minimumKc: 50, isMembers: true },
-    [Boss.CRAZY_ARCHAEOLOGIST]: { name: 'Crazy Archaeologist', minimumKc: 50, isMembers: true },
-    [Boss.DAGANNOTH_PRIME]: { name: 'Dagannoth Prime', minimumKc: 50, isMembers: true },
-    [Boss.DAGANNOTH_REX]: { name: 'Dagannoth Rex', minimumKc: 50, isMembers: true },
-    [Boss.DAGANNOTH_SUPREME]: { name: 'Dagannoth Supreme', minimumKc: 50, isMembers: true },
-    [Boss.DERANGED_ARCHAEOLOGIST]: { name: 'Deranged Archaeologist', minimumKc: 50, isMembers: true },
-    [Boss.GENERAL_GRAARDOR]: { name: 'General Graardor', minimumKc: 50, isMembers: true },
-    [Boss.GIANT_MOLE]: { name: 'Giant Mole', minimumKc: 50, isMembers: true },
-    [Boss.GROTESQUE_GUARDIANS]: { name: 'Grotesque Guardians', minimumKc: 50, isMembers: true },
-    [Boss.HESPORI]: { name: 'Hespori', minimumKc: 5, isMembers: true },
-    [Boss.KALPHITE_QUEEN]: { name: 'Kalphite Queen', minimumKc: 50, isMembers: true },
-    [Boss.KING_BLACK_DRAGON]: { name: 'King Black Dragon', minimumKc: 50, isMembers: true },
-    [Boss.KRAKEN]: { name: 'Kraken', minimumKc: 50, isMembers: true },
-    [Boss.KREEARRA]: { name: "Kree'Arra", minimumKc: 50, isMembers: true },
-    [Boss.KRIL_TSUTSAROTH]: { name: "K'ril Tsutsaroth", minimumKc: 50, isMembers: true },
-    [Boss.MIMIC]: { name: 'Mimic', minimumKc: 1, isMembers: true },
-    [Boss.NEX]: { name: 'Nex', minimumKc: 50, isMembers: true },
-    [Boss.NIGHTMARE]: { name: 'Nightmare', minimumKc: 50, isMembers: true },
-    [Boss.PHOSANIS_NIGHTMARE]: { name: "Phosani's Nightmare", minimumKc: 50, isMembers: true },
-    [Boss.OBOR]: { name: 'Obor', minimumKc: 5, isMembers: false },
-    [Boss.SARACHNIS]: { name: 'Sarachnis', minimumKc: 50, isMembers: true },
-    [Boss.SKOTIZO]: { name: 'Skotizo', minimumKc: 5, isMembers: true },
-    [Boss.SCORPIA]: { name: 'Scorpia', minimumKc: 50, isMembers: true },
-    [Boss.TEMPOROSS]: { name: 'Tempoross', minimumKc: 50, isMembers: true },
-    [Boss.THE_GAUNTLET]: { name: 'The Gauntlet', minimumKc: 50, isMembers: true },
-    [Boss.THE_CORRUPTED_GAUNTLET]: { name: 'The Corrupted Gauntlet', minimumKc: 5, isMembers: true },
-    [Boss.THEATRE_OF_BLOOD]: { name: 'Theatre Of Blood', minimumKc: 50, isMembers: true },
-    [Boss.THEATRE_OF_BLOOD_HARD_MODE]: { name: 'Theatre Of Blood (HM)', minimumKc: 50, isMembers: true },
-    [Boss.THERMONUCLEAR_SMOKE_DEVIL]: { name: 'Thermonuclear Smoke Devil', minimumKc: 50, isMembers: true },
-    [Boss.TZKAL_ZUK]: { name: 'TzKal-Zuk', minimumKc: 1, isMembers: true },
-    [Boss.TZTOK_JAD]: { name: 'TzTok-Jad', minimumKc: 5, isMembers: true },
-    [Boss.VENENATIS]: { name: 'Venenatis', minimumKc: 50, isMembers: true },
-    [Boss.VETION]: { name: "Vet'ion", minimumKc: 50, isMembers: true },
-    [Boss.VORKATH]: { name: 'Vorkath', minimumKc: 50, isMembers: true },
-    [Boss.WINTERTODT]: { name: 'Wintertodt', minimumKc: 50, isMembers: true },
-    [Boss.ZALCANO]: { name: 'Zalcano', minimumKc: 50, isMembers: true },
-    [Boss.ZULRAH]: { name: 'Zulrah', minimumKc: 50, isMembers: true }
-}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.BOSS, measure: exports.MetricMeasure.KILLS })));
-const ActivityProps = lodash.mapValues({
-    [Activity.LEAGUE_POINTS]: { name: 'League Points' },
-    [Activity.BOUNTY_HUNTER_HUNTER]: { name: 'Bounty Hunter (Hunter)' },
-    [Activity.BOUNTY_HUNTER_ROGUE]: { name: 'Bounty Hunter (Rogue)' },
-    [Activity.CLUE_SCROLLS_ALL]: { name: 'Clue Scrolls (All)' },
-    [Activity.CLUE_SCROLLS_BEGINNER]: { name: 'Clue Scrolls (Beginner)' },
-    [Activity.CLUE_SCROLLS_EASY]: { name: 'Clue Scrolls (Easy)' },
-    [Activity.CLUE_SCROLLS_MEDIUM]: { name: 'Clue Scrolls (Medium)' },
-    [Activity.CLUE_SCROLLS_HARD]: { name: 'Clue Scrolls (Hard)' },
-    [Activity.CLUE_SCROLLS_ELITE]: { name: 'Clue Scrolls (Elite)' },
-    [Activity.CLUE_SCROLLS_MASTER]: { name: 'Clue Scrolls (Master)' },
-    [Activity.LAST_MAN_STANDING]: { name: 'Last Man Standing' },
-    [Activity.PVP_ARENA]: { name: 'PvP Arena' },
-    [Activity.SOUL_WARS_ZEAL]: { name: 'Soul Wars Zeal' },
-    [Activity.GUARDIANS_OF_THE_RIFT]: { name: 'Guardians of the Rift' }
-}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.ACTIVITY, measure: exports.MetricMeasure.SCORE })));
-const VirtualProps = lodash.mapValues({
-    [Virtual.EHP]: { name: 'EHP' },
-    [Virtual.EHB]: { name: 'EHB' }
-}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.VIRTUAL, measure: exports.MetricMeasure.VALUE })));
-const MetricProps = Object.assign(Object.assign(Object.assign(Object.assign({}, SkillProps), BossProps), ActivityProps), VirtualProps);
-const METRICS = Object.values(Metric);
-const SKILLS = Object.values(Skill);
-const BOSSES = Object.values(Boss);
-const ACTIVITIES = Object.values(Activity);
-const VIRTUALS = Object.values(Virtual);
-const REAL_SKILLS = SKILLS.filter(s => s !== Skill.OVERALL);
-const F2P_BOSSES = BOSSES.filter(b => !MetricProps[b].isMembers);
-const MEMBER_SKILLS = SKILLS.filter(s => MetricProps[s].isMembers);
-const COMBAT_SKILLS = SKILLS.filter(s => MetricProps[s].isCombat);
-function findMetric(metricName) {
-    for (const [key, value] of Object.entries(MetricProps)) {
-        if (value.name.toUpperCase() === metricName.toUpperCase())
-            return key;
+// Maximum effective skill level at 13,034,431 experience.
+const MAX_LEVEL = 99;
+// The maximum virtual skill level for any skill (200M experience).
+const MAX_VIRTUAL_LEVEL = 126;
+// The maximum skill experience (200M experience).
+const MAX_SKILL_EXP = 200000000;
+// The minimum skill exp for level 99
+const SKILL_EXP_AT_99 = 13034431;
+// The maximum skill at exactly 99 on all skills
+const CAPPED_MAX_TOTAL_XP = 23 * SKILL_EXP_AT_99;
+// Builds a lookup table for each level's required experience
+// exp = XP_FOR_LEVEL[level - 1] || 13m = XP_FOR_LEVEL[98]
+const XP_FOR_LEVEL = (function () {
+    let xp = 0;
+    const array = [];
+    for (let level = 1; level <= MAX_VIRTUAL_LEVEL; ++level) {
+        array[level - 1] = Math.floor(xp / 4);
+        xp += Math.floor(level + 300 * Math.pow(2, level / 7));
     }
-    return null;
-}
-function isSkill(metric) {
-    return metric in SkillProps;
-}
-function isActivity(metric) {
-    return metric in ActivityProps;
-}
-function isBoss(metric) {
-    return metric in BossProps;
+    return array;
+})();
+function getExpForLevel(level) {
+    if (level < 1 || level > MAX_VIRTUAL_LEVEL)
+        return 0;
+    return XP_FOR_LEVEL[level - 1];
 }
-function isVirtualMetric(metric) {
-    return metric in VirtualProps;
+function getLevel(exp, virtual = false) {
+    if (!exp || exp < 0) {
+        return 1;
+    }
+    let low = 0;
+    let high = virtual ? XP_FOR_LEVEL.length - 1 : 98;
+    while (low <= high) {
+        const mid = Math.floor(low + (high - low) / 2);
+        const xpForLevel = XP_FOR_LEVEL[mid];
+        if (exp < xpForLevel) {
+            high = mid - 1;
+        }
+        else if (exp > xpForLevel) {
+            low = mid + 1;
+        }
+        else {
+            return mid + 1;
+        }
+    }
+    return high + 1;
 }
-function getMetricRankKey(metric) {
-    return `${metric}Rank`;
-}
-function getMetricValueKey(metric) {
-    return `${metric}${lodash.capitalize(MetricProps[metric].measure)}`;
-}
-function getMetricMeasure(metric) {
-    return MetricProps[metric].measure;
-}
-function getMetricName(metric) {
-    return MetricProps[metric].name;
-}
-function getMinimumBossKc(metric) {
-    return isBoss(metric) ? MetricProps[metric].minimumKc : 0;
-}
-function getParentVirtualMetric(metric) {
-    if (isBoss(metric))
-        return Metric.EHB;
-    if (isSkill(metric))
-        return Metric.EHP;
-    return null;
-}
-function parseMetricAbbreviation(abbreviation) {
-    if (!abbreviation || abbreviation.length === 0) {
-        return null;
-    }
-    switch (abbreviation.toLowerCase()) {
-        // Bosses
-        case 'sire':
-            return Metric.ABYSSAL_SIRE;
-        case 'hydra':
-            return Metric.ALCHEMICAL_HYDRA;
-        case 'barrows':
-            return Metric.BARROWS_CHESTS;
-        case 'bryo':
-            return Metric.BRYOPHYTA;
-        case 'cerb':
-            return Metric.CERBERUS;
-        case 'cox':
-        case 'xeric':
-        case 'chambers':
-        case 'olm':
-        case 'raids':
-            return Metric.CHAMBERS_OF_XERIC;
-        case 'cox-cm':
-        case 'xeric-cm':
-        case 'chambers-cm':
-        case 'olm-cm':
-        case 'raids-cm':
-            return Metric.CHAMBERS_OF_XERIC_CM;
-        case 'chaos-ele':
-            return Metric.CHAOS_ELEMENTAL;
-        case 'fanatic':
-            return Metric.CHAOS_FANATIC;
-        case 'sara':
-        case 'saradomin':
-        case 'zilyana':
-        case 'zily':
-            return Metric.COMMANDER_ZILYANA;
-        case 'corp':
-            return Metric.CORPOREAL_BEAST;
-        case 'crazy-arch':
-            return Metric.CRAZY_ARCHAEOLOGIST;
-        case 'prime':
-            return Metric.DAGANNOTH_PRIME;
-        case 'rex':
-            return Metric.DAGANNOTH_REX;
-        case 'supreme':
-            return Metric.DAGANNOTH_SUPREME;
-        case 'deranged-arch':
-            return Metric.DERANGED_ARCHAEOLOGIST;
-        case 'bandos':
-        case 'graardor':
-            return Metric.GENERAL_GRAARDOR;
-        case 'mole':
-            return Metric.GIANT_MOLE;
-        case 'dusk':
-        case 'dawn':
-        case 'gargs':
-        case 'guardians':
-        case 'ggs':
-            return Metric.GROTESQUE_GUARDIANS;
-        case 'kq':
-            return Metric.KALPHITE_QUEEN;
-        case 'kbd':
-            return Metric.KING_BLACK_DRAGON;
-        case 'kree':
-        case 'kreearra':
-        case 'armadyl':
-        case 'arma':
-            return Metric.KREEARRA;
-        case 'zammy':
-        case 'zamorak':
-        case 'kril':
-        case 'kril-tsutsaroth':
-            return Metric.KRIL_TSUTSAROTH;
-        case 'gaunt':
-        case 'gauntlet':
-        case 'the-gauntlet':
-            return Metric.THE_GAUNTLET;
-        case 'cgaunt':
-        case 'cgauntlet':
-        case 'corrupted':
-        case 'corrupted-gauntlet':
-        case 'the-corrupted-gauntlet':
-            return Metric.THE_CORRUPTED_GAUNTLET;
-        case 'tob':
-        case 'theatre':
-        case 'verzik':
-        case 'tob-normal':
-            return Metric.THEATRE_OF_BLOOD;
-        case 'tob-hm':
-        case 'tob-cm':
-        case 'tob-hard-mode':
-        case 'tob-hard':
-            return Metric.THEATRE_OF_BLOOD_HARD_MODE;
-        case 'nm':
-        case 'tnm':
-        case 'nmare':
-        case 'the-nightmare':
-            return Metric.NIGHTMARE;
-        case 'pnm':
-        case 'phosani':
-        case 'phosanis':
-        case 'phosani-nm':
-        case 'phosani-nightmare':
-        case 'phosanis nightmare':
-            return Metric.PHOSANIS_NIGHTMARE;
-        case 'thermy':
-        case 'smoke-devil':
-            return Metric.THERMONUCLEAR_SMOKE_DEVIL;
-        case 'zuk':
-        case 'inferno':
-            return Metric.TZKAL_ZUK;
-        case 'jad':
-        case 'fight-caves':
-        case 'fc':
-            return Metric.TZTOK_JAD;
-        case 'vork':
-        case 'vorky':
-            return Metric.VORKATH;
-        case 'wt':
-            return Metric.WINTERTODT;
-        case 'snek':
-        case 'zul':
-            return Metric.ZULRAH;
-        // Minigames and others
-        case 'all-clues':
-        case 'clues':
-            return Metric.CLUE_SCROLLS_ALL;
-        case 'beginner':
-        case 'beginner-clues':
-        case 'beg-clues':
-        case 'beginners':
-            return Metric.CLUE_SCROLLS_BEGINNER;
-        case 'easy':
-        case 'easy-clues':
-        case 'easies':
-            return Metric.CLUE_SCROLLS_EASY;
-        case 'medium':
-        case 'med':
-        case 'meds':
-        case 'medium-clues':
-        case 'med-clues':
-        case 'mediums':
-            return Metric.CLUE_SCROLLS_MEDIUM;
-        case 'hard':
-        case 'hard-clues':
-        case 'hards':
-            return Metric.CLUE_SCROLLS_HARD;
-        case 'elite':
-        case 'elite-clues':
-        case 'elites':
-            return Metric.CLUE_SCROLLS_ELITE;
-        case 'master':
-        case 'master-clues':
-        case 'masters':
-            return Metric.CLUE_SCROLLS_MASTER;
-        case 'lms':
-            return Metric.LAST_MAN_STANDING;
-        case 'league':
-        case 'lp':
-        case 'lps':
-            return Metric.LEAGUE_POINTS;
-        case 'sw':
-        case 'zeal':
-        case 'soul-wars':
-            return Metric.SOUL_WARS_ZEAL;
-        // Skills
-        case 'runecraft':
-        case 'rc':
-            return Metric.RUNECRAFTING;
-        case 'att':
-        case 'atk':
-        case 'attk':
-            return Metric.ATTACK;
-        case 'def':
-        case 'defense':
-            return Metric.DEFENCE;
-        case 'str':
-            return Metric.STRENGTH;
-        case 'hp':
-            return Metric.HITPOINTS;
-        case 'range':
-            return Metric.RANGED;
-        case 'pray':
-            return Metric.PRAYER;
-        case 'mage':
-            return Metric.MAGIC;
-        case 'cook':
-            return Metric.COOKING;
-        case 'wc':
-            return Metric.WOODCUTTING;
-        case 'fletch':
-            return Metric.FLETCHING;
-        case 'fish':
-            return Metric.FISHING;
-        case 'fm':
-        case 'burning':
-            return Metric.FIREMAKING;
-        case 'craft':
-            return Metric.CRAFTING;
-        case 'sm':
-        case 'smith':
-            return Metric.SMITHING;
-        case 'mine':
-        case 'smash':
-            return Metric.MINING;
-        case 'herb':
-            return Metric.HERBLORE;
-        case 'agi':
-        case 'agil':
-            return Metric.AGILITY;
-        case 'thief':
-            return Metric.THIEVING;
-        case 'slay':
-            return Metric.SLAYER;
-        case 'farm':
-            return Metric.FARMING;
-        case 'hunt':
-        case 'hunting':
-            return Metric.HUNTER;
-        case 'con':
-        case 'cons':
-        case 'const':
-            return Metric.CONSTRUCTION;
-        default:
-            return abbreviation;
-    }
-}
-
-// Maximum effective skill level at 13,034,431 experience.
-const MAX_LEVEL = 99;
-// The maximum virtual skill level for any skill (200M experience).
-const MAX_VIRTUAL_LEVEL = 126;
-// The maximum skill experience (200M experience).
-const MAX_SKILL_EXP = 200000000;
-// The minimum skill exp for level 99
-const SKILL_EXP_AT_99 = 13034431;
-// The maximum skill at exactly 99 on all skills
-const CAPPED_MAX_TOTAL_XP = 23 * SKILL_EXP_AT_99;
-// Builds a lookup table for each level's required experience
-// exp = XP_FOR_LEVEL[level - 1] || 13m = XP_FOR_LEVEL[98]
-const XP_FOR_LEVEL = (function () {
-    let xp = 0;
-    const array = [];
-    for (let level = 1; level <= MAX_VIRTUAL_LEVEL; ++level) {
-        array[level - 1] = Math.floor(xp / 4);
-        xp += Math.floor(level + 300 * Math.pow(2, level / 7));
-    }
-    return array;
-})();
-function getExpForLevel(level) {
-    if (level < 1 || level > MAX_VIRTUAL_LEVEL)
-        return 0;
-    return XP_FOR_LEVEL[level - 1];
-}
-function getLevel(exp, virtual = false) {
-    if (!exp || exp < 0) {
-        return 1;
-    }
-    let low = 0;
-    let high = virtual ? XP_FOR_LEVEL.length - 1 : 98;
-    while (low <= high) {
-        const mid = Math.floor(low + (high - low) / 2);
-        const xpForLevel = XP_FOR_LEVEL[mid];
-        if (exp < xpForLevel) {
-            high = mid - 1;
-        }
-        else if (exp > xpForLevel) {
-            low = mid + 1;
-        }
-        else {
-            return mid + 1;
-        }
-    }
-    return high + 1;
-}
-function getCombatLevelFromExp(attack, strength, defence, ranged, magic, hitpoints, prayer) {
-    if ([attack, strength, defence, ranged, magic, hitpoints, prayer].some(l => l === 0))
-        return 0;
-    const baseCombat = 0.25 * (defence + Math.max(hitpoints, 10) + Math.floor(prayer / 2));
-    const meleeCombat = 0.325 * (attack + strength);
-    const rangeCombat = 0.325 * Math.floor((3 * ranged) / 2);
-    const mageCombat = 0.325 * Math.floor((3 * magic) / 2);
-    return Math.floor(baseCombat + Math.max(meleeCombat, rangeCombat, mageCombat));
-}
-function getCombatLevel(snapshot) {
-    if (!snapshot)
-        return 3;
-    return getCombatLevelFromExp(getLevel(snapshot.attackExperience), getLevel(snapshot.strengthExperience), getLevel(snapshot.defenceExperience), getLevel(snapshot.rangedExperience), getLevel(snapshot.magicExperience), getLevel(snapshot.hitpointsExperience), getLevel(snapshot.prayerExperience));
-}
-function get200msCount(snapshot) {
-    return REAL_SKILLS.filter(s => snapshot[getMetricValueKey(s)] === MAX_SKILL_EXP).length;
-}
-function getMinimumExp(snapshot) {
-    return REAL_SKILLS.map(s => Math.max(0, snapshot[getMetricValueKey(s)] || 0)).sort((a, b) => a - b)[0];
-}
-function getCappedExp(snapshot, max) {
-    return REAL_SKILLS.map(s => Math.min(snapshot[getMetricValueKey(s)], max)).reduce((acc, cur) => acc + cur);
-}
-function getTotalLevel(snapshot) {
-    return REAL_SKILLS.map(s => getLevel(snapshot[getMetricValueKey(s)])).reduce((acc, cur) => acc + cur);
-}
-function isF2p(snapshot) {
-    const hasMemberStats = MEMBER_SKILLS.some(s => getLevel(snapshot[getMetricValueKey(s)]) > 1);
-    const hasBossKc = BOSSES.filter(b => !F2P_BOSSES.includes(b)).some(b => snapshot[getMetricValueKey(b)] > 0);
-    return !hasMemberStats && !hasBossKc;
-}
-function isLvl3(snapshot) {
-    return getCombatLevel(snapshot) <= 3;
-}
-function is1Def(snapshot) {
-    return getLevel(snapshot.defenceExperience) === 1;
-}
-function is10HP(snapshot) {
-    return getCombatLevel(snapshot) > 3 && getLevel(snapshot.hitpointsExperience) === 10;
-}
-function isZerker(snapshot) {
-    return getLevel(snapshot.defenceExperience) === 45;
+function getCombatLevel(attack, strength, defence, ranged, magic, hitpoints, prayer) {
+    if ([attack, strength, defence, ranged, magic, hitpoints, prayer].some(l => l === 0))
+        return 0;
+    const baseCombat = 0.25 * (defence + Math.max(hitpoints, 10) + Math.floor(prayer / 2));
+    const meleeCombat = 0.325 * (attack + strength);
+    const rangeCombat = 0.325 * Math.floor((3 * ranged) / 2);
+    const mageCombat = 0.325 * Math.floor((3 * magic) / 2);
+    return Math.floor(baseCombat + Math.max(meleeCombat, rangeCombat, mageCombat));
 }
 
 const GROUP_ROLES = Object.values(GroupRole);
@@ -1980,7 +1769,420 @@ function findGroupRole(roleName) {
             return key;
         }
     }
-    return null;
+    return null;
+}
+function isGroupRole(roleString) {
+    return roleString in GroupRoleProps;
+}
+
+exports.MetricType = void 0;
+(function (MetricType) {
+    MetricType["SKILL"] = "skill";
+    MetricType["BOSS"] = "boss";
+    MetricType["ACTIVITY"] = "activity";
+    MetricType["COMPUTED"] = "computed";
+})(exports.MetricType || (exports.MetricType = {}));
+exports.MetricMeasure = void 0;
+(function (MetricMeasure) {
+    MetricMeasure["EXPERIENCE"] = "experience";
+    MetricMeasure["KILLS"] = "kills";
+    MetricMeasure["SCORE"] = "score";
+    MetricMeasure["VALUE"] = "value";
+})(exports.MetricMeasure || (exports.MetricMeasure = {}));
+const SkillProps = lodash.mapValues({
+    [Skill.OVERALL]: { name: 'Overall', isCombat: false, isMembers: false },
+    [Skill.ATTACK]: { name: 'Attack', isCombat: true, isMembers: false },
+    [Skill.DEFENCE]: { name: 'Defence', isCombat: true, isMembers: false },
+    [Skill.STRENGTH]: { name: 'Strength', isCombat: true, isMembers: false },
+    [Skill.HITPOINTS]: { name: 'Hitpoints', isCombat: true, isMembers: false },
+    [Skill.RANGED]: { name: 'Ranged', isCombat: true, isMembers: false },
+    [Skill.PRAYER]: { name: 'Prayer', isCombat: true, isMembers: false },
+    [Skill.MAGIC]: { name: 'Magic', isCombat: true, isMembers: false },
+    [Skill.COOKING]: { name: 'Cooking', isCombat: false, isMembers: false },
+    [Skill.WOODCUTTING]: { name: 'Woodcutting', isCombat: false, isMembers: false },
+    [Skill.FLETCHING]: { name: 'Fletching', isCombat: false, isMembers: true },
+    [Skill.FISHING]: { name: 'Fishing', isCombat: false, isMembers: false },
+    [Skill.FIREMAKING]: { name: 'Firemaking', isCombat: false, isMembers: false },
+    [Skill.CRAFTING]: { name: 'Crafting', isCombat: false, isMembers: false },
+    [Skill.SMITHING]: { name: 'Smithing', isCombat: false, isMembers: false },
+    [Skill.MINING]: { name: 'Mining', isCombat: false, isMembers: false },
+    [Skill.HERBLORE]: { name: 'Herblore', isCombat: false, isMembers: true },
+    [Skill.AGILITY]: { name: 'Agility', isCombat: false, isMembers: true },
+    [Skill.THIEVING]: { name: 'Thieving', isCombat: false, isMembers: true },
+    [Skill.SLAYER]: { name: 'Slayer', isCombat: false, isMembers: true },
+    [Skill.FARMING]: { name: 'Farming', isCombat: false, isMembers: true },
+    [Skill.RUNECRAFTING]: { name: 'Runecrafting', isCombat: false, isMembers: false },
+    [Skill.HUNTER]: { name: 'Hunter', isCombat: false, isMembers: true },
+    [Skill.CONSTRUCTION]: { name: 'Construction', isCombat: false, isMembers: false }
+}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.SKILL, measure: exports.MetricMeasure.EXPERIENCE })));
+const BossProps = lodash.mapValues({
+    [Boss.ABYSSAL_SIRE]: { name: 'Abyssal Sire', minimumKc: 50, isMembers: true },
+    [Boss.ALCHEMICAL_HYDRA]: { name: 'Alchemical Hydra', minimumKc: 50, isMembers: true },
+    [Boss.BARROWS_CHESTS]: { name: 'Barrows Chests', minimumKc: 50, isMembers: true },
+    [Boss.BRYOPHYTA]: { name: 'Bryophyta', minimumKc: 5, isMembers: false },
+    [Boss.CALLISTO]: { name: 'Callisto', minimumKc: 50, isMembers: true },
+    [Boss.CERBERUS]: { name: 'Cerberus', minimumKc: 50, isMembers: true },
+    [Boss.CHAMBERS_OF_XERIC]: { name: 'Chambers Of Xeric', minimumKc: 50, isMembers: true },
+    [Boss.CHAMBERS_OF_XERIC_CM]: { name: 'Chambers Of Xeric (CM)', minimumKc: 5, isMembers: true },
+    [Boss.CHAOS_ELEMENTAL]: { name: 'Chaos Elemental', minimumKc: 50, isMembers: true },
+    [Boss.CHAOS_FANATIC]: { name: 'Chaos Fanatic', minimumKc: 50, isMembers: true },
+    [Boss.COMMANDER_ZILYANA]: { name: 'Commander Zilyana', minimumKc: 50, isMembers: true },
+    [Boss.CORPOREAL_BEAST]: { name: 'Corporeal Beast', minimumKc: 50, isMembers: true },
+    [Boss.CRAZY_ARCHAEOLOGIST]: { name: 'Crazy Archaeologist', minimumKc: 50, isMembers: true },
+    [Boss.DAGANNOTH_PRIME]: { name: 'Dagannoth Prime', minimumKc: 50, isMembers: true },
+    [Boss.DAGANNOTH_REX]: { name: 'Dagannoth Rex', minimumKc: 50, isMembers: true },
+    [Boss.DAGANNOTH_SUPREME]: { name: 'Dagannoth Supreme', minimumKc: 50, isMembers: true },
+    [Boss.DERANGED_ARCHAEOLOGIST]: { name: 'Deranged Archaeologist', minimumKc: 50, isMembers: true },
+    [Boss.GENERAL_GRAARDOR]: { name: 'General Graardor', minimumKc: 50, isMembers: true },
+    [Boss.GIANT_MOLE]: { name: 'Giant Mole', minimumKc: 50, isMembers: true },
+    [Boss.GROTESQUE_GUARDIANS]: { name: 'Grotesque Guardians', minimumKc: 50, isMembers: true },
+    [Boss.HESPORI]: { name: 'Hespori', minimumKc: 5, isMembers: true },
+    [Boss.KALPHITE_QUEEN]: { name: 'Kalphite Queen', minimumKc: 50, isMembers: true },
+    [Boss.KING_BLACK_DRAGON]: { name: 'King Black Dragon', minimumKc: 50, isMembers: true },
+    [Boss.KRAKEN]: { name: 'Kraken', minimumKc: 50, isMembers: true },
+    [Boss.KREEARRA]: { name: "Kree'Arra", minimumKc: 50, isMembers: true },
+    [Boss.KRIL_TSUTSAROTH]: { name: "K'ril Tsutsaroth", minimumKc: 50, isMembers: true },
+    [Boss.MIMIC]: { name: 'Mimic', minimumKc: 1, isMembers: true },
+    [Boss.NEX]: { name: 'Nex', minimumKc: 50, isMembers: true },
+    [Boss.NIGHTMARE]: { name: 'Nightmare', minimumKc: 50, isMembers: true },
+    [Boss.PHOSANIS_NIGHTMARE]: { name: "Phosani's Nightmare", minimumKc: 50, isMembers: true },
+    [Boss.OBOR]: { name: 'Obor', minimumKc: 5, isMembers: false },
+    [Boss.SARACHNIS]: { name: 'Sarachnis', minimumKc: 50, isMembers: true },
+    [Boss.SKOTIZO]: { name: 'Skotizo', minimumKc: 5, isMembers: true },
+    [Boss.SCORPIA]: { name: 'Scorpia', minimumKc: 50, isMembers: true },
+    [Boss.TEMPOROSS]: { name: 'Tempoross', minimumKc: 50, isMembers: true },
+    [Boss.THE_GAUNTLET]: { name: 'The Gauntlet', minimumKc: 50, isMembers: true },
+    [Boss.THE_CORRUPTED_GAUNTLET]: { name: 'The Corrupted Gauntlet', minimumKc: 5, isMembers: true },
+    [Boss.THEATRE_OF_BLOOD]: { name: 'Theatre Of Blood', minimumKc: 50, isMembers: true },
+    [Boss.THEATRE_OF_BLOOD_HARD_MODE]: { name: 'Theatre Of Blood (HM)', minimumKc: 50, isMembers: true },
+    [Boss.THERMONUCLEAR_SMOKE_DEVIL]: { name: 'Thermonuclear Smoke Devil', minimumKc: 50, isMembers: true },
+    [Boss.TOMBS_OF_AMASCUT]: { name: 'Tombs of Amascut', minimumKc: 50, isMembers: true },
+    [Boss.TOMBS_OF_AMASCUT_EXPERT]: {
+        name: 'Tombs of Amascut (Expert Mode)',
+        minimumKc: 50,
+        isMembers: true
+    },
+    [Boss.TZKAL_ZUK]: { name: 'TzKal-Zuk', minimumKc: 1, isMembers: true },
+    [Boss.TZTOK_JAD]: { name: 'TzTok-Jad', minimumKc: 5, isMembers: true },
+    [Boss.VENENATIS]: { name: 'Venenatis', minimumKc: 50, isMembers: true },
+    [Boss.VETION]: { name: "Vet'ion", minimumKc: 50, isMembers: true },
+    [Boss.VORKATH]: { name: 'Vorkath', minimumKc: 50, isMembers: true },
+    [Boss.WINTERTODT]: { name: 'Wintertodt', minimumKc: 50, isMembers: true },
+    [Boss.ZALCANO]: { name: 'Zalcano', minimumKc: 50, isMembers: true },
+    [Boss.ZULRAH]: { name: 'Zulrah', minimumKc: 50, isMembers: true }
+}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.BOSS, measure: exports.MetricMeasure.KILLS })));
+const ActivityProps = lodash.mapValues({
+    [Activity.LEAGUE_POINTS]: { name: 'League Points' },
+    [Activity.BOUNTY_HUNTER_HUNTER]: { name: 'Bounty Hunter (Hunter)' },
+    [Activity.BOUNTY_HUNTER_ROGUE]: { name: 'Bounty Hunter (Rogue)' },
+    [Activity.CLUE_SCROLLS_ALL]: { name: 'Clue Scrolls (All)' },
+    [Activity.CLUE_SCROLLS_BEGINNER]: { name: 'Clue Scrolls (Beginner)' },
+    [Activity.CLUE_SCROLLS_EASY]: { name: 'Clue Scrolls (Easy)' },
+    [Activity.CLUE_SCROLLS_MEDIUM]: { name: 'Clue Scrolls (Medium)' },
+    [Activity.CLUE_SCROLLS_HARD]: { name: 'Clue Scrolls (Hard)' },
+    [Activity.CLUE_SCROLLS_ELITE]: { name: 'Clue Scrolls (Elite)' },
+    [Activity.CLUE_SCROLLS_MASTER]: { name: 'Clue Scrolls (Master)' },
+    [Activity.LAST_MAN_STANDING]: { name: 'Last Man Standing' },
+    [Activity.PVP_ARENA]: { name: 'PvP Arena' },
+    [Activity.SOUL_WARS_ZEAL]: { name: 'Soul Wars Zeal' },
+    [Activity.GUARDIANS_OF_THE_RIFT]: { name: 'Guardians of the Rift' }
+}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.ACTIVITY, measure: exports.MetricMeasure.SCORE })));
+const ComputedMetricProps = lodash.mapValues({
+    [ComputedMetric.EHP]: { name: 'EHP' },
+    [ComputedMetric.EHB]: { name: 'EHB' }
+}, props => (Object.assign(Object.assign({}, props), { type: exports.MetricType.COMPUTED, measure: exports.MetricMeasure.VALUE })));
+const MetricProps = Object.assign(Object.assign(Object.assign(Object.assign({}, SkillProps), BossProps), ActivityProps), ComputedMetricProps);
+const METRICS = Object.values(Metric);
+const SKILLS = Object.values(Skill);
+const BOSSES = Object.values(Boss);
+const ACTIVITIES = Object.values(Activity);
+const COMPUTED_METRICS = Object.values(ComputedMetric);
+const REAL_SKILLS = SKILLS.filter(s => s !== Skill.OVERALL);
+const F2P_BOSSES = BOSSES.filter(b => !MetricProps[b].isMembers);
+const MEMBER_SKILLS = SKILLS.filter(s => MetricProps[s].isMembers);
+const COMBAT_SKILLS = SKILLS.filter(s => MetricProps[s].isCombat);
+function findMetric(metricName) {
+    for (const [key, value] of Object.entries(MetricProps)) {
+        if (value.name.toUpperCase() === metricName.toUpperCase())
+            return key;
+    }
+    return null;
+}
+function isMetric(metricString) {
+    return metricString in MetricProps;
+}
+function isSkill(metric) {
+    return metric in SkillProps;
+}
+function isActivity(metric) {
+    return metric in ActivityProps;
+}
+function isBoss(metric) {
+    return metric in BossProps;
+}
+function isComputedMetric(metric) {
+    return metric in ComputedMetricProps;
+}
+function getMetricRankKey(metric) {
+    return `${metric}Rank`;
+}
+function getMetricValueKey(metric) {
+    return `${metric}${lodash.capitalize(MetricProps[metric].measure)}`;
+}
+function getMetricMeasure(metric) {
+    return MetricProps[metric].measure;
+}
+function getMetricName(metric) {
+    return MetricProps[metric].name;
+}
+function getMinimumBossKc(metric) {
+    return isBoss(metric) ? MetricProps[metric].minimumKc : 0;
+}
+function getParentEfficiencyMetric(metric) {
+    if (isBoss(metric))
+        return Metric.EHB;
+    if (isSkill(metric))
+        return Metric.EHP;
+    return null;
+}
+function parseMetricAbbreviation(abbreviation) {
+    if (!abbreviation || abbreviation.length === 0) {
+        return null;
+    }
+    switch (abbreviation.toLowerCase()) {
+        // Bosses
+        case 'sire':
+            return Metric.ABYSSAL_SIRE;
+        case 'hydra':
+            return Metric.ALCHEMICAL_HYDRA;
+        case 'barrows':
+            return Metric.BARROWS_CHESTS;
+        case 'bryo':
+            return Metric.BRYOPHYTA;
+        case 'cerb':
+            return Metric.CERBERUS;
+        case 'cox':
+        case 'xeric':
+        case 'chambers':
+        case 'olm':
+        case 'raids':
+            return Metric.CHAMBERS_OF_XERIC;
+        case 'cox-cm':
+        case 'xeric-cm':
+        case 'chambers-cm':
+        case 'olm-cm':
+        case 'raids-cm':
+            return Metric.CHAMBERS_OF_XERIC_CM;
+        case 'chaos-ele':
+            return Metric.CHAOS_ELEMENTAL;
+        case 'fanatic':
+            return Metric.CHAOS_FANATIC;
+        case 'sara':
+        case 'saradomin':
+        case 'zilyana':
+        case 'zily':
+            return Metric.COMMANDER_ZILYANA;
+        case 'corp':
+            return Metric.CORPOREAL_BEAST;
+        case 'crazy-arch':
+            return Metric.CRAZY_ARCHAEOLOGIST;
+        case 'prime':
+            return Metric.DAGANNOTH_PRIME;
+        case 'rex':
+            return Metric.DAGANNOTH_REX;
+        case 'supreme':
+            return Metric.DAGANNOTH_SUPREME;
+        case 'deranged-arch':
+            return Metric.DERANGED_ARCHAEOLOGIST;
+        case 'bandos':
+        case 'graardor':
+            return Metric.GENERAL_GRAARDOR;
+        case 'mole':
+            return Metric.GIANT_MOLE;
+        case 'dusk':
+        case 'dawn':
+        case 'gargs':
+        case 'guardians':
+        case 'ggs':
+            return Metric.GROTESQUE_GUARDIANS;
+        case 'kq':
+            return Metric.KALPHITE_QUEEN;
+        case 'kbd':
+            return Metric.KING_BLACK_DRAGON;
+        case 'kree':
+        case 'kreearra':
+        case 'armadyl':
+        case 'arma':
+            return Metric.KREEARRA;
+        case 'zammy':
+        case 'zamorak':
+        case 'kril':
+        case 'kril-tsutsaroth':
+            return Metric.KRIL_TSUTSAROTH;
+        case 'gaunt':
+        case 'gauntlet':
+        case 'the-gauntlet':
+            return Metric.THE_GAUNTLET;
+        case 'cgaunt':
+        case 'cgauntlet':
+        case 'corrupted':
+        case 'corrupted-gauntlet':
+        case 'the-corrupted-gauntlet':
+            return Metric.THE_CORRUPTED_GAUNTLET;
+        case 'tob':
+        case 'theatre':
+        case 'verzik':
+        case 'tob-normal':
+            return Metric.THEATRE_OF_BLOOD;
+        case 'tob-hm':
+        case 'tob-cm':
+        case 'tob-hard-mode':
+        case 'tob-hard':
+            return Metric.THEATRE_OF_BLOOD_HARD_MODE;
+        case 'toa':
+        case 'tombs':
+        case 'amascut':
+            return Metric.TOMBS_OF_AMASCUT;
+        case 'toa-expert':
+        case 'toa-hm':
+        case 'tombs-expert':
+        case 'tombs-hm':
+        case 'amascut-expert':
+        case 'amascut-hm':
+            return Metric.TOMBS_OF_AMASCUT_EXPERT;
+        case 'nm':
+        case 'tnm':
+        case 'nmare':
+        case 'the-nightmare':
+            return Metric.NIGHTMARE;
+        case 'pnm':
+        case 'phosani':
+        case 'phosanis':
+        case 'phosani-nm':
+        case 'phosani-nightmare':
+        case 'phosanis nightmare':
+            return Metric.PHOSANIS_NIGHTMARE;
+        case 'thermy':
+        case 'smoke-devil':
+            return Metric.THERMONUCLEAR_SMOKE_DEVIL;
+        case 'zuk':
+        case 'inferno':
+            return Metric.TZKAL_ZUK;
+        case 'jad':
+        case 'fight-caves':
+        case 'fc':
+            return Metric.TZTOK_JAD;
+        case 'vork':
+        case 'vorky':
+            return Metric.VORKATH;
+        case 'wt':
+            return Metric.WINTERTODT;
+        case 'snek':
+        case 'zul':
+            return Metric.ZULRAH;
+        // Minigames and others
+        case 'all-clues':
+        case 'clues':
+            return Metric.CLUE_SCROLLS_ALL;
+        case 'beginner':
+        case 'beginner-clues':
+        case 'beg-clues':
+        case 'beginners':
+            return Metric.CLUE_SCROLLS_BEGINNER;
+        case 'easy':
+        case 'easy-clues':
+        case 'easies':
+            return Metric.CLUE_SCROLLS_EASY;
+        case 'medium':
+        case 'med':
+        case 'meds':
+        case 'medium-clues':
+        case 'med-clues':
+        case 'mediums':
+            return Metric.CLUE_SCROLLS_MEDIUM;
+        case 'hard':
+        case 'hard-clues':
+        case 'hards':
+            return Metric.CLUE_SCROLLS_HARD;
+        case 'elite':
+        case 'elite-clues':
+        case 'elites':
+            return Metric.CLUE_SCROLLS_ELITE;
+        case 'master':
+        case 'master-clues':
+        case 'masters':
+            return Metric.CLUE_SCROLLS_MASTER;
+        case 'lms':
+            return Metric.LAST_MAN_STANDING;
+        case 'league':
+        case 'lp':
+        case 'lps':
+            return Metric.LEAGUE_POINTS;
+        case 'sw':
+        case 'zeal':
+        case 'soul-wars':
+            return Metric.SOUL_WARS_ZEAL;
+        // Skills
+        case 'runecraft':
+        case 'rc':
+            return Metric.RUNECRAFTING;
+        case 'att':
+        case 'atk':
+        case 'attk':
+            return Metric.ATTACK;
+        case 'def':
+        case 'defense':
+            return Metric.DEFENCE;
+        case 'str':
+            return Metric.STRENGTH;
+        case 'hp':
+            return Metric.HITPOINTS;
+        case 'range':
+            return Metric.RANGED;
+        case 'pray':
+            return Metric.PRAYER;
+        case 'mage':
+            return Metric.MAGIC;
+        case 'cook':
+            return Metric.COOKING;
+        case 'wc':
+            return Metric.WOODCUTTING;
+        case 'fletch':
+            return Metric.FLETCHING;
+        case 'fish':
+            return Metric.FISHING;
+        case 'fm':
+        case 'burning':
+            return Metric.FIREMAKING;
+        case 'craft':
+            return Metric.CRAFTING;
+        case 'sm':
+        case 'smith':
+            return Metric.SMITHING;
+        case 'mine':
+        case 'smash':
+            return Metric.MINING;
+        case 'herb':
+            return Metric.HERBLORE;
+        case 'agi':
+        case 'agil':
+            return Metric.AGILITY;
+        case 'thief':
+            return Metric.THIEVING;
+        case 'slay':
+            return Metric.SLAYER;
+        case 'farm':
+            return Metric.FARMING;
+        case 'hunt':
+        case 'hunting':
+            return Metric.HUNTER;
+        case 'con':
+        case 'cons':
+        case 'const':
+            return Metric.CONSTRUCTION;
+        default:
+            return abbreviation;
+    }
 }
 
 const CUSTOM_PERIOD_REGEX = /(\d+y)?(\d+m)?(\d+w)?(\d+d)?(\d+h)?/;
@@ -1999,9 +2201,12 @@ function findPeriod(periodName) {
     }
     return null;
 }
+function isPeriod(periodString) {
+    return periodString in PeriodProps;
+}
 function parsePeriodExpression(periodExpression) {
     const fixed = periodExpression.toLowerCase();
-    if (PERIODS.includes(fixed)) {
+    if (isPeriod(fixed)) {
         return {
             expression: fixed,
             durationMs: PeriodProps[fixed].milliseconds
@@ -2044,6 +2249,12 @@ const PlayerBuildProps = {
 };
 const PLAYER_TYPES = Object.values(PlayerType);
 const PLAYER_BUILDS = Object.values(PlayerBuild);
+function isPlayerType(typeString) {
+    return typeString in PlayerTypeProps;
+}
+function isPlayerBuild(buildString) {
+    return buildString in PlayerBuildProps;
+}
 function findPlayerType(typeName) {
     for (const [key, value] of Object.entries(PlayerTypeProps)) {
         if (value.name.toUpperCase() === typeName.toUpperCase())
@@ -2114,23 +2325,159 @@ exports.SnapshotDataSource = void 0;
 })(exports.SnapshotDataSource || (exports.SnapshotDataSource = {}));
 
 class EfficiencyClient {
+    /**
+     * Fetches the current efficiency leaderboard for a specific efficiency metric, playerType, playerBuild and country.
+     * @returns A list of players.
+     */
     getEfficiencyLeaderboards(filter, pagination) {
         return sendGetRequest('/efficiency/leaderboard', Object.assign(Object.assign({}, filter), pagination));
     }
+    /**
+     * Fetches the top EHP (Efficient Hours Played) rates.
+     * @returns A list of skilling methods and their bonus exp ratios.
+     */
     getEHPRates(algorithmType) {
         return sendGetRequest('/efficiency/rates', { metric: Metric.EHP, type: algorithmType });
     }
+    /**
+     * Fetches the top EHB (Efficient Hours Bossed) rates.
+     * @returns A list of bosses and their respective "per-hour" kill rates.
+     */
     getEHBRates(algorithmType) {
         return sendGetRequest('/efficiency/rates', { metric: Metric.EHB, type: algorithmType });
     }
 }
 
+class NameChangesClient {
+    /**
+     * Searches for name changes that match a name and/or status filter.
+     * @returns A list of name changes.
+     */
+    searchNameChanges(filter, pagination) {
+        return sendGetRequest('/names', Object.assign(Object.assign({}, filter), pagination));
+    }
+    /**
+     * Submits a name change request between two usernames (old and new).
+     * @returns A pending name change request, to be reviewed and resolved at a later date.
+     */
+    submitNameChange(oldName, newName) {
+        return sendPostRequest('/names', { oldName, newName });
+    }
+    /**
+     * Gets details on a specific name change request.
+     * @returns The name change request's details, which includes all data required to review.
+     */
+    getNameChangeDetails(id) {
+        return sendGetRequest(`/names/${id}`);
+    }
+}
+
+class CompetitionsClient {
+    /**
+     * Searches for competitions that match a title, type, metric and status filter.
+     * @returns A list of competitions.
+     */
+    searchCompetitions(filter, pagination) {
+        return sendGetRequest('/competitions', Object.assign(Object.assign({}, filter), pagination));
+    }
+    /**
+     * Fetches the competition's full details, including all the participants and their progress.
+     * @returns A competition with a list of participants.
+     */
+    getCompetitionDetails(id, previewMetric) {
+        return sendGetRequest(`/competitions/${id}`, { metric: previewMetric });
+    }
+    /**
+     * Fetches all the values (exp, kc, etc) in chronological order within the bounds
+     * of the competition, for the top 5 participants.
+     * @returns A list of competition progress objects, including the player and their value history over time.
+     */
+    getCompetitionTopHistory(id, previewMetric) {
+        return sendGetRequest(`/competitions/${id}/top-history`, {
+            metric: previewMetric
+        });
+    }
+    /**
+     * Creates a new competition.
+     * @returns The newly created competition, and the verification code that authorizes future changes to it.
+     */
+    createCompetition(payload) {
+        return sendPostRequest('/competitions', payload);
+    }
+    /**
+     * Edits an existing competition.
+     * @returns The updated competition.
+     */
+    editCompetition(id, payload, verificationCode) {
+        return sendPutRequest(`/competitions/${id}`, Object.assign(Object.assign({}, payload), { verificationCode }));
+    }
+    /**
+     * Deletes an existing competition.
+     * @returns A confirmation message.
+     */
+    deleteCompetition(id, verificationCode) {
+        return sendDeleteRequest(`/competitions/${id}`, { verificationCode });
+    }
+    /**
+     * Adds all (valid) given participants to a competition, ignoring duplicates.
+     * @returns The number of participants added and a confirmation message.
+     */
+    addParticipants(id, participants, verificationCode) {
+        return sendPostRequest(`/competitions/${id}/participants`, {
+            verificationCode,
+            participants
+        });
+    }
+    /**
+     * Remove all given usernames from a competition, ignoring usernames that aren't competing.
+     * @returns The number of participants removed and a confirmation message.
+     */
+    removeParticipants(id, participants, verificationCode) {
+        return sendDeleteRequest(`/competitions/${id}/participants`, {
+            verificationCode,
+            participants
+        });
+    }
+    /**
+     * Adds all (valid) given teams to a team competition, ignoring duplicates.
+     * @returns The number of participants added and a confirmation message.
+     */
+    addTeams(id, teams, verificationCode) {
+        return sendPostRequest(`/competitions/${id}/teams`, {
+            verificationCode,
+            teams
+        });
+    }
+    /**
+     * Remove all given team names from a competition, ignoring names that don't exist.
+     * @returns The number of participants removed and a confirmation message.
+     */
+    removeTeams(id, teamNames, verificationCode) {
+        return sendDeleteRequest(`/competitions/${id}/teams`, {
+            verificationCode,
+            teamNames
+        });
+    }
+    /**
+     * Adds an "update" request to the queue, for each outdated competition participant.
+     * @returns The number of players to be updated and a confirmation message.
+     */
+    updateAll(id, verificationCode) {
+        return sendPostRequest(`/competitions/${id}/update-all`, {
+            verificationCode
+        });
+    }
+}
+
 class WOMClient {
     constructor() {
+        this.deltas = new DeltasClient();
+        this.groups = new GroupsClient();
         this.players = new PlayersClient();
         this.records = new RecordsClient();
-        this.deltas = new DeltasClient();
         this.efficiency = new EfficiencyClient();
+        this.nameChanges = new NameChangesClient();
+        this.competitions = new CompetitionsClient();
     }
 }
 
@@ -2142,10 +2489,12 @@ exports.CAPPED_MAX_TOTAL_XP = CAPPED_MAX_TOTAL_XP;
 exports.COMBAT_SKILLS = COMBAT_SKILLS;
 exports.COMPETITION_STATUSES = COMPETITION_STATUSES;
 exports.COMPETITION_TYPES = COMPETITION_TYPES;
+exports.COMPUTED_METRICS = COMPUTED_METRICS;
 exports.COUNTRY_CODES = COUNTRY_CODES;
 exports.CompetitionStatusProps = CompetitionStatusProps;
 exports.CompetitionType = CompetitionType;
 exports.CompetitionTypeProps = CompetitionTypeProps;
+exports.ComputedMetric = ComputedMetric;
 exports.Country = Country;
 exports.CountryProps = CountryProps;
 exports.F2P_BOSSES = F2P_BOSSES;
@@ -2174,11 +2523,7 @@ exports.REAL_SKILLS = REAL_SKILLS;
 exports.SKILLS = SKILLS;
 exports.SKILL_EXP_AT_99 = SKILL_EXP_AT_99;
 exports.Skill = Skill;
-exports.VIRTUALS = VIRTUALS;
-exports.Virtual = Virtual;
 exports.WOMClient = WOMClient;
-exports.findCompetitionStatus = findCompetitionStatus;
-exports.findCompetitionType = findCompetitionType;
 exports.findCountry = findCountry;
 exports.findCountryByCode = findCountryByCode;
 exports.findCountryByName = findCountryByName;
@@ -2188,10 +2533,7 @@ exports.findPeriod = findPeriod;
 exports.findPlayerBuild = findPlayerBuild;
 exports.findPlayerType = findPlayerType;
 exports.formatNumber = formatNumber;
-exports.get200msCount = get200msCount;
-exports.getCappedExp = getCappedExp;
 exports.getCombatLevel = getCombatLevel;
-exports.getCombatLevelFromExp = getCombatLevelFromExp;
 exports.getExpForLevel = getExpForLevel;
 exports.getLevel = getLevel;
 exports.getMetricMeasure = getMetricMeasure;
@@ -2199,18 +2541,19 @@ exports.getMetricName = getMetricName;
 exports.getMetricRankKey = getMetricRankKey;
 exports.getMetricValueKey = getMetricValueKey;
 exports.getMinimumBossKc = getMinimumBossKc;
-exports.getMinimumExp = getMinimumExp;
-exports.getParentVirtualMetric = getParentVirtualMetric;
-exports.getTotalLevel = getTotalLevel;
-exports.is10HP = is10HP;
-exports.is1Def = is1Def;
+exports.getParentEfficiencyMetric = getParentEfficiencyMetric;
 exports.isActivity = isActivity;
 exports.isBoss = isBoss;
-exports.isF2p = isF2p;
-exports.isLvl3 = isLvl3;
+exports.isCompetitionStatus = isCompetitionStatus;
+exports.isCompetitionType = isCompetitionType;
+exports.isComputedMetric = isComputedMetric;
+exports.isCountry = isCountry;
+exports.isGroupRole = isGroupRole;
+exports.isMetric = isMetric;
+exports.isPeriod = isPeriod;
+exports.isPlayerBuild = isPlayerBuild;
+exports.isPlayerType = isPlayerType;
 exports.isSkill = isSkill;
-exports.isVirtualMetric = isVirtualMetric;
-exports.isZerker = isZerker;
 exports.padNumber = padNumber;
 exports.parseMetricAbbreviation = parseMetricAbbreviation;
 exports.parsePeriodExpression = parsePeriodExpression;