hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/structures/MiniGames/WoolWars.test.js

@@ -0,0 +1,251 @@
+import WoolWars from './WoolWars';
+import { expect, expectTypeOf, test } from 'vitest';
+test('WoolWars', () => {
+    const data = new WoolWars({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(WoolWars);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.layers).toBeDefined();
+    expect(data.layers).greaterThanOrEqual(0);
+    expectTypeOf(data.layers).toEqualTypeOf();
+    expect(data.xp).toBeDefined();
+    expect(data.xp).greaterThanOrEqual(0);
+    expectTypeOf(data.xp).toEqualTypeOf();
+    expect(data.exactLevel).toBeDefined();
+    expect(data.exactLevel).greaterThanOrEqual(0);
+    expectTypeOf(data.exactLevel).toEqualTypeOf();
+    expect(data.level).toBeDefined();
+    expect(data.level).greaterThanOrEqual(0);
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.coins).toBeDefined();
+    expect(data.coins).greaterThanOrEqual(0);
+    expectTypeOf(data.coins).toEqualTypeOf();
+    expect(data.wins).toBeDefined();
+    expect(data.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.wins).toEqualTypeOf();
+    expect(data.gamesPlayed).toBeDefined();
+    expect(data.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.gamesPlayed).toEqualTypeOf();
+    expect(data.woolsPlaced).toBeDefined();
+    expect(data.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.woolsPlaced).toEqualTypeOf();
+    expect(data.blocksBroken).toBeDefined();
+    expect(data.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.blocksBroken).toEqualTypeOf();
+    expect(data.placeBreakRatio).toBeDefined();
+    expect(data.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.placeBreakRatio).toEqualTypeOf();
+    expect(data.kills).toBeDefined();
+    expect(data.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.kills).toEqualTypeOf();
+    expect(data.deaths).toBeDefined();
+    expect(data.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.deaths).toEqualTypeOf();
+    expect(data.KDR).toBeDefined();
+    expect(data.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.KDR).toEqualTypeOf();
+    expect(data.assists).toBeDefined();
+    expect(data.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.assists).toEqualTypeOf();
+    expect(data.powerups).toBeDefined();
+    expect(data.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.powerups).toEqualTypeOf();
+    expect(data.selectedClass).toBeDefined();
+    expectTypeOf(data.selectedClass).toEqualTypeOf();
+    expect(data.assault).toBeDefined();
+    expectTypeOf(data.assault).toEqualTypeOf();
+    expect(data.assault.wins).toBeDefined();
+    expect(data.assault.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.wins).toEqualTypeOf();
+    expect(data.assault.gamesPlayed).toBeDefined();
+    expect(data.assault.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.gamesPlayed).toEqualTypeOf();
+    expect(data.assault.woolsPlaced).toBeDefined();
+    expect(data.assault.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.woolsPlaced).toEqualTypeOf();
+    expect(data.assault.blocksBroken).toBeDefined();
+    expect(data.assault.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.blocksBroken).toEqualTypeOf();
+    expect(data.assault.placeBreakRatio).toBeDefined();
+    expect(data.assault.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.placeBreakRatio).toEqualTypeOf();
+    expect(data.assault.kills).toBeDefined();
+    expect(data.assault.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.kills).toEqualTypeOf();
+    expect(data.assault.deaths).toBeDefined();
+    expect(data.assault.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.deaths).toEqualTypeOf();
+    expect(data.assault.KDR).toBeDefined();
+    expect(data.assault.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.KDR).toEqualTypeOf();
+    expect(data.assault.assists).toBeDefined();
+    expect(data.assault.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.assists).toEqualTypeOf();
+    expect(data.assault.powerups).toBeDefined();
+    expect(data.assault.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.assault.powerups).toEqualTypeOf();
+    expect(data.tank).toBeDefined();
+    expectTypeOf(data.tank).toEqualTypeOf();
+    expect(data.tank.wins).toBeDefined();
+    expect(data.tank.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.wins).toEqualTypeOf();
+    expect(data.tank.gamesPlayed).toBeDefined();
+    expect(data.tank.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.gamesPlayed).toEqualTypeOf();
+    expect(data.tank.woolsPlaced).toBeDefined();
+    expect(data.tank.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.woolsPlaced).toEqualTypeOf();
+    expect(data.tank.blocksBroken).toBeDefined();
+    expect(data.tank.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.blocksBroken).toEqualTypeOf();
+    expect(data.tank.placeBreakRatio).toBeDefined();
+    expect(data.tank.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.placeBreakRatio).toEqualTypeOf();
+    expect(data.tank.kills).toBeDefined();
+    expect(data.tank.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.kills).toEqualTypeOf();
+    expect(data.tank.deaths).toBeDefined();
+    expect(data.tank.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.deaths).toEqualTypeOf();
+    expect(data.tank.KDR).toBeDefined();
+    expect(data.tank.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.KDR).toEqualTypeOf();
+    expect(data.tank.assists).toBeDefined();
+    expect(data.tank.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.assists).toEqualTypeOf();
+    expect(data.tank.powerups).toBeDefined();
+    expect(data.tank.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.tank.powerups).toEqualTypeOf();
+    expect(data.golem).toBeDefined();
+    expectTypeOf(data.golem).toEqualTypeOf();
+    expect(data.golem.wins).toBeDefined();
+    expect(data.golem.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.wins).toEqualTypeOf();
+    expect(data.golem.gamesPlayed).toBeDefined();
+    expect(data.golem.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.gamesPlayed).toEqualTypeOf();
+    expect(data.golem.woolsPlaced).toBeDefined();
+    expect(data.golem.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.woolsPlaced).toEqualTypeOf();
+    expect(data.golem.blocksBroken).toBeDefined();
+    expect(data.golem.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.blocksBroken).toEqualTypeOf();
+    expect(data.golem.placeBreakRatio).toBeDefined();
+    expect(data.golem.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.placeBreakRatio).toEqualTypeOf();
+    expect(data.golem.kills).toBeDefined();
+    expect(data.golem.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.kills).toEqualTypeOf();
+    expect(data.golem.deaths).toBeDefined();
+    expect(data.golem.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.deaths).toEqualTypeOf();
+    expect(data.golem.KDR).toBeDefined();
+    expect(data.golem.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.KDR).toEqualTypeOf();
+    expect(data.golem.assists).toBeDefined();
+    expect(data.golem.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.assists).toEqualTypeOf();
+    expect(data.golem.powerups).toBeDefined();
+    expect(data.golem.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.powerups).toEqualTypeOf();
+    expect(data.swordsman).toBeDefined();
+    expectTypeOf(data.swordsman).toEqualTypeOf();
+    expect(data.swordsman.wins).toBeDefined();
+    expect(data.swordsman.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.wins).toEqualTypeOf();
+    expect(data.swordsman.gamesPlayed).toBeDefined();
+    expect(data.swordsman.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.gamesPlayed).toEqualTypeOf();
+    expect(data.swordsman.woolsPlaced).toBeDefined();
+    expect(data.swordsman.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.woolsPlaced).toEqualTypeOf();
+    expect(data.swordsman.blocksBroken).toBeDefined();
+    expect(data.swordsman.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.blocksBroken).toEqualTypeOf();
+    expect(data.swordsman.placeBreakRatio).toBeDefined();
+    expect(data.swordsman.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.placeBreakRatio).toEqualTypeOf();
+    expect(data.swordsman.kills).toBeDefined();
+    expect(data.swordsman.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.kills).toEqualTypeOf();
+    expect(data.swordsman.deaths).toBeDefined();
+    expect(data.swordsman.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.deaths).toEqualTypeOf();
+    expect(data.swordsman.KDR).toBeDefined();
+    expect(data.swordsman.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.KDR).toEqualTypeOf();
+    expect(data.swordsman.assists).toBeDefined();
+    expect(data.swordsman.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.assists).toEqualTypeOf();
+    expect(data.swordsman.powerups).toBeDefined();
+    expect(data.swordsman.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.swordsman.powerups).toEqualTypeOf();
+    expect(data.engineer).toBeDefined();
+    expectTypeOf(data.engineer).toEqualTypeOf();
+    expect(data.engineer.wins).toBeDefined();
+    expect(data.engineer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.wins).toEqualTypeOf();
+    expect(data.engineer.gamesPlayed).toBeDefined();
+    expect(data.engineer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.gamesPlayed).toEqualTypeOf();
+    expect(data.engineer.woolsPlaced).toBeDefined();
+    expect(data.engineer.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.woolsPlaced).toEqualTypeOf();
+    expect(data.engineer.blocksBroken).toBeDefined();
+    expect(data.engineer.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.blocksBroken).toEqualTypeOf();
+    expect(data.engineer.placeBreakRatio).toBeDefined();
+    expect(data.engineer.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.placeBreakRatio).toEqualTypeOf();
+    expect(data.engineer.kills).toBeDefined();
+    expect(data.engineer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.kills).toEqualTypeOf();
+    expect(data.engineer.deaths).toBeDefined();
+    expect(data.engineer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.deaths).toEqualTypeOf();
+    expect(data.engineer.KDR).toBeDefined();
+    expect(data.engineer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.KDR).toEqualTypeOf();
+    expect(data.engineer.assists).toBeDefined();
+    expect(data.engineer.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.assists).toEqualTypeOf();
+    expect(data.engineer.powerups).toBeDefined();
+    expect(data.engineer.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.engineer.powerups).toEqualTypeOf();
+    expect(data.archer).toBeDefined();
+    expectTypeOf(data.archer).toEqualTypeOf();
+    expect(data.archer.wins).toBeDefined();
+    expect(data.archer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.wins).toEqualTypeOf();
+    expect(data.archer.gamesPlayed).toBeDefined();
+    expect(data.archer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.gamesPlayed).toEqualTypeOf();
+    expect(data.archer.woolsPlaced).toBeDefined();
+    expect(data.archer.woolsPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.woolsPlaced).toEqualTypeOf();
+    expect(data.archer.blocksBroken).toBeDefined();
+    expect(data.archer.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.blocksBroken).toEqualTypeOf();
+    expect(data.archer.placeBreakRatio).toBeDefined();
+    expect(data.archer.placeBreakRatio).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.placeBreakRatio).toEqualTypeOf();
+    expect(data.archer.kills).toBeDefined();
+    expect(data.archer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.kills).toEqualTypeOf();
+    expect(data.archer.deaths).toBeDefined();
+    expect(data.archer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.deaths).toEqualTypeOf();
+    expect(data.archer.KDR).toBeDefined();
+    expect(data.archer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.KDR).toEqualTypeOf();
+    expect(data.archer.assists).toBeDefined();
+    expect(data.archer.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.assists).toEqualTypeOf();
+    expect(data.archer.powerups).toBeDefined();
+    expect(data.archer.powerups).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.powerups).toEqualTypeOf();
+    expect(data.ownedCosmetics).toBeDefined();
+    expectTypeOf(data.ownedCosmetics).toEqualTypeOf();
+    expect(data.privateGamesConfig).toBeDefined();
+    expectTypeOf(data.privateGamesConfig).toEqualTypeOf();
+});

