hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/structures/SkyBlock/SkyblockMember.js

@@ -0,0 +1,406 @@
+import Constants from '../../utils/Constants';
+import SkyblockInventoryItem from './SkyblockInventoryItem';
+import SkyblockPet from './SkyblockPet';
+import { getNetworth } from 'skyhelper-networth';
+import { createFarmingWeightCalculator } from 'farming-weight';
+import { decode, getBestiaryLevel, getChocolateFactory, getDungeons, getJacobData, getLevelByXp, getPetLevel, getSkills, getSlayer, getTrophyFishRank } from '../../utils/SkyblockUtils';
+export class MemberStats {
+    candy;
+    petMilestones;
+    highestCriticalDamage;
+    highestDamage;
+    glowingMusroomsBroken;
+    kills;
+    deaths;
+    auctions;
+    gifts;
+    itemsFished;
+    mythos;
+    constructor(data) {
+        this.candy = {
+            green: data?.candy_collected?.green_candy || 0,
+            purple: data?.candy_collected?.purple_candy || 0,
+            total: data?.candy_collected?.total || 0,
+            festivals: []
+        };
+        Object.keys(data?.candy_collected || {}).forEach((year) => {
+            if ('total' !== year && 'green_candy' !== year && 'purple_candy' !== year) {
+                this.candy?.festivals?.push({
+                    year: Number(data?.candy_collected?.[`spooky_festival_${year}`] || '0'),
+                    collected: {
+                        green: data?.candy_collected?.[`spooky_festival_${year}`]?.green_candy || 0,
+                        purple: data?.candy_collected?.[`spooky_festival_${year}`]?.purple_candy || 0,
+                        total: data?.candy_collected?.[`spooky_festival_${year}`]?.total || 0
+                    }
+                });
+            }
+        });
+        this.petMilestones = {
+            oresMinned: data?.pets?.milestones?.ores_mined || 0,
+            seaCreaturesKilled: data?.pets?.milestones?.sea_creatures_killed || 0
+        };
+        this.highestCriticalDamage = data?.highest_critical_damage || 0;
+        this.highestDamage = data?.highest_damage || 0;
+        this.glowingMusroomsBroken = data?.glowing_mushrooms_broken || 0;
+        this.kills = {
+            total: Object.values(data?.kills || {})?.reduce((acc, curr) => acc + curr, 0),
+            ...Object.keys(data?.kills || {})
+                .filter((key) => 'total' !== key)
+                .sort((a, b) => data?.kills[b] - data?.kills[a])
+                .map((key) => ({ [key]: data?.kills[key] }))
+                .reduce((acc, curr) => ({ ...acc, ...curr }), {})
+        };
+        this.deaths = {
+            total: Object.values(data?.deaths || {})?.reduce((acc, curr) => acc + curr, 0),
+            ...Object.keys(data?.deaths || {})
+                .filter((key) => 'total' !== key)
+                .sort((a, b) => data?.deaths[b] - data?.deaths[a])
+                .map((key) => ({ [key]: data?.deaths[key] }))
+                .reduce((acc, curr) => ({ ...acc, ...curr }), {})
+        };
+        this.auctions = {
+            bids: data?.auctions?.bids || 0,
+            highestBid: data?.auctions?.highest_bid || 0,
+            goldSpent: data?.auctions?.gold_spent || 0,
+            goldEarnt: data?.auctions?.gold_earnt || 0,
+            auctionsWon: data?.auctions?.won || 0,
+            auctionsCompleted: data?.auctions?.completed || 0,
+            auctionsCreated: data?.auctions?.created || 0,
+            auctionFees: data?.auctions?.auction_fees || 0,
+            auctionsWithOutBids: data?.auctions?.no_bids || 0,
+            bought: {
+                uncommon: data?.auctions?.total_bought?.uncommon || 0,
+                common: data?.auctions?.total_bought?.common || 0,
+                rare: data?.auctions?.total_bought?.rare || 0,
+                epic: data?.auctions?.total_bought?.epic || 0,
+                legendary: data?.auctions?.total_bought?.legendary || 0,
+                special: data?.auctions?.total_bought?.special || 0,
+                mythic: data?.auctions?.total_bought?.mythic || 0,
+                total: data?.auctions?.total_bought?.uncommon ||
+                    0 + data?.auctions?.total_bought?.common ||
+                    0 + data?.auctions?.total_bought?.rare ||
+                    0 + data?.auctions?.total_bought?.epic ||
+                    0 + data?.auctions?.total_bought?.legendary ||
+                    0 + data?.auctions?.total_bought?.special ||
+                    0 + data?.auctions?.total_bought?.mythic ||
+                    0
+            },
+            sold: {
+                uncommon: data?.auctions?.total_sold?.uncommon || 0,
+                common: data?.auctions?.total_sold?.common || 0,
+                rare: data?.auctions?.total_sold?.rare || 0,
+                epic: data?.auctions?.total_sold?.epic || 0,
+                legendary: data?.auctions?.total_sold?.legendary || 0,
+                special: data?.auctions?.total_sold?.special || 0,
+                mythic: data?.auctions?.total_sold?.mythic || 0,
+                total: data?.auctions?.total_sold?.uncommon ||
+                    0 + data?.auctions?.total_sold?.common ||
+                    0 + data?.auctions?.total_sold?.rare ||
+                    0 + data?.auctions?.total_sold?.epic ||
+                    0 + data?.auctions?.total_sold?.legendary ||
+                    0 + data?.auctions?.total_sold?.special ||
+                    0 + data?.auctions?.total_sold?.mythic ||
+                    0
+            }
+        };
+        this.gifts = { given: data?.gifts?.total_given || 0, received: data?.gifts?.total_received || 0 };
+        this.itemsFished = {
+            total: data?.items_fished?.total || 0,
+            normal: data?.items_fished?.normal || 0,
+            tresure: data?.items_fished?.treasure || 0,
+            largeTresure: data?.items_fished?.large_treasure || 0
+        };
+        this.mythos = {
+            kills: data?.mythos?.kills || 0,
+            burrowsDugNext: {
+                total: data?.mythos?.burrows_dug_next?.total || 0,
+                common: data?.mythos?.burrows_dug_next?.common || 0
+            },
+            burrowsDugCombat: {
+                total: data?.mythos?.burrows_dug_combat?.total || 0,
+                common: data?.mythos?.burrows_dug_combat?.common || 0
+            },
+            burrowsDugTreasure: {
+                total: data?.mythos?.burrows_dug_treasure?.total || 0,
+                common: data?.mythos?.burrows_dug_treasure?.common || 0
+            },
+            burrowsDugComplate: {
+                total: data?.mythos?.burrows_dug_complete?.total || 0,
+                common: data?.mythos?.burrows_dug_complete?.common || 0
+            }
+        };
+    }
+}
+class SkyblockMemberMinion {
+    t1;
+    t2;
+    t3;
+    t4;
+    t5;
+    t6;
+    t7;
+    t8;
+    t9;
+    t10;
+    t11;
+    t12;
+    constructor(data) {
+        this.t1 = false;
+        this.t2 = false;
+        this.t3 = false;
+        this.t4 = false;
+        this.t5 = false;
+        this.t6 = false;
+        this.t7 = false;
+        this.t8 = false;
+        this.t9 = false;
+        this.t10 = false;
+        this.t11 = false;
+        this.t12 = false;
+        data.forEach((tier) => {
+            if (1 <= tier && 12 >= tier) {
+                this[`t${tier}`] = true;
+            }
+        });
+    }
+}
+export class SkyblockMemberMinions {
+    constructor(data) {
+        const parsed = this.#parse(data);
+        Object.keys(parsed).forEach((minion) => {
+            this[minion] = new SkyblockMemberMinion(parsed[minion]);
+        });
+    }
+    #parse(data) {
+        return data.reduce((acc, item) => {
+            const lastUnderscoreIndex = item.lastIndexOf('_');
+            if (-1 === lastUnderscoreIndex)
+                return acc;
+            const name = item.substring(0, lastUnderscoreIndex);
+            const number = item.substring(lastUnderscoreIndex + 1);
+            const num = parseInt(number, 10);
+            if (isNaN(num))
+                return acc;
+            if (!acc[name])
+                acc[name] = [];
+            acc[name].push(num);
+            return acc;
+        }, {});
+    }
+}
+class SkyblockMember {
+    uuid;
+    gameMode;
+    selected;
+    garden;
+    museum;
+    profileName;
+    profileId;
+    firstJoinTimestamp;
+    firstJoinAt;
+    experience;
+    level;
+    hotm;
+    trophyFish;
+    highestMagicalPower;
+    fairySouls;
+    fairyExchanges;
+    skills;
+    bestiary;
+    slayer;
+    dungeons;
+    collections;
+    purse;
+    stats;
+    pets;
+    jacob;
+    chocolate;
+    minions;
+    getArmor;
+    getWardrobe;
+    getEnderChest;
+    getInventory;
+    getPetScore;
+    getEquipment;
+    getPersonalVault;
+    getNetworth;
+    getFarmingWeight;
+    constructor(data) {
+        this.uuid = data?.uuid || '';
+        this.gameMode = data?.gameMode || null;
+        this.selected = data?.selected || false;
+        this.garden = data?.garden || null;
+        this.museum = data?.museum || null;
+        this.profileName = data?.profileName || '';
+        this.profileId = data?.profileId || '';
+        this.firstJoinTimestamp = data?.m?.profile?.first_join || null;
+        this.firstJoinAt = this.firstJoinTimestamp ? new Date(this.firstJoinTimestamp) : null;
+        this.experience = data?.m?.leveling?.experience || 0;
+        this.level = this.experience / 100;
+        this.hotm = getLevelByXp(data?.m?.mining_core?.experience, 'hotm');
+        this.trophyFish = getTrophyFishRank(data?.m?.trophy_fish?.rewards?.length || 0);
+        this.highestMagicalPower = data?.m?.accessory_bag_storage?.highest_magical_power || 0;
+        this.fairySouls = data?.m?.fairy_soul?.total_collected || 0;
+        this.fairyExchanges = data?.m?.fairy_soul?.fairy_exchanges || 0;
+        this.skills = getSkills(data?.m);
+        this.bestiary = getBestiaryLevel(data?.m);
+        this.slayer = getSlayer(data?.m);
+        this.dungeons = getDungeons(data?.m);
+        this.collections = data?.m?.collection || {};
+        this.purse = data?.m?.currencies?.coin_purse ?? 0;
+        this.stats = new MemberStats(data?.m?.player_stats);
+        this.pets = data?.m?.pets_data?.pets ? data?.m?.pets_data?.pets?.map((pet) => new SkyblockPet(pet)) : [];
+        this.jacob = getJacobData(data?.m);
+        this.chocolate = getChocolateFactory(data?.m);
+        this.minions = new SkyblockMemberMinions(data?.m?.player_data?.crafted_generators || []);
+        this.getArmor = async () => {
+            const base64 = data?.m?.inventory?.inv_armor;
+            const decoded = await decode(base64?.data);
+            const armor = {
+                helmet: decoded[3]?.id ? new SkyblockInventoryItem(decoded[3]) : null,
+                chestplate: decoded[2]?.id ? new SkyblockInventoryItem(decoded[2]) : null,
+                leggings: decoded[1]?.id ? new SkyblockInventoryItem(decoded[1]) : null,
+                boots: decoded[0]?.id ? new SkyblockInventoryItem(decoded[0]) : null
+            };
+            return armor;
+        };
+        this.getWardrobe = async () => {
+            const base64 = data?.m?.inventory?.wardrobe_contents?.data;
+            if (!base64)
+                return [];
+            const decoded = await decode(base64);
+            const armor = decoded
+                .filter((item) => 0 !== Object.keys(item).length)
+                .map((item) => new SkyblockInventoryItem(item));
+            return armor;
+        };
+        this.getEnderChest = async () => {
+            let chest = data?.m?.inventory?.ender_chest_contents;
+            if (!chest)
+                return [];
+            try {
+                chest = await decode(chest?.data);
+                const edited = [];
+                for (let i = 0; i < chest.length; i++) {
+                    if (!chest[i]?.id)
+                        continue;
+                    edited.push(new SkyblockInventoryItem(chest[i]));
+                }
+                return edited;
+            }
+            catch {
+                return [];
+            }
+        };
+        this.getInventory = async () => {
+            let inventory = data?.m?.inventory?.inv_contents;
+            if (!inventory)
+                return [];
+            try {
+                inventory = await decode(inventory?.data);
+                const edited = [];
+                for (let i = 0; i < inventory.length; i++) {
+                    if (!inventory[i]?.id)
+                        continue;
+                    edited.push(new SkyblockInventoryItem(inventory[i]));
+                }
+                return edited;
+            }
+            catch {
+                return [];
+            }
+        };
+        this.getPetScore = () => {
+            const highestRarity = {};
+            for (const pet of data?.m?.pets_data?.pets) {
+                if (!(pet?.type in highestRarity) ||
+                    Constants.petScore[pet?.tier] > highestRarity[pet?.type]) {
+                    highestRarity[pet?.type] = Constants.petScore[pet?.tier];
+                }
+            }
+            const highestLevel = {};
+            for (const pet of data?.m?.pets_data?.pets) {
+                const maxLevel = 'GOLDEN_DRAGON' === pet?.type ? 200 : 100;
+                const petLevel = getPetLevel(pet?.exp, pet?.tier, maxLevel);
+                if (!(pet?.type in highestLevel) || petLevel?.level > highestLevel[pet?.type]) {
+                    if (petLevel?.level < maxLevel) {
+                        continue;
+                    }
+                    highestLevel[pet?.type] = 1;
+                }
+            }
+            return (Object.values(highestRarity).reduce((a, b) => a + b, 0) + Object.values(highestLevel).reduce((a, b) => a + b, 0));
+        };
+        this.getEquipment = async () => {
+            let equipment = data?.m?.inventory?.equipment_contents;
+            if (!equipment) {
+                return { gauntlet: null, belt: null, cloak: null, necklace: null };
+            }
+            try {
+                equipment = await decode(equipment?.data);
+                const playerEquipment = {
+                    gauntlet: equipment?.[3]?.id ? new SkyblockInventoryItem(equipment[3]) : null,
+                    belt: equipment?.[2]?.id ? new SkyblockInventoryItem(equipment[2]) : null,
+                    cloak: equipment?.[1]?.id ? new SkyblockInventoryItem(equipment[1]) : null,
+                    necklace: equipment?.[0]?.id ? new SkyblockInventoryItem(equipment[0]) : null
+                };
+                return playerEquipment;
+            }
+            catch {
+                return { gauntlet: null, belt: null, cloak: null, necklace: null };
+            }
+        };
+        this.getPersonalVault = async () => {
+            let vault = data?.m?.inventory?.personal_vault_contents;
+            if (!vault)
+                return [];
+            try {
+                vault = await decode(vault?.data);
+                const edited = [];
+                for (let i = 0; i < vault?.length; i++) {
+                    if (!vault[i]?.id)
+                        continue;
+                    edited.push(new SkyblockInventoryItem(vault[i]));
+                }
+                return edited;
+            }
+            catch {
+                return [];
+            }
+        };
+        this.getNetworth = async () => {
+            try {
+                const nw = await getNetworth(data?.m, data?.banking?.balance ?? 0, {
+                    onlyNetworth: true,
+                    v2Endpoint: true,
+                    cache: true,
+                    museumData: data?.museum?.raw ?? {}
+                });
+                return nw;
+            }
+            catch {
+                return null;
+            }
+        };
+        this.getFarmingWeight = () => {
+            try {
+                return createFarmingWeightCalculator({
+                    collection: this.collections,
+                    farmingXp: this.skills.farming.xp,
+                    levelCapUpgrade: this.jacob.perks.farmingLevelCap,
+                    anitaBonusFarmingFortuneLevel: this.jacob.perks.doubleDrops,
+                    minions: data?.m?.player_data?.crafted_generators,
+                    contests: Object.values(this.jacob.contests),
+                    pests: data?.m?.bestiary?.kills
+                }).getWeightInfo().totalWeight;
+            }
+            catch {
+                return 0;
+            }
+        };
+    }
+    toString() {
+        return this.uuid;
+    }
+}
+export default SkyblockMember;

