hypixel-api-reborn 11.3.4 → 12.0.0-0

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

@@ -0,0 +1,405 @@
+import Warlords from './Warlords';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Warlords', () => {
+    const data = new Warlords({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Warlords);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.coins).toBeDefined();
+    expect(data.coins).greaterThanOrEqual(0);
+    expectTypeOf(data.coins).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.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.winstreak).toBeDefined();
+    expect(data.winstreak).greaterThanOrEqual(0);
+    expectTypeOf(data.winstreak).toEqualTypeOf();
+    expect(data.assists).toBeDefined();
+    expect(data.assists).greaterThanOrEqual(0);
+    expectTypeOf(data.assists).toEqualTypeOf();
+    expect(data.class).toBeDefined();
+    expectTypeOf(data.class).toEqualTypeOf();
+    expect(data.pyromancer).toBeDefined();
+    expectTypeOf(data.pyromancer).toEqualTypeOf();
+    expect(data.pyromancer.wins).toBeDefined();
+    expect(data.pyromancer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.wins).toEqualTypeOf();
+    expect(data.pyromancer.losses).toBeDefined();
+    expect(data.pyromancer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.losses).toEqualTypeOf();
+    expect(data.pyromancer.WLR).toBeDefined();
+    expect(data.pyromancer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.WLR).toEqualTypeOf();
+    expect(data.pyromancer.gamesPlayed).toBeDefined();
+    expect(data.pyromancer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.gamesPlayed).toEqualTypeOf();
+    expect(data.pyromancer.damage).toBeDefined();
+    expect(data.pyromancer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.damage).toEqualTypeOf();
+    expect(data.pyromancer.heal).toBeDefined();
+    expect(data.pyromancer.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.heal).toEqualTypeOf();
+    expect(data.pyromancer.damagePrevented).toBeDefined();
+    expect(data.pyromancer.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.pyromancer.damagePrevented).toEqualTypeOf();
+    expect(data.mage).toBeDefined();
+    expectTypeOf(data.mage).toEqualTypeOf();
+    expect(data.mage.wins).toBeDefined();
+    expect(data.mage.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.wins).toEqualTypeOf();
+    expect(data.mage.losses).toBeDefined();
+    expect(data.mage.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.losses).toEqualTypeOf();
+    expect(data.mage.WLR).toBeDefined();
+    expect(data.mage.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.WLR).toEqualTypeOf();
+    expect(data.mage.gamesPlayed).toBeDefined();
+    expect(data.mage.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.gamesPlayed).toEqualTypeOf();
+    expect(data.mage.damage).toBeDefined();
+    expect(data.mage.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.damage).toEqualTypeOf();
+    expect(data.mage.heal).toBeDefined();
+    expect(data.mage.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.heal).toEqualTypeOf();
+    expect(data.mage.damagePrevented).toBeDefined();
+    expect(data.mage.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.mage.damagePrevented).toEqualTypeOf();
+    expect(data.thunderlord).toBeDefined();
+    expectTypeOf(data.thunderlord).toEqualTypeOf();
+    expect(data.thunderlord.wins).toBeDefined();
+    expect(data.thunderlord.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.wins).toEqualTypeOf();
+    expect(data.thunderlord.losses).toBeDefined();
+    expect(data.thunderlord.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.losses).toEqualTypeOf();
+    expect(data.thunderlord.WLR).toBeDefined();
+    expect(data.thunderlord.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.WLR).toEqualTypeOf();
+    expect(data.thunderlord.gamesPlayed).toBeDefined();
+    expect(data.thunderlord.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.gamesPlayed).toEqualTypeOf();
+    expect(data.thunderlord.damage).toBeDefined();
+    expect(data.thunderlord.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.damage).toEqualTypeOf();
+    expect(data.thunderlord.heal).toBeDefined();
+    expect(data.thunderlord.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.heal).toEqualTypeOf();
+    expect(data.thunderlord.damagePrevented).toBeDefined();
+    expect(data.thunderlord.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.thunderlord.damagePrevented).toEqualTypeOf();
+    expect(data.shaman).toBeDefined();
+    expectTypeOf(data.shaman).toEqualTypeOf();
+    expect(data.shaman.wins).toBeDefined();
+    expect(data.shaman.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.wins).toEqualTypeOf();
+    expect(data.shaman.losses).toBeDefined();
+    expect(data.shaman.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.losses).toEqualTypeOf();
+    expect(data.shaman.WLR).toBeDefined();
+    expect(data.shaman.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.WLR).toEqualTypeOf();
+    expect(data.shaman.gamesPlayed).toBeDefined();
+    expect(data.shaman.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.gamesPlayed).toEqualTypeOf();
+    expect(data.shaman.damage).toBeDefined();
+    expect(data.shaman.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.damage).toEqualTypeOf();
+    expect(data.shaman.heal).toBeDefined();
+    expect(data.shaman.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.heal).toEqualTypeOf();
+    expect(data.shaman.damagePrevented).toBeDefined();
+    expect(data.shaman.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.shaman.damagePrevented).toEqualTypeOf();
+    expect(data.earthwarden).toBeDefined();
+    expectTypeOf(data.earthwarden).toEqualTypeOf();
+    expect(data.earthwarden.wins).toBeDefined();
+    expect(data.earthwarden.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.wins).toEqualTypeOf();
+    expect(data.earthwarden.losses).toBeDefined();
+    expect(data.earthwarden.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.losses).toEqualTypeOf();
+    expect(data.earthwarden.WLR).toBeDefined();
+    expect(data.earthwarden.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.WLR).toEqualTypeOf();
+    expect(data.earthwarden.gamesPlayed).toBeDefined();
+    expect(data.earthwarden.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.gamesPlayed).toEqualTypeOf();
+    expect(data.earthwarden.damage).toBeDefined();
+    expect(data.earthwarden.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.damage).toEqualTypeOf();
+    expect(data.earthwarden.heal).toBeDefined();
+    expect(data.earthwarden.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.heal).toEqualTypeOf();
+    expect(data.earthwarden.damagePrevented).toBeDefined();
+    expect(data.earthwarden.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.earthwarden.damagePrevented).toEqualTypeOf();
+    expect(data.aquamancer).toBeDefined();
+    expectTypeOf(data.aquamancer).toEqualTypeOf();
+    expect(data.aquamancer.wins).toBeDefined();
+    expect(data.aquamancer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.wins).toEqualTypeOf();
+    expect(data.aquamancer.losses).toBeDefined();
+    expect(data.aquamancer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.losses).toEqualTypeOf();
+    expect(data.aquamancer.WLR).toBeDefined();
+    expect(data.aquamancer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.WLR).toEqualTypeOf();
+    expect(data.aquamancer.gamesPlayed).toBeDefined();
+    expect(data.aquamancer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.gamesPlayed).toEqualTypeOf();
+    expect(data.aquamancer.damage).toBeDefined();
+    expect(data.aquamancer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.damage).toEqualTypeOf();
+    expect(data.aquamancer.heal).toBeDefined();
+    expect(data.aquamancer.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.heal).toEqualTypeOf();
+    expect(data.aquamancer.damagePrevented).toBeDefined();
+    expect(data.aquamancer.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.aquamancer.damagePrevented).toEqualTypeOf();
+    expect(data.paladin).toBeDefined();
+    expectTypeOf(data.paladin).toEqualTypeOf();
+    expect(data.paladin.wins).toBeDefined();
+    expect(data.paladin.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.wins).toEqualTypeOf();
+    expect(data.paladin.losses).toBeDefined();
+    expect(data.paladin.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.losses).toEqualTypeOf();
+    expect(data.paladin.WLR).toBeDefined();
+    expect(data.paladin.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.WLR).toEqualTypeOf();
+    expect(data.paladin.gamesPlayed).toBeDefined();
+    expect(data.paladin.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.gamesPlayed).toEqualTypeOf();
+    expect(data.paladin.damage).toBeDefined();
+    expect(data.paladin.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.damage).toEqualTypeOf();
+    expect(data.paladin.heal).toBeDefined();
+    expect(data.paladin.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.heal).toEqualTypeOf();
+    expect(data.paladin.damagePrevented).toBeDefined();
+    expect(data.paladin.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.damagePrevented).toEqualTypeOf();
+    expect(data.avenger).toBeDefined();
+    expectTypeOf(data.avenger).toEqualTypeOf();
+    expect(data.avenger.wins).toBeDefined();
+    expect(data.avenger.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.wins).toEqualTypeOf();
+    expect(data.avenger.losses).toBeDefined();
+    expect(data.avenger.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.losses).toEqualTypeOf();
+    expect(data.avenger.WLR).toBeDefined();
+    expect(data.avenger.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.WLR).toEqualTypeOf();
+    expect(data.avenger.gamesPlayed).toBeDefined();
+    expect(data.avenger.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.gamesPlayed).toEqualTypeOf();
+    expect(data.avenger.damage).toBeDefined();
+    expect(data.avenger.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.damage).toEqualTypeOf();
+    expect(data.avenger.heal).toBeDefined();
+    expect(data.avenger.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.heal).toEqualTypeOf();
+    expect(data.avenger.damagePrevented).toBeDefined();
+    expect(data.avenger.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.avenger.damagePrevented).toEqualTypeOf();
+    expect(data.warrior).toBeDefined();
+    expectTypeOf(data.warrior).toEqualTypeOf();
+    expect(data.warrior.wins).toBeDefined();
+    expect(data.warrior.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.wins).toEqualTypeOf();
+    expect(data.warrior.losses).toBeDefined();
+    expect(data.warrior.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.losses).toEqualTypeOf();
+    expect(data.warrior.WLR).toBeDefined();
+    expect(data.warrior.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.WLR).toEqualTypeOf();
+    expect(data.warrior.gamesPlayed).toBeDefined();
+    expect(data.warrior.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.gamesPlayed).toEqualTypeOf();
+    expect(data.warrior.damage).toBeDefined();
+    expect(data.warrior.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.damage).toEqualTypeOf();
+    expect(data.warrior.heal).toBeDefined();
+    expect(data.warrior.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.heal).toEqualTypeOf();
+    expect(data.warrior.damagePrevented).toBeDefined();
+    expect(data.warrior.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.warrior.damagePrevented).toEqualTypeOf();
+    expect(data.defender).toBeDefined();
+    expectTypeOf(data.defender).toEqualTypeOf();
+    expect(data.defender.wins).toBeDefined();
+    expect(data.defender.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.wins).toEqualTypeOf();
+    expect(data.defender.losses).toBeDefined();
+    expect(data.defender.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.losses).toEqualTypeOf();
+    expect(data.defender.WLR).toBeDefined();
+    expect(data.defender.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.WLR).toEqualTypeOf();
+    expect(data.defender.gamesPlayed).toBeDefined();
+    expect(data.defender.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.gamesPlayed).toEqualTypeOf();
+    expect(data.defender.damage).toBeDefined();
+    expect(data.defender.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.damage).toEqualTypeOf();
+    expect(data.defender.heal).toBeDefined();
+    expect(data.defender.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.heal).toEqualTypeOf();
+    expect(data.defender.damagePrevented).toBeDefined();
+    expect(data.defender.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.defender.damagePrevented).toEqualTypeOf();
+    expect(data.cryomancer).toBeDefined();
+    expectTypeOf(data.cryomancer).toEqualTypeOf();
+    expect(data.cryomancer.wins).toBeDefined();
+    expect(data.cryomancer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.wins).toEqualTypeOf();
+    expect(data.cryomancer.losses).toBeDefined();
+    expect(data.cryomancer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.losses).toEqualTypeOf();
+    expect(data.cryomancer.WLR).toBeDefined();
+    expect(data.cryomancer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.WLR).toEqualTypeOf();
+    expect(data.cryomancer.gamesPlayed).toBeDefined();
+    expect(data.cryomancer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.gamesPlayed).toEqualTypeOf();
+    expect(data.cryomancer.damage).toBeDefined();
+    expect(data.cryomancer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.damage).toEqualTypeOf();
+    expect(data.cryomancer.heal).toBeDefined();
+    expect(data.cryomancer.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.heal).toEqualTypeOf();
+    expect(data.cryomancer.damagePrevented).toBeDefined();
+    expect(data.cryomancer.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.cryomancer.damagePrevented).toEqualTypeOf();
+    expect(data.crusader).toBeDefined();
+    expectTypeOf(data.crusader).toEqualTypeOf();
+    expect(data.crusader.wins).toBeDefined();
+    expect(data.crusader.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.wins).toEqualTypeOf();
+    expect(data.crusader.losses).toBeDefined();
+    expect(data.crusader.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.losses).toEqualTypeOf();
+    expect(data.crusader.WLR).toBeDefined();
+    expect(data.crusader.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.WLR).toEqualTypeOf();
+    expect(data.crusader.gamesPlayed).toBeDefined();
+    expect(data.crusader.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.gamesPlayed).toEqualTypeOf();
+    expect(data.crusader.damage).toBeDefined();
+    expect(data.crusader.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.damage).toEqualTypeOf();
+    expect(data.crusader.heal).toBeDefined();
+    expect(data.crusader.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.heal).toEqualTypeOf();
+    expect(data.crusader.damagePrevented).toBeDefined();
+    expect(data.crusader.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.crusader.damagePrevented).toEqualTypeOf();
+    expect(data.berserker).toBeDefined();
+    expectTypeOf(data.berserker).toEqualTypeOf();
+    expect(data.berserker.wins).toBeDefined();
+    expect(data.berserker.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.wins).toEqualTypeOf();
+    expect(data.berserker.losses).toBeDefined();
+    expect(data.berserker.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.losses).toEqualTypeOf();
+    expect(data.berserker.WLR).toBeDefined();
+    expect(data.berserker.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.WLR).toEqualTypeOf();
+    expect(data.berserker.gamesPlayed).toBeDefined();
+    expect(data.berserker.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.gamesPlayed).toEqualTypeOf();
+    expect(data.berserker.damage).toBeDefined();
+    expect(data.berserker.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.damage).toEqualTypeOf();
+    expect(data.berserker.heal).toBeDefined();
+    expect(data.berserker.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.heal).toEqualTypeOf();
+    expect(data.berserker.damagePrevented).toBeDefined();
+    expect(data.berserker.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.berserker.damagePrevented).toEqualTypeOf();
+    expect(data.protector).toBeDefined();
+    expectTypeOf(data.protector).toEqualTypeOf();
+    expect(data.protector.wins).toBeDefined();
+    expect(data.protector.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.wins).toEqualTypeOf();
+    expect(data.protector.losses).toBeDefined();
+    expect(data.protector.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.losses).toEqualTypeOf();
+    expect(data.protector.WLR).toBeDefined();
+    expect(data.protector.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.WLR).toEqualTypeOf();
+    expect(data.protector.gamesPlayed).toBeDefined();
+    expect(data.protector.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.gamesPlayed).toEqualTypeOf();
+    expect(data.protector.damage).toBeDefined();
+    expect(data.protector.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.damage).toEqualTypeOf();
+    expect(data.protector.heal).toBeDefined();
+    expect(data.protector.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.heal).toEqualTypeOf();
+    expect(data.protector.damagePrevented).toBeDefined();
+    expect(data.protector.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.protector.damagePrevented).toEqualTypeOf();
+    expect(data.revenant).toBeDefined();
+    expectTypeOf(data.revenant).toEqualTypeOf();
+    expect(data.revenant.wins).toBeDefined();
+    expect(data.revenant.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.wins).toEqualTypeOf();
+    expect(data.revenant.losses).toBeDefined();
+    expect(data.revenant.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.losses).toEqualTypeOf();
+    expect(data.revenant.WLR).toBeDefined();
+    expect(data.revenant.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.WLR).toEqualTypeOf();
+    expect(data.revenant.gamesPlayed).toBeDefined();
+    expect(data.revenant.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.gamesPlayed).toEqualTypeOf();
+    expect(data.revenant.damage).toBeDefined();
+    expect(data.revenant.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.damage).toEqualTypeOf();
+    expect(data.revenant.heal).toBeDefined();
+    expect(data.revenant.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.heal).toEqualTypeOf();
+    expect(data.revenant.damagePrevented).toBeDefined();
+    expect(data.revenant.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.revenant.damagePrevented).toEqualTypeOf();
+    expect(data.spiritguard).toBeDefined();
+    expectTypeOf(data.spiritguard).toEqualTypeOf();
+    expect(data.spiritguard.wins).toBeDefined();
+    expect(data.spiritguard.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.wins).toEqualTypeOf();
+    expect(data.spiritguard.losses).toBeDefined();
+    expect(data.spiritguard.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.losses).toEqualTypeOf();
+    expect(data.spiritguard.WLR).toBeDefined();
+    expect(data.spiritguard.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.WLR).toEqualTypeOf();
+    expect(data.spiritguard.gamesPlayed).toBeDefined();
+    expect(data.spiritguard.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.gamesPlayed).toEqualTypeOf();
+    expect(data.spiritguard.damage).toBeDefined();
+    expect(data.spiritguard.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.damage).toEqualTypeOf();
+    expect(data.spiritguard.heal).toBeDefined();
+    expect(data.spiritguard.heal).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.heal).toEqualTypeOf();
+    expect(data.spiritguard.damagePrevented).toBeDefined();
+    expect(data.spiritguard.damagePrevented).greaterThanOrEqual(0);
+    expectTypeOf(data.spiritguard.damagePrevented).toEqualTypeOf();
+});

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