package/dist/src/structures/Pet.js

@@ -0,0 +1,38 @@
+import { recursive } from '../utils/removeSnakeCase';
+class Pet {
+    isFavorite;
+    name;
+    active;
+    hunger;
+    lastFed;
+    lastFedAt;
+    thirst;
+    lastDrank;
+    lastDrankAt;
+    exercise;
+    lastExercised;
+    lastExercisedAt;
+    rawNickname;
+    nickname;
+    experience;
+    constructor(name, data) {
+        this.isFavorite = data?.vanityFavorites ? Boolean(data?.vanityFavorites?.includes(name?.toUpperCase())) : false;
+        name = name?.replace('pet_', '');
+        this.name = recursive(name) || null;
+        this.active = data?.currentPet === name?.toUpperCase();
+        const stats = data?.petStats[name?.toUpperCase()];
+        this.hunger = stats?.HUNGER?.value || 0;
+        this.lastFed = stats?.HUNGER?.timestamp || null;
+        this.lastFedAt = this.lastFed ? new Date(this.lastFed) : null;
+        this.thirst = stats?.THIRST?.value || 0;
+        this.lastDrank = stats?.THIRST?.timestamp || null;
+        this.lastDrankAt = this.lastDrank ? new Date(this.lastDrank) : null;
+        this.exercise = stats?.EXERCISE?.value || 0;
+        this.lastExercised = stats?.EXERCISE ? stats?.EXERCISE?.timestamp : null;
+        this.lastExercisedAt = this.lastExercised ? new Date(this.lastExercised) : null;
+        this.rawNickname = stats?.name;
+        this.nickname = this.rawNickname?.replace(/§([0-9]|[a-f])|§/gm, '');
+        this.experience = stats?.experience || 0;
+    }
+}
+export default Pet;