package/dist/src/structures/SkyBlock/SkyblockMember.test.js

@@ -0,0 +1,71 @@
+import SkyblockMember from './SkyblockMember';
+import { expect, expectTypeOf, test } from 'vitest';
+test('SkyblockMember', () => {
+    const data = new SkyblockMember({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(SkyblockMember);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.uuid).toBeDefined();
+    expectTypeOf(data.uuid).toEqualTypeOf();
+    expect(data.gameMode).toBeDefined();
+    expectTypeOf(data.gameMode).toEqualTypeOf();
+    expect(data.selected).toBeDefined();
+    expectTypeOf(data.selected).toEqualTypeOf();
+    expect(data.garden).toBeDefined();
+    expect(data.garden).toBeNull();
+    expectTypeOf(data.garden).toEqualTypeOf();
+    expect(data.museum).toBeDefined();
+    expectTypeOf(data.museum).toEqualTypeOf();
+    expect(data.profileName).toBeDefined();
+    expectTypeOf(data.profileName).toEqualTypeOf();
+    expect(data.profileId).toBeDefined();
+    expectTypeOf(data.profileId).toEqualTypeOf();
+    expect(data.firstJoinTimestamp).toBeDefined();
+    expectTypeOf(data.firstJoinTimestamp).toEqualTypeOf();
+    expect(data.firstJoinAt).toBeDefined();
+    expectTypeOf(data.firstJoinAt).toEqualTypeOf();
+    expect(data.experience).toBeDefined();
+    expect(data.experience).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.experience).toEqualTypeOf();
+    expect(data.level).toBeDefined();
+    expect(data.level).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.hotm).toBeDefined();
+    expectTypeOf(data.hotm).toEqualTypeOf();
+    expect(data.trophyFish).toBeDefined();
+    expectTypeOf(data.trophyFish).toEqualTypeOf();
+    expect(data.highestMagicalPower).toBeDefined();
+    expect(data.highestMagicalPower).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.highestMagicalPower).toEqualTypeOf();
+    expect(data.fairySouls).toBeDefined();
+    expect(data.fairySouls).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fairySouls).toEqualTypeOf();
+    expect(data.fairyExchanges).toBeDefined();
+    expect(data.fairyExchanges).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fairyExchanges).toEqualTypeOf();
+    expect(data.skills).toBeDefined();
+    expectTypeOf(data.skills).toEqualTypeOf();
+    expect(data.bestiary).toBeDefined();
+    expect(data.bestiary).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bestiary).toEqualTypeOf();
+    expect(data.slayer).toBeDefined();
+    expectTypeOf(data.slayer).toEqualTypeOf();
+    expect(data.dungeons).toBeDefined();
+    expectTypeOf(data.dungeons).toEqualTypeOf();
+    expect(data.collections).toBeDefined();
+    expectTypeOf(data.collections).toEqualTypeOf();
+    expect(data.purse).toBeDefined();
+    expect(data.purse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.purse).toEqualTypeOf();
+    expect(data.stats).toBeDefined();
+    expectTypeOf(data.stats).toEqualTypeOf();
+    expect(data.pets).toBeDefined();
+    expectTypeOf(data.pets).toEqualTypeOf();
+    expect(data.jacob).toBeDefined();
+    expectTypeOf(data.jacob).toEqualTypeOf();
+    expect(data.chocolate).toBeDefined();
+    expectTypeOf(data.chocolate).toEqualTypeOf();
+    expect(data.toString()).toBeDefined();
+    expect(data.toString()).toBe(data.uuid);
+    expectTypeOf(data.toString()).toEqualTypeOf();
+});

