hypixel-api-reborn 11.3.4 → 12.0.0-0

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

@@ -0,0 +1,413 @@
+import SkyWars from './SkyWars';
+import { expect, expectTypeOf, test } from 'vitest';
+test('SkyWars', () => {
+    const data = new SkyWars({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(SkyWars);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.coins).toBeDefined();
+    expect(data.coins).greaterThanOrEqual(0);
+    expectTypeOf(data.coins).toEqualTypeOf();
+    expect(data.souls).toBeDefined();
+    expect(data.souls).greaterThanOrEqual(0);
+    expectTypeOf(data.souls).toEqualTypeOf();
+    expect(data.tokens).toBeDefined();
+    expect(data.tokens).greaterThanOrEqual(0);
+    expectTypeOf(data.tokens).toEqualTypeOf();
+    expect(data.experience).toBeDefined();
+    expect(data.experience).greaterThanOrEqual(0);
+    expectTypeOf(data.experience).toEqualTypeOf();
+    expect(data.level).toBeDefined();
+    expect(data.level).greaterThanOrEqual(0);
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.levelProgress).toBeDefined();
+    expectTypeOf(data.levelProgress).toEqualTypeOf();
+    expect(data.levelFormatted).toBeDefined();
+    expectTypeOf(data.levelFormatted).toEqualTypeOf();
+    expect(data.prestige).toBeDefined();
+    expectTypeOf(data.prestige).toEqualTypeOf();
+    expect(data.opals).toBeDefined();
+    expect(data.opals).greaterThanOrEqual(0);
+    expectTypeOf(data.opals).toEqualTypeOf();
+    expect(data.avarice).toBeDefined();
+    expect(data.avarice).greaterThanOrEqual(0);
+    expectTypeOf(data.avarice).toEqualTypeOf();
+    expect(data.tenacity).toBeDefined();
+    expect(data.tenacity).greaterThanOrEqual(0);
+    expectTypeOf(data.tenacity).toEqualTypeOf();
+    expect(data.shards).toBeDefined();
+    expect(data.shards).greaterThanOrEqual(0);
+    expectTypeOf(data.shards).toEqualTypeOf();
+    expect(data.angelOfDeathLevel).toBeDefined();
+    expect(data.angelOfDeathLevel).greaterThanOrEqual(0);
+    expectTypeOf(data.angelOfDeathLevel).toEqualTypeOf();
+    expect(data.killstreak).toBeDefined();
+    expect(data.killstreak).greaterThanOrEqual(0);
+    expectTypeOf(data.killstreak).toEqualTypeOf();
+    expect(data.kills).toBeDefined();
+    expect(data.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.kills).toEqualTypeOf();
+    expect(data.voidKills).toBeDefined();
+    expect(data.voidKills).greaterThanOrEqual(0);
+    expectTypeOf(data.voidKills).toEqualTypeOf();
+    expect(data.meleeKills).toBeDefined();
+    expect(data.meleeKills).greaterThanOrEqual(0);
+    expectTypeOf(data.meleeKills).toEqualTypeOf();
+    expect(data.bowKills).toBeDefined();
+    expect(data.bowKills).greaterThanOrEqual(0);
+    expectTypeOf(data.bowKills).toEqualTypeOf();
+    expect(data.mobKills).toBeDefined();
+    expect(data.mobKills).greaterThanOrEqual(0);
+    expectTypeOf(data.mobKills).toEqualTypeOf();
+    expect(data.assists).toBeDefined();
+    expect(data.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.assists).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.wins).toBeDefined();
+    expect(data.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.wins).toEqualTypeOf();
+    expect(data.losses).toBeDefined();
+    expect(data.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.losses).toEqualTypeOf();
+    expect(data.WLR).toBeDefined();
+    expect(data.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.WLR).toEqualTypeOf();
+    expect(data.gamesPlayed).toBeDefined();
+    expect(data.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.gamesPlayed).toEqualTypeOf();
+    expect(data.survivedPlayers).toBeDefined();
+    expect(data.survivedPlayers).greaterThanOrEqual(0);
+    expectTypeOf(data.survivedPlayers).toEqualTypeOf();
+    expect(data.chestsOpened).toBeDefined();
+    expect(data.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.chestsOpened).toEqualTypeOf();
+    expect(data.timePlayed).toBeDefined();
+    expect(data.timePlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.timePlayed).toEqualTypeOf();
+    expect(data.shard).toBeDefined();
+    expect(data.shard).greaterThanOrEqual(0);
+    expectTypeOf(data.shard).toEqualTypeOf();
+    expect(data.longestBowShot).toBeDefined();
+    expect(data.longestBowShot).greaterThanOrEqual(0);
+    expectTypeOf(data.longestBowShot).toEqualTypeOf();
+    expect(data.arrowsShot).toBeDefined();
+    expect(data.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.arrowsShot).toEqualTypeOf();
+    expect(data.arrowsHit).toBeDefined();
+    expect(data.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.arrowsHit).toEqualTypeOf();
+    expect(data.bowAccuracy).toBeDefined();
+    expect(data.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.bowAccuracy).toEqualTypeOf();
+    expect(data.fastestWin).toBeDefined();
+    expect(data.fastestWin).greaterThanOrEqual(0);
+    expectTypeOf(data.fastestWin).toEqualTypeOf();
+    expect(data.heads).toBeDefined();
+    expect(data.heads).greaterThanOrEqual(0);
+    expectTypeOf(data.heads).toEqualTypeOf();
+    expect(data.blocksPlaced).toBeDefined();
+    expect(data.blocksPlaced).greaterThanOrEqual(0);
+    expectTypeOf(data.blocksPlaced).toEqualTypeOf();
+    expect(data.blocksBroken).toBeDefined();
+    expect(data.blocksBroken).greaterThanOrEqual(0);
+    expectTypeOf(data.blocksBroken).toEqualTypeOf();
+    expect(data.eggThrown).toBeDefined();
+    expect(data.eggThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.eggThrown).toEqualTypeOf();
+    expect(data.enderpearlsThrown).toBeDefined();
+    expect(data.enderpearlsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.enderpearlsThrown).toEqualTypeOf();
+    expect(data.solo).toBeDefined();
+    expectTypeOf(data.solo).toEqualTypeOf();
+    expect(data.solo.activeKit).toBeDefined();
+    expectTypeOf(data.solo.activeKit).toEqualTypeOf();
+    expect(data.solo.killstreak).toBeDefined();
+    expect(data.solo.killstreak).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.killstreak).toEqualTypeOf();
+    expect(data.solo.kills).toBeDefined();
+    expect(data.solo.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.kills).toEqualTypeOf();
+    expect(data.solo.voidKills).toBeDefined();
+    expect(data.solo.voidKills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.voidKills).toEqualTypeOf();
+    expect(data.solo.meleeKills).toBeDefined();
+    expect(data.solo.meleeKills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.meleeKills).toEqualTypeOf();
+    expect(data.solo.bowKills).toBeDefined();
+    expect(data.solo.bowKills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.bowKills).toEqualTypeOf();
+    expect(data.solo.mobKills).toBeDefined();
+    expect(data.solo.mobKills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.mobKills).toEqualTypeOf();
+    expect(data.solo.assists).toBeDefined();
+    expect(data.solo.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.assists).toEqualTypeOf();
+    expect(data.solo.deaths).toBeDefined();
+    expect(data.solo.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.deaths).toEqualTypeOf();
+    expect(data.solo.KDR).toBeDefined();
+    expect(data.solo.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.KDR).toEqualTypeOf();
+    expect(data.solo.wins).toBeDefined();
+    expect(data.solo.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.wins).toEqualTypeOf();
+    expect(data.solo.losses).toBeDefined();
+    expect(data.solo.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.losses).toEqualTypeOf();
+    expect(data.solo.WLR).toBeDefined();
+    expect(data.solo.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.WLR).toEqualTypeOf();
+    expect(data.solo.gamesPlayed).toBeDefined();
+    expect(data.solo.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.gamesPlayed).toEqualTypeOf();
+    expect(data.solo.survivedPlayers).toBeDefined();
+    expect(data.solo.survivedPlayers).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.survivedPlayers).toEqualTypeOf();
+    expect(data.solo.chestsOpened).toBeDefined();
+    expect(data.solo.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.chestsOpened).toEqualTypeOf();
+    expect(data.solo.timePlayed).toBeDefined();
+    expect(data.solo.timePlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.timePlayed).toEqualTypeOf();
+    expect(data.solo.shard).toBeDefined();
+    expect(data.solo.shard).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.shard).toEqualTypeOf();
+    expect(data.solo.longestBowShot).toBeDefined();
+    expect(data.solo.longestBowShot).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.longestBowShot).toEqualTypeOf();
+    expect(data.solo.arrowsShot).toBeDefined();
+    expect(data.solo.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.arrowsShot).toEqualTypeOf();
+    expect(data.solo.arrowsHit).toBeDefined();
+    expect(data.solo.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.arrowsHit).toEqualTypeOf();
+    expect(data.solo.bowAccuracy).toBeDefined();
+    expect(data.solo.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.bowAccuracy).toEqualTypeOf();
+    expect(data.solo.fastestWin).toBeDefined();
+    expect(data.solo.fastestWin).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.fastestWin).toEqualTypeOf();
+    expect(data.solo.heads).toBeDefined();
+    expect(data.solo.heads).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.heads).toEqualTypeOf();
+    expect(data.solo.normal).toBeDefined();
+    expectTypeOf(data.solo.normal).toEqualTypeOf();
+    expect(data.solo.normal.kills).toBeDefined();
+    expect(data.solo.normal.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.normal.kills).toEqualTypeOf();
+    expect(data.solo.normal.deaths).toBeDefined();
+    expect(data.solo.normal.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.normal.deaths).toEqualTypeOf();
+    expect(data.solo.normal.KDR).toBeDefined();
+    expect(data.solo.normal.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.normal.KDR).toEqualTypeOf();
+    expect(data.solo.normal.wins).toBeDefined();
+    expect(data.solo.normal.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.normal.wins).toEqualTypeOf();
+    expect(data.solo.normal.losses).toBeDefined();
+    expect(data.solo.normal.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.normal.losses).toEqualTypeOf();
+    expect(data.solo.normal.WLR).toBeDefined();
+    expect(data.solo.normal.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.normal.WLR).toEqualTypeOf();
+    expect(data.solo.insane).toBeDefined();
+    expectTypeOf(data.solo.insane).toEqualTypeOf();
+    expect(data.solo.insane.kills).toBeDefined();
+    expect(data.solo.insane.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.insane.kills).toEqualTypeOf();
+    expect(data.solo.insane.deaths).toBeDefined();
+    expect(data.solo.insane.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.insane.deaths).toEqualTypeOf();
+    expect(data.solo.insane.KDR).toBeDefined();
+    expect(data.solo.insane.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.insane.KDR).toEqualTypeOf();
+    expect(data.solo.insane.wins).toBeDefined();
+    expect(data.solo.insane.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.insane.wins).toEqualTypeOf();
+    expect(data.solo.insane.losses).toBeDefined();
+    expect(data.solo.insane.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.insane.losses).toEqualTypeOf();
+    expect(data.solo.insane.WLR).toBeDefined();
+    expect(data.solo.insane.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.solo.insane.WLR).toEqualTypeOf();
+    expect(data.team).toBeDefined();
+    expectTypeOf(data.team).toEqualTypeOf();
+    expect(data.team.activeKit).toBeDefined();
+    expectTypeOf(data.team.activeKit).toEqualTypeOf();
+    expect(data.team.killstreak).toBeDefined();
+    expect(data.team.killstreak).greaterThanOrEqual(0);
+    expectTypeOf(data.team.killstreak).toEqualTypeOf();
+    expect(data.team.kills).toBeDefined();
+    expect(data.team.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.kills).toEqualTypeOf();
+    expect(data.team.voidKills).toBeDefined();
+    expect(data.team.voidKills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.voidKills).toEqualTypeOf();
+    expect(data.team.meleeKills).toBeDefined();
+    expect(data.team.meleeKills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.meleeKills).toEqualTypeOf();
+    expect(data.team.bowKills).toBeDefined();
+    expect(data.team.bowKills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.bowKills).toEqualTypeOf();
+    expect(data.team.mobKills).toBeDefined();
+    expect(data.team.mobKills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.mobKills).toEqualTypeOf();
+    expect(data.team.assists).toBeDefined();
+    expect(data.team.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.team.assists).toEqualTypeOf();
+    expect(data.team.deaths).toBeDefined();
+    expect(data.team.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.team.deaths).toEqualTypeOf();
+    expect(data.team.KDR).toBeDefined();
+    expect(data.team.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.team.KDR).toEqualTypeOf();
+    expect(data.team.wins).toBeDefined();
+    expect(data.team.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.team.wins).toEqualTypeOf();
+    expect(data.team.losses).toBeDefined();
+    expect(data.team.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.team.losses).toEqualTypeOf();
+    expect(data.team.WLR).toBeDefined();
+    expect(data.team.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.team.WLR).toEqualTypeOf();
+    expect(data.team.gamesPlayed).toBeDefined();
+    expect(data.team.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.team.gamesPlayed).toEqualTypeOf();
+    expect(data.team.survivedPlayers).toBeDefined();
+    expect(data.team.survivedPlayers).greaterThanOrEqual(0);
+    expectTypeOf(data.team.survivedPlayers).toEqualTypeOf();
+    expect(data.team.chestsOpened).toBeDefined();
+    expect(data.team.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.team.chestsOpened).toEqualTypeOf();
+    expect(data.team.timePlayed).toBeDefined();
+    expect(data.team.timePlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.team.timePlayed).toEqualTypeOf();
+    expect(data.team.shard).toBeDefined();
+    expect(data.team.shard).greaterThanOrEqual(0);
+    expectTypeOf(data.team.shard).toEqualTypeOf();
+    expect(data.team.longestBowShot).toBeDefined();
+    expect(data.team.longestBowShot).greaterThanOrEqual(0);
+    expectTypeOf(data.team.longestBowShot).toEqualTypeOf();
+    expect(data.team.arrowsShot).toBeDefined();
+    expect(data.team.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.team.arrowsShot).toEqualTypeOf();
+    expect(data.team.arrowsHit).toBeDefined();
+    expect(data.team.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.team.arrowsHit).toEqualTypeOf();
+    expect(data.team.bowAccuracy).toBeDefined();
+    expect(data.team.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.team.bowAccuracy).toEqualTypeOf();
+    expect(data.team.fastestWin).toBeDefined();
+    expect(data.team.fastestWin).greaterThanOrEqual(0);
+    expectTypeOf(data.team.fastestWin).toEqualTypeOf();
+    expect(data.team.heads).toBeDefined();
+    expect(data.team.heads).greaterThanOrEqual(0);
+    expectTypeOf(data.team.heads).toEqualTypeOf();
+    expect(data.team.normal).toBeDefined();
+    expectTypeOf(data.team.normal).toEqualTypeOf();
+    expect(data.team.normal.kills).toBeDefined();
+    expect(data.team.normal.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.normal.kills).toEqualTypeOf();
+    expect(data.team.normal.deaths).toBeDefined();
+    expect(data.team.normal.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.team.normal.deaths).toEqualTypeOf();
+    expect(data.team.normal.KDR).toBeDefined();
+    expect(data.team.normal.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.team.normal.KDR).toEqualTypeOf();
+    expect(data.team.normal.wins).toBeDefined();
+    expect(data.team.normal.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.team.normal.wins).toEqualTypeOf();
+    expect(data.team.normal.losses).toBeDefined();
+    expect(data.team.normal.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.team.normal.losses).toEqualTypeOf();
+    expect(data.team.normal.WLR).toBeDefined();
+    expect(data.team.normal.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.team.normal.WLR).toEqualTypeOf();
+    expect(data.team.insane).toBeDefined();
+    expectTypeOf(data.team.insane).toEqualTypeOf();
+    expect(data.team.insane.kills).toBeDefined();
+    expect(data.team.insane.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.team.insane.kills).toEqualTypeOf();
+    expect(data.team.insane.deaths).toBeDefined();
+    expect(data.team.insane.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.team.insane.deaths).toEqualTypeOf();
+    expect(data.team.insane.KDR).toBeDefined();
+    expect(data.team.insane.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.team.insane.KDR).toEqualTypeOf();
+    expect(data.team.insane.wins).toBeDefined();
+    expect(data.team.insane.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.team.insane.wins).toEqualTypeOf();
+    expect(data.team.insane.losses).toBeDefined();
+    expect(data.team.insane.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.team.insane.losses).toEqualTypeOf();
+    expect(data.team.insane.WLR).toBeDefined();
+    expect(data.team.insane.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.team.insane.WLR).toEqualTypeOf();
+    expect(data.mega).toBeDefined();
+    expectTypeOf(data.mega).toEqualTypeOf();
+    expect(data.mega.kills).toBeDefined();
+    expect(data.mega.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.mega.kills).toEqualTypeOf();
+    expect(data.mega.deaths).toBeDefined();
+    expect(data.mega.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.mega.deaths).toEqualTypeOf();
+    expect(data.mega.KDR).toBeDefined();
+    expect(data.mega.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.mega.KDR).toEqualTypeOf();
+    expect(data.mega.wins).toBeDefined();
+    expect(data.mega.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.mega.wins).toEqualTypeOf();
+    expect(data.mega.losses).toBeDefined();
+    expect(data.mega.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.mega.losses).toEqualTypeOf();
+    expect(data.mega.WLR).toBeDefined();
+    expect(data.mega.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.mega.WLR).toEqualTypeOf();
+    expect(data.megaDoubles).toBeDefined();
+    expectTypeOf(data.megaDoubles).toEqualTypeOf();
+    expect(data.megaDoubles.kills).toBeDefined();
+    expect(data.megaDoubles.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.megaDoubles.kills).toEqualTypeOf();
+    expect(data.megaDoubles.deaths).toBeDefined();
+    expect(data.megaDoubles.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.megaDoubles.deaths).toEqualTypeOf();
+    expect(data.megaDoubles.KDR).toBeDefined();
+    expect(data.megaDoubles.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.megaDoubles.KDR).toEqualTypeOf();
+    expect(data.megaDoubles.wins).toBeDefined();
+    expect(data.megaDoubles.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.megaDoubles.wins).toEqualTypeOf();
+    expect(data.megaDoubles.losses).toBeDefined();
+    expect(data.megaDoubles.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.megaDoubles.losses).toEqualTypeOf();
+    expect(data.megaDoubles.WLR).toBeDefined();
+    expect(data.megaDoubles.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.megaDoubles.WLR).toEqualTypeOf();
+    expect(data.lab).toBeDefined();
+    expectTypeOf(data.lab).toEqualTypeOf();
+    expect(data.lab.kills).toBeDefined();
+    expect(data.lab.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.lab.kills).toEqualTypeOf();
+    expect(data.lab.deaths).toBeDefined();
+    expect(data.lab.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.lab.deaths).toEqualTypeOf();
+    expect(data.lab.KDR).toBeDefined();
+    expect(data.lab.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.lab.KDR).toEqualTypeOf();
+    expect(data.lab.wins).toBeDefined();
+    expect(data.lab.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.lab.wins).toEqualTypeOf();
+    expect(data.lab.losses).toBeDefined();
+    expect(data.lab.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.lab.losses).toEqualTypeOf();
+    expect(data.lab.WLR).toBeDefined();
+    expect(data.lab.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.lab.WLR).toEqualTypeOf();
+    expect(data.packages).toBeDefined();
+    expectTypeOf(data.packages).toEqualTypeOf();
+});