package/dist/src/structures/Pets.js

@@ -0,0 +1,14 @@
+import Pet from './Pet';
+class Pets {
+    pets;
+    lastJourneyTimestamp;
+    lastJourneyAt;
+    petConsumables;
+    constructor(data, pets) {
+        this.pets = pets.map((x) => new Pet(x, data));
+        this.lastJourneyTimestamp = data.petJourneyTimestamp || null;
+        this.lastJourneyAt = this.lastJourneyTimestamp ? new Date(this.lastJourneyTimestamp) : null;
+        this.petConsumables = data.petConsumables;
+    }
+}
+export default Pets;

package/dist/src/structures/Player.js

@@ -0,0 +1,147 @@
+import Arcade from './MiniGames/Arcade';
+import ArenaBrawl from './MiniGames/ArenaBrawl';
+import BedWars from './MiniGames/BedWars';
+import BlitzSurvivalGames from './MiniGames/BlitzSurvivalGames';
+import BuildBattle from './MiniGames/BuildBattle';
+import Color from './Color';
+import CopsAndCrims from './MiniGames/CopsAndCrims';
+import Duels from './MiniGames/Duels';
+import MegaWalls from './MiniGames/MegaWalls';
+import MurderMystery from './MiniGames/MurderMystery';
+import Paintball from './MiniGames/Paintball';
+import Pit from './MiniGames/Pit';
+import PlayerCosmetics from './PlayerCosmetics';
+import Quakecraft from './MiniGames/Quakecraft';
+import SkyWars from './MiniGames/SkyWars';
+import SmashHeroes from './MiniGames/SmashHeroes';
+import SpeedUHC from './MiniGames/SpeedUHC';
+import TNTGames from './MiniGames/TNTGames';
+import TurboKartRacers from './MiniGames/TurboKartRacers';
+import UHC from './MiniGames/UHC';
+import VampireZ from './MiniGames/VampireZ';
+import Walls from './MiniGames/Walls';
+import Warlords from './MiniGames/Warlords';
+import WoolWars from './MiniGames/WoolWars';
+import { getPlayerLevel, getRank, getSocialMedia, parseClaimedRewards, playerLevelProgress } from '../utils/Player';
+import { recursive } from '../utils/removeSnakeCase';
+class Player {
+    nickname;
+    uuid;
+    rank;
+    guild;
+    houses;
+    recentGames;
+    channel;
+    firstLoginTimestamp;
+    firstLogin;
+    lastLoginTimestamp;
+    lastLogin;
+    lastLogoutTimestamp;
+    lastLogout;
+    plusColor;
+    prefixColor;
+    karma;
+    achievements;
+    achievementPoints;
+    totalExperience;
+    level;
+    socialMedia;
+    giftBundlesSent;
+    giftBundlesReceived;
+    giftsSent;
+    isOnline;
+    lastDailyRewardTimestamp;
+    lastDailyReward;
+    totalRewards;
+    totalDailyRewards;
+    rewardStreak;
+    rewardScore;
+    rewardHighScore;
+    levelProgress;
+    stats;
+    userLanguage;
+    claimedLevelingRewards;
+    globalCosmetics;
+    ranksPurchaseTime;
+    constructor(data, extra) {
+        this.nickname = data?.displayname || '';
+        this.uuid = data?.uuid || '';
+        this.rank = getRank(data);
+        this.guild = extra?.guild;
+        this.houses = extra?.houses;
+        this.recentGames = extra?.recentGames;
+        this.channel = data?.channel || 'ALL';
+        this.firstLoginTimestamp = data?.firstLogin || null;
+        this.firstLogin = data?.firstLogin ? new Date(data?.firstLogin) : null;
+        this.lastLoginTimestamp = data?.lastLogin || null;
+        this.lastLogin = data?.lastLogin ? new Date(data?.lastLogin) : null;
+        this.lastLogoutTimestamp = data?.lastLogout || null;
+        this.lastLogout = data?.lastLogout ? new Date(data?.lastLogout) : null;
+        this.plusColor =
+            'MVP+' === this.rank || 'MVP++' === this.rank
+                ? data?.rankPlusColor
+                    ? new Color(data?.rankPlusColor)
+                    : new Color('RED')
+                : null;
+        this.prefixColor =
+            'MVP++' === this.rank ? (data?.monthlyRankColor ? new Color(data?.monthlyRankColor) : new Color('GOLD')) : null;
+        this.karma = data?.karma || 0;
+        this.achievements = recursive(data?.achievements) || {};
+        this.achievementPoints = data?.achievementPoints || 0;
+        this.totalExperience = data?.networkExp || 0;
+        this.level = getPlayerLevel(this.totalExperience) || 0;
+        this.socialMedia = getSocialMedia(data?.socialMedia) || [];
+        this.giftBundlesSent = data?.giftingMeta?.realBundlesGiven || 0;
+        this.giftBundlesReceived = data?.giftingMeta?.realBundlesReceived || 0;
+        this.giftsSent = data?.giftingMeta?.giftsGiven || 0;
+        this.isOnline =
+            null !== this.lastLoginTimestamp &&
+                null !== this.lastLogoutTimestamp &&
+                this.lastLoginTimestamp > this.lastLogoutTimestamp;
+        this.lastDailyRewardTimestamp = data?.lastAdsenseGenerateTime || null;
+        this.lastDailyReward = this.lastDailyRewardTimestamp ? new Date(this.lastDailyRewardTimestamp) : null;
+        this.totalRewards = data?.totalRewards || 0;
+        this.totalDailyRewards = data?.totalDailyRewards || 0;
+        this.rewardStreak = data?.rewardStreak || 0;
+        this.rewardScore = data?.rewardScore || 0;
+        this.rewardHighScore = data?.rewardHighScore || 0;
+        this.levelProgress = playerLevelProgress(data?.networkExp);
+        this.stats = {
+            arcade: new Arcade({ ...data?.stats?.Arcade, ...data?.achievements }),
+            arena: new ArenaBrawl(data?.stats?.Arena),
+            bedwars: new BedWars(data?.stats?.Bedwars),
+            blitzsg: new BlitzSurvivalGames(data?.stats?.HungerGames),
+            buildbattle: new BuildBattle(data?.stats?.BuildBattle),
+            copsandcrims: new CopsAndCrims(data?.stats?.MCGO),
+            duels: new Duels(data?.stats?.Duels),
+            megawalls: new MegaWalls(data?.stats?.Walls3),
+            murdermystery: new MurderMystery(data?.stats?.MurderMystery),
+            paintball: new Paintball(data?.stats?.Paintball),
+            pit: new Pit(data?.stats?.Pit),
+            quakecraft: new Quakecraft(data?.stats?.Quake),
+            skywars: new SkyWars(data?.stats?.SkyWars),
+            smashheroes: new SmashHeroes(data?.stats?.SuperSmash),
+            speeduhc: new SpeedUHC(data?.stats?.SpeedUHC),
+            tntgames: new TNTGames(data?.stats?.TNTGames),
+            turbokartracers: new TurboKartRacers(data?.stats?.GingerBread),
+            uhc: new UHC(data?.stats?.UHC),
+            vampirez: new VampireZ(data?.stats?.VampireZ),
+            walls: new Walls(data?.stats?.Walls),
+            warlords: new Warlords(data?.stats?.Battleground),
+            woolwars: new WoolWars(data?.stats?.WoolGames)
+        };
+        this.userLanguage = data?.userLanguage || 'ENGLISH';
+        this.claimedLevelingRewards = parseClaimedRewards(data) || [];
+        this.globalCosmetics = new PlayerCosmetics(data);
+        this.ranksPurchaseTime = {
+            VIP: data?.levelUp_VIP ? new Date(data?.levelUp_VIP) : null,
+            VIP_PLUS: data?.levelUp_VIP_PLUS ? new Date(data?.levelUp_VIP_PLUS) : null,
+            MVP: data?.levelUp_MVP ? new Date(data?.levelUp_MVP) : null,
+            MVP_PLUS: data?.levelUp_MVP_PLUS ? new Date(data?.levelUp_MVP_PLUS) : null
+        };
+    }
+    toString() {
+        return this.nickname;
+    }
+}
+export default Player;