package/dist/src/structures/SkyBlock/SkyblockMuseum.js

@@ -0,0 +1,29 @@
+import SkyblockMuseumItem from './SkyblockMuseumItem';
+import { decode } from '../../utils/SkyblockUtils';
+class SkyblockMuseum {
+    raw;
+    value;
+    appraisal;
+    getItems;
+    getSpecial;
+    constructor(data) {
+        this.raw = data.m.members?.[data.uuid] ?? {};
+        this.value = data.value;
+        this.appraisal = data.appraisal;
+        this.getItems = async () => {
+            const items = [];
+            for (const item of Object.keys(data?.m?.members[data?.uuid]?.items) || {}) {
+                items.push(new SkyblockMuseumItem(item, data?.m?.members[data?.uuid]?.items[item], await decode(data?.m?.members[data?.uuid]?.items[item]?.items?.data)));
+            }
+            return items;
+        };
+        this.getSpecial = async () => {
+            const items = [];
+            for (const item of Object.keys(data?.m?.members[data?.uuid]?.special || {})) {
+                items.push(new SkyblockMuseumItem(item, data?.m?.members[data?.uuid]?.special[item], await decode(data?.m?.members[data?.uuid]?.special[item]?.items?.data)));
+            }
+            return items;
+        };
+    }
+}
+export default SkyblockMuseum;