package/dist/src/structures/MiniGames/SmashHeroes.js

@@ -0,0 +1,110 @@
+import divide from '../../utils/divide';
+export class SmashHeroesMode {
+    kills;
+    deaths;
+    KDR;
+    wins;
+    losses;
+    WLR;
+    constructor(data, mode) {
+        this.kills = data?.[`kills_${mode}`] || 0;
+        this.deaths = data?.[`deaths_${mode}`] || 0;
+        this.KDR = divide(this.kills, this.deaths);
+        this.wins = data?.[`wins_${mode}`] || 0;
+        this.losses = data?.[`losses_${mode}`] || 0;
+        this.WLR = divide(this.wins, this.losses);
+    }
+}
+export class SmashHeoresHero {
+    name;
+    level;
+    xp;
+    prestige;
+    playedGames;
+    kills;
+    deaths;
+    KDR;
+    wins;
+    losses;
+    WLR;
+    constructor(data, hero) {
+        this.name = hero;
+        this.level = data?.[`lastLevel_${hero}`] || 0;
+        this.xp = data?.[`xp_${hero}`] || 0;
+        this.prestige = data?.[`pg_${hero}`] || 0;
+        this.playedGames = data?.class_stats?.[hero]?.games || 0;
+        this.kills = data?.class_stats?.[hero]?.kills || 0;
+        this.deaths = data?.class_stats?.[hero]?.deaths || 0;
+        this.KDR = divide(this.kills, this.deaths);
+        this.wins = data?.class_stats?.[hero]?.wins || 0;
+        this.losses = data?.class_stats?.[hero]?.losses || 0;
+        this.WLR = divide(this.wins, this.losses);
+    }
+}
+class SmashHeroes {
+    coins;
+    level;
+    winstreak;
+    playedGames;
+    kills;
+    deaths;
+    KDR;
+    wins;
+    losses;
+    WLR;
+    smashed;
+    '1v1v1v1';
+    '2v2';
+    '2v2v2';
+    activeClass;
+    theBulk;
+    cakeMonster;
+    generalCluck;
+    botmun;
+    marauder;
+    pug;
+    tinman;
+    spoderman;
+    frosty;
+    sergeantShield;
+    skullfire;
+    goku;
+    sanic;
+    duskCrawler;
+    shoopDaWhoop;
+    greenHood;
+    constructor(data) {
+        this.coins = data?.coins || 0;
+        this.level = data?.smash_level_total || 0;
+        this.winstreak = data?.win_streak || 0;
+        this.playedGames = data?.games || 0;
+        this.kills = data?.kills || 0;
+        this.deaths = data?.deaths || 0;
+        this.KDR = divide(this.kills, this.deaths);
+        this.wins = data?.wins || 0;
+        this.losses = data?.losses || 0;
+        this.WLR = divide(this.wins, this.losses);
+        this.smashed = data?.smashed || 0;
+        this['1v1v1v1'] = new SmashHeroesMode(data, 'normal');
+        this['2v2'] = new SmashHeroesMode(data, '2v2');
+        this['2v2v2'] = new SmashHeroesMode(data, 'teams');
+        this.activeClass = data?.active_class || null;
+        this.theBulk = new SmashHeoresHero(data, 'THE_BULK');
+        this.cakeMonster = new SmashHeoresHero(data, 'CAKE_MONSTER');
+        this.generalCluck = new SmashHeoresHero(data, 'GENERAL_CLUCK');
+        this.botmun = new SmashHeoresHero(data, 'BOTMUN');
+        this.marauder = new SmashHeoresHero(data, 'MARAUDER');
+        this.pug = new SmashHeoresHero(data, 'PUG');
+        this.tinman = new SmashHeoresHero(data, 'TINMAN');
+        this.spoderman = new SmashHeoresHero(data, 'SPODERMAN');
+        this.frosty = new SmashHeoresHero(data, 'FROSTY');
+        this.sergeantShield = new SmashHeoresHero(data, 'SERGEANT_SHIELD');
+        this.skullfire = new SmashHeoresHero(data, 'SKULLFIRE');
+        this.goku = new SmashHeoresHero(data, 'GOKU');
+        this.sanic = new SmashHeoresHero(data, 'SANIC');
+        this.duskCrawler = new SmashHeoresHero(data, 'DUSK_CRAWLER');
+        this.shoopDaWhoop = new SmashHeoresHero(data, 'SHOOP_DA_WHOOP');
+        this.greenHood = new SmashHeoresHero(data, 'GREEN_HOOD');
+    }
+}
+export default SmashHeroes;