package/dist/src/structures/Player.test.js

@@ -0,0 +1,96 @@
+import Player from './Player';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Player', () => {
+    const data = new Player({ stats: 'meow' }, { guild: null, houses: null, recentGames: null });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Player);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.nickname).toBeDefined();
+    expectTypeOf(data.nickname).toEqualTypeOf();
+    expect(data.uuid).toBeDefined();
+    expectTypeOf(data.uuid).toEqualTypeOf();
+    expect(data.rank).toBeDefined();
+    expectTypeOf(data.rank).toEqualTypeOf();
+    expect(data.guild).toBeDefined();
+    expectTypeOf(data.guild).toEqualTypeOf();
+    expect(data.houses).toBeDefined();
+    expectTypeOf(data.houses).toEqualTypeOf();
+    expect(data.recentGames).toBeDefined();
+    expectTypeOf(data.recentGames).toEqualTypeOf();
+    expect(data.channel).toBeDefined();
+    expectTypeOf(data.channel).toEqualTypeOf();
+    expect(data.firstLoginTimestamp).toBeDefined();
+    expectTypeOf(data.firstLoginTimestamp).toEqualTypeOf();
+    expect(data.firstLogin).toBeDefined();
+    expectTypeOf(data.firstLogin).toEqualTypeOf();
+    expect(data.lastLoginTimestamp).toBeDefined();
+    expectTypeOf(data.lastLoginTimestamp).toEqualTypeOf();
+    expect(data.lastLogin).toBeDefined();
+    expectTypeOf(data.lastLogin).toEqualTypeOf();
+    expect(data.lastLogoutTimestamp).toBeDefined();
+    expectTypeOf(data.lastLogoutTimestamp).toEqualTypeOf();
+    expect(data.lastLogout).toBeDefined();
+    expectTypeOf(data.lastLogout).toEqualTypeOf();
+    expect(data.plusColor).toBeDefined();
+    expectTypeOf(data.plusColor).toEqualTypeOf();
+    expect(data.prefixColor).toBeDefined();
+    expectTypeOf(data.prefixColor).toEqualTypeOf();
+    expect(data.karma).toBeDefined();
+    expect(data.karma).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.karma).toEqualTypeOf();
+    expect(data.achievements).toBeDefined();
+    expectTypeOf(data.achievements).toEqualTypeOf();
+    expect(data.achievementPoints).toBeDefined();
+    expect(data.achievementPoints).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.achievementPoints).toEqualTypeOf();
+    expect(data.totalExperience).toBeDefined();
+    expect(data.totalExperience).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.totalExperience).toEqualTypeOf();
+    expect(data.level).toBeDefined();
+    expect(data.level).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.socialMedia).toBeDefined();
+    expectTypeOf(data.socialMedia).toEqualTypeOf();
+    expect(data.giftBundlesSent).toBeDefined();
+    expect(data.giftBundlesSent).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.giftBundlesSent).toEqualTypeOf();
+    expect(data.giftBundlesReceived).toBeDefined();
+    expect(data.giftBundlesReceived).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.giftBundlesReceived).toEqualTypeOf();
+    expect(data.giftsSent).toBeDefined();
+    expect(data.giftsSent).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.giftsSent).toEqualTypeOf();
+    expect(data.isOnline).toBeDefined();
+    expectTypeOf(data.isOnline).toEqualTypeOf();
+    expect(data.lastDailyRewardTimestamp).toBeDefined();
+    expectTypeOf(data.lastDailyRewardTimestamp).toEqualTypeOf();
+    expect(data.lastDailyReward).toBeDefined();
+    expectTypeOf(data.lastDailyReward).toEqualTypeOf();
+    expect(data.totalRewards).toBeDefined();
+    expect(data.totalRewards).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.totalRewards).toEqualTypeOf();
+    expect(data.totalDailyRewards).toBeDefined();
+    expect(data.totalDailyRewards).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.totalDailyRewards).toEqualTypeOf();
+    expect(data.rewardStreak).toBeDefined();
+    expect(data.rewardStreak).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rewardStreak).toEqualTypeOf();
+    expect(data.rewardScore).toBeDefined();
+    expect(data.rewardScore).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rewardScore).toEqualTypeOf();
+    expect(data.rewardHighScore).toBeDefined();
+    expect(data.rewardHighScore).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rewardHighScore).toEqualTypeOf();
+    expect(data.levelProgress).toBeDefined();
+    expectTypeOf(data.levelProgress).toEqualTypeOf();
+    expect(data.stats).toBeDefined();
+    expectTypeOf(data.stats).toEqualTypeOf();
+    expect(data.userLanguage).toBeDefined();
+    expectTypeOf(data.userLanguage).toEqualTypeOf();
+    expect(data.claimedLevelingRewards).toBeDefined();
+    expectTypeOf(data.claimedLevelingRewards).toEqualTypeOf();
+    expect(data.globalCosmetics).toBeDefined();
+    expectTypeOf(data.globalCosmetics).toEqualTypeOf();
+    expect(data.ranksPurchaseTime).toBeDefined();
+    expectTypeOf(data.ranksPurchaseTime).toEqualTypeOf();
+});