package/dist/src/structures/SkyBlock/SkyblockMuseumItem.js

@@ -0,0 +1,24 @@
+import SkyblockInventoryItem from './SkyblockInventoryItem';
+class SkyblockMuseumItem {
+    name;
+    donated;
+    items;
+    borrowing;
+    featuredSlot;
+    constructor(name, data, decoded) {
+        this.name = name;
+        this.donated = data.donated_time || 0;
+        this.featuredSlot = data.featured_slot || null;
+        this.borrowing = data.borrowing || false;
+        this.items = [];
+        decoded.forEach((item) => {
+            if (!item.tag)
+                return;
+            this.items.push(new SkyblockInventoryItem(item));
+        });
+    }
+    toString() {
+        return this.name;
+    }
+}
+export default SkyblockMuseumItem;

package/dist/src/structures/SkyBlock/SkyblockPet.js

@@ -0,0 +1,27 @@
+import Constants from '../../utils/Constants';
+class SkyblockPet {
+    uuid;
+    name;
+    xp;
+    active;
+    rarity;
+    petScore;
+    heldItem;
+    candyUsed;
+    skin;
+    constructor(data) {
+        this.uuid = data.uuid;
+        this.name = data.type;
+        this.xp = data.exp || 0;
+        this.active = Boolean(data.active);
+        this.rarity = data.tier;
+        this.petScore = Constants.petScore[this.rarity] || 0;
+        this.heldItem = data.heldItem ? data.heldItem.replace(/^PET_ITEM_/, '') : null;
+        this.candyUsed = data.candyUsed || 0;
+        this.skin = data.skin;
+    }
+    toString() {
+        return this.name;
+    }
+}
+export default SkyblockPet;