@@ -0,0 +1,81 @@
+import divide from '../../utils/divide';
+function convertXPToLevel(exp) {
+    const minimalExp = [0, 1e3, 3e3, 6e3, 1e4, 15e3];
+    const baseLevel = minimalExp.length;
+    const baseExp = minimalExp[minimalExp.length - 1];
+    const expToLevel100 = 49e4;
+    if (exp < baseExp)
+        return minimalExp?.findIndex((x) => exp < x);
+    const theoreticalLevel = (exp - baseExp) / 5e3 + baseLevel;
+    if (100 < theoreticalLevel)
+        return 100 + convertXPToLevel(exp - expToLevel100);
+    return theoreticalLevel;
+}
+function generateStatsFor(data, className) {
+    const workingData = (className ? data?.classes?.[className] : data) || {};
+    return {
+        wins: workingData?.wins || 0,
+        gamesPlayed: workingData?.games_played || 0,
+        woolsPlaced: workingData?.wool_placed || 0,
+        blocksBroken: workingData?.blocks_broken || 0,
+        placeBreakRatio: divide(workingData?.wool_placed || 0, workingData?.blocks_broken || 0),
+        kills: workingData?.kills || 0,
+        deaths: workingData?.deaths || 0,
+        KDR: divide(workingData?.kills, workingData?.deaths),
+        assists: workingData?.assists || 0,
+        powerups: workingData?.powerups_gotten || 0
+    };
+}
+class WoolWars {
+    layers;
+    xp;
+    exactLevel;
+    level;
+    coins;
+    wins;
+    gamesPlayed;
+    woolsPlaced;
+    blocksBroken;
+    placeBreakRatio;
+    kills;
+    deaths;
+    KDR;
+    assists;
+    powerups;
+    selectedClass;
+    assault;
+    tank;
+    golem;
+    swordsman;
+    engineer;
+    archer;
+    ownedCosmetics;
+    privateGamesConfig;
+    constructor(data) {
+        this.layers = data?.progression?.available_layers || 0;
+        this.xp = data?.progression?.experience || 0;
+        this.exactLevel = convertXPToLevel(this.xp);
+        this.level = Math.floor(this.exactLevel);
+        this.coins = data?.coins || 0;
+        this.wins = data?.wins || 0;
+        this.gamesPlayed = data?.games_played || 0;
+        this.woolsPlaced = data?.wool_placed || 0;
+        this.blocksBroken = data?.blocks_broken || 0;
+        this.placeBreakRatio = divide(this.woolsPlaced, this.blocksBroken);
+        this.kills = data?.kills || 0;
+        this.deaths = data?.deaths || 0;
+        this.KDR = divide(this.kills, this.deaths);
+        this.assists = data?.assists || 0;
+        this.powerups = data?.powerups_gotten || 0;
+        this.selectedClass = data?.wool_wars?.selected_class || 'NONE';
+        this.assault = generateStatsFor(data?.wool_wars?.stats, 'assault');
+        this.tank = generateStatsFor(data?.wool_wars?.stats, 'tank');
+        this.golem = generateStatsFor(data?.wool_wars?.stats, 'golem');
+        this.swordsman = generateStatsFor(data?.wool_wars?.stats, 'swordsman');
+        this.engineer = generateStatsFor(data?.wool_wars?.stats, 'engineer');
+        this.archer = generateStatsFor(data?.wool_wars?.stats, 'archer');
+        this.ownedCosmetics = data?.packages || [];
+        this.privateGamesConfig = data?.privategames || {};
+    }
+}
+export default WoolWars;