package/dist/src/structures/PlayerCosmetics.js

@@ -0,0 +1,53 @@
+import Pets from './Pets';
+import { removeSnakeCaseString } from '../utils/removeSnakeCase';
+/**
+ * Player Cosmetics class
+ */
+class PlayerCosmetics {
+    cosmetics;
+    pets;
+    suits;
+    hats;
+    gadgets;
+    morphs;
+    cloaks;
+    taunts;
+    rankColors;
+    particlePacks;
+    clickfx;
+    constructor(data) {
+        this.cosmetics = data?.vanityMeta?.packages || [];
+        this.pets = new Pets(data, this.cosmetics.filter((x) => x.startsWith('pet_')));
+        this.suits =
+            this.cosmetics.filter((x) => x.startsWith('suit_')).map((x) => removeSnakeCaseString(x.replace('suit_', ''))) ||
+                [];
+        this.hats =
+            this.cosmetics.filter((x) => x.startsWith('hat_')).map((x) => removeSnakeCaseString(x.replace('hat_', ''))) || [];
+        this.gadgets =
+            this.cosmetics
+                .filter((x) => x.startsWith('gadget_'))
+                .map((x) => removeSnakeCaseString(x.replace('gadget_', ''))) || [];
+        this.morphs =
+            this.cosmetics.filter((x) => x.startsWith('morph_')).map((x) => removeSnakeCaseString(x.replace('morph_', ''))) ||
+                [];
+        this.cloaks =
+            this.cosmetics.filter((x) => x.startsWith('cloak_')).map((x) => removeSnakeCaseString(x.replace('cloak_', ''))) ||
+                [];
+        this.taunts =
+            this.cosmetics.filter((x) => x.startsWith('taunt_')).map((x) => removeSnakeCaseString(x.replace('taunt_', ''))) ||
+                [];
+        this.rankColors =
+            this.cosmetics
+                .filter((x) => x.startsWith('rankcolor_'))
+                .map((x) => removeSnakeCaseString(x.replace('rankcolor_', ''))) || [];
+        this.particlePacks =
+            this.cosmetics
+                .filter((x) => x.startsWith('particlepack_'))
+                .map((x) => removeSnakeCaseString(x.replace('particlepack_', ''))) || [];
+        this.clickfx =
+            this.cosmetics
+                .filter((x) => x.startsWith('clickeffects_'))
+                .map((x) => removeSnakeCaseString(x.replace('clickeffects_', ''))) || [];
+    }
+}
+export default PlayerCosmetics;