package/dist/src/structures/SkyBlock/SkyblockProfile.js

@@ -0,0 +1,36 @@
+import SkyblockMember from './SkyblockMember';
+class SkyblockProfile {
+    profileId;
+    profileName;
+    gameMode;
+    banking;
+    communityUpgrades;
+    selected;
+    members;
+    me;
+    constructor(data) {
+        this.profileId = data.profileId;
+        this.profileName = data.profileName;
+        this.gameMode = data.gameMode;
+        this.banking = data.banking;
+        this.communityUpgrades = data.communityUpgrades;
+        this.selected = data.selected;
+        this.members = Object.keys(data.members).map((uuid) => new SkyblockMember({
+            uuid: uuid,
+            profileId: this.profileId,
+            garden: data.garden,
+            museum: data.museum,
+            profileName: this.profileName,
+            gameMode: this.gameMode,
+            m: data.members[uuid],
+            banking: this.banking,
+            communityUpgrades: this.communityUpgrades,
+            selected: this.selected
+        }));
+        this.me = this.members.find((x) => x.uuid === data.uuid);
+    }
+    toString() {
+        return this.profileName;
+    }
+}
+export default SkyblockProfile;

package/dist/src/structures/SkyBlock/Static/Bingo.js

@@ -0,0 +1,49 @@
+function parsePosition(position) {
+    const x = (position % 5) + 1;
+    const y = Math.floor(position / 5) + 1;
+    return [x, y];
+}
+class Bingo {
+    name;
+    id;
+    row;
+    column;
+    rawLore;
+    lore;
+    tiers;
+    tierStep;
+    requiredAmount;
+    type;
+    constructor(data, position = 0) {
+        this.name = data.name;
+        this.id = data.id;
+        const [row, column] = parsePosition(position);
+        this.row = row;
+        this.column = column;
+        this.rawLore = data.lore;
+        this.lore = data.lore?.replace?.(/§([1-9]|[a-l])|§/gm, '') || [];
+        this.tiers = Array.isArray(data.tiers) ? data.tiers.map((x) => parseInt(x, 10) || 0) : [];
+        this.tierStep = this.getTierStep();
+        this.requiredAmount = parseInt(data.requiredAmount, 10) ?? null;
+        this.type = this.tiers ? 'TIERED' : this.requiredAmount ? 'ONE_TIER' : 'ONE_TIME';
+    }
+    toString() {
+        return this.id;
+    }
+    getTierStep() {
+        if ('TIERED' !== this.type)
+            return null;
+        // No step possible
+        if (2 > this.tiers.length)
+            return null;
+        const hypotheticStep = this.tiers[1] - this.tiers[0];
+        // Check if every 2 elements have the same step
+        const isConstant = this.tiers.slice(1).every((el, index) => {
+            return hypotheticStep === this.tiers[index - 1] - el;
+        });
+        if (!isConstant)
+            return null;
+        return hypotheticStep;
+    }
+}
+export default Bingo;

