hypixel-api-reborn 11.3.4 → 12.0.0-0

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

@@ -0,0 +1,2238 @@
+import BlitzSurvivalGames from './BlitzSurvivalGames';
+import { expect, expectTypeOf, test } from 'vitest';
+test('BlitzSurvivalGames', () => {
+    const data = new BlitzSurvivalGames({ stats: 'meow' });
+    expect(data).toBeInstanceOf(BlitzSurvivalGames);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.coins).toBeDefined();
+    expectTypeOf(data.coins).toEqualTypeOf();
+    expect(data.kills).toBeDefined();
+    expectTypeOf(data.kills).toEqualTypeOf();
+    expect(data.kit).toBeDefined();
+    expectTypeOf(data.kit).toEqualTypeOf();
+    expect(data.killsSolo).toBeDefined();
+    expectTypeOf(data.killsSolo).toEqualTypeOf();
+    expect(data.killsTeams).toBeDefined();
+    expectTypeOf(data.killsTeams).toEqualTypeOf();
+    expect(data.deaths).toBeDefined();
+    expectTypeOf(data.deaths).toEqualTypeOf();
+    expect(data.KDR).toBeDefined();
+    expectTypeOf(data.KDR).toEqualTypeOf();
+    expect(data.wins).toBeDefined();
+    expectTypeOf(data.wins).toEqualTypeOf();
+    expect(data.winsSolo).toBeDefined();
+    expectTypeOf(data.winsSolo).toEqualTypeOf();
+    expect(data.winsTeam).toBeDefined();
+    expectTypeOf(data.winsTeam).toEqualTypeOf();
+    expect(data.gamesPlayed).toBeDefined();
+    expectTypeOf(data.gamesPlayed).toEqualTypeOf();
+    expect(data.losses).toBeDefined();
+    expectTypeOf(data.losses).toEqualTypeOf();
+    expect(data.WLR).toBeDefined();
+    expectTypeOf(data.WLR).toEqualTypeOf();
+    expect(data.arrowsShot).toBeDefined();
+    expectTypeOf(data.arrowsShot).toEqualTypeOf();
+    expect(data.arrowsHit).toBeDefined();
+    expectTypeOf(data.arrowsHit).toEqualTypeOf();
+    expect(data.bowAccuracy).toBeDefined();
+    expectTypeOf(data.bowAccuracy).toEqualTypeOf();
+    expect(data.damage).toBeDefined();
+    expectTypeOf(data.damage).toEqualTypeOf();
+    expect(data.damageTaken).toBeDefined();
+    expectTypeOf(data.damageTaken).toEqualTypeOf();
+    expect(data.potionsDrunk).toBeDefined();
+    expectTypeOf(data.potionsDrunk).toEqualTypeOf();
+    expect(data.potionsThrown).toBeDefined();
+    expectTypeOf(data.potionsThrown).toEqualTypeOf();
+    expect(data.mobsSpawned).toBeDefined();
+    expectTypeOf(data.mobsSpawned).toEqualTypeOf();
+    expect(data.playTime).toBeDefined();
+    expectTypeOf(data.playTime).toEqualTypeOf();
+    expect(data.blitzUses).toBeDefined();
+    expectTypeOf(data.blitzUses).toEqualTypeOf();
+    expect(data.chestsOpened).toBeDefined();
+    expectTypeOf(data.chestsOpened).toEqualTypeOf();
+    expect(data.archer).toBeDefined();
+    expectTypeOf(data.archer).toEqualTypeOf();
+    expect(data.archer.level).toBeDefined();
+    expect(data.archer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.level).toEqualTypeOf();
+    expect(data.archer.exp).toBeDefined();
+    expect(data.archer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.exp).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.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.losses).toBeDefined();
+    expect(data.archer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.losses).toEqualTypeOf();
+    expect(data.archer.WLR).toBeDefined();
+    expect(data.archer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.WLR).toEqualTypeOf();
+    expect(data.archer.arrowsShot).toBeDefined();
+    expect(data.archer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.arrowsShot).toEqualTypeOf();
+    expect(data.archer.arrowsHit).toBeDefined();
+    expect(data.archer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.arrowsHit).toEqualTypeOf();
+    expect(data.archer.bowAccuracy).toBeDefined();
+    expect(data.archer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.bowAccuracy).toEqualTypeOf();
+    expect(data.archer.damage).toBeDefined();
+    expect(data.archer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.damage).toEqualTypeOf();
+    expect(data.archer.damageTaken).toBeDefined();
+    expect(data.archer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.damageTaken).toEqualTypeOf();
+    expect(data.archer.potionsDrunk).toBeDefined();
+    expect(data.archer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.potionsDrunk).toEqualTypeOf();
+    expect(data.archer.potionsThrown).toBeDefined();
+    expect(data.archer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.potionsThrown).toEqualTypeOf();
+    expect(data.archer.playTime).toBeDefined();
+    expect(data.archer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.playTime).toEqualTypeOf();
+    expect(data.archer.mobsSpawned).toBeDefined();
+    expect(data.archer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.mobsSpawned).toEqualTypeOf();
+    expect(data.archer.chestsOpened).toBeDefined();
+    expect(data.archer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.archer.chestsOpened).toEqualTypeOf();
+    expect(data.meatmaster).toBeDefined();
+    expectTypeOf(data.meatmaster).toEqualTypeOf();
+    expect(data.meatmaster.level).toBeDefined();
+    expect(data.meatmaster.level).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.level).toEqualTypeOf();
+    expect(data.meatmaster.exp).toBeDefined();
+    expect(data.meatmaster.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.exp).toEqualTypeOf();
+    expect(data.meatmaster.kills).toBeDefined();
+    expect(data.meatmaster.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.kills).toEqualTypeOf();
+    expect(data.meatmaster.deaths).toBeDefined();
+    expect(data.meatmaster.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.deaths).toEqualTypeOf();
+    expect(data.meatmaster.KDR).toBeDefined();
+    expect(data.meatmaster.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.KDR).toEqualTypeOf();
+    expect(data.meatmaster.wins).toBeDefined();
+    expect(data.meatmaster.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.wins).toEqualTypeOf();
+    expect(data.meatmaster.gamesPlayed).toBeDefined();
+    expect(data.meatmaster.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.gamesPlayed).toEqualTypeOf();
+    expect(data.meatmaster.losses).toBeDefined();
+    expect(data.meatmaster.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.losses).toEqualTypeOf();
+    expect(data.meatmaster.WLR).toBeDefined();
+    expect(data.meatmaster.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.WLR).toEqualTypeOf();
+    expect(data.meatmaster.arrowsShot).toBeDefined();
+    expect(data.meatmaster.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.arrowsShot).toEqualTypeOf();
+    expect(data.meatmaster.arrowsHit).toBeDefined();
+    expect(data.meatmaster.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.arrowsHit).toEqualTypeOf();
+    expect(data.meatmaster.bowAccuracy).toBeDefined();
+    expect(data.meatmaster.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.bowAccuracy).toEqualTypeOf();
+    expect(data.meatmaster.damage).toBeDefined();
+    expect(data.meatmaster.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.damage).toEqualTypeOf();
+    expect(data.meatmaster.damageTaken).toBeDefined();
+    expect(data.meatmaster.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.damageTaken).toEqualTypeOf();
+    expect(data.meatmaster.potionsDrunk).toBeDefined();
+    expect(data.meatmaster.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.potionsDrunk).toEqualTypeOf();
+    expect(data.meatmaster.potionsThrown).toBeDefined();
+    expect(data.meatmaster.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.potionsThrown).toEqualTypeOf();
+    expect(data.meatmaster.playTime).toBeDefined();
+    expect(data.meatmaster.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.playTime).toEqualTypeOf();
+    expect(data.meatmaster.mobsSpawned).toBeDefined();
+    expect(data.meatmaster.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.mobsSpawned).toEqualTypeOf();
+    expect(data.meatmaster.chestsOpened).toBeDefined();
+    expect(data.meatmaster.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.meatmaster.chestsOpened).toEqualTypeOf();
+    expect(data.speleologist).toBeDefined();
+    expectTypeOf(data.speleologist).toEqualTypeOf();
+    expect(data.speleologist.level).toBeDefined();
+    expect(data.speleologist.level).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.level).toEqualTypeOf();
+    expect(data.speleologist.exp).toBeDefined();
+    expect(data.speleologist.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.exp).toEqualTypeOf();
+    expect(data.speleologist.kills).toBeDefined();
+    expect(data.speleologist.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.kills).toEqualTypeOf();
+    expect(data.speleologist.deaths).toBeDefined();
+    expect(data.speleologist.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.deaths).toEqualTypeOf();
+    expect(data.speleologist.KDR).toBeDefined();
+    expect(data.speleologist.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.KDR).toEqualTypeOf();
+    expect(data.speleologist.wins).toBeDefined();
+    expect(data.speleologist.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.wins).toEqualTypeOf();
+    expect(data.speleologist.gamesPlayed).toBeDefined();
+    expect(data.speleologist.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.gamesPlayed).toEqualTypeOf();
+    expect(data.speleologist.losses).toBeDefined();
+    expect(data.speleologist.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.losses).toEqualTypeOf();
+    expect(data.speleologist.WLR).toBeDefined();
+    expect(data.speleologist.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.WLR).toEqualTypeOf();
+    expect(data.speleologist.arrowsShot).toBeDefined();
+    expect(data.speleologist.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.arrowsShot).toEqualTypeOf();
+    expect(data.speleologist.arrowsHit).toBeDefined();
+    expect(data.speleologist.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.arrowsHit).toEqualTypeOf();
+    expect(data.speleologist.bowAccuracy).toBeDefined();
+    expect(data.speleologist.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.bowAccuracy).toEqualTypeOf();
+    expect(data.speleologist.damage).toBeDefined();
+    expect(data.speleologist.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.damage).toEqualTypeOf();
+    expect(data.speleologist.damageTaken).toBeDefined();
+    expect(data.speleologist.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.damageTaken).toEqualTypeOf();
+    expect(data.speleologist.potionsDrunk).toBeDefined();
+    expect(data.speleologist.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.potionsDrunk).toEqualTypeOf();
+    expect(data.speleologist.potionsThrown).toBeDefined();
+    expect(data.speleologist.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.potionsThrown).toEqualTypeOf();
+    expect(data.speleologist.playTime).toBeDefined();
+    expect(data.speleologist.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.playTime).toEqualTypeOf();
+    expect(data.speleologist.mobsSpawned).toBeDefined();
+    expect(data.speleologist.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.mobsSpawned).toEqualTypeOf();
+    expect(data.speleologist.chestsOpened).toBeDefined();
+    expect(data.speleologist.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.speleologist.chestsOpened).toEqualTypeOf();
+    expect(data.baker).toBeDefined();
+    expectTypeOf(data.baker).toEqualTypeOf();
+    expect(data.baker.level).toBeDefined();
+    expect(data.baker.level).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.level).toEqualTypeOf();
+    expect(data.baker.exp).toBeDefined();
+    expect(data.baker.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.exp).toEqualTypeOf();
+    expect(data.baker.kills).toBeDefined();
+    expect(data.baker.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.kills).toEqualTypeOf();
+    expect(data.baker.deaths).toBeDefined();
+    expect(data.baker.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.deaths).toEqualTypeOf();
+    expect(data.baker.KDR).toBeDefined();
+    expect(data.baker.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.KDR).toEqualTypeOf();
+    expect(data.baker.wins).toBeDefined();
+    expect(data.baker.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.wins).toEqualTypeOf();
+    expect(data.baker.gamesPlayed).toBeDefined();
+    expect(data.baker.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.gamesPlayed).toEqualTypeOf();
+    expect(data.baker.losses).toBeDefined();
+    expect(data.baker.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.losses).toEqualTypeOf();
+    expect(data.baker.WLR).toBeDefined();
+    expect(data.baker.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.WLR).toEqualTypeOf();
+    expect(data.baker.arrowsShot).toBeDefined();
+    expect(data.baker.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.arrowsShot).toEqualTypeOf();
+    expect(data.baker.arrowsHit).toBeDefined();
+    expect(data.baker.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.arrowsHit).toEqualTypeOf();
+    expect(data.baker.bowAccuracy).toBeDefined();
+    expect(data.baker.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.bowAccuracy).toEqualTypeOf();
+    expect(data.baker.damage).toBeDefined();
+    expect(data.baker.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.damage).toEqualTypeOf();
+    expect(data.baker.damageTaken).toBeDefined();
+    expect(data.baker.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.damageTaken).toEqualTypeOf();
+    expect(data.baker.potionsDrunk).toBeDefined();
+    expect(data.baker.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.potionsDrunk).toEqualTypeOf();
+    expect(data.baker.potionsThrown).toBeDefined();
+    expect(data.baker.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.potionsThrown).toEqualTypeOf();
+    expect(data.baker.playTime).toBeDefined();
+    expect(data.baker.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.playTime).toEqualTypeOf();
+    expect(data.baker.mobsSpawned).toBeDefined();
+    expect(data.baker.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.mobsSpawned).toEqualTypeOf();
+    expect(data.baker.chestsOpened).toBeDefined();
+    expect(data.baker.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.baker.chestsOpened).toEqualTypeOf();
+    expect(data.knight).toBeDefined();
+    expectTypeOf(data.knight).toEqualTypeOf();
+    expect(data.knight.level).toBeDefined();
+    expect(data.knight.level).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.level).toEqualTypeOf();
+    expect(data.knight.exp).toBeDefined();
+    expect(data.knight.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.exp).toEqualTypeOf();
+    expect(data.knight.kills).toBeDefined();
+    expect(data.knight.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.kills).toEqualTypeOf();
+    expect(data.knight.deaths).toBeDefined();
+    expect(data.knight.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.deaths).toEqualTypeOf();
+    expect(data.knight.KDR).toBeDefined();
+    expect(data.knight.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.KDR).toEqualTypeOf();
+    expect(data.knight.wins).toBeDefined();
+    expect(data.knight.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.wins).toEqualTypeOf();
+    expect(data.knight.gamesPlayed).toBeDefined();
+    expect(data.knight.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.gamesPlayed).toEqualTypeOf();
+    expect(data.knight.losses).toBeDefined();
+    expect(data.knight.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.losses).toEqualTypeOf();
+    expect(data.knight.WLR).toBeDefined();
+    expect(data.knight.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.WLR).toEqualTypeOf();
+    expect(data.knight.arrowsShot).toBeDefined();
+    expect(data.knight.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.arrowsShot).toEqualTypeOf();
+    expect(data.knight.arrowsHit).toBeDefined();
+    expect(data.knight.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.arrowsHit).toEqualTypeOf();
+    expect(data.knight.bowAccuracy).toBeDefined();
+    expect(data.knight.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.bowAccuracy).toEqualTypeOf();
+    expect(data.knight.damage).toBeDefined();
+    expect(data.knight.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.damage).toEqualTypeOf();
+    expect(data.knight.damageTaken).toBeDefined();
+    expect(data.knight.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.damageTaken).toEqualTypeOf();
+    expect(data.knight.potionsDrunk).toBeDefined();
+    expect(data.knight.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.potionsDrunk).toEqualTypeOf();
+    expect(data.knight.potionsThrown).toBeDefined();
+    expect(data.knight.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.potionsThrown).toEqualTypeOf();
+    expect(data.knight.playTime).toBeDefined();
+    expect(data.knight.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.playTime).toEqualTypeOf();
+    expect(data.knight.mobsSpawned).toBeDefined();
+    expect(data.knight.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.mobsSpawned).toEqualTypeOf();
+    expect(data.knight.chestsOpened).toBeDefined();
+    expect(data.knight.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.knight.chestsOpened).toEqualTypeOf();
+    expect(data.guardian).toBeDefined();
+    expectTypeOf(data.guardian).toEqualTypeOf();
+    expect(data.guardian.level).toBeDefined();
+    expect(data.guardian.level).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.level).toEqualTypeOf();
+    expect(data.guardian.exp).toBeDefined();
+    expect(data.guardian.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.exp).toEqualTypeOf();
+    expect(data.guardian.kills).toBeDefined();
+    expect(data.guardian.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.kills).toEqualTypeOf();
+    expect(data.guardian.deaths).toBeDefined();
+    expect(data.guardian.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.deaths).toEqualTypeOf();
+    expect(data.guardian.KDR).toBeDefined();
+    expect(data.guardian.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.KDR).toEqualTypeOf();
+    expect(data.guardian.wins).toBeDefined();
+    expect(data.guardian.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.wins).toEqualTypeOf();
+    expect(data.guardian.gamesPlayed).toBeDefined();
+    expect(data.guardian.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.gamesPlayed).toEqualTypeOf();
+    expect(data.guardian.losses).toBeDefined();
+    expect(data.guardian.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.losses).toEqualTypeOf();
+    expect(data.guardian.WLR).toBeDefined();
+    expect(data.guardian.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.WLR).toEqualTypeOf();
+    expect(data.guardian.arrowsShot).toBeDefined();
+    expect(data.guardian.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.arrowsShot).toEqualTypeOf();
+    expect(data.guardian.arrowsHit).toBeDefined();
+    expect(data.guardian.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.arrowsHit).toEqualTypeOf();
+    expect(data.guardian.bowAccuracy).toBeDefined();
+    expect(data.guardian.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.bowAccuracy).toEqualTypeOf();
+    expect(data.guardian.damage).toBeDefined();
+    expect(data.guardian.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.damage).toEqualTypeOf();
+    expect(data.guardian.damageTaken).toBeDefined();
+    expect(data.guardian.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.damageTaken).toEqualTypeOf();
+    expect(data.guardian.potionsDrunk).toBeDefined();
+    expect(data.guardian.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.potionsDrunk).toEqualTypeOf();
+    expect(data.guardian.potionsThrown).toBeDefined();
+    expect(data.guardian.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.potionsThrown).toEqualTypeOf();
+    expect(data.guardian.playTime).toBeDefined();
+    expect(data.guardian.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.playTime).toEqualTypeOf();
+    expect(data.guardian.mobsSpawned).toBeDefined();
+    expect(data.guardian.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.mobsSpawned).toEqualTypeOf();
+    expect(data.guardian.chestsOpened).toBeDefined();
+    expect(data.guardian.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.guardian.chestsOpened).toEqualTypeOf();
+    expect(data.scout).toBeDefined();
+    expectTypeOf(data.scout).toEqualTypeOf();
+    expect(data.scout.level).toBeDefined();
+    expect(data.scout.level).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.level).toEqualTypeOf();
+    expect(data.scout.exp).toBeDefined();
+    expect(data.scout.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.exp).toEqualTypeOf();
+    expect(data.scout.kills).toBeDefined();
+    expect(data.scout.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.kills).toEqualTypeOf();
+    expect(data.scout.deaths).toBeDefined();
+    expect(data.scout.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.deaths).toEqualTypeOf();
+    expect(data.scout.KDR).toBeDefined();
+    expect(data.scout.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.KDR).toEqualTypeOf();
+    expect(data.scout.wins).toBeDefined();
+    expect(data.scout.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.wins).toEqualTypeOf();
+    expect(data.scout.gamesPlayed).toBeDefined();
+    expect(data.scout.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.gamesPlayed).toEqualTypeOf();
+    expect(data.scout.losses).toBeDefined();
+    expect(data.scout.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.losses).toEqualTypeOf();
+    expect(data.scout.WLR).toBeDefined();
+    expect(data.scout.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.WLR).toEqualTypeOf();
+    expect(data.scout.arrowsShot).toBeDefined();
+    expect(data.scout.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.arrowsShot).toEqualTypeOf();
+    expect(data.scout.arrowsHit).toBeDefined();
+    expect(data.scout.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.arrowsHit).toEqualTypeOf();
+    expect(data.scout.bowAccuracy).toBeDefined();
+    expect(data.scout.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.bowAccuracy).toEqualTypeOf();
+    expect(data.scout.damage).toBeDefined();
+    expect(data.scout.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.damage).toEqualTypeOf();
+    expect(data.scout.damageTaken).toBeDefined();
+    expect(data.scout.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.damageTaken).toEqualTypeOf();
+    expect(data.scout.potionsDrunk).toBeDefined();
+    expect(data.scout.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.potionsDrunk).toEqualTypeOf();
+    expect(data.scout.potionsThrown).toBeDefined();
+    expect(data.scout.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.potionsThrown).toEqualTypeOf();
+    expect(data.scout.playTime).toBeDefined();
+    expect(data.scout.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.playTime).toEqualTypeOf();
+    expect(data.scout.mobsSpawned).toBeDefined();
+    expect(data.scout.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.mobsSpawned).toEqualTypeOf();
+    expect(data.scout.chestsOpened).toBeDefined();
+    expect(data.scout.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.scout.chestsOpened).toEqualTypeOf();
+    expect(data.hunter).toBeDefined();
+    expectTypeOf(data.hunter).toEqualTypeOf();
+    expect(data.hunter.level).toBeDefined();
+    expect(data.hunter.level).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.level).toEqualTypeOf();
+    expect(data.hunter.exp).toBeDefined();
+    expect(data.hunter.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.exp).toEqualTypeOf();
+    expect(data.hunter.kills).toBeDefined();
+    expect(data.hunter.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.kills).toEqualTypeOf();
+    expect(data.hunter.deaths).toBeDefined();
+    expect(data.hunter.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.deaths).toEqualTypeOf();
+    expect(data.hunter.KDR).toBeDefined();
+    expect(data.hunter.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.KDR).toEqualTypeOf();
+    expect(data.hunter.wins).toBeDefined();
+    expect(data.hunter.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.wins).toEqualTypeOf();
+    expect(data.hunter.gamesPlayed).toBeDefined();
+    expect(data.hunter.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.gamesPlayed).toEqualTypeOf();
+    expect(data.hunter.losses).toBeDefined();
+    expect(data.hunter.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.losses).toEqualTypeOf();
+    expect(data.hunter.WLR).toBeDefined();
+    expect(data.hunter.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.WLR).toEqualTypeOf();
+    expect(data.hunter.arrowsShot).toBeDefined();
+    expect(data.hunter.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.arrowsShot).toEqualTypeOf();
+    expect(data.hunter.arrowsHit).toBeDefined();
+    expect(data.hunter.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.arrowsHit).toEqualTypeOf();
+    expect(data.hunter.bowAccuracy).toBeDefined();
+    expect(data.hunter.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.bowAccuracy).toEqualTypeOf();
+    expect(data.hunter.damage).toBeDefined();
+    expect(data.hunter.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.damage).toEqualTypeOf();
+    expect(data.hunter.damageTaken).toBeDefined();
+    expect(data.hunter.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.damageTaken).toEqualTypeOf();
+    expect(data.hunter.potionsDrunk).toBeDefined();
+    expect(data.hunter.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.potionsDrunk).toEqualTypeOf();
+    expect(data.hunter.potionsThrown).toBeDefined();
+    expect(data.hunter.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.potionsThrown).toEqualTypeOf();
+    expect(data.hunter.playTime).toBeDefined();
+    expect(data.hunter.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.playTime).toEqualTypeOf();
+    expect(data.hunter.mobsSpawned).toBeDefined();
+    expect(data.hunter.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.mobsSpawned).toEqualTypeOf();
+    expect(data.hunter.chestsOpened).toBeDefined();
+    expect(data.hunter.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.hunter.chestsOpened).toEqualTypeOf();
+    expect(data.hypeTrain).toBeDefined();
+    expectTypeOf(data.hypeTrain).toEqualTypeOf();
+    expect(data.hypeTrain.level).toBeDefined();
+    expect(data.hypeTrain.level).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.level).toEqualTypeOf();
+    expect(data.hypeTrain.exp).toBeDefined();
+    expect(data.hypeTrain.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.exp).toEqualTypeOf();
+    expect(data.hypeTrain.kills).toBeDefined();
+    expect(data.hypeTrain.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.kills).toEqualTypeOf();
+    expect(data.hypeTrain.deaths).toBeDefined();
+    expect(data.hypeTrain.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.deaths).toEqualTypeOf();
+    expect(data.hypeTrain.KDR).toBeDefined();
+    expect(data.hypeTrain.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.KDR).toEqualTypeOf();
+    expect(data.hypeTrain.wins).toBeDefined();
+    expect(data.hypeTrain.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.wins).toEqualTypeOf();
+    expect(data.hypeTrain.gamesPlayed).toBeDefined();
+    expect(data.hypeTrain.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.gamesPlayed).toEqualTypeOf();
+    expect(data.hypeTrain.losses).toBeDefined();
+    expect(data.hypeTrain.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.losses).toEqualTypeOf();
+    expect(data.hypeTrain.WLR).toBeDefined();
+    expect(data.hypeTrain.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.WLR).toEqualTypeOf();
+    expect(data.hypeTrain.arrowsShot).toBeDefined();
+    expect(data.hypeTrain.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.arrowsShot).toEqualTypeOf();
+    expect(data.hypeTrain.arrowsHit).toBeDefined();
+    expect(data.hypeTrain.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.arrowsHit).toEqualTypeOf();
+    expect(data.hypeTrain.bowAccuracy).toBeDefined();
+    expect(data.hypeTrain.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.bowAccuracy).toEqualTypeOf();
+    expect(data.hypeTrain.damage).toBeDefined();
+    expect(data.hypeTrain.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.damage).toEqualTypeOf();
+    expect(data.hypeTrain.damageTaken).toBeDefined();
+    expect(data.hypeTrain.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.damageTaken).toEqualTypeOf();
+    expect(data.hypeTrain.potionsDrunk).toBeDefined();
+    expect(data.hypeTrain.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.potionsDrunk).toEqualTypeOf();
+    expect(data.hypeTrain.potionsThrown).toBeDefined();
+    expect(data.hypeTrain.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.potionsThrown).toEqualTypeOf();
+    expect(data.hypeTrain.playTime).toBeDefined();
+    expect(data.hypeTrain.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.playTime).toEqualTypeOf();
+    expect(data.hypeTrain.mobsSpawned).toBeDefined();
+    expect(data.hypeTrain.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.mobsSpawned).toEqualTypeOf();
+    expect(data.hypeTrain.chestsOpened).toBeDefined();
+    expect(data.hypeTrain.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.hypeTrain.chestsOpened).toEqualTypeOf();
+    expect(data.fisherman).toBeDefined();
+    expectTypeOf(data.fisherman).toEqualTypeOf();
+    expect(data.fisherman.level).toBeDefined();
+    expect(data.fisherman.level).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.level).toEqualTypeOf();
+    expect(data.fisherman.exp).toBeDefined();
+    expect(data.fisherman.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.exp).toEqualTypeOf();
+    expect(data.fisherman.kills).toBeDefined();
+    expect(data.fisherman.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.kills).toEqualTypeOf();
+    expect(data.fisherman.deaths).toBeDefined();
+    expect(data.fisherman.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.deaths).toEqualTypeOf();
+    expect(data.fisherman.KDR).toBeDefined();
+    expect(data.fisherman.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.KDR).toEqualTypeOf();
+    expect(data.fisherman.wins).toBeDefined();
+    expect(data.fisherman.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.wins).toEqualTypeOf();
+    expect(data.fisherman.gamesPlayed).toBeDefined();
+    expect(data.fisherman.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.gamesPlayed).toEqualTypeOf();
+    expect(data.fisherman.losses).toBeDefined();
+    expect(data.fisherman.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.losses).toEqualTypeOf();
+    expect(data.fisherman.WLR).toBeDefined();
+    expect(data.fisherman.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.WLR).toEqualTypeOf();
+    expect(data.fisherman.arrowsShot).toBeDefined();
+    expect(data.fisherman.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.arrowsShot).toEqualTypeOf();
+    expect(data.fisherman.arrowsHit).toBeDefined();
+    expect(data.fisherman.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.arrowsHit).toEqualTypeOf();
+    expect(data.fisherman.bowAccuracy).toBeDefined();
+    expect(data.fisherman.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.bowAccuracy).toEqualTypeOf();
+    expect(data.fisherman.damage).toBeDefined();
+    expect(data.fisherman.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.damage).toEqualTypeOf();
+    expect(data.fisherman.damageTaken).toBeDefined();
+    expect(data.fisherman.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.damageTaken).toEqualTypeOf();
+    expect(data.fisherman.potionsDrunk).toBeDefined();
+    expect(data.fisherman.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.potionsDrunk).toEqualTypeOf();
+    expect(data.fisherman.potionsThrown).toBeDefined();
+    expect(data.fisherman.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.potionsThrown).toEqualTypeOf();
+    expect(data.fisherman.playTime).toBeDefined();
+    expect(data.fisherman.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.playTime).toEqualTypeOf();
+    expect(data.fisherman.mobsSpawned).toBeDefined();
+    expect(data.fisherman.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.mobsSpawned).toEqualTypeOf();
+    expect(data.fisherman.chestsOpened).toBeDefined();
+    expect(data.fisherman.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.fisherman.chestsOpened).toEqualTypeOf();
+    expect(data.armorer).toBeDefined();
+    expectTypeOf(data.armorer).toEqualTypeOf();
+    expect(data.armorer.level).toBeDefined();
+    expect(data.armorer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.level).toEqualTypeOf();
+    expect(data.armorer.exp).toBeDefined();
+    expect(data.armorer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.exp).toEqualTypeOf();
+    expect(data.armorer.kills).toBeDefined();
+    expect(data.armorer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.kills).toEqualTypeOf();
+    expect(data.armorer.deaths).toBeDefined();
+    expect(data.armorer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.deaths).toEqualTypeOf();
+    expect(data.armorer.KDR).toBeDefined();
+    expect(data.armorer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.KDR).toEqualTypeOf();
+    expect(data.armorer.wins).toBeDefined();
+    expect(data.armorer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.wins).toEqualTypeOf();
+    expect(data.armorer.gamesPlayed).toBeDefined();
+    expect(data.armorer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.gamesPlayed).toEqualTypeOf();
+    expect(data.armorer.losses).toBeDefined();
+    expect(data.armorer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.losses).toEqualTypeOf();
+    expect(data.armorer.WLR).toBeDefined();
+    expect(data.armorer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.WLR).toEqualTypeOf();
+    expect(data.armorer.arrowsShot).toBeDefined();
+    expect(data.armorer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.arrowsShot).toEqualTypeOf();
+    expect(data.armorer.arrowsHit).toBeDefined();
+    expect(data.armorer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.arrowsHit).toEqualTypeOf();
+    expect(data.armorer.bowAccuracy).toBeDefined();
+    expect(data.armorer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.bowAccuracy).toEqualTypeOf();
+    expect(data.armorer.damage).toBeDefined();
+    expect(data.armorer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.damage).toEqualTypeOf();
+    expect(data.armorer.damageTaken).toBeDefined();
+    expect(data.armorer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.damageTaken).toEqualTypeOf();
+    expect(data.armorer.potionsDrunk).toBeDefined();
+    expect(data.armorer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.potionsDrunk).toEqualTypeOf();
+    expect(data.armorer.potionsThrown).toBeDefined();
+    expect(data.armorer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.potionsThrown).toEqualTypeOf();
+    expect(data.armorer.playTime).toBeDefined();
+    expect(data.armorer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.playTime).toEqualTypeOf();
+    expect(data.armorer.mobsSpawned).toBeDefined();
+    expect(data.armorer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.mobsSpawned).toEqualTypeOf();
+    expect(data.armorer.chestsOpened).toBeDefined();
+    expect(data.armorer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.armorer.chestsOpened).toEqualTypeOf();
+    expect(data.horsetamer).toBeDefined();
+    expectTypeOf(data.horsetamer).toEqualTypeOf();
+    expect(data.horsetamer.level).toBeDefined();
+    expect(data.horsetamer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.level).toEqualTypeOf();
+    expect(data.horsetamer.exp).toBeDefined();
+    expect(data.horsetamer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.exp).toEqualTypeOf();
+    expect(data.horsetamer.kills).toBeDefined();
+    expect(data.horsetamer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.kills).toEqualTypeOf();
+    expect(data.horsetamer.deaths).toBeDefined();
+    expect(data.horsetamer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.deaths).toEqualTypeOf();
+    expect(data.horsetamer.KDR).toBeDefined();
+    expect(data.horsetamer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.KDR).toEqualTypeOf();
+    expect(data.horsetamer.wins).toBeDefined();
+    expect(data.horsetamer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.wins).toEqualTypeOf();
+    expect(data.horsetamer.gamesPlayed).toBeDefined();
+    expect(data.horsetamer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.gamesPlayed).toEqualTypeOf();
+    expect(data.horsetamer.losses).toBeDefined();
+    expect(data.horsetamer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.losses).toEqualTypeOf();
+    expect(data.horsetamer.WLR).toBeDefined();
+    expect(data.horsetamer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.WLR).toEqualTypeOf();
+    expect(data.horsetamer.arrowsShot).toBeDefined();
+    expect(data.horsetamer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.arrowsShot).toEqualTypeOf();
+    expect(data.horsetamer.arrowsHit).toBeDefined();
+    expect(data.horsetamer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.arrowsHit).toEqualTypeOf();
+    expect(data.horsetamer.bowAccuracy).toBeDefined();
+    expect(data.horsetamer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.bowAccuracy).toEqualTypeOf();
+    expect(data.horsetamer.damage).toBeDefined();
+    expect(data.horsetamer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.damage).toEqualTypeOf();
+    expect(data.horsetamer.damageTaken).toBeDefined();
+    expect(data.horsetamer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.damageTaken).toEqualTypeOf();
+    expect(data.horsetamer.potionsDrunk).toBeDefined();
+    expect(data.horsetamer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.potionsDrunk).toEqualTypeOf();
+    expect(data.horsetamer.potionsThrown).toBeDefined();
+    expect(data.horsetamer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.potionsThrown).toEqualTypeOf();
+    expect(data.horsetamer.playTime).toBeDefined();
+    expect(data.horsetamer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.playTime).toEqualTypeOf();
+    expect(data.horsetamer.mobsSpawned).toBeDefined();
+    expect(data.horsetamer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.mobsSpawned).toEqualTypeOf();
+    expect(data.horsetamer.chestsOpened).toBeDefined();
+    expect(data.horsetamer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.horsetamer.chestsOpened).toEqualTypeOf();
+    expect(data.astronaut).toBeDefined();
+    expectTypeOf(data.astronaut).toEqualTypeOf();
+    expect(data.astronaut.level).toBeDefined();
+    expect(data.astronaut.level).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.level).toEqualTypeOf();
+    expect(data.astronaut.exp).toBeDefined();
+    expect(data.astronaut.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.exp).toEqualTypeOf();
+    expect(data.astronaut.kills).toBeDefined();
+    expect(data.astronaut.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.kills).toEqualTypeOf();
+    expect(data.astronaut.deaths).toBeDefined();
+    expect(data.astronaut.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.deaths).toEqualTypeOf();
+    expect(data.astronaut.KDR).toBeDefined();
+    expect(data.astronaut.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.KDR).toEqualTypeOf();
+    expect(data.astronaut.wins).toBeDefined();
+    expect(data.astronaut.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.wins).toEqualTypeOf();
+    expect(data.astronaut.gamesPlayed).toBeDefined();
+    expect(data.astronaut.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.gamesPlayed).toEqualTypeOf();
+    expect(data.astronaut.losses).toBeDefined();
+    expect(data.astronaut.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.losses).toEqualTypeOf();
+    expect(data.astronaut.WLR).toBeDefined();
+    expect(data.astronaut.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.WLR).toEqualTypeOf();
+    expect(data.astronaut.arrowsShot).toBeDefined();
+    expect(data.astronaut.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.arrowsShot).toEqualTypeOf();
+    expect(data.astronaut.arrowsHit).toBeDefined();
+    expect(data.astronaut.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.arrowsHit).toEqualTypeOf();
+    expect(data.astronaut.bowAccuracy).toBeDefined();
+    expect(data.astronaut.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.bowAccuracy).toEqualTypeOf();
+    expect(data.astronaut.damage).toBeDefined();
+    expect(data.astronaut.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.damage).toEqualTypeOf();
+    expect(data.astronaut.damageTaken).toBeDefined();
+    expect(data.astronaut.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.damageTaken).toEqualTypeOf();
+    expect(data.astronaut.potionsDrunk).toBeDefined();
+    expect(data.astronaut.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.potionsDrunk).toEqualTypeOf();
+    expect(data.astronaut.potionsThrown).toBeDefined();
+    expect(data.astronaut.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.potionsThrown).toEqualTypeOf();
+    expect(data.astronaut.playTime).toBeDefined();
+    expect(data.astronaut.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.playTime).toEqualTypeOf();
+    expect(data.astronaut.mobsSpawned).toBeDefined();
+    expect(data.astronaut.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.mobsSpawned).toEqualTypeOf();
+    expect(data.astronaut.chestsOpened).toBeDefined();
+    expect(data.astronaut.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.astronaut.chestsOpened).toEqualTypeOf();
+    expect(data.troll).toBeDefined();
+    expectTypeOf(data.troll).toEqualTypeOf();
+    expect(data.troll.level).toBeDefined();
+    expect(data.troll.level).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.level).toEqualTypeOf();
+    expect(data.troll.exp).toBeDefined();
+    expect(data.troll.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.exp).toEqualTypeOf();
+    expect(data.troll.kills).toBeDefined();
+    expect(data.troll.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.kills).toEqualTypeOf();
+    expect(data.troll.deaths).toBeDefined();
+    expect(data.troll.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.deaths).toEqualTypeOf();
+    expect(data.troll.KDR).toBeDefined();
+    expect(data.troll.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.KDR).toEqualTypeOf();
+    expect(data.troll.wins).toBeDefined();
+    expect(data.troll.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.wins).toEqualTypeOf();
+    expect(data.troll.gamesPlayed).toBeDefined();
+    expect(data.troll.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.gamesPlayed).toEqualTypeOf();
+    expect(data.troll.losses).toBeDefined();
+    expect(data.troll.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.losses).toEqualTypeOf();
+    expect(data.troll.WLR).toBeDefined();
+    expect(data.troll.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.WLR).toEqualTypeOf();
+    expect(data.troll.arrowsShot).toBeDefined();
+    expect(data.troll.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.arrowsShot).toEqualTypeOf();
+    expect(data.troll.arrowsHit).toBeDefined();
+    expect(data.troll.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.arrowsHit).toEqualTypeOf();
+    expect(data.troll.bowAccuracy).toBeDefined();
+    expect(data.troll.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.bowAccuracy).toEqualTypeOf();
+    expect(data.troll.damage).toBeDefined();
+    expect(data.troll.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.damage).toEqualTypeOf();
+    expect(data.troll.damageTaken).toBeDefined();
+    expect(data.troll.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.damageTaken).toEqualTypeOf();
+    expect(data.troll.potionsDrunk).toBeDefined();
+    expect(data.troll.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.potionsDrunk).toEqualTypeOf();
+    expect(data.troll.potionsThrown).toBeDefined();
+    expect(data.troll.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.potionsThrown).toEqualTypeOf();
+    expect(data.troll.playTime).toBeDefined();
+    expect(data.troll.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.playTime).toEqualTypeOf();
+    expect(data.troll.mobsSpawned).toBeDefined();
+    expect(data.troll.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.mobsSpawned).toEqualTypeOf();
+    expect(data.troll.chestsOpened).toBeDefined();
+    expect(data.troll.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.troll.chestsOpened).toEqualTypeOf();
+    expect(data.reaper).toBeDefined();
+    expectTypeOf(data.reaper).toEqualTypeOf();
+    expect(data.reaper.level).toBeDefined();
+    expect(data.reaper.level).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.level).toEqualTypeOf();
+    expect(data.reaper.exp).toBeDefined();
+    expect(data.reaper.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.exp).toEqualTypeOf();
+    expect(data.reaper.kills).toBeDefined();
+    expect(data.reaper.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.kills).toEqualTypeOf();
+    expect(data.reaper.deaths).toBeDefined();
+    expect(data.reaper.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.deaths).toEqualTypeOf();
+    expect(data.reaper.KDR).toBeDefined();
+    expect(data.reaper.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.KDR).toEqualTypeOf();
+    expect(data.reaper.wins).toBeDefined();
+    expect(data.reaper.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.wins).toEqualTypeOf();
+    expect(data.reaper.gamesPlayed).toBeDefined();
+    expect(data.reaper.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.gamesPlayed).toEqualTypeOf();
+    expect(data.reaper.losses).toBeDefined();
+    expect(data.reaper.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.losses).toEqualTypeOf();
+    expect(data.reaper.WLR).toBeDefined();
+    expect(data.reaper.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.WLR).toEqualTypeOf();
+    expect(data.reaper.arrowsShot).toBeDefined();
+    expect(data.reaper.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.arrowsShot).toEqualTypeOf();
+    expect(data.reaper.arrowsHit).toBeDefined();
+    expect(data.reaper.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.arrowsHit).toEqualTypeOf();
+    expect(data.reaper.bowAccuracy).toBeDefined();
+    expect(data.reaper.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.bowAccuracy).toEqualTypeOf();
+    expect(data.reaper.damage).toBeDefined();
+    expect(data.reaper.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.damage).toEqualTypeOf();
+    expect(data.reaper.damageTaken).toBeDefined();
+    expect(data.reaper.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.damageTaken).toEqualTypeOf();
+    expect(data.reaper.potionsDrunk).toBeDefined();
+    expect(data.reaper.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.potionsDrunk).toEqualTypeOf();
+    expect(data.reaper.potionsThrown).toBeDefined();
+    expect(data.reaper.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.potionsThrown).toEqualTypeOf();
+    expect(data.reaper.playTime).toBeDefined();
+    expect(data.reaper.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.playTime).toEqualTypeOf();
+    expect(data.reaper.mobsSpawned).toBeDefined();
+    expect(data.reaper.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.mobsSpawned).toEqualTypeOf();
+    expect(data.reaper.chestsOpened).toBeDefined();
+    expect(data.reaper.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.reaper.chestsOpened).toEqualTypeOf();
+    expect(data.shark).toBeDefined();
+    expectTypeOf(data.shark).toEqualTypeOf();
+    expect(data.shark.level).toBeDefined();
+    expect(data.shark.level).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.level).toEqualTypeOf();
+    expect(data.shark.exp).toBeDefined();
+    expect(data.shark.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.exp).toEqualTypeOf();
+    expect(data.shark.kills).toBeDefined();
+    expect(data.shark.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.kills).toEqualTypeOf();
+    expect(data.shark.deaths).toBeDefined();
+    expect(data.shark.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.deaths).toEqualTypeOf();
+    expect(data.shark.KDR).toBeDefined();
+    expect(data.shark.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.KDR).toEqualTypeOf();
+    expect(data.shark.wins).toBeDefined();
+    expect(data.shark.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.wins).toEqualTypeOf();
+    expect(data.shark.gamesPlayed).toBeDefined();
+    expect(data.shark.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.gamesPlayed).toEqualTypeOf();
+    expect(data.shark.losses).toBeDefined();
+    expect(data.shark.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.losses).toEqualTypeOf();
+    expect(data.shark.WLR).toBeDefined();
+    expect(data.shark.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.WLR).toEqualTypeOf();
+    expect(data.shark.arrowsShot).toBeDefined();
+    expect(data.shark.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.arrowsShot).toEqualTypeOf();
+    expect(data.shark.arrowsHit).toBeDefined();
+    expect(data.shark.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.arrowsHit).toEqualTypeOf();
+    expect(data.shark.bowAccuracy).toBeDefined();
+    expect(data.shark.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.bowAccuracy).toEqualTypeOf();
+    expect(data.shark.damage).toBeDefined();
+    expect(data.shark.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.damage).toEqualTypeOf();
+    expect(data.shark.damageTaken).toBeDefined();
+    expect(data.shark.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.damageTaken).toEqualTypeOf();
+    expect(data.shark.potionsDrunk).toBeDefined();
+    expect(data.shark.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.potionsDrunk).toEqualTypeOf();
+    expect(data.shark.potionsThrown).toBeDefined();
+    expect(data.shark.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.potionsThrown).toEqualTypeOf();
+    expect(data.shark.playTime).toBeDefined();
+    expect(data.shark.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.playTime).toEqualTypeOf();
+    expect(data.shark.mobsSpawned).toBeDefined();
+    expect(data.shark.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.mobsSpawned).toEqualTypeOf();
+    expect(data.shark.chestsOpened).toBeDefined();
+    expect(data.shark.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.shark.chestsOpened).toEqualTypeOf();
+    expect(data.reddragon).toBeDefined();
+    expectTypeOf(data.reddragon).toEqualTypeOf();
+    expect(data.reddragon.level).toBeDefined();
+    expect(data.reddragon.level).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.level).toEqualTypeOf();
+    expect(data.reddragon.exp).toBeDefined();
+    expect(data.reddragon.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.exp).toEqualTypeOf();
+    expect(data.reddragon.kills).toBeDefined();
+    expect(data.reddragon.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.kills).toEqualTypeOf();
+    expect(data.reddragon.deaths).toBeDefined();
+    expect(data.reddragon.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.deaths).toEqualTypeOf();
+    expect(data.reddragon.KDR).toBeDefined();
+    expect(data.reddragon.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.KDR).toEqualTypeOf();
+    expect(data.reddragon.wins).toBeDefined();
+    expect(data.reddragon.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.wins).toEqualTypeOf();
+    expect(data.reddragon.gamesPlayed).toBeDefined();
+    expect(data.reddragon.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.gamesPlayed).toEqualTypeOf();
+    expect(data.reddragon.losses).toBeDefined();
+    expect(data.reddragon.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.losses).toEqualTypeOf();
+    expect(data.reddragon.WLR).toBeDefined();
+    expect(data.reddragon.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.WLR).toEqualTypeOf();
+    expect(data.reddragon.arrowsShot).toBeDefined();
+    expect(data.reddragon.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.arrowsShot).toEqualTypeOf();
+    expect(data.reddragon.arrowsHit).toBeDefined();
+    expect(data.reddragon.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.arrowsHit).toEqualTypeOf();
+    expect(data.reddragon.bowAccuracy).toBeDefined();
+    expect(data.reddragon.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.bowAccuracy).toEqualTypeOf();
+    expect(data.reddragon.damage).toBeDefined();
+    expect(data.reddragon.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.damage).toEqualTypeOf();
+    expect(data.reddragon.damageTaken).toBeDefined();
+    expect(data.reddragon.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.damageTaken).toEqualTypeOf();
+    expect(data.reddragon.potionsDrunk).toBeDefined();
+    expect(data.reddragon.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.potionsDrunk).toEqualTypeOf();
+    expect(data.reddragon.potionsThrown).toBeDefined();
+    expect(data.reddragon.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.potionsThrown).toEqualTypeOf();
+    expect(data.reddragon.playTime).toBeDefined();
+    expect(data.reddragon.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.playTime).toEqualTypeOf();
+    expect(data.reddragon.mobsSpawned).toBeDefined();
+    expect(data.reddragon.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.mobsSpawned).toEqualTypeOf();
+    expect(data.reddragon.chestsOpened).toBeDefined();
+    expect(data.reddragon.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.reddragon.chestsOpened).toEqualTypeOf();
+    expect(data.toxicologist).toBeDefined();
+    expectTypeOf(data.toxicologist).toEqualTypeOf();
+    expect(data.toxicologist.level).toBeDefined();
+    expect(data.toxicologist.level).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.level).toEqualTypeOf();
+    expect(data.toxicologist.exp).toBeDefined();
+    expect(data.toxicologist.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.exp).toEqualTypeOf();
+    expect(data.toxicologist.kills).toBeDefined();
+    expect(data.toxicologist.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.kills).toEqualTypeOf();
+    expect(data.toxicologist.deaths).toBeDefined();
+    expect(data.toxicologist.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.deaths).toEqualTypeOf();
+    expect(data.toxicologist.KDR).toBeDefined();
+    expect(data.toxicologist.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.KDR).toEqualTypeOf();
+    expect(data.toxicologist.wins).toBeDefined();
+    expect(data.toxicologist.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.wins).toEqualTypeOf();
+    expect(data.toxicologist.gamesPlayed).toBeDefined();
+    expect(data.toxicologist.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.gamesPlayed).toEqualTypeOf();
+    expect(data.toxicologist.losses).toBeDefined();
+    expect(data.toxicologist.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.losses).toEqualTypeOf();
+    expect(data.toxicologist.WLR).toBeDefined();
+    expect(data.toxicologist.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.WLR).toEqualTypeOf();
+    expect(data.toxicologist.arrowsShot).toBeDefined();
+    expect(data.toxicologist.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.arrowsShot).toEqualTypeOf();
+    expect(data.toxicologist.arrowsHit).toBeDefined();
+    expect(data.toxicologist.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.arrowsHit).toEqualTypeOf();
+    expect(data.toxicologist.bowAccuracy).toBeDefined();
+    expect(data.toxicologist.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.bowAccuracy).toEqualTypeOf();
+    expect(data.toxicologist.damage).toBeDefined();
+    expect(data.toxicologist.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.damage).toEqualTypeOf();
+    expect(data.toxicologist.damageTaken).toBeDefined();
+    expect(data.toxicologist.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.damageTaken).toEqualTypeOf();
+    expect(data.toxicologist.potionsDrunk).toBeDefined();
+    expect(data.toxicologist.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.potionsDrunk).toEqualTypeOf();
+    expect(data.toxicologist.potionsThrown).toBeDefined();
+    expect(data.toxicologist.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.potionsThrown).toEqualTypeOf();
+    expect(data.toxicologist.playTime).toBeDefined();
+    expect(data.toxicologist.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.playTime).toEqualTypeOf();
+    expect(data.toxicologist.mobsSpawned).toBeDefined();
+    expect(data.toxicologist.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.mobsSpawned).toEqualTypeOf();
+    expect(data.toxicologist.chestsOpened).toBeDefined();
+    expect(data.toxicologist.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.toxicologist.chestsOpened).toEqualTypeOf();
+    expect(data.rogue).toBeDefined();
+    expectTypeOf(data.rogue).toEqualTypeOf();
+    expect(data.rogue.level).toBeDefined();
+    expect(data.rogue.level).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.level).toEqualTypeOf();
+    expect(data.rogue.exp).toBeDefined();
+    expect(data.rogue.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.exp).toEqualTypeOf();
+    expect(data.rogue.kills).toBeDefined();
+    expect(data.rogue.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.kills).toEqualTypeOf();
+    expect(data.rogue.deaths).toBeDefined();
+    expect(data.rogue.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.deaths).toEqualTypeOf();
+    expect(data.rogue.KDR).toBeDefined();
+    expect(data.rogue.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.KDR).toEqualTypeOf();
+    expect(data.rogue.wins).toBeDefined();
+    expect(data.rogue.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.wins).toEqualTypeOf();
+    expect(data.rogue.gamesPlayed).toBeDefined();
+    expect(data.rogue.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.gamesPlayed).toEqualTypeOf();
+    expect(data.rogue.losses).toBeDefined();
+    expect(data.rogue.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.losses).toEqualTypeOf();
+    expect(data.rogue.WLR).toBeDefined();
+    expect(data.rogue.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.WLR).toEqualTypeOf();
+    expect(data.rogue.arrowsShot).toBeDefined();
+    expect(data.rogue.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.arrowsShot).toEqualTypeOf();
+    expect(data.rogue.arrowsHit).toBeDefined();
+    expect(data.rogue.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.arrowsHit).toEqualTypeOf();
+    expect(data.rogue.bowAccuracy).toBeDefined();
+    expect(data.rogue.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.bowAccuracy).toEqualTypeOf();
+    expect(data.rogue.damage).toBeDefined();
+    expect(data.rogue.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.damage).toEqualTypeOf();
+    expect(data.rogue.damageTaken).toBeDefined();
+    expect(data.rogue.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.damageTaken).toEqualTypeOf();
+    expect(data.rogue.potionsDrunk).toBeDefined();
+    expect(data.rogue.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.potionsDrunk).toEqualTypeOf();
+    expect(data.rogue.potionsThrown).toBeDefined();
+    expect(data.rogue.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.potionsThrown).toEqualTypeOf();
+    expect(data.rogue.playTime).toBeDefined();
+    expect(data.rogue.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.playTime).toEqualTypeOf();
+    expect(data.rogue.mobsSpawned).toBeDefined();
+    expect(data.rogue.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.mobsSpawned).toEqualTypeOf();
+    expect(data.rogue.chestsOpened).toBeDefined();
+    expect(data.rogue.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.rogue.chestsOpened).toEqualTypeOf();
+    expect(data.warlock).toBeDefined();
+    expectTypeOf(data.warlock).toEqualTypeOf();
+    expect(data.warlock.level).toBeDefined();
+    expect(data.warlock.level).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.level).toEqualTypeOf();
+    expect(data.warlock.exp).toBeDefined();
+    expect(data.warlock.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.exp).toEqualTypeOf();
+    expect(data.warlock.kills).toBeDefined();
+    expect(data.warlock.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.kills).toEqualTypeOf();
+    expect(data.warlock.deaths).toBeDefined();
+    expect(data.warlock.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.deaths).toEqualTypeOf();
+    expect(data.warlock.KDR).toBeDefined();
+    expect(data.warlock.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.KDR).toEqualTypeOf();
+    expect(data.warlock.wins).toBeDefined();
+    expect(data.warlock.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.wins).toEqualTypeOf();
+    expect(data.warlock.gamesPlayed).toBeDefined();
+    expect(data.warlock.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.gamesPlayed).toEqualTypeOf();
+    expect(data.warlock.losses).toBeDefined();
+    expect(data.warlock.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.losses).toEqualTypeOf();
+    expect(data.warlock.WLR).toBeDefined();
+    expect(data.warlock.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.WLR).toEqualTypeOf();
+    expect(data.warlock.arrowsShot).toBeDefined();
+    expect(data.warlock.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.arrowsShot).toEqualTypeOf();
+    expect(data.warlock.arrowsHit).toBeDefined();
+    expect(data.warlock.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.arrowsHit).toEqualTypeOf();
+    expect(data.warlock.bowAccuracy).toBeDefined();
+    expect(data.warlock.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.bowAccuracy).toEqualTypeOf();
+    expect(data.warlock.damage).toBeDefined();
+    expect(data.warlock.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.damage).toEqualTypeOf();
+    expect(data.warlock.damageTaken).toBeDefined();
+    expect(data.warlock.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.damageTaken).toEqualTypeOf();
+    expect(data.warlock.potionsDrunk).toBeDefined();
+    expect(data.warlock.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.potionsDrunk).toEqualTypeOf();
+    expect(data.warlock.potionsThrown).toBeDefined();
+    expect(data.warlock.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.potionsThrown).toEqualTypeOf();
+    expect(data.warlock.playTime).toBeDefined();
+    expect(data.warlock.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.playTime).toEqualTypeOf();
+    expect(data.warlock.mobsSpawned).toBeDefined();
+    expect(data.warlock.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.mobsSpawned).toEqualTypeOf();
+    expect(data.warlock.chestsOpened).toBeDefined();
+    expect(data.warlock.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.warlock.chestsOpened).toEqualTypeOf();
+    expect(data.slimeyslime).toBeDefined();
+    expectTypeOf(data.slimeyslime).toEqualTypeOf();
+    expect(data.slimeyslime.level).toBeDefined();
+    expect(data.slimeyslime.level).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.level).toEqualTypeOf();
+    expect(data.slimeyslime.exp).toBeDefined();
+    expect(data.slimeyslime.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.exp).toEqualTypeOf();
+    expect(data.slimeyslime.kills).toBeDefined();
+    expect(data.slimeyslime.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.kills).toEqualTypeOf();
+    expect(data.slimeyslime.deaths).toBeDefined();
+    expect(data.slimeyslime.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.deaths).toEqualTypeOf();
+    expect(data.slimeyslime.KDR).toBeDefined();
+    expect(data.slimeyslime.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.KDR).toEqualTypeOf();
+    expect(data.slimeyslime.wins).toBeDefined();
+    expect(data.slimeyslime.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.wins).toEqualTypeOf();
+    expect(data.slimeyslime.gamesPlayed).toBeDefined();
+    expect(data.slimeyslime.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.gamesPlayed).toEqualTypeOf();
+    expect(data.slimeyslime.losses).toBeDefined();
+    expect(data.slimeyslime.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.losses).toEqualTypeOf();
+    expect(data.slimeyslime.WLR).toBeDefined();
+    expect(data.slimeyslime.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.WLR).toEqualTypeOf();
+    expect(data.slimeyslime.arrowsShot).toBeDefined();
+    expect(data.slimeyslime.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.arrowsShot).toEqualTypeOf();
+    expect(data.slimeyslime.arrowsHit).toBeDefined();
+    expect(data.slimeyslime.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.arrowsHit).toEqualTypeOf();
+    expect(data.slimeyslime.bowAccuracy).toBeDefined();
+    expect(data.slimeyslime.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.bowAccuracy).toEqualTypeOf();
+    expect(data.slimeyslime.damage).toBeDefined();
+    expect(data.slimeyslime.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.damage).toEqualTypeOf();
+    expect(data.slimeyslime.damageTaken).toBeDefined();
+    expect(data.slimeyslime.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.damageTaken).toEqualTypeOf();
+    expect(data.slimeyslime.potionsDrunk).toBeDefined();
+    expect(data.slimeyslime.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.potionsDrunk).toEqualTypeOf();
+    expect(data.slimeyslime.potionsThrown).toBeDefined();
+    expect(data.slimeyslime.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.potionsThrown).toEqualTypeOf();
+    expect(data.slimeyslime.playTime).toBeDefined();
+    expect(data.slimeyslime.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.playTime).toEqualTypeOf();
+    expect(data.slimeyslime.mobsSpawned).toBeDefined();
+    expect(data.slimeyslime.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.mobsSpawned).toEqualTypeOf();
+    expect(data.slimeyslime.chestsOpened).toBeDefined();
+    expect(data.slimeyslime.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.slimeyslime.chestsOpened).toEqualTypeOf();
+    expect(data.jockey).toBeDefined();
+    expectTypeOf(data.jockey).toEqualTypeOf();
+    expect(data.jockey.level).toBeDefined();
+    expect(data.jockey.level).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.level).toEqualTypeOf();
+    expect(data.jockey.exp).toBeDefined();
+    expect(data.jockey.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.exp).toEqualTypeOf();
+    expect(data.jockey.kills).toBeDefined();
+    expect(data.jockey.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.kills).toEqualTypeOf();
+    expect(data.jockey.deaths).toBeDefined();
+    expect(data.jockey.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.deaths).toEqualTypeOf();
+    expect(data.jockey.KDR).toBeDefined();
+    expect(data.jockey.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.KDR).toEqualTypeOf();
+    expect(data.jockey.wins).toBeDefined();
+    expect(data.jockey.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.wins).toEqualTypeOf();
+    expect(data.jockey.gamesPlayed).toBeDefined();
+    expect(data.jockey.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.gamesPlayed).toEqualTypeOf();
+    expect(data.jockey.losses).toBeDefined();
+    expect(data.jockey.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.losses).toEqualTypeOf();
+    expect(data.jockey.WLR).toBeDefined();
+    expect(data.jockey.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.WLR).toEqualTypeOf();
+    expect(data.jockey.arrowsShot).toBeDefined();
+    expect(data.jockey.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.arrowsShot).toEqualTypeOf();
+    expect(data.jockey.arrowsHit).toBeDefined();
+    expect(data.jockey.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.arrowsHit).toEqualTypeOf();
+    expect(data.jockey.bowAccuracy).toBeDefined();
+    expect(data.jockey.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.bowAccuracy).toEqualTypeOf();
+    expect(data.jockey.damage).toBeDefined();
+    expect(data.jockey.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.damage).toEqualTypeOf();
+    expect(data.jockey.damageTaken).toBeDefined();
+    expect(data.jockey.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.damageTaken).toEqualTypeOf();
+    expect(data.jockey.potionsDrunk).toBeDefined();
+    expect(data.jockey.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.potionsDrunk).toEqualTypeOf();
+    expect(data.jockey.potionsThrown).toBeDefined();
+    expect(data.jockey.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.potionsThrown).toEqualTypeOf();
+    expect(data.jockey.playTime).toBeDefined();
+    expect(data.jockey.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.playTime).toEqualTypeOf();
+    expect(data.jockey.mobsSpawned).toBeDefined();
+    expect(data.jockey.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.mobsSpawned).toEqualTypeOf();
+    expect(data.jockey.chestsOpened).toBeDefined();
+    expect(data.jockey.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.jockey.chestsOpened).toEqualTypeOf();
+    expect(data.golem).toBeDefined();
+    expectTypeOf(data.golem).toEqualTypeOf();
+    expect(data.golem.level).toBeDefined();
+    expect(data.golem.level).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.level).toEqualTypeOf();
+    expect(data.golem.exp).toBeDefined();
+    expect(data.golem.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.exp).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.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.losses).toBeDefined();
+    expect(data.golem.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.losses).toEqualTypeOf();
+    expect(data.golem.WLR).toBeDefined();
+    expect(data.golem.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.WLR).toEqualTypeOf();
+    expect(data.golem.arrowsShot).toBeDefined();
+    expect(data.golem.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.arrowsShot).toEqualTypeOf();
+    expect(data.golem.arrowsHit).toBeDefined();
+    expect(data.golem.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.arrowsHit).toEqualTypeOf();
+    expect(data.golem.bowAccuracy).toBeDefined();
+    expect(data.golem.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.bowAccuracy).toEqualTypeOf();
+    expect(data.golem.damage).toBeDefined();
+    expect(data.golem.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.damage).toEqualTypeOf();
+    expect(data.golem.damageTaken).toBeDefined();
+    expect(data.golem.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.damageTaken).toEqualTypeOf();
+    expect(data.golem.potionsDrunk).toBeDefined();
+    expect(data.golem.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.potionsDrunk).toEqualTypeOf();
+    expect(data.golem.potionsThrown).toBeDefined();
+    expect(data.golem.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.potionsThrown).toEqualTypeOf();
+    expect(data.golem.playTime).toBeDefined();
+    expect(data.golem.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.playTime).toEqualTypeOf();
+    expect(data.golem.mobsSpawned).toBeDefined();
+    expect(data.golem.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.mobsSpawned).toEqualTypeOf();
+    expect(data.golem.chestsOpened).toBeDefined();
+    expect(data.golem.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.golem.chestsOpened).toEqualTypeOf();
+    expect(data.viking).toBeDefined();
+    expectTypeOf(data.viking).toEqualTypeOf();
+    expect(data.viking.level).toBeDefined();
+    expect(data.viking.level).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.level).toEqualTypeOf();
+    expect(data.viking.exp).toBeDefined();
+    expect(data.viking.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.exp).toEqualTypeOf();
+    expect(data.viking.kills).toBeDefined();
+    expect(data.viking.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.kills).toEqualTypeOf();
+    expect(data.viking.deaths).toBeDefined();
+    expect(data.viking.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.deaths).toEqualTypeOf();
+    expect(data.viking.KDR).toBeDefined();
+    expect(data.viking.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.KDR).toEqualTypeOf();
+    expect(data.viking.wins).toBeDefined();
+    expect(data.viking.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.wins).toEqualTypeOf();
+    expect(data.viking.gamesPlayed).toBeDefined();
+    expect(data.viking.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.gamesPlayed).toEqualTypeOf();
+    expect(data.viking.losses).toBeDefined();
+    expect(data.viking.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.losses).toEqualTypeOf();
+    expect(data.viking.WLR).toBeDefined();
+    expect(data.viking.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.WLR).toEqualTypeOf();
+    expect(data.viking.arrowsShot).toBeDefined();
+    expect(data.viking.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.arrowsShot).toEqualTypeOf();
+    expect(data.viking.arrowsHit).toBeDefined();
+    expect(data.viking.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.arrowsHit).toEqualTypeOf();
+    expect(data.viking.bowAccuracy).toBeDefined();
+    expect(data.viking.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.bowAccuracy).toEqualTypeOf();
+    expect(data.viking.damage).toBeDefined();
+    expect(data.viking.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.damage).toEqualTypeOf();
+    expect(data.viking.damageTaken).toBeDefined();
+    expect(data.viking.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.damageTaken).toEqualTypeOf();
+    expect(data.viking.potionsDrunk).toBeDefined();
+    expect(data.viking.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.potionsDrunk).toEqualTypeOf();
+    expect(data.viking.potionsThrown).toBeDefined();
+    expect(data.viking.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.potionsThrown).toEqualTypeOf();
+    expect(data.viking.playTime).toBeDefined();
+    expect(data.viking.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.playTime).toEqualTypeOf();
+    expect(data.viking.mobsSpawned).toBeDefined();
+    expect(data.viking.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.mobsSpawned).toEqualTypeOf();
+    expect(data.viking.chestsOpened).toBeDefined();
+    expect(data.viking.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.viking.chestsOpened).toEqualTypeOf();
+    expect(data.shadowKnight).toBeDefined();
+    expectTypeOf(data.shadowKnight).toEqualTypeOf();
+    expect(data.shadowKnight.level).toBeDefined();
+    expect(data.shadowKnight.level).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.level).toEqualTypeOf();
+    expect(data.shadowKnight.exp).toBeDefined();
+    expect(data.shadowKnight.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.exp).toEqualTypeOf();
+    expect(data.shadowKnight.kills).toBeDefined();
+    expect(data.shadowKnight.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.kills).toEqualTypeOf();
+    expect(data.shadowKnight.deaths).toBeDefined();
+    expect(data.shadowKnight.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.deaths).toEqualTypeOf();
+    expect(data.shadowKnight.KDR).toBeDefined();
+    expect(data.shadowKnight.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.KDR).toEqualTypeOf();
+    expect(data.shadowKnight.wins).toBeDefined();
+    expect(data.shadowKnight.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.wins).toEqualTypeOf();
+    expect(data.shadowKnight.gamesPlayed).toBeDefined();
+    expect(data.shadowKnight.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.gamesPlayed).toEqualTypeOf();
+    expect(data.shadowKnight.losses).toBeDefined();
+    expect(data.shadowKnight.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.losses).toEqualTypeOf();
+    expect(data.shadowKnight.WLR).toBeDefined();
+    expect(data.shadowKnight.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.WLR).toEqualTypeOf();
+    expect(data.shadowKnight.arrowsShot).toBeDefined();
+    expect(data.shadowKnight.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.arrowsShot).toEqualTypeOf();
+    expect(data.shadowKnight.arrowsHit).toBeDefined();
+    expect(data.shadowKnight.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.arrowsHit).toEqualTypeOf();
+    expect(data.shadowKnight.bowAccuracy).toBeDefined();
+    expect(data.shadowKnight.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.bowAccuracy).toEqualTypeOf();
+    expect(data.shadowKnight.damage).toBeDefined();
+    expect(data.shadowKnight.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.damage).toEqualTypeOf();
+    expect(data.shadowKnight.damageTaken).toBeDefined();
+    expect(data.shadowKnight.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.damageTaken).toEqualTypeOf();
+    expect(data.shadowKnight.potionsDrunk).toBeDefined();
+    expect(data.shadowKnight.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.potionsDrunk).toEqualTypeOf();
+    expect(data.shadowKnight.potionsThrown).toBeDefined();
+    expect(data.shadowKnight.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.potionsThrown).toEqualTypeOf();
+    expect(data.shadowKnight.playTime).toBeDefined();
+    expect(data.shadowKnight.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.playTime).toEqualTypeOf();
+    expect(data.shadowKnight.mobsSpawned).toBeDefined();
+    expect(data.shadowKnight.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.mobsSpawned).toEqualTypeOf();
+    expect(data.shadowKnight.chestsOpened).toBeDefined();
+    expect(data.shadowKnight.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.shadowKnight.chestsOpened).toEqualTypeOf();
+    expect(data.pigman).toBeDefined();
+    expectTypeOf(data.pigman).toEqualTypeOf();
+    expect(data.pigman.level).toBeDefined();
+    expect(data.pigman.level).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.level).toEqualTypeOf();
+    expect(data.pigman.exp).toBeDefined();
+    expect(data.pigman.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.exp).toEqualTypeOf();
+    expect(data.pigman.kills).toBeDefined();
+    expect(data.pigman.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.kills).toEqualTypeOf();
+    expect(data.pigman.deaths).toBeDefined();
+    expect(data.pigman.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.deaths).toEqualTypeOf();
+    expect(data.pigman.KDR).toBeDefined();
+    expect(data.pigman.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.KDR).toEqualTypeOf();
+    expect(data.pigman.wins).toBeDefined();
+    expect(data.pigman.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.wins).toEqualTypeOf();
+    expect(data.pigman.gamesPlayed).toBeDefined();
+    expect(data.pigman.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.gamesPlayed).toEqualTypeOf();
+    expect(data.pigman.losses).toBeDefined();
+    expect(data.pigman.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.losses).toEqualTypeOf();
+    expect(data.pigman.WLR).toBeDefined();
+    expect(data.pigman.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.WLR).toEqualTypeOf();
+    expect(data.pigman.arrowsShot).toBeDefined();
+    expect(data.pigman.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.arrowsShot).toEqualTypeOf();
+    expect(data.pigman.arrowsHit).toBeDefined();
+    expect(data.pigman.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.arrowsHit).toEqualTypeOf();
+    expect(data.pigman.bowAccuracy).toBeDefined();
+    expect(data.pigman.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.bowAccuracy).toEqualTypeOf();
+    expect(data.pigman.damage).toBeDefined();
+    expect(data.pigman.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.damage).toEqualTypeOf();
+    expect(data.pigman.damageTaken).toBeDefined();
+    expect(data.pigman.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.damageTaken).toEqualTypeOf();
+    expect(data.pigman.potionsDrunk).toBeDefined();
+    expect(data.pigman.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.potionsDrunk).toEqualTypeOf();
+    expect(data.pigman.potionsThrown).toBeDefined();
+    expect(data.pigman.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.potionsThrown).toEqualTypeOf();
+    expect(data.pigman.playTime).toBeDefined();
+    expect(data.pigman.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.playTime).toEqualTypeOf();
+    expect(data.pigman.mobsSpawned).toBeDefined();
+    expect(data.pigman.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.mobsSpawned).toEqualTypeOf();
+    expect(data.pigman.chestsOpened).toBeDefined();
+    expect(data.pigman.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.pigman.chestsOpened).toEqualTypeOf();
+    expect(data.paladin).toBeDefined();
+    expectTypeOf(data.paladin).toEqualTypeOf();
+    expect(data.paladin.level).toBeDefined();
+    expect(data.paladin.level).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.level).toEqualTypeOf();
+    expect(data.paladin.exp).toBeDefined();
+    expect(data.paladin.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.exp).toEqualTypeOf();
+    expect(data.paladin.kills).toBeDefined();
+    expect(data.paladin.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.kills).toEqualTypeOf();
+    expect(data.paladin.deaths).toBeDefined();
+    expect(data.paladin.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.deaths).toEqualTypeOf();
+    expect(data.paladin.KDR).toBeDefined();
+    expect(data.paladin.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.KDR).toEqualTypeOf();
+    expect(data.paladin.wins).toBeDefined();
+    expect(data.paladin.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.wins).toEqualTypeOf();
+    expect(data.paladin.gamesPlayed).toBeDefined();
+    expect(data.paladin.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.gamesPlayed).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.arrowsShot).toBeDefined();
+    expect(data.paladin.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.arrowsShot).toEqualTypeOf();
+    expect(data.paladin.arrowsHit).toBeDefined();
+    expect(data.paladin.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.arrowsHit).toEqualTypeOf();
+    expect(data.paladin.bowAccuracy).toBeDefined();
+    expect(data.paladin.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.bowAccuracy).toEqualTypeOf();
+    expect(data.paladin.damage).toBeDefined();
+    expect(data.paladin.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.damage).toEqualTypeOf();
+    expect(data.paladin.damageTaken).toBeDefined();
+    expect(data.paladin.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.damageTaken).toEqualTypeOf();
+    expect(data.paladin.potionsDrunk).toBeDefined();
+    expect(data.paladin.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.potionsDrunk).toEqualTypeOf();
+    expect(data.paladin.potionsThrown).toBeDefined();
+    expect(data.paladin.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.potionsThrown).toEqualTypeOf();
+    expect(data.paladin.playTime).toBeDefined();
+    expect(data.paladin.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.playTime).toEqualTypeOf();
+    expect(data.paladin.mobsSpawned).toBeDefined();
+    expect(data.paladin.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.mobsSpawned).toEqualTypeOf();
+    expect(data.paladin.chestsOpened).toBeDefined();
+    expect(data.paladin.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.paladin.chestsOpened).toEqualTypeOf();
+    expect(data.necromancer).toBeDefined();
+    expectTypeOf(data.necromancer).toEqualTypeOf();
+    expect(data.necromancer.level).toBeDefined();
+    expect(data.necromancer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.level).toEqualTypeOf();
+    expect(data.necromancer.exp).toBeDefined();
+    expect(data.necromancer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.exp).toEqualTypeOf();
+    expect(data.necromancer.kills).toBeDefined();
+    expect(data.necromancer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.kills).toEqualTypeOf();
+    expect(data.necromancer.deaths).toBeDefined();
+    expect(data.necromancer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.deaths).toEqualTypeOf();
+    expect(data.necromancer.KDR).toBeDefined();
+    expect(data.necromancer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.KDR).toEqualTypeOf();
+    expect(data.necromancer.wins).toBeDefined();
+    expect(data.necromancer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.wins).toEqualTypeOf();
+    expect(data.necromancer.gamesPlayed).toBeDefined();
+    expect(data.necromancer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.gamesPlayed).toEqualTypeOf();
+    expect(data.necromancer.losses).toBeDefined();
+    expect(data.necromancer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.losses).toEqualTypeOf();
+    expect(data.necromancer.WLR).toBeDefined();
+    expect(data.necromancer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.WLR).toEqualTypeOf();
+    expect(data.necromancer.arrowsShot).toBeDefined();
+    expect(data.necromancer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.arrowsShot).toEqualTypeOf();
+    expect(data.necromancer.arrowsHit).toBeDefined();
+    expect(data.necromancer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.arrowsHit).toEqualTypeOf();
+    expect(data.necromancer.bowAccuracy).toBeDefined();
+    expect(data.necromancer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.bowAccuracy).toEqualTypeOf();
+    expect(data.necromancer.damage).toBeDefined();
+    expect(data.necromancer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.damage).toEqualTypeOf();
+    expect(data.necromancer.damageTaken).toBeDefined();
+    expect(data.necromancer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.damageTaken).toEqualTypeOf();
+    expect(data.necromancer.potionsDrunk).toBeDefined();
+    expect(data.necromancer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.potionsDrunk).toEqualTypeOf();
+    expect(data.necromancer.potionsThrown).toBeDefined();
+    expect(data.necromancer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.potionsThrown).toEqualTypeOf();
+    expect(data.necromancer.playTime).toBeDefined();
+    expect(data.necromancer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.playTime).toEqualTypeOf();
+    expect(data.necromancer.mobsSpawned).toBeDefined();
+    expect(data.necromancer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.mobsSpawned).toEqualTypeOf();
+    expect(data.necromancer.chestsOpened).toBeDefined();
+    expect(data.necromancer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.necromancer.chestsOpened).toEqualTypeOf();
+    expect(data.florist).toBeDefined();
+    expectTypeOf(data.florist).toEqualTypeOf();
+    expect(data.florist.level).toBeDefined();
+    expect(data.florist.level).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.level).toEqualTypeOf();
+    expect(data.florist.exp).toBeDefined();
+    expect(data.florist.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.exp).toEqualTypeOf();
+    expect(data.florist.kills).toBeDefined();
+    expect(data.florist.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.kills).toEqualTypeOf();
+    expect(data.florist.deaths).toBeDefined();
+    expect(data.florist.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.deaths).toEqualTypeOf();
+    expect(data.florist.KDR).toBeDefined();
+    expect(data.florist.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.KDR).toEqualTypeOf();
+    expect(data.florist.wins).toBeDefined();
+    expect(data.florist.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.wins).toEqualTypeOf();
+    expect(data.florist.gamesPlayed).toBeDefined();
+    expect(data.florist.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.gamesPlayed).toEqualTypeOf();
+    expect(data.florist.losses).toBeDefined();
+    expect(data.florist.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.losses).toEqualTypeOf();
+    expect(data.florist.WLR).toBeDefined();
+    expect(data.florist.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.WLR).toEqualTypeOf();
+    expect(data.florist.arrowsShot).toBeDefined();
+    expect(data.florist.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.arrowsShot).toEqualTypeOf();
+    expect(data.florist.arrowsHit).toBeDefined();
+    expect(data.florist.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.arrowsHit).toEqualTypeOf();
+    expect(data.florist.bowAccuracy).toBeDefined();
+    expect(data.florist.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.bowAccuracy).toEqualTypeOf();
+    expect(data.florist.damage).toBeDefined();
+    expect(data.florist.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.damage).toEqualTypeOf();
+    expect(data.florist.damageTaken).toBeDefined();
+    expect(data.florist.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.damageTaken).toEqualTypeOf();
+    expect(data.florist.potionsDrunk).toBeDefined();
+    expect(data.florist.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.potionsDrunk).toEqualTypeOf();
+    expect(data.florist.potionsThrown).toBeDefined();
+    expect(data.florist.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.potionsThrown).toEqualTypeOf();
+    expect(data.florist.playTime).toBeDefined();
+    expect(data.florist.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.playTime).toEqualTypeOf();
+    expect(data.florist.mobsSpawned).toBeDefined();
+    expect(data.florist.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.mobsSpawned).toEqualTypeOf();
+    expect(data.florist.chestsOpened).toBeDefined();
+    expect(data.florist.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.florist.chestsOpened).toEqualTypeOf();
+    expect(data.diver).toBeDefined();
+    expectTypeOf(data.diver).toEqualTypeOf();
+    expect(data.diver.level).toBeDefined();
+    expect(data.diver.level).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.level).toEqualTypeOf();
+    expect(data.diver.exp).toBeDefined();
+    expect(data.diver.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.exp).toEqualTypeOf();
+    expect(data.diver.kills).toBeDefined();
+    expect(data.diver.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.kills).toEqualTypeOf();
+    expect(data.diver.deaths).toBeDefined();
+    expect(data.diver.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.deaths).toEqualTypeOf();
+    expect(data.diver.KDR).toBeDefined();
+    expect(data.diver.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.KDR).toEqualTypeOf();
+    expect(data.diver.wins).toBeDefined();
+    expect(data.diver.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.wins).toEqualTypeOf();
+    expect(data.diver.gamesPlayed).toBeDefined();
+    expect(data.diver.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.gamesPlayed).toEqualTypeOf();
+    expect(data.diver.losses).toBeDefined();
+    expect(data.diver.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.losses).toEqualTypeOf();
+    expect(data.diver.WLR).toBeDefined();
+    expect(data.diver.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.WLR).toEqualTypeOf();
+    expect(data.diver.arrowsShot).toBeDefined();
+    expect(data.diver.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.arrowsShot).toEqualTypeOf();
+    expect(data.diver.arrowsHit).toBeDefined();
+    expect(data.diver.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.arrowsHit).toEqualTypeOf();
+    expect(data.diver.bowAccuracy).toBeDefined();
+    expect(data.diver.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.bowAccuracy).toEqualTypeOf();
+    expect(data.diver.damage).toBeDefined();
+    expect(data.diver.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.damage).toEqualTypeOf();
+    expect(data.diver.damageTaken).toBeDefined();
+    expect(data.diver.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.damageTaken).toEqualTypeOf();
+    expect(data.diver.potionsDrunk).toBeDefined();
+    expect(data.diver.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.potionsDrunk).toEqualTypeOf();
+    expect(data.diver.potionsThrown).toBeDefined();
+    expect(data.diver.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.potionsThrown).toEqualTypeOf();
+    expect(data.diver.playTime).toBeDefined();
+    expect(data.diver.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.playTime).toEqualTypeOf();
+    expect(data.diver.mobsSpawned).toBeDefined();
+    expect(data.diver.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.mobsSpawned).toEqualTypeOf();
+    expect(data.diver.chestsOpened).toBeDefined();
+    expect(data.diver.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.diver.chestsOpened).toEqualTypeOf();
+    expect(data.arachnologist).toBeDefined();
+    expectTypeOf(data.arachnologist).toEqualTypeOf();
+    expect(data.arachnologist.level).toBeDefined();
+    expect(data.arachnologist.level).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.level).toEqualTypeOf();
+    expect(data.arachnologist.exp).toBeDefined();
+    expect(data.arachnologist.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.exp).toEqualTypeOf();
+    expect(data.arachnologist.kills).toBeDefined();
+    expect(data.arachnologist.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.kills).toEqualTypeOf();
+    expect(data.arachnologist.deaths).toBeDefined();
+    expect(data.arachnologist.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.deaths).toEqualTypeOf();
+    expect(data.arachnologist.KDR).toBeDefined();
+    expect(data.arachnologist.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.KDR).toEqualTypeOf();
+    expect(data.arachnologist.wins).toBeDefined();
+    expect(data.arachnologist.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.wins).toEqualTypeOf();
+    expect(data.arachnologist.gamesPlayed).toBeDefined();
+    expect(data.arachnologist.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.gamesPlayed).toEqualTypeOf();
+    expect(data.arachnologist.losses).toBeDefined();
+    expect(data.arachnologist.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.losses).toEqualTypeOf();
+    expect(data.arachnologist.WLR).toBeDefined();
+    expect(data.arachnologist.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.WLR).toEqualTypeOf();
+    expect(data.arachnologist.arrowsShot).toBeDefined();
+    expect(data.arachnologist.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.arrowsShot).toEqualTypeOf();
+    expect(data.arachnologist.arrowsHit).toBeDefined();
+    expect(data.arachnologist.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.arrowsHit).toEqualTypeOf();
+    expect(data.arachnologist.bowAccuracy).toBeDefined();
+    expect(data.arachnologist.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.bowAccuracy).toEqualTypeOf();
+    expect(data.arachnologist.damage).toBeDefined();
+    expect(data.arachnologist.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.damage).toEqualTypeOf();
+    expect(data.arachnologist.damageTaken).toBeDefined();
+    expect(data.arachnologist.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.damageTaken).toEqualTypeOf();
+    expect(data.arachnologist.potionsDrunk).toBeDefined();
+    expect(data.arachnologist.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.potionsDrunk).toEqualTypeOf();
+    expect(data.arachnologist.potionsThrown).toBeDefined();
+    expect(data.arachnologist.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.potionsThrown).toEqualTypeOf();
+    expect(data.arachnologist.playTime).toBeDefined();
+    expect(data.arachnologist.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.playTime).toEqualTypeOf();
+    expect(data.arachnologist.mobsSpawned).toBeDefined();
+    expect(data.arachnologist.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.mobsSpawned).toEqualTypeOf();
+    expect(data.arachnologist.chestsOpened).toBeDefined();
+    expect(data.arachnologist.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.arachnologist.chestsOpened).toEqualTypeOf();
+    expect(data.blaze).toBeDefined();
+    expectTypeOf(data.blaze).toEqualTypeOf();
+    expect(data.blaze.level).toBeDefined();
+    expect(data.blaze.level).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.level).toEqualTypeOf();
+    expect(data.blaze.exp).toBeDefined();
+    expect(data.blaze.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.exp).toEqualTypeOf();
+    expect(data.blaze.kills).toBeDefined();
+    expect(data.blaze.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.kills).toEqualTypeOf();
+    expect(data.blaze.deaths).toBeDefined();
+    expect(data.blaze.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.deaths).toEqualTypeOf();
+    expect(data.blaze.KDR).toBeDefined();
+    expect(data.blaze.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.KDR).toEqualTypeOf();
+    expect(data.blaze.wins).toBeDefined();
+    expect(data.blaze.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.wins).toEqualTypeOf();
+    expect(data.blaze.gamesPlayed).toBeDefined();
+    expect(data.blaze.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.gamesPlayed).toEqualTypeOf();
+    expect(data.blaze.losses).toBeDefined();
+    expect(data.blaze.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.losses).toEqualTypeOf();
+    expect(data.blaze.WLR).toBeDefined();
+    expect(data.blaze.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.WLR).toEqualTypeOf();
+    expect(data.blaze.arrowsShot).toBeDefined();
+    expect(data.blaze.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.arrowsShot).toEqualTypeOf();
+    expect(data.blaze.arrowsHit).toBeDefined();
+    expect(data.blaze.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.arrowsHit).toEqualTypeOf();
+    expect(data.blaze.bowAccuracy).toBeDefined();
+    expect(data.blaze.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.bowAccuracy).toEqualTypeOf();
+    expect(data.blaze.damage).toBeDefined();
+    expect(data.blaze.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.damage).toEqualTypeOf();
+    expect(data.blaze.damageTaken).toBeDefined();
+    expect(data.blaze.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.damageTaken).toEqualTypeOf();
+    expect(data.blaze.potionsDrunk).toBeDefined();
+    expect(data.blaze.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.potionsDrunk).toEqualTypeOf();
+    expect(data.blaze.potionsThrown).toBeDefined();
+    expect(data.blaze.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.potionsThrown).toEqualTypeOf();
+    expect(data.blaze.playTime).toBeDefined();
+    expect(data.blaze.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.playTime).toEqualTypeOf();
+    expect(data.blaze.mobsSpawned).toBeDefined();
+    expect(data.blaze.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.mobsSpawned).toEqualTypeOf();
+    expect(data.blaze.chestsOpened).toBeDefined();
+    expect(data.blaze.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.blaze.chestsOpened).toEqualTypeOf();
+    expect(data.wolftamer).toBeDefined();
+    expectTypeOf(data.wolftamer).toEqualTypeOf();
+    expect(data.wolftamer.level).toBeDefined();
+    expect(data.wolftamer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.level).toEqualTypeOf();
+    expect(data.wolftamer.exp).toBeDefined();
+    expect(data.wolftamer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.exp).toEqualTypeOf();
+    expect(data.wolftamer.kills).toBeDefined();
+    expect(data.wolftamer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.kills).toEqualTypeOf();
+    expect(data.wolftamer.deaths).toBeDefined();
+    expect(data.wolftamer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.deaths).toEqualTypeOf();
+    expect(data.wolftamer.KDR).toBeDefined();
+    expect(data.wolftamer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.KDR).toEqualTypeOf();
+    expect(data.wolftamer.wins).toBeDefined();
+    expect(data.wolftamer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.wins).toEqualTypeOf();
+    expect(data.wolftamer.gamesPlayed).toBeDefined();
+    expect(data.wolftamer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.gamesPlayed).toEqualTypeOf();
+    expect(data.wolftamer.losses).toBeDefined();
+    expect(data.wolftamer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.losses).toEqualTypeOf();
+    expect(data.wolftamer.WLR).toBeDefined();
+    expect(data.wolftamer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.WLR).toEqualTypeOf();
+    expect(data.wolftamer.arrowsShot).toBeDefined();
+    expect(data.wolftamer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.arrowsShot).toEqualTypeOf();
+    expect(data.wolftamer.arrowsHit).toBeDefined();
+    expect(data.wolftamer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.arrowsHit).toEqualTypeOf();
+    expect(data.wolftamer.bowAccuracy).toBeDefined();
+    expect(data.wolftamer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.bowAccuracy).toEqualTypeOf();
+    expect(data.wolftamer.damage).toBeDefined();
+    expect(data.wolftamer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.damage).toEqualTypeOf();
+    expect(data.wolftamer.damageTaken).toBeDefined();
+    expect(data.wolftamer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.damageTaken).toEqualTypeOf();
+    expect(data.wolftamer.potionsDrunk).toBeDefined();
+    expect(data.wolftamer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.potionsDrunk).toEqualTypeOf();
+    expect(data.wolftamer.potionsThrown).toBeDefined();
+    expect(data.wolftamer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.potionsThrown).toEqualTypeOf();
+    expect(data.wolftamer.playTime).toBeDefined();
+    expect(data.wolftamer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.playTime).toEqualTypeOf();
+    expect(data.wolftamer.mobsSpawned).toBeDefined();
+    expect(data.wolftamer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.mobsSpawned).toEqualTypeOf();
+    expect(data.wolftamer.chestsOpened).toBeDefined();
+    expect(data.wolftamer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.wolftamer.chestsOpened).toEqualTypeOf();
+    expect(data.tim).toBeDefined();
+    expectTypeOf(data.tim).toEqualTypeOf();
+    expect(data.tim.level).toBeDefined();
+    expect(data.tim.level).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.level).toEqualTypeOf();
+    expect(data.tim.exp).toBeDefined();
+    expect(data.tim.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.exp).toEqualTypeOf();
+    expect(data.tim.kills).toBeDefined();
+    expect(data.tim.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.kills).toEqualTypeOf();
+    expect(data.tim.deaths).toBeDefined();
+    expect(data.tim.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.deaths).toEqualTypeOf();
+    expect(data.tim.KDR).toBeDefined();
+    expect(data.tim.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.KDR).toEqualTypeOf();
+    expect(data.tim.wins).toBeDefined();
+    expect(data.tim.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.wins).toEqualTypeOf();
+    expect(data.tim.gamesPlayed).toBeDefined();
+    expect(data.tim.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.gamesPlayed).toEqualTypeOf();
+    expect(data.tim.losses).toBeDefined();
+    expect(data.tim.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.losses).toEqualTypeOf();
+    expect(data.tim.WLR).toBeDefined();
+    expect(data.tim.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.WLR).toEqualTypeOf();
+    expect(data.tim.arrowsShot).toBeDefined();
+    expect(data.tim.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.arrowsShot).toEqualTypeOf();
+    expect(data.tim.arrowsHit).toBeDefined();
+    expect(data.tim.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.arrowsHit).toEqualTypeOf();
+    expect(data.tim.bowAccuracy).toBeDefined();
+    expect(data.tim.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.bowAccuracy).toEqualTypeOf();
+    expect(data.tim.damage).toBeDefined();
+    expect(data.tim.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.damage).toEqualTypeOf();
+    expect(data.tim.damageTaken).toBeDefined();
+    expect(data.tim.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.damageTaken).toEqualTypeOf();
+    expect(data.tim.potionsDrunk).toBeDefined();
+    expect(data.tim.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.potionsDrunk).toEqualTypeOf();
+    expect(data.tim.potionsThrown).toBeDefined();
+    expect(data.tim.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.potionsThrown).toEqualTypeOf();
+    expect(data.tim.playTime).toBeDefined();
+    expect(data.tim.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.playTime).toEqualTypeOf();
+    expect(data.tim.mobsSpawned).toBeDefined();
+    expect(data.tim.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.mobsSpawned).toEqualTypeOf();
+    expect(data.tim.chestsOpened).toBeDefined();
+    expect(data.tim.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.tim.chestsOpened).toEqualTypeOf();
+    expect(data.farmer).toBeDefined();
+    expectTypeOf(data.farmer).toEqualTypeOf();
+    expect(data.farmer.level).toBeDefined();
+    expect(data.farmer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.level).toEqualTypeOf();
+    expect(data.farmer.exp).toBeDefined();
+    expect(data.farmer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.exp).toEqualTypeOf();
+    expect(data.farmer.kills).toBeDefined();
+    expect(data.farmer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.kills).toEqualTypeOf();
+    expect(data.farmer.deaths).toBeDefined();
+    expect(data.farmer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.deaths).toEqualTypeOf();
+    expect(data.farmer.KDR).toBeDefined();
+    expect(data.farmer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.KDR).toEqualTypeOf();
+    expect(data.farmer.wins).toBeDefined();
+    expect(data.farmer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.wins).toEqualTypeOf();
+    expect(data.farmer.gamesPlayed).toBeDefined();
+    expect(data.farmer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.gamesPlayed).toEqualTypeOf();
+    expect(data.farmer.losses).toBeDefined();
+    expect(data.farmer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.losses).toEqualTypeOf();
+    expect(data.farmer.WLR).toBeDefined();
+    expect(data.farmer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.WLR).toEqualTypeOf();
+    expect(data.farmer.arrowsShot).toBeDefined();
+    expect(data.farmer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.arrowsShot).toEqualTypeOf();
+    expect(data.farmer.arrowsHit).toBeDefined();
+    expect(data.farmer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.arrowsHit).toEqualTypeOf();
+    expect(data.farmer.bowAccuracy).toBeDefined();
+    expect(data.farmer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.bowAccuracy).toEqualTypeOf();
+    expect(data.farmer.damage).toBeDefined();
+    expect(data.farmer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.damage).toEqualTypeOf();
+    expect(data.farmer.damageTaken).toBeDefined();
+    expect(data.farmer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.damageTaken).toEqualTypeOf();
+    expect(data.farmer.potionsDrunk).toBeDefined();
+    expect(data.farmer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.potionsDrunk).toEqualTypeOf();
+    expect(data.farmer.potionsThrown).toBeDefined();
+    expect(data.farmer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.potionsThrown).toEqualTypeOf();
+    expect(data.farmer.playTime).toBeDefined();
+    expect(data.farmer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.playTime).toEqualTypeOf();
+    expect(data.farmer.mobsSpawned).toBeDefined();
+    expect(data.farmer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.mobsSpawned).toEqualTypeOf();
+    expect(data.farmer.chestsOpened).toBeDefined();
+    expect(data.farmer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.farmer.chestsOpened).toEqualTypeOf();
+    expect(data.creepertamer).toBeDefined();
+    expectTypeOf(data.creepertamer).toEqualTypeOf();
+    expect(data.creepertamer.level).toBeDefined();
+    expect(data.creepertamer.level).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.level).toEqualTypeOf();
+    expect(data.creepertamer.exp).toBeDefined();
+    expect(data.creepertamer.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.exp).toEqualTypeOf();
+    expect(data.creepertamer.kills).toBeDefined();
+    expect(data.creepertamer.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.kills).toEqualTypeOf();
+    expect(data.creepertamer.deaths).toBeDefined();
+    expect(data.creepertamer.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.deaths).toEqualTypeOf();
+    expect(data.creepertamer.KDR).toBeDefined();
+    expect(data.creepertamer.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.KDR).toEqualTypeOf();
+    expect(data.creepertamer.wins).toBeDefined();
+    expect(data.creepertamer.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.wins).toEqualTypeOf();
+    expect(data.creepertamer.gamesPlayed).toBeDefined();
+    expect(data.creepertamer.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.gamesPlayed).toEqualTypeOf();
+    expect(data.creepertamer.losses).toBeDefined();
+    expect(data.creepertamer.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.losses).toEqualTypeOf();
+    expect(data.creepertamer.WLR).toBeDefined();
+    expect(data.creepertamer.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.WLR).toEqualTypeOf();
+    expect(data.creepertamer.arrowsShot).toBeDefined();
+    expect(data.creepertamer.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.arrowsShot).toEqualTypeOf();
+    expect(data.creepertamer.arrowsHit).toBeDefined();
+    expect(data.creepertamer.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.arrowsHit).toEqualTypeOf();
+    expect(data.creepertamer.bowAccuracy).toBeDefined();
+    expect(data.creepertamer.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.bowAccuracy).toEqualTypeOf();
+    expect(data.creepertamer.damage).toBeDefined();
+    expect(data.creepertamer.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.damage).toEqualTypeOf();
+    expect(data.creepertamer.damageTaken).toBeDefined();
+    expect(data.creepertamer.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.damageTaken).toEqualTypeOf();
+    expect(data.creepertamer.potionsDrunk).toBeDefined();
+    expect(data.creepertamer.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.potionsDrunk).toEqualTypeOf();
+    expect(data.creepertamer.potionsThrown).toBeDefined();
+    expect(data.creepertamer.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.potionsThrown).toEqualTypeOf();
+    expect(data.creepertamer.playTime).toBeDefined();
+    expect(data.creepertamer.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.playTime).toEqualTypeOf();
+    expect(data.creepertamer.mobsSpawned).toBeDefined();
+    expect(data.creepertamer.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.mobsSpawned).toEqualTypeOf();
+    expect(data.creepertamer.chestsOpened).toBeDefined();
+    expect(data.creepertamer.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.creepertamer.chestsOpened).toEqualTypeOf();
+    expect(data.snowman).toBeDefined();
+    expectTypeOf(data.snowman).toEqualTypeOf();
+    expect(data.snowman.level).toBeDefined();
+    expect(data.snowman.level).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.level).toEqualTypeOf();
+    expect(data.snowman.exp).toBeDefined();
+    expect(data.snowman.exp).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.exp).toEqualTypeOf();
+    expect(data.snowman.kills).toBeDefined();
+    expect(data.snowman.kills).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.kills).toEqualTypeOf();
+    expect(data.snowman.deaths).toBeDefined();
+    expect(data.snowman.deaths).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.deaths).toEqualTypeOf();
+    expect(data.snowman.KDR).toBeDefined();
+    expect(data.snowman.KDR).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.KDR).toEqualTypeOf();
+    expect(data.snowman.wins).toBeDefined();
+    expect(data.snowman.wins).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.wins).toEqualTypeOf();
+    expect(data.snowman.gamesPlayed).toBeDefined();
+    expect(data.snowman.gamesPlayed).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.gamesPlayed).toEqualTypeOf();
+    expect(data.snowman.losses).toBeDefined();
+    expect(data.snowman.losses).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.losses).toEqualTypeOf();
+    expect(data.snowman.WLR).toBeDefined();
+    expect(data.snowman.WLR).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.WLR).toEqualTypeOf();
+    expect(data.snowman.arrowsShot).toBeDefined();
+    expect(data.snowman.arrowsShot).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.arrowsShot).toEqualTypeOf();
+    expect(data.snowman.arrowsHit).toBeDefined();
+    expect(data.snowman.arrowsHit).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.arrowsHit).toEqualTypeOf();
+    expect(data.snowman.bowAccuracy).toBeDefined();
+    expect(data.snowman.bowAccuracy).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.bowAccuracy).toEqualTypeOf();
+    expect(data.snowman.damage).toBeDefined();
+    expect(data.snowman.damage).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.damage).toEqualTypeOf();
+    expect(data.snowman.damageTaken).toBeDefined();
+    expect(data.snowman.damageTaken).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.damageTaken).toEqualTypeOf();
+    expect(data.snowman.potionsDrunk).toBeDefined();
+    expect(data.snowman.potionsDrunk).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.potionsDrunk).toEqualTypeOf();
+    expect(data.snowman.potionsThrown).toBeDefined();
+    expect(data.snowman.potionsThrown).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.potionsThrown).toEqualTypeOf();
+    expect(data.snowman.playTime).toBeDefined();
+    expect(data.snowman.playTime).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.playTime).toEqualTypeOf();
+    expect(data.snowman.mobsSpawned).toBeDefined();
+    expect(data.snowman.mobsSpawned).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.mobsSpawned).toEqualTypeOf();
+    expect(data.snowman.chestsOpened).toBeDefined();
+    expect(data.snowman.chestsOpened).greaterThanOrEqual(0);
+    expectTypeOf(data.snowman.chestsOpened).toEqualTypeOf();
+});