package/dist/src/structures/RecentGame.js

@@ -0,0 +1,25 @@
+import Game from './Game';
+class RecentGame {
+    game;
+    dateTimestamp;
+    date;
+    mode;
+    map;
+    ongoing;
+    endedAt;
+    endedTimestamp;
+    constructor(data) {
+        this.game = new Game(data.gameType);
+        this.dateTimestamp = data.date || null;
+        this.date = this.dateTimestamp ? new Date(this.dateTimestamp) : null;
+        this.mode = data.mode || null;
+        this.map = data.map || null;
+        this.ongoing = Boolean(!data.ended);
+        this.endedAt = data.ended ? new Date(data.ended) : null;
+        this.endedTimestamp = data.ended ? data.ended : null;
+    }
+    toString() {
+        return this.mode;
+    }
+}
+export default RecentGame;

package/dist/src/structures/SkyBlock/Auctions/Auction.js

@@ -0,0 +1,39 @@
+import BaseAuction from './BaseAuction';
+import Bid from './Bid';
+class Auction extends BaseAuction {
+    coop;
+    auctionStartTimestamp;
+    auctionStart;
+    auctionEndTimestamp;
+    auctionEnd;
+    item;
+    itemLore;
+    itemLoreRaw;
+    rarity;
+    startingBid;
+    highestBid;
+    bids;
+    claimed;
+    claimedBidders;
+    constructor(data, includeItemBytes = false) {
+        super(data, includeItemBytes);
+        this.coop = data.coop || [];
+        this.auctionStartTimestamp = data.start;
+        this.auctionStart = new Date(this.auctionStartTimestamp);
+        this.auctionEndTimestamp = data.end || null;
+        this.auctionEnd = this.auctionEndTimestamp ? new Date(this.auctionEndTimestamp) : null;
+        this.item = data.item_name || null;
+        this.itemLore = data.item_lore ? data.item_lore.replace(/§([1-9]|[a-l])|§/gm, '') : null;
+        this.itemLoreRaw = data.item_lore || null;
+        this.rarity = data.tier || null;
+        this.startingBid = data.starting_bid || 0;
+        this.highestBid = this.bin ? data.starting_bid : data.highest_bid_amount || 0;
+        this.bids = data.bids.length ? data.bids.map((b) => new Bid(b)) : [];
+        this.claimed = data.claimed || false;
+        this.claimedBidders = this.claimed ? data.claimed_bidders : [];
+    }
+    toString() {
+        return this.item;
+    }
+}
+export default Auction;