package/dist/src/structures/SkyBlock/Static/BingoData.js

@@ -0,0 +1,19 @@
+import Bingo from './Bingo';
+class BingoData {
+    lastUpdatedTimestamp;
+    lastUpdatedAt;
+    id;
+    goals;
+    constructor(data) {
+        this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+        this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+        this.id = parseInt(data.id, 10) || null;
+        this.goals = Array.isArray(data.goals) ? data.goals.map((goal, index) => new Bingo(goal, index)) : null;
+    }
+    getGoal(column, row) {
+        if (!this.goals || 1 > this.goals.length)
+            return;
+        return this.goals.find((goal) => goal.row === row && goal.column === column);
+    }
+}
+export default BingoData;

package/dist/src/structures/SkyBlock/Static/Candidate.js

@@ -0,0 +1,19 @@
+import Perk from './Perk';
+class Candidate {
+    name;
+    keyBenefit;
+    perks;
+    isMayor;
+    votesReceived;
+    constructor(data, isMayor = false) {
+        this.name = data.name;
+        this.keyBenefit = data.key;
+        this.perks = data.perks.map((x) => new Perk(x));
+        this.isMayor = isMayor || false;
+        this.votesReceived = parseInt(data.votes, 10);
+    }
+    toString() {
+        return this.name;
+    }
+}
+export default Candidate;