From 0b9f9cdc6cf476662b622c03ed0375ac81d8571d Mon Sep 17 00:00:00 2001 From: Jacob <55346310+Kathund@users.noreply.github.com> Date: Sat, 7 Sep 2024 11:31:36 +0800 Subject: [PATCH] 95% code test coverage (#51) * tests * firesale * fix * im going to die * fix * fix * Games * Color * misc change * coco -> cocoa * Rewrite Member Stats * feat(getPlayer): add getplayer never logged in test * Clean tests * Check coverage * fix * better testing * Meow * code * fix formatting * Booster Test * meow * MeowWWW * Test * meow meow meow * Testers * fix * feat(tests): add mock data for firesales * 90% testers * Change Data * Move WatchdogStats * fix idiot * Bazaar * Replace Usernames With UUID * Move coverageCheck.ts * Coverage Check change * i hate my life. Please end it now fucking cunt * update(skills): taming cap * Tests * Testersssszzszszszszsz 95% go brrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr * code i think * Fix Urls --------- Co-authored-by: Zickles --- .github/checkCoverage.ts | 54 + .github/workflows/ci-cd.yml | 8 +- .gitignore | 1 + .npmignore | 3 +- package.json | 7 +- pnpm-lock.yaml | 22 + src/API/API.d.ts | 2 + src/API/getAchievements.test.ts | 4 +- src/API/getActiveHouses.test.ts | 8 +- src/API/getBoosters.test.ts | 29 +- src/API/getChallenges.test.ts | 4 +- src/API/getGameCounts.test.ts | 4 +- src/API/getGuild.test.ts | 67 +- src/API/getGuild.ts | 7 +- src/API/getGuildAchievements.test.ts | 4 +- src/API/getHouse.test.ts | 6 +- src/API/getLeaderboards.test.ts | 33 +- src/API/getLeaderboards.ts | 15 +- src/API/getPlayer.test.ts | 501 +- src/API/getPlayerHouses.test.ts | 10 +- src/API/getQuests.test.ts | 4 +- src/API/getRecentGames.test.ts | 12 +- src/API/getSkyblockAuction.test.ts | 153 +- src/API/getSkyblockAuction.ts | 2 +- src/API/getSkyblockAuctions.test.ts | 84 +- src/API/getSkyblockAuctionsByPlayer.test.ts | 71 +- src/API/getSkyblockAuctionsByPlayer.ts | 2 +- src/API/getSkyblockBazaar.test.ts | 8 +- src/API/getSkyblockBazaar.ts | 2 +- src/API/getSkyblockBingo.test.ts | 4 +- src/API/getSkyblockFireSales.test.ts | 74 +- src/API/getSkyblockGarden.test.ts | 10 +- src/API/getSkyblockGovernment.test.ts | 4 +- src/API/getSkyblockMember.test.ts | 568 +- src/API/getSkyblockMember.ts | 2 +- src/API/getSkyblockMuseum.test.ts | 12 +- src/API/getSkyblockNews.test.ts | 4 +- src/API/getSkyblockProfiles.test.ts | 12 +- src/API/getStatus.test.ts | 29 +- src/API/getWatchdogStats.test.ts | 6 +- src/API/getWatchdogStats.ts | 2 +- src/Private/CacheHandler.test.ts | 2 +- src/Private/Endpoint.test.ts | 2 +- src/Private/RateLimit.test.ts | 17 +- src/Private/RequestHandler.test.ts | 32 +- src/Private/RequestHandler.ts | 2 +- src/Private/Updater.test.ts | 8 +- src/index.ts | 7 +- src/structures/Boosters/Booster.test.ts | 8 + src/structures/Boosters/Booster.ts | 6 +- src/structures/Color.test.ts | 24 + src/structures/Color.ts | 88 +- src/structures/Game.ts | 26 +- src/structures/House.test.ts | 25 + src/structures/House.ts | 8 +- src/structures/ItemBytes.ts | 6 - src/structures/Leaderboard.test.ts | 27 + src/structures/Leaderboard.ts | 16 +- src/structures/MiniGames/Arcade.test.ts | 629 +++ src/structures/MiniGames/Arcade.ts | 212 +- src/structures/MiniGames/ArenaBrawl.test.ts | 121 + src/structures/MiniGames/ArenaBrawl.ts | 30 +- src/structures/MiniGames/BedWars.test.ts | 949 ++++ src/structures/MiniGames/BedWars.ts | 292 +- .../MiniGames/BlitzSurvivalGames.test.ts | 2239 ++++++++ .../MiniGames/BlitzSurvivalGames.ts | 72 +- src/structures/MiniGames/BuildBattle.test.ts | 43 + src/structures/MiniGames/BuildBattle.ts | 20 +- src/structures/MiniGames/CopsAndCrims.test.ts | 163 + src/structures/MiniGames/CopsAndCrims.ts | 70 +- src/structures/MiniGames/Duels.test.ts | 1854 +++++++ src/structures/MiniGames/Duels.ts | 108 +- src/structures/MiniGames/MegaWalls.test.ts | 4792 +++++++++++++++++ src/structures/MiniGames/MegaWalls.ts | 106 +- .../MiniGames/MurderMystery.test.ts | 242 + src/structures/MiniGames/MurderMystery.ts | 64 +- src/structures/MiniGames/Paintball.test.ts | 52 + src/structures/MiniGames/Paintball.ts | 28 +- src/structures/MiniGames/Pit.test.ts | 220 + src/structures/MiniGames/Pit.ts | 97 +- src/structures/MiniGames/PitInventoryItem.ts | 10 +- src/structures/MiniGames/Quakecraft.test.ts | 106 + src/structures/MiniGames/Quakecraft.ts | 50 +- src/structures/MiniGames/SkyWars.ts | 191 +- src/structures/MiniGames/Skywars.test.ts | 414 ++ src/structures/MiniGames/SmashHeroes.test.ts | 648 +++ src/structures/MiniGames/SmashHeroes.ts | 48 +- src/structures/MiniGames/SpeedUHC.test.ts | 246 + src/structures/MiniGames/SpeedUHC.ts | 48 +- src/structures/MiniGames/TNTGames.test.ts | 140 + src/structures/MiniGames/TNTGames.ts | 89 +- .../MiniGames/TurboKartRacers.test.ts | 143 + src/structures/MiniGames/TurboKartRacers.ts | 38 +- src/structures/MiniGames/UHC.test.ts | 181 + src/structures/MiniGames/UHC.ts | 20 +- src/structures/MiniGames/VampireZ.test.ts | 60 + src/structures/MiniGames/VampireZ.ts | 22 +- src/structures/MiniGames/Walls.test.ts | 33 + src/structures/MiniGames/Walls.ts | 12 +- src/structures/MiniGames/Warlords.test.ts | 407 ++ src/structures/MiniGames/Warlords.ts | 30 +- src/structures/MiniGames/WoolGames.test.ts | 156 + src/structures/MiniGames/WoolGames.ts | 8 +- src/structures/Pet.ts | 31 +- src/structures/Pets.ts | 2 +- src/structures/Player.test.ts | 102 + src/structures/Player.ts | 169 +- src/structures/PlayerCosmetics.ts | 169 +- src/structures/RecentGame.ts | 17 +- src/structures/RecentGames.test.ts | 29 + src/structures/ServerInfo.ts | 40 - src/structures/SkyBlock/Auctions/Auction.ts | 4 +- .../SkyBlock/Auctions/AuctionInfo.ts | 4 - .../SkyBlock/Auctions/BaseAuction.test.ts | 22 + src/structures/SkyBlock/Auctions/Bid.ts | 22 +- src/structures/SkyBlock/Bazaar/Order.test.ts | 24 + .../SkyBlock/{Bazzar => Bazaar}/Order.ts | 0 .../SkyBlock/Bazaar/Product.test.ts | 47 + src/structures/SkyBlock/Bazaar/Product.ts | 36 + src/structures/SkyBlock/Bazzar/Product.ts | 40 - .../SkyBlock/SkyblockGarden.test.ts | 29 + src/structures/SkyBlock/SkyblockGarden.ts | 25 +- .../SkyBlock/SkyblockMember.test.ts | 76 + src/structures/SkyBlock/SkyblockMember.ts | 314 +- .../SkyBlock/SkyblockMemberTypes.d.ts | 343 ++ src/structures/SkyBlock/SkyblockPet.ts | 7 +- src/structures/SkyBlock/Static/FireSale.ts | 10 +- src/structures/Static/GameQuests.ts | 2 +- src/structures/Status.test.ts | 20 + src/structures/Status.ts | 6 +- src/structures/Watchdog/Stats.ts | 16 - src/structures/WatchdogStats.test.ts | 24 + src/structures/WatchdogStats.ts | 16 + src/utils/Constants.ts | 145 +- src/utils/Player.test.ts | 100 + src/utils/Player.ts | 2 +- src/utils/SkyblockUtils.ts | 419 +- src/utils/oscillation.test.ts | 18 + src/utils/oscillation.ts | 7 +- 139 files changed, 17543 insertions(+), 2455 deletions(-) create mode 100644 .github/checkCoverage.ts create mode 100644 src/structures/Boosters/Booster.test.ts create mode 100644 src/structures/Color.test.ts create mode 100644 src/structures/House.test.ts create mode 100644 src/structures/Leaderboard.test.ts create mode 100644 src/structures/MiniGames/Arcade.test.ts create mode 100644 src/structures/MiniGames/ArenaBrawl.test.ts create mode 100644 src/structures/MiniGames/BedWars.test.ts create mode 100644 src/structures/MiniGames/BlitzSurvivalGames.test.ts create mode 100644 src/structures/MiniGames/BuildBattle.test.ts create mode 100644 src/structures/MiniGames/CopsAndCrims.test.ts create mode 100644 src/structures/MiniGames/Duels.test.ts create mode 100644 src/structures/MiniGames/MegaWalls.test.ts create mode 100644 src/structures/MiniGames/MurderMystery.test.ts create mode 100644 src/structures/MiniGames/Paintball.test.ts create mode 100644 src/structures/MiniGames/Pit.test.ts create mode 100644 src/structures/MiniGames/Quakecraft.test.ts create mode 100644 src/structures/MiniGames/Skywars.test.ts create mode 100644 src/structures/MiniGames/SmashHeroes.test.ts create mode 100644 src/structures/MiniGames/SpeedUHC.test.ts create mode 100644 src/structures/MiniGames/TNTGames.test.ts create mode 100644 src/structures/MiniGames/TurboKartRacers.test.ts create mode 100644 src/structures/MiniGames/UHC.test.ts create mode 100644 src/structures/MiniGames/VampireZ.test.ts create mode 100644 src/structures/MiniGames/Walls.test.ts create mode 100644 src/structures/MiniGames/Warlords.test.ts create mode 100644 src/structures/MiniGames/WoolGames.test.ts create mode 100644 src/structures/Player.test.ts create mode 100644 src/structures/RecentGames.test.ts delete mode 100644 src/structures/ServerInfo.ts create mode 100644 src/structures/SkyBlock/Auctions/BaseAuction.test.ts create mode 100644 src/structures/SkyBlock/Bazaar/Order.test.ts rename src/structures/SkyBlock/{Bazzar => Bazaar}/Order.ts (100%) create mode 100644 src/structures/SkyBlock/Bazaar/Product.test.ts create mode 100644 src/structures/SkyBlock/Bazaar/Product.ts delete mode 100644 src/structures/SkyBlock/Bazzar/Product.ts create mode 100644 src/structures/SkyBlock/SkyblockGarden.test.ts create mode 100644 src/structures/SkyBlock/SkyblockMember.test.ts create mode 100644 src/structures/SkyBlock/SkyblockMemberTypes.d.ts create mode 100644 src/structures/Status.test.ts delete mode 100644 src/structures/Watchdog/Stats.ts create mode 100644 src/structures/WatchdogStats.test.ts create mode 100644 src/structures/WatchdogStats.ts create mode 100644 src/utils/Player.test.ts create mode 100644 src/utils/oscillation.test.ts diff --git a/.github/checkCoverage.ts b/.github/checkCoverage.ts new file mode 100644 index 00000000..574bcd08 --- /dev/null +++ b/.github/checkCoverage.ts @@ -0,0 +1,54 @@ +import { parseString } from 'xml2js'; +import { readFile } from 'fs'; + +function parseXMLFile(): Promise { + return new Promise((resolve, reject) => { + readFile('.github/coverageData.xml', 'utf8', (err, data) => { + if (err) { + reject('File Dose not exist!'); + return; + } + + parseString(data, (err, result) => { + if (err) { + reject('Something Went wrong!'); + return; + } + + resolve(result); + }); + }); + }); +} + +const data = await parseXMLFile(); +const codeStats = data.coverage.project[0].metrics[0].$; +const info = { + statements: Number(codeStats.statements), + coveredstatements: Number(codeStats.coveredstatements), + conditionals: Number(codeStats.conditionals), + coveredconditionals: Number(codeStats.coveredconditionals), + methods: Number(codeStats.methods), + coveredmethods: Number(codeStats.coveredmethods) +}; + +if (95 > (info.coveredstatements / info.statements) * 100) { + throw new Error('Statements is required to be 95% or higher'); +} + +if (95 > (info.coveredconditionals / info.conditionals) * 100) { + throw new Error('Conditionals is required to be 95% or higher'); +} + +if (95 > (info.coveredmethods / info.methods) * 100) { + throw new Error('Methods is required to be 95% or higher'); +} + +if ( + 95 > + ((info.coveredstatements + info.coveredconditionals + info.coveredmethods) / + (info.statements + info.conditionals + info.methods)) * + 100 +) { + throw new Error('Everythng Combinded is required to be 95% or higher'); +} diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml index ce0c899f..de924b9f 100644 --- a/.github/workflows/ci-cd.yml +++ b/.github/workflows/ci-cd.yml @@ -123,4 +123,10 @@ jobs: - name: Check tests env: HYPIXEL_KEY: ${{ secrets.HYPIXEL_KEY }} - run: pnpm test + run: pnpm test:coverage + + - name: Move Coverage Data + run: mv coverage/clover.xml .github/coverageData.xml + + - name: Check Coverage + run: npx tsx .github/checkCoverage.ts diff --git a/.gitignore b/.gitignore index f6526432..b7da7a47 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,4 @@ oldreborn/ dist/ .eslintcache coverage/ +.github/coverageData.xml \ No newline at end of file diff --git a/.npmignore b/.npmignore index eb1e6682..d6a4437b 100644 --- a/.npmignore +++ b/.npmignore @@ -4,4 +4,5 @@ oldreborn/ .eslintcache .git .gitignore -coverage/ \ No newline at end of file +coverage/ +.github/coverageData.xml \ No newline at end of file diff --git a/package.json b/package.json index 47f444f8..5f9db3bf 100644 --- a/package.json +++ b/package.json @@ -22,7 +22,8 @@ "prettier": "npx prettier --write src/", "build": "npx tsc", "test": "npx vitest run", - "test:coverage": "npx vitest --ui --coverage" + "test:coverage": "npx vitest run --coverage", + "test:ui": "npx vitest --ui --coverage" }, "engines": { "node": ">=20.16.0" @@ -52,6 +53,7 @@ "@j4cobi/eslint-plugin-sort-imports": "^1.0.2", "@types/eslint": "^9.6.1", "@types/node": "^20.16.5", + "@types/xml2js": "^0.4.14", "@vitest/coverage-v8": "^2.0.5", "@vitest/ui": "^2.0.5", "dotenv": "^16.4.5", @@ -61,6 +63,7 @@ "prettier": "^3.3.3", "typescript": "^5.5.4", "typescript-eslint": "^8.4.0", - "vitest": "^2.0.5" + "vitest": "^2.0.5", + "xml2js": "^0.6.2" } } diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 94574d94..a16b3f2b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -39,6 +39,9 @@ importers: '@types/node': specifier: ^20.16.5 version: 20.16.5 + '@types/xml2js': + specifier: ^0.4.14 + version: 0.4.14 '@vitest/coverage-v8': specifier: ^2.0.5 version: 2.0.5(vitest@2.0.5(@types/node@20.16.5)(@vitest/ui@2.0.5)) @@ -69,6 +72,9 @@ importers: vitest: specifier: ^2.0.5 version: 2.0.5(@types/node@20.16.5)(@vitest/ui@2.0.5) + xml2js: + specifier: ^0.6.2 + version: 0.6.2 packages: @@ -408,6 +414,9 @@ packages: '@types/node@20.16.5': resolution: {integrity: sha512-VwYCweNo3ERajwy0IUlqqcyZ8/A7Zwa9ZP3MnENWcB11AejO+tLy3pu850goUW2FC/IJMdZUfKpX/yxL1gymCA==} + '@types/xml2js@0.4.14': + resolution: {integrity: sha512-4YnrRemBShWRO2QjvUin8ESA41rH+9nQGLUGZV/1IDhi3SL9OhdpNC/MrulTWuptXKwhx/aDxE7toV0f/ypIXQ==} + '@typescript-eslint/eslint-plugin@8.4.0': resolution: {integrity: sha512-rg8LGdv7ri3oAlenMACk9e+AR4wUV0yrrG+XKsGKOK0EVgeEDqurkXMPILG2836fW4ibokTB5v4b6Z9+GYQDEw==} engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0} @@ -1350,6 +1359,10 @@ packages: resolution: {integrity: sha512-drPFnkQJik/O+uPKpqSgr22mpuFHqKdbS835iAQrUC73L2F5WkboIRd63ai/2Yg6I1jzifPFKH2NTK+cfglkIA==} engines: {node: '>=4.0.0'} + xml2js@0.6.2: + resolution: {integrity: sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA==} + engines: {node: '>=4.0.0'} + xmlbuilder@11.0.1: resolution: {integrity: sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==} engines: {node: '>=4.0'} @@ -1601,6 +1614,10 @@ snapshots: dependencies: undici-types: 6.19.8 + '@types/xml2js@0.4.14': + dependencies: + '@types/node': 20.16.5 + '@typescript-eslint/eslint-plugin@8.4.0(@typescript-eslint/parser@8.4.0(eslint@9.9.1)(typescript@5.5.4))(eslint@9.9.1)(typescript@5.5.4)': dependencies: '@eslint-community/regexpp': 4.11.0 @@ -2592,6 +2609,11 @@ snapshots: sax: 1.4.1 xmlbuilder: 11.0.1 + xml2js@0.6.2: + dependencies: + sax: 1.4.1 + xmlbuilder: 11.0.1 + xmlbuilder@11.0.1: {} yocto-queue@0.1.0: {} diff --git a/src/API/API.d.ts b/src/API/API.d.ts index 68e8ac70..8221f663 100644 --- a/src/API/API.d.ts +++ b/src/API/API.d.ts @@ -14,3 +14,5 @@ export interface SkyblockRequestOptions extends RequestOptions { garden?: boolean; museum?: boolean; } + +export type GuildFetchOptions = 'id' | 'name' | 'player'; diff --git a/src/API/getAchievements.test.ts b/src/API/getAchievements.test.ts index cee1923a..68e06cb2 100644 --- a/src/API/getAchievements.test.ts +++ b/src/API/getAchievements.test.ts @@ -7,7 +7,7 @@ import { StaticGameNames } from '../typings'; import { expect, expectTypeOf, test } from 'vitest'; test('getAchievements (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getAchievements({ raw: true }); @@ -17,7 +17,7 @@ test('getAchievements (raw)', async () => { }); test('getAchievements', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getAchievements(); diff --git a/src/API/getActiveHouses.test.ts b/src/API/getActiveHouses.test.ts index 8db451e4..70f78600 100644 --- a/src/API/getActiveHouses.test.ts +++ b/src/API/getActiveHouses.test.ts @@ -3,7 +3,7 @@ import House from '../structures/House'; import { expect, expectTypeOf, test } from 'vitest'; test('getActiveHouses (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getActiveHouses({ raw: true }); @@ -13,7 +13,7 @@ test('getActiveHouses (raw)', async () => { }); test('getActiveHouses', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getActiveHouses(); @@ -30,9 +30,9 @@ test('getActiveHouses', async () => { expect(house.owner).toBeDefined(); expectTypeOf(house.owner).toEqualTypeOf(); expect(house.createdAtTimestamp).toBeDefined(); - expectTypeOf(house.createdAtTimestamp).toEqualTypeOf(); + expectTypeOf(house.createdAtTimestamp).toEqualTypeOf(); expect(house.createdAt).toBeDefined(); - expectTypeOf(house.createdAt).toEqualTypeOf(); + expectTypeOf(house.createdAt).toEqualTypeOf(); expect(house.players).toBeDefined(); expectTypeOf(house.players).toEqualTypeOf(); expect(house.cookies).toBeDefined(); diff --git a/src/API/getBoosters.test.ts b/src/API/getBoosters.test.ts index c4c9ca7e..e62a7524 100644 --- a/src/API/getBoosters.test.ts +++ b/src/API/getBoosters.test.ts @@ -1,10 +1,10 @@ import Booster from '../structures/Boosters/Booster'; import Client from '../Client'; -import Game from '../structures/Game'; +import Game, { GameCode, GameID, GameString } from '../structures/Game'; import { expect, expectTypeOf, test } from 'vitest'; test('getBoosters (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getBoosters({ raw: true }); @@ -14,7 +14,7 @@ test('getBoosters (raw)', async () => { }); test('getBoosters', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getBoosters(); @@ -37,7 +37,28 @@ test('getBoosters', async () => { expect(booster.activated).toBeDefined(); expectTypeOf(booster.activated).toEqualTypeOf(); expect(booster.game).toBeDefined(); - expectTypeOf(booster.game).toEqualTypeOf(); + expectTypeOf(booster.game).toEqualTypeOf(); + expect(booster.game).toBeDefined(); + expectTypeOf(booster.game).toEqualTypeOf(); + expect(booster.game.game).toBeDefined(); + expectTypeOf(booster.game.game).toEqualTypeOf(); + expect(booster.game.id).toBeDefined(); + expectTypeOf(booster.game.id).toEqualTypeOf(); + expect(booster.game.code).toBeDefined(); + expectTypeOf(booster.game.code).toEqualTypeOf(); + expect(booster.game.name).toBeDefined(); + expectTypeOf(booster.game.name).toEqualTypeOf(); + expect(booster.game.found).toBeDefined(); + expectTypeOf(booster.game.found).toEqualTypeOf(); + expect(booster.game.toString()).toBeDefined(); + expect(booster.game.toString()).toBe(booster.game.name); + expectTypeOf(booster.game.toString()).toEqualTypeOf(); + expect(Game.IDS).toBeDefined(); + expectTypeOf(Game.IDS).toEqualTypeOf(); + expect(Game.CODES).toBeDefined(); + expectTypeOf(Game.CODES).toEqualTypeOf(); + expect(Game.NAMES).toBeDefined(); + expectTypeOf(Game.NAMES).toEqualTypeOf(); expect(booster.isActive).toBeDefined(); expectTypeOf(booster.isActive).toEqualTypeOf(); expect(booster.type).toBeDefined(); diff --git a/src/API/getChallenges.test.ts b/src/API/getChallenges.test.ts index 31c02922..ab582109 100644 --- a/src/API/getChallenges.test.ts +++ b/src/API/getChallenges.test.ts @@ -5,7 +5,7 @@ import { StaticGameNames } from '../typings'; import { expect, expectTypeOf, test } from 'vitest'; test('getChallenges (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getChallenges({ raw: true }); @@ -15,7 +15,7 @@ test('getChallenges (raw)', async () => { }); test('getChallenges', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getChallenges(); diff --git a/src/API/getGameCounts.test.ts b/src/API/getGameCounts.test.ts index ceb44825..1971e274 100644 --- a/src/API/getGameCounts.test.ts +++ b/src/API/getGameCounts.test.ts @@ -3,7 +3,7 @@ import GameCounts from '../structures/GameCounts'; import { expect, expectTypeOf, test } from 'vitest'; test('getGameCounts (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGameCounts({ raw: true }); @@ -13,7 +13,7 @@ test('getGameCounts (raw)', async () => { }); test('getGameCounts', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGameCounts(); diff --git a/src/API/getGuild.test.ts b/src/API/getGuild.test.ts index 8cb1fa68..db5b5086 100644 --- a/src/API/getGuild.test.ts +++ b/src/API/getGuild.test.ts @@ -1,6 +1,6 @@ import Client from '../Client'; -import Color from '../structures/Color'; -import Game from '../structures/Game'; +import Color, { ColorCode, ColorHex, ColorString, InGameCode } from '../structures/Color'; +import Game, { GameCode, GameID, GameString } from '../structures/Game'; import Guild from '../structures/Guild/Guild'; import GuildMember from '../structures/Guild/GuildMember'; import GuildRank from '../structures/Guild/GuildRank'; @@ -8,7 +8,7 @@ import { ExpHistory } from '../utils/Guild'; import { expect, expectTypeOf, test } from 'vitest'; test('Invalid Guild Type', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getGuild('invalid', 'invalid')).rejects.toThrowError( @@ -18,7 +18,7 @@ test('Invalid Guild Type', () => { }); test('Invalid Guild', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getGuild('name', 'this guild dose not exist')).rejects.toThrowError( @@ -28,7 +28,7 @@ test('Invalid Guild', () => { }); test('Invalid Guild ID', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getGuild('id', 'invalid guild id')).rejects.toThrowError(client.errors.INVALID_GUILD_ID); @@ -36,7 +36,7 @@ test('Invalid Guild ID', () => { }); test('No Guild Query', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getGuild('id')).rejects.toThrowError(client.errors.NO_GUILD_QUERY); @@ -44,7 +44,7 @@ test('No Guild Query', () => { }); test('User not in a guild', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuild('player', '37501e7512b845ab8796e2baf9e9677a'); @@ -54,7 +54,7 @@ test('User not in a guild', async () => { }); test('getGuild (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuild('name', 'Pixelic', { raw: true }); @@ -64,7 +64,7 @@ test('getGuild (raw)', async () => { }); test('getGuild (Name)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuild('name', 'Pixelic'); @@ -180,6 +180,28 @@ test('getGuild (Name)', async () => { expectTypeOf(data.tag).toEqualTypeOf(); expect(data.tagColor).toBeDefined(); expectTypeOf(data.tagColor).toEqualTypeOf(); + if (data.tagColor) { + expect(data.tagColor).toBeDefined(); + expectTypeOf(data.tagColor).toEqualTypeOf(); + expect(data.tagColor.color).toBeDefined(); + expectTypeOf(data.tagColor.color).toEqualTypeOf(); + expect(data.tagColor.toString).toBeDefined(); + expectTypeOf(data.tagColor.toString).toEqualTypeOf<() => ColorString>(); + expect(data.tagColor.toString()).toBeDefined(); + expectTypeOf(data.tagColor.toString()).toEqualTypeOf(); + expect(data.tagColor.toHex).toBeDefined(); + expectTypeOf(data.tagColor.toHex).toEqualTypeOf<() => ColorHex>(); + expect(data.tagColor.toHex()).toBeDefined(); + expectTypeOf(data.tagColor.toHex()).toEqualTypeOf(); + expect(data.tagColor.toCode).toBeDefined(); + expectTypeOf(data.tagColor.toCode).toEqualTypeOf<() => ColorCode>(); + expect(data.tagColor.toCode()).toBeDefined(); + expectTypeOf(data.tagColor.toCode()).toEqualTypeOf(); + expect(data.tagColor.toInGameCode).toBeDefined(); + expectTypeOf(data.tagColor.toInGameCode).toEqualTypeOf<() => InGameCode>(); + expect(data.tagColor.toInGameCode()).toBeDefined(); + expectTypeOf(data.tagColor.toInGameCode()).toEqualTypeOf(); + } expect(data.expHistory).toBeDefined(); expectTypeOf(data.expHistory).toEqualTypeOf(); expect(data.achievements).toBeDefined(); @@ -192,6 +214,29 @@ test('getGuild (Name)', async () => { expect(data.achievements.experienceKings).toBeGreaterThanOrEqual(0); expect(data.preferredGames).toBeDefined(); expectTypeOf(data.preferredGames).toEqualTypeOf(); + data.preferredGames.forEach((game: Game) => { + expect(game).toBeDefined(); + expectTypeOf(game).toEqualTypeOf(); + expect(game.game).toBeDefined(); + expectTypeOf(game.game).toEqualTypeOf(); + expect(game.id).toBeDefined(); + expectTypeOf(game.id).toEqualTypeOf(); + expect(game.code).toBeDefined(); + expectTypeOf(game.code).toEqualTypeOf(); + expect(game.name).toBeDefined(); + expectTypeOf(game.name).toEqualTypeOf(); + expect(game.found).toBeDefined(); + expectTypeOf(game.found).toEqualTypeOf(); + expect(game.toString()).toBeDefined(); + expect(game.toString()).toBe(game.name); + expectTypeOf(game.toString()).toEqualTypeOf(); + expect(Game.IDS).toBeDefined(); + expectTypeOf(Game.IDS).toEqualTypeOf(); + expect(Game.CODES).toBeDefined(); + expectTypeOf(Game.CODES).toEqualTypeOf(); + expect(Game.NAMES).toBeDefined(); + expectTypeOf(Game.NAMES).toEqualTypeOf(); + }); expect(data.toString()).toBeDefined(); expectTypeOf(data.toString()).toEqualTypeOf(); expect(data.guildMaster()).toBeDefined(); @@ -202,7 +247,7 @@ test('getGuild (Name)', async () => { }); test('getGuild (Id)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuild('id', '64b54f9d8ea8c96aaedafe84'); @@ -340,7 +385,7 @@ test('getGuild (Id)', async () => { }); test('getGuild (Player)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuild('player', '14727faefbdc4aff848cd2713eb9939e'); diff --git a/src/API/getGuild.ts b/src/API/getGuild.ts index bb298274..fef22a12 100644 --- a/src/API/getGuild.ts +++ b/src/API/getGuild.ts @@ -2,6 +2,7 @@ import Client from '../Client'; import Endpoint from '../Private/Endpoint'; import Guild from '../structures/Guild/Guild'; import isGuildID from '../utils/isGuildID'; +import { GuildFetchOptions } from './API'; import { RequestOptions } from '../Private/RequestHandler'; class getGuild extends Endpoint { @@ -11,11 +12,7 @@ class getGuild extends Endpoint { this.client = client; } - async execute( - searchParameter: 'id' | 'name' | 'player', - query: string, - options?: RequestOptions - ): Promise { + async execute(searchParameter: GuildFetchOptions, query: string, options?: RequestOptions): Promise { if (!query) throw new Error(this.client.errors.NO_GUILD_QUERY); if ('id' === searchParameter && !isGuildID(query)) throw new Error(this.client.errors.INVALID_GUILD_ID); const isPlayerQuery = 'player' === searchParameter; diff --git a/src/API/getGuildAchievements.test.ts b/src/API/getGuildAchievements.test.ts index a0c13f77..a36e4a2f 100644 --- a/src/API/getGuildAchievements.test.ts +++ b/src/API/getGuildAchievements.test.ts @@ -5,7 +5,7 @@ import GuildAchievements from '../structures/Static/GuildAchievements'; import { expect, expectTypeOf, test } from 'vitest'; test('getGuildAchievements (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuildAchievements({ raw: true }); @@ -15,7 +15,7 @@ test('getGuildAchievements (raw)', async () => { }); test('getGuildAchievements', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getGuildAchievements(); diff --git a/src/API/getHouse.test.ts b/src/API/getHouse.test.ts index 7a92348d..98af8d16 100644 --- a/src/API/getHouse.test.ts +++ b/src/API/getHouse.test.ts @@ -3,7 +3,7 @@ import House from '../structures/House'; import { expect, expectTypeOf, test } from 'vitest'; test('getHouse (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const houses = await client.getActiveHouses(); @@ -16,7 +16,7 @@ test('getHouse (raw)', async () => { }); test('getHouse (no input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getHouse()).rejects.toThrowError(client.errors.NO_UUID); @@ -24,7 +24,7 @@ test('getHouse (no input)', () => { }); test('getHouse', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const houses = await client.getActiveHouses(); diff --git a/src/API/getLeaderboards.test.ts b/src/API/getLeaderboards.test.ts index e3a0d002..7d4d78e0 100644 --- a/src/API/getLeaderboards.test.ts +++ b/src/API/getLeaderboards.test.ts @@ -3,7 +3,7 @@ import Leaderboard from '../structures/Leaderboard'; import { expect, expectTypeOf, test } from 'vitest'; test('getLeaderboards (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getLeaderboards({ raw: true }); @@ -13,7 +13,7 @@ test('getLeaderboards (raw)', async () => { }); test('getLeaderboards', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getLeaderboards(); @@ -22,16 +22,23 @@ test('getLeaderboards', async () => { expectTypeOf(data[key]).toEqualTypeOf(); data[key].forEach((leaderboard: Leaderboard) => { expect(leaderboard).toBeDefined(); + expect(leaderboard).instanceOf(Leaderboard); expectTypeOf(leaderboard).toEqualTypeOf(); - expect(leaderboard.name).toBeDefined(); - expectTypeOf(leaderboard.name).toEqualTypeOf(); + + expect(leaderboard.path).toBeDefined(); + expectTypeOf(leaderboard.path).toEqualTypeOf(); + expect(leaderboard.prefix).toBeDefined(); + expectTypeOf(leaderboard.prefix).toEqualTypeOf(); expect(leaderboard.title).toBeDefined(); expectTypeOf(leaderboard.title).toEqualTypeOf(); - expect(leaderboard.playerCount).toBeDefined(); - expectTypeOf(leaderboard.playerCount).toEqualTypeOf(); + expect(leaderboard.location).toBeDefined(); + expectTypeOf(leaderboard.location).toEqualTypeOf(); + expect(leaderboard.count).toBeDefined(); + expect(leaderboard.count).toBeGreaterThanOrEqual(0); + expectTypeOf(leaderboard.count).toEqualTypeOf(); expect(leaderboard.leaders).toBeDefined(); expectTypeOf(leaderboard.leaders).toEqualTypeOf(); - leaderboard.leaders.forEach((leader) => { + leaderboard.leaders.forEach((leader: string) => { expect(leader).toBeDefined(); expectTypeOf(leader).toEqualTypeOf(); }); @@ -39,3 +46,15 @@ test('getLeaderboards', async () => { }); client.destroy(); }); + +// test('getLeaderboards (Missing Data)', () => { +// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { success: true } }); +// // eslint-disable-next-line @typescript-eslint/ban-ts-comment +// // @ts-expect-error +// expect(() => client.getLeaderboards()).rejects.toThrowError( +// client.errors.SOMETHING_WENT_WRONG.replace(/{cause}/, 'Try again.') +// ); +// vi.restoreAllMocks(); +// client.destroy(); +// }); diff --git a/src/API/getLeaderboards.ts b/src/API/getLeaderboards.ts index 8810da50..ab822816 100644 --- a/src/API/getLeaderboards.ts +++ b/src/API/getLeaderboards.ts @@ -1,5 +1,4 @@ import Client from '../Client'; -import Constants from '../utils/Constants'; import Endpoint from '../Private/Endpoint'; import Leaderboard from '../structures/Leaderboard'; import { RequestOptions } from '../Private/RequestHandler'; @@ -11,19 +10,17 @@ class getLeaderboards extends Endpoint { this.client = client; } - async execute(options?: RequestOptions): Promise { + async execute(options?: RequestOptions): Promise> { const res = await this.client.requestHandler.request('/leaderboards', options); if (res.options.raw) return res.data; if (!res.data.leaderboards) { throw new Error(this.client.errors.SOMETHING_WENT_WRONG.replace(/{cause}/, 'Try again.')); } - const lbnames = Object.create(Constants.leaderboardNames); - for (const name in lbnames) { - lbnames[name] = res.data.leaderboards[lbnames[name]].length - ? res.data.leaderboards[lbnames[name]].map((lb: any) => new Leaderboard(lb)) - : []; - } - return lbnames; + const leaderboards: Record = {}; + Object.keys(res.data.leaderboards).forEach((key) => { + leaderboards[key] = res.data.leaderboards[key].map((l: Record) => new Leaderboard(l)); + }); + return leaderboards; } } diff --git a/src/API/getPlayer.test.ts b/src/API/getPlayer.test.ts index 9bc37396..a6b7e25e 100644 --- a/src/API/getPlayer.test.ts +++ b/src/API/getPlayer.test.ts @@ -4,18 +4,22 @@ import BedWars from '../structures/MiniGames/BedWars'; import BlitzSurvivalGames from '../structures/MiniGames/BlitzSurvivalGames'; import BuildBattle from '../structures/MiniGames/BuildBattle'; import Client from '../Client'; -import Color from '../structures/Color'; +import Color, { ColorCode, ColorHex, ColorString, InGameCode } from '../structures/Color'; import CopsAndCrims from '../structures/MiniGames/CopsAndCrims'; import Duels from '../structures/MiniGames/Duels'; -import Game from '../structures/Game'; import Guild from '../structures/Guild/Guild'; import House from '../structures/House'; import MegaWalls from '../structures/MiniGames/MegaWalls'; import MurderMystery from '../structures/MiniGames/MurderMystery'; import Paintball from '../structures/MiniGames/Paintball'; -import Pit, { PitArmor } from '../structures/MiniGames/Pit'; -import PitInventoryItem from '../structures/MiniGames/PitInventoryItem'; -import Player, { LevelProgress, PlayerRank, PlayerSocialMedia, RanksPurchaseTime } from '../structures/Player'; +import Pit from '../structures/MiniGames/Pit'; +import Player, { + LevelProgress, + PlayerRank, + PlayerSocialMedia, + PlayerStats, + RanksPurchaseTime +} from '../structures/Player'; import PlayerCosmetics from '../structures/PlayerCosmetics'; import Quakecraft from '../structures/MiniGames/Quakecraft'; import RecentGame from '../structures/RecentGame'; @@ -31,8 +35,20 @@ import Warlords from '../structures/MiniGames/Warlords'; import WoolGames from '../structures/MiniGames/WoolGames'; import { expect, expectTypeOf, test } from 'vitest'; -test('No Player Input', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); +// test('getPlayer (never joinned hypixel)', async () => { +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); +// vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { success: true } }); +// // eslint-disable-next-line @typescript-eslint/ban-ts-comment +// // @ts-expect-error +// await expect(() => client.getPlayer('14727faefbdc4aff848cd2713eb9939e')).rejects.toThrowError( +// client.errors.PLAYER_HAS_NEVER_LOGGED +// ); +// vi.restoreAllMocks(); +// client.destroy(); +// }); + +test('getPlayer (no input)', () => { + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getPlayer()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); @@ -40,17 +56,17 @@ test('No Player Input', () => { }); test('getPLayer (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error - const data = await client.getPlayer('fb3d96498a5b4d5b91b763db14b195ad', { raw: true }); + const data = await client.getPlayer('4855c53ee4fb4100997600a92fc50984', { raw: true }); expect(data).toBeDefined(); expectTypeOf(data).toEqualTypeOf(); client.destroy(); }); test('getPlayer (guild)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getPlayer('28667672039044989b0019b14a2c34d6', { guild: true }); @@ -63,7 +79,7 @@ test('getPlayer (guild)', async () => { }); test('getPlayer (houses)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getPlayer('618a96fec8b0493fa89427891049550b', { houses: true }); @@ -80,7 +96,7 @@ test('getPlayer (houses)', async () => { }); test('getPlayer (recent games)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getPlayer('37501e7512b845ab8796e2baf9e9677a', { recentGames: true }); @@ -97,7 +113,7 @@ test('getPlayer (recent games)', async () => { }); test('getPlayer', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getPlayer('14727faefbdc4aff848cd2713eb9939e'); @@ -126,12 +142,54 @@ test('getPlayer', async () => { expectTypeOf(data.lastLogoutTimestamp).toEqualTypeOf(); expect(data.lastLogout).toBeDefined(); expectTypeOf(data.lastLogout).toEqualTypeOf(); - expect(data.recentlyPlayedGame).toBeDefined(); - expectTypeOf(data.recentlyPlayedGame).toEqualTypeOf(); expect(data.plusColor).toBeDefined(); expectTypeOf(data.plusColor).toEqualTypeOf(); + if (data.plusColor) { + expect(data.plusColor).toBeDefined(); + expectTypeOf(data.plusColor).toEqualTypeOf(); + expect(data.plusColor.color).toBeDefined(); + expectTypeOf(data.plusColor.color).toEqualTypeOf(); + expect(data.plusColor.toString).toBeDefined(); + expectTypeOf(data.plusColor.toString).toEqualTypeOf<() => ColorString>(); + expect(data.plusColor.toString()).toBeDefined(); + expectTypeOf(data.plusColor.toString()).toEqualTypeOf(); + expect(data.plusColor.toHex).toBeDefined(); + expectTypeOf(data.plusColor.toHex).toEqualTypeOf<() => ColorHex>(); + expect(data.plusColor.toHex()).toBeDefined(); + expectTypeOf(data.plusColor.toHex()).toEqualTypeOf(); + expect(data.plusColor.toCode).toBeDefined(); + expectTypeOf(data.plusColor.toCode).toEqualTypeOf<() => ColorCode>(); + expect(data.plusColor.toCode()).toBeDefined(); + expectTypeOf(data.plusColor.toCode()).toEqualTypeOf(); + expect(data.plusColor.toInGameCode).toBeDefined(); + expectTypeOf(data.plusColor.toInGameCode).toEqualTypeOf<() => InGameCode>(); + expect(data.plusColor.toInGameCode()).toBeDefined(); + expectTypeOf(data.plusColor.toInGameCode()).toEqualTypeOf(); + } expect(data.prefixColor).toBeDefined(); expectTypeOf(data.prefixColor).toEqualTypeOf(); + if (data.prefixColor) { + expect(data.prefixColor).toBeDefined(); + expectTypeOf(data.prefixColor).toEqualTypeOf(); + expect(data.prefixColor.color).toBeDefined(); + expectTypeOf(data.prefixColor.color).toEqualTypeOf(); + expect(data.prefixColor.toString).toBeDefined(); + expectTypeOf(data.prefixColor.toString).toEqualTypeOf<() => ColorString>(); + expect(data.prefixColor.toString()).toBeDefined(); + expectTypeOf(data.prefixColor.toString()).toEqualTypeOf(); + expect(data.prefixColor.toHex).toBeDefined(); + expectTypeOf(data.prefixColor.toHex).toEqualTypeOf<() => ColorHex>(); + expect(data.prefixColor.toHex()).toBeDefined(); + expectTypeOf(data.prefixColor.toHex()).toEqualTypeOf(); + expect(data.prefixColor.toCode).toBeDefined(); + expectTypeOf(data.prefixColor.toCode).toEqualTypeOf<() => ColorCode>(); + expect(data.prefixColor.toCode()).toBeDefined(); + expectTypeOf(data.prefixColor.toCode()).toEqualTypeOf(); + expect(data.prefixColor.toInGameCode).toBeDefined(); + expectTypeOf(data.prefixColor.toInGameCode).toEqualTypeOf<() => InGameCode>(); + expect(data.prefixColor.toInGameCode()).toBeDefined(); + expectTypeOf(data.prefixColor.toInGameCode()).toEqualTypeOf(); + } expect(data.karma).toBeDefined(); expectTypeOf(data.karma).toEqualTypeOf(); expect(data.achievements).toBeDefined(); @@ -157,331 +215,108 @@ test('getPlayer', async () => { expect(data.lastDailyRewardTimestamp).toBeDefined(); expectTypeOf(data.lastDailyRewardTimestamp).toEqualTypeOf(); expect(data.totalRewards).toBeDefined(); - expectTypeOf(data.totalRewards).toEqualTypeOf(); + expectTypeOf(data.totalRewards).toEqualTypeOf(); expect(data.totalDailyRewards).toBeDefined(); - expectTypeOf(data.totalDailyRewards).toEqualTypeOf(); + expectTypeOf(data.totalDailyRewards).toEqualTypeOf(); expect(data.rewardStreak).toBeDefined(); - expectTypeOf(data.rewardStreak).toEqualTypeOf(); + expectTypeOf(data.rewardStreak).toEqualTypeOf(); expect(data.rewardScore).toBeDefined(); - expectTypeOf(data.rewardScore).toEqualTypeOf(); + expectTypeOf(data.rewardScore).toEqualTypeOf(); expect(data.rewardHighScore).toBeDefined(); - expectTypeOf(data.rewardHighScore).toEqualTypeOf(); + expectTypeOf(data.rewardHighScore).toEqualTypeOf(); expect(data.levelProgress).toBeDefined(); expectTypeOf(data.levelProgress).toEqualTypeOf(); expect(data.stats).toBeDefined(); - expectTypeOf(data.stats).toEqualTypeOf(); - if (null !== data.stats) { - expect(data.stats).toBeDefined(); - expectTypeOf(data.stats).toEqualTypeOf(); - expect(data.stats.arcade).toBeDefined(); - expectTypeOf(data.stats.arcade).toEqualTypeOf(); - expect(data.stats.arena).toBeDefined(); - expectTypeOf(data.stats.arena).toEqualTypeOf(); - expect(data.stats.bedwars).toBeDefined(); - expectTypeOf(data.stats.bedwars).toEqualTypeOf(); - if (null !== data.stats.bedwars) { - expect(data.stats.bedwars).toBeInstanceOf(BedWars); - } - expect(data.stats.blitzsg).toBeDefined(); - expectTypeOf(data.stats.blitzsg).toEqualTypeOf(); - if (null !== data.stats.blitzsg) { - expect(data.stats.blitzsg).toBeInstanceOf(BlitzSurvivalGames); - } - expect(data.stats.buildbattle).toBeDefined(); - expectTypeOf(data.stats.buildbattle).toEqualTypeOf(); - if (null !== data.stats.buildbattle) { - expect(data.stats.buildbattle).toBeInstanceOf(BuildBattle); - } - expect(data.stats.copsandcrims).toBeDefined(); - expectTypeOf(data.stats.copsandcrims).toEqualTypeOf(); - if (null !== data.stats.copsandcrims) { - expect(data.stats.copsandcrims).toBeInstanceOf(CopsAndCrims); - } - expect(data.stats.duels).toBeDefined(); - expectTypeOf(data.stats.duels).toEqualTypeOf(); - if (null !== data.stats.duels) { - expect(data.stats.duels).toBeInstanceOf(Duels); - } - expect(data.stats.megawalls).toBeDefined(); - expectTypeOf(data.stats.megawalls).toEqualTypeOf(); - if (null !== data.stats.megawalls) { - expect(data.stats.megawalls).toBeInstanceOf(MegaWalls); - } - expect(data.stats.murdermystery).toBeDefined(); - expectTypeOf(data.stats.murdermystery).toEqualTypeOf(); - if (null !== data.stats.murdermystery) { - expect(data.stats.murdermystery).toBeInstanceOf(MurderMystery); - } - expect(data.stats.paintball).toBeDefined(); - expectTypeOf(data.stats.paintball).toEqualTypeOf(); - if (null !== data.stats.paintball) { - expect(data.stats.paintball).toBeInstanceOf(Paintball); - } - expect(data.stats.pit).toBeDefined(); - expectTypeOf(data.stats.pit).toEqualTypeOf(); - if (null !== data.stats.pit) { - expect(data.stats.pit).toBeInstanceOf(Pit); - expect(data.stats.pit.prestige).toBeDefined(); - expectTypeOf(data.stats.pit.prestige).toEqualTypeOf(); - expect(data.stats.pit.prestige).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.xp).toBeDefined(); - expectTypeOf(data.stats.pit.xp).toEqualTypeOf(); - expect(data.stats.pit.xp).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.level).toBeDefined(); - expectTypeOf(data.stats.pit.level).toEqualTypeOf(); - expect(data.stats.pit.level).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.kills).toBeDefined(); - expectTypeOf(data.stats.pit.kills).toEqualTypeOf(); - expect(data.stats.pit.kills).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.deaths).toBeDefined(); - expectTypeOf(data.stats.pit.deaths).toEqualTypeOf(); - expect(data.stats.pit.deaths).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.KDR).toBeDefined(); - expectTypeOf(data.stats.pit.KDR).toEqualTypeOf(); - expect(data.stats.pit.KDR).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.assists).toBeDefined(); - expectTypeOf(data.stats.pit.assists).toEqualTypeOf(); - expect(data.stats.pit.assists).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.maxKillStreak).toBeDefined(); - expectTypeOf(data.stats.pit.maxKillStreak).toEqualTypeOf(); - expect(data.stats.pit.maxKillStreak).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.playtime).toBeDefined(); - expectTypeOf(data.stats.pit.playtime).toEqualTypeOf(); - expect(data.stats.pit.playtime).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.joins).toBeDefined(); - expectTypeOf(data.stats.pit.joins).toEqualTypeOf(); - expect(data.stats.pit.joins).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.damageReceived).toBeDefined(); - expectTypeOf(data.stats.pit.damageReceived).toEqualTypeOf(); - expect(data.stats.pit.damageReceived).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.damageDealt).toBeDefined(); - expectTypeOf(data.stats.pit.damageDealt).toEqualTypeOf(); - expect(data.stats.pit.damageDealt).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.damageRatio).toBeDefined(); - expectTypeOf(data.stats.pit.damageRatio).toEqualTypeOf(); - expect(data.stats.pit.damageRatio).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.meleeDamageReceived).toBeDefined(); - expectTypeOf(data.stats.pit.meleeDamageReceived).toEqualTypeOf(); - expect(data.stats.pit.meleeDamageReceived).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.meleeDamageDealt).toBeDefined(); - expectTypeOf(data.stats.pit.meleeDamageDealt).toEqualTypeOf(); - expect(data.stats.pit.meleeDamageDealt).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.swordHits).toBeDefined(); - expectTypeOf(data.stats.pit.swordHits).toEqualTypeOf(); - expect(data.stats.pit.swordHits).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.leftClicks).toBeDefined(); - expectTypeOf(data.stats.pit.leftClicks).toEqualTypeOf(); - expect(data.stats.pit.leftClicks).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.meleeAccuracy).toBeDefined(); - expectTypeOf(data.stats.pit.meleeAccuracy).toEqualTypeOf(); - expect(data.stats.pit.meleeAccuracy).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.meleeDamageRatio).toBeDefined(); - expectTypeOf(data.stats.pit.meleeDamageRatio).toEqualTypeOf(); - expect(data.stats.pit.meleeDamageRatio).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.bowDamageReceived).toBeDefined(); - expectTypeOf(data.stats.pit.bowDamageReceived).toEqualTypeOf(); - expect(data.stats.pit.bowDamageReceived).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.bowDamageDealt).toBeDefined(); - expectTypeOf(data.stats.pit.bowDamageDealt).toEqualTypeOf(); - expect(data.stats.pit.bowDamageDealt).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.arrowsHit).toBeDefined(); - expectTypeOf(data.stats.pit.arrowsHit).toEqualTypeOf(); - expect(data.stats.pit.arrowsHit).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.arrowsFired).toBeDefined(); - expectTypeOf(data.stats.pit.arrowsFired).toEqualTypeOf(); - expect(data.stats.pit.arrowsFired).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.bowAccuracy).toBeDefined(); - expectTypeOf(data.stats.pit.bowAccuracy).toEqualTypeOf(); - expect(data.stats.pit.bowAccuracy).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.bowDamageRatio).toBeDefined(); - expectTypeOf(data.stats.pit.bowDamageRatio).toEqualTypeOf(); - expect(data.stats.pit.bowDamageRatio).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.goldenHeadsEaten).toBeDefined(); - expectTypeOf(data.stats.pit.goldenHeadsEaten).toEqualTypeOf(); - expect(data.stats.pit.goldenHeadsEaten).toBeGreaterThanOrEqual(0); - expect(data.stats.pit.getInventory).toBeDefined(); - expectTypeOf(data.stats.pit.getInventory).toEqualTypeOf<() => Promise>(); - expect(data.stats.pit.getInventory).toBeInstanceOf(Function); - const pitInventory = await data.stats.pit.getInventory(); - expect(pitInventory).toBeDefined(); - pitInventory.forEach((item: PitInventoryItem) => { - expect(item).toBeDefined(); - expect(item).toBeInstanceOf(PitInventoryItem); - expectTypeOf(item).toEqualTypeOf(); - expect(item.itemId).toBeDefined(); - expectTypeOf(item.itemId).toEqualTypeOf(); - expect(item.count).toBeDefined(); - expectTypeOf(item.count).toEqualTypeOf(); - expect(item.name).toBeDefined(); - expectTypeOf(item.name).toEqualTypeOf(); - expect(item.lore).toBeDefined(); - expectTypeOf(item.lore).toEqualTypeOf(); - expect(item.loreArray).toBeDefined(); - expectTypeOf(item.loreArray).toEqualTypeOf(); - expect(item.extraAttributes).toBeDefined(); - expectTypeOf(item.extraAttributes).toEqualTypeOf(); - }); - expect(data.stats.pit.getEnterChest).toBeDefined(); - expectTypeOf(data.stats.pit.getEnterChest).toEqualTypeOf<() => Promise>(); - expect(data.stats.pit.getEnterChest).toBeInstanceOf(Function); - const pitEnterChest = await data.stats.pit.getEnterChest(); - expect(pitEnterChest).toBeDefined(); - pitEnterChest.forEach((item: PitInventoryItem) => { - expect(item).toBeDefined(); - expect(item).toBeInstanceOf(PitInventoryItem); - expectTypeOf(item).toEqualTypeOf(); - expect(item.itemId).toBeDefined(); - expectTypeOf(item.itemId).toEqualTypeOf(); - expect(item.count).toBeDefined(); - expectTypeOf(item.count).toEqualTypeOf(); - expect(item.name).toBeDefined(); - expectTypeOf(item.name).toEqualTypeOf(); - expect(item.lore).toBeDefined(); - expectTypeOf(item.lore).toEqualTypeOf(); - expect(item.loreArray).toBeDefined(); - expectTypeOf(item.loreArray).toEqualTypeOf(); - expect(item.extraAttributes).toBeDefined(); - expectTypeOf(item.extraAttributes).toEqualTypeOf(); - }); - expect(data.stats.pit.getArmor).toBeDefined(); - expectTypeOf(data.stats.pit.getArmor).toEqualTypeOf<() => Promise>(); - expect(data.stats.pit.getArmor).toBeInstanceOf(Function); - const pitArmor = await data.stats.pit.getArmor(); - expect(pitArmor).toBeDefined(); - expectTypeOf(pitArmor).toEqualTypeOf(); - expect(pitArmor.helmet).toBeDefined(); - expectTypeOf(pitArmor.helmet).toEqualTypeOf(); - if (null !== pitArmor.helmet) { - expect(pitArmor.helmet).toBeDefined(); - expect(pitArmor.helmet).toBeInstanceOf(PitInventoryItem); - expectTypeOf(pitArmor.helmet).toEqualTypeOf(); - expect(pitArmor.helmet.itemId).toBeDefined(); - expectTypeOf(pitArmor.helmet.itemId).toEqualTypeOf(); - expect(pitArmor.helmet.count).toBeDefined(); - expectTypeOf(pitArmor.helmet.count).toEqualTypeOf(); - expect(pitArmor.helmet.name).toBeDefined(); - expectTypeOf(pitArmor.helmet.name).toEqualTypeOf(); - expect(pitArmor.helmet.lore).toBeDefined(); - expectTypeOf(pitArmor.helmet.lore).toEqualTypeOf(); - expect(pitArmor.helmet.loreArray).toBeDefined(); - expectTypeOf(pitArmor.helmet.loreArray).toEqualTypeOf(); - expect(pitArmor.helmet.extraAttributes).toBeDefined(); - expectTypeOf(pitArmor.helmet.extraAttributes).toEqualTypeOf(); - } - expect(pitArmor.chestplate).toBeDefined(); - expectTypeOf(pitArmor.chestplate).toEqualTypeOf(); - if (null !== pitArmor.chestplate) { - expect(pitArmor.chestplate).toBeDefined(); - expect(pitArmor.chestplate).toBeInstanceOf(PitInventoryItem); - expectTypeOf(pitArmor.chestplate).toEqualTypeOf(); - expect(pitArmor.chestplate.itemId).toBeDefined(); - expectTypeOf(pitArmor.chestplate.itemId).toEqualTypeOf(); - expect(pitArmor.chestplate.count).toBeDefined(); - expectTypeOf(pitArmor.chestplate.count).toEqualTypeOf(); - expect(pitArmor.chestplate.name).toBeDefined(); - expectTypeOf(pitArmor.chestplate.name).toEqualTypeOf(); - expect(pitArmor.chestplate.lore).toBeDefined(); - expectTypeOf(pitArmor.chestplate.lore).toEqualTypeOf(); - expect(pitArmor.chestplate.loreArray).toBeDefined(); - expectTypeOf(pitArmor.chestplate.loreArray).toEqualTypeOf(); - expect(pitArmor.chestplate.extraAttributes).toBeDefined(); - expectTypeOf(pitArmor.chestplate.extraAttributes).toEqualTypeOf(); - } - expect(pitArmor.leggings).toBeDefined(); - expectTypeOf(pitArmor.leggings).toEqualTypeOf(); - if (null !== pitArmor.leggings) { - expect(pitArmor.leggings).toBeDefined(); - expect(pitArmor.leggings).toBeInstanceOf(PitInventoryItem); - expectTypeOf(pitArmor.leggings).toEqualTypeOf(); - expect(pitArmor.leggings.itemId).toBeDefined(); - expectTypeOf(pitArmor.leggings.itemId).toEqualTypeOf(); - expect(pitArmor.leggings.count).toBeDefined(); - expectTypeOf(pitArmor.leggings.count).toEqualTypeOf(); - expect(pitArmor.leggings.name).toBeDefined(); - expectTypeOf(pitArmor.leggings.name).toEqualTypeOf(); - expect(pitArmor.leggings.lore).toBeDefined(); - expectTypeOf(pitArmor.leggings.lore).toEqualTypeOf(); - expect(pitArmor.leggings.loreArray).toBeDefined(); - expectTypeOf(pitArmor.leggings.loreArray).toEqualTypeOf(); - expect(pitArmor.leggings.extraAttributes).toBeDefined(); - expectTypeOf(pitArmor.leggings.extraAttributes).toEqualTypeOf(); - } - expect(pitArmor.boots).toBeDefined(); - expectTypeOf(pitArmor.boots).toEqualTypeOf(); - if (null !== pitArmor.boots) { - expect(pitArmor.boots).toBeDefined(); - expect(pitArmor.boots).toBeInstanceOf(PitInventoryItem); - expectTypeOf(pitArmor.boots).toEqualTypeOf(); - expect(pitArmor.boots.itemId).toBeDefined(); - expectTypeOf(pitArmor.boots.itemId).toEqualTypeOf(); - expect(pitArmor.boots.count).toBeDefined(); - expectTypeOf(pitArmor.boots.count).toEqualTypeOf(); - expect(pitArmor.boots.name).toBeDefined(); - expectTypeOf(pitArmor.boots.name).toEqualTypeOf(); - expect(pitArmor.boots.lore).toBeDefined(); - expectTypeOf(pitArmor.boots.lore).toEqualTypeOf(); - expect(pitArmor.boots.loreArray).toBeDefined(); - expectTypeOf(pitArmor.boots.loreArray).toEqualTypeOf(); - expect(pitArmor.boots.extraAttributes).toBeDefined(); - expectTypeOf(pitArmor.boots.extraAttributes).toEqualTypeOf(); - } - } - expect(data.stats.quakecraft).toBeDefined(); - expectTypeOf(data.stats.quakecraft).toEqualTypeOf(); - if (null !== data.stats.quakecraft) { - expect(data.stats.quakecraft).toBeInstanceOf(Quakecraft); - } - expect(data.stats.skywars).toBeDefined(); - expectTypeOf(data.stats.skywars).toEqualTypeOf(); - if (null !== data.stats.skywars) { - expect(data.stats.skywars).toBeInstanceOf(SkyWars); - } - expect(data.stats.smashheroes).toBeDefined(); - expectTypeOf(data.stats.smashheroes).toEqualTypeOf(); - if (null !== data.stats.smashheroes) { - expect(data.stats.smashheroes).toBeInstanceOf(SmashHeroes); - } - expect(data.stats.speeduhc).toBeDefined(); - expectTypeOf(data.stats.speeduhc).toEqualTypeOf(); - if (null !== data.stats.speeduhc) { - expect(data.stats.speeduhc).toBeInstanceOf(SpeedUHC); - } - expect(data.stats.tntgames).toBeDefined(); - expectTypeOf(data.stats.tntgames).toEqualTypeOf(); - if (null !== data.stats.tntgames) { - expect(data.stats.tntgames).toBeInstanceOf(TNTGames); - } - expect(data.stats.turbokartracers).toBeDefined(); - expectTypeOf(data.stats.turbokartracers).toEqualTypeOf(); - if (null !== data.stats.turbokartracers) { - expect(data.stats.turbokartracers).toBeInstanceOf(TurboKartRacers); - } - expect(data.stats.uhc).toBeDefined(); - expectTypeOf(data.stats.uhc).toEqualTypeOf(); - if (null !== data.stats.uhc) { - expect(data.stats.uhc).toBeInstanceOf(UHC); - } - expect(data.stats.vampirez).toBeDefined(); - expectTypeOf(data.stats.vampirez).toEqualTypeOf(); - if (null !== data.stats.vampirez) { - expect(data.stats.vampirez).toBeInstanceOf(VampireZ); - } - expect(data.stats.walls).toBeDefined(); - expectTypeOf(data.stats.walls).toEqualTypeOf(); - if (null !== data.stats.walls) { - expect(data.stats.walls).toBeInstanceOf(Walls); - } - expect(data.stats.warlords).toBeDefined(); - expectTypeOf(data.stats.warlords).toEqualTypeOf(); - if (null !== data.stats.warlords) { - expect(data.stats.warlords).toBeInstanceOf(Warlords); - } - expect(data.stats.woolgames).toBeDefined(); - expectTypeOf(data.stats.woolgames).toEqualTypeOf(); - if (null !== data.stats.woolgames) { - expect(data.stats.woolgames).toBeInstanceOf(WoolGames); - } - } + expectTypeOf(data.stats).toEqualTypeOf(); + + expect(data.stats.arcade).toBeDefined(); + expect(data.stats.arcade).instanceOf(Arcade); + expectTypeOf(data.stats.arcade).toEqualTypeOf(); + + expect(data.stats.arena).toBeDefined(); + expect(data.stats.arena).instanceOf(ArenaBrawl); + expectTypeOf(data.stats.arena).toEqualTypeOf(); + + expect(data.stats.bedwars).toBeDefined(); + expect(data.stats.bedwars).instanceOf(BedWars); + expectTypeOf(data.stats.bedwars).toEqualTypeOf(); + + expect(data.stats.blitzsg).toBeDefined(); + expect(data.stats.blitzsg).instanceOf(BlitzSurvivalGames); + expectTypeOf(data.stats.blitzsg).toEqualTypeOf(); + + expect(data.stats.buildbattle).toBeDefined(); + expect(data.stats.buildbattle).instanceOf(BuildBattle); + expectTypeOf(data.stats.buildbattle).toEqualTypeOf(); + + expect(data.stats.copsandcrims).toBeDefined(); + expect(data.stats.copsandcrims).instanceOf(CopsAndCrims); + expectTypeOf(data.stats.copsandcrims).toEqualTypeOf(); + + expect(data.stats.duels).toBeDefined(); + expect(data.stats.duels).instanceOf(Duels); + expectTypeOf(data.stats.duels).toEqualTypeOf(); + + expect(data.stats.megawalls).toBeDefined(); + expect(data.stats.megawalls).instanceOf(MegaWalls); + expectTypeOf(data.stats.megawalls).toEqualTypeOf(); + + expect(data.stats.murdermystery).toBeDefined(); + expect(data.stats.murdermystery).instanceOf(MurderMystery); + expectTypeOf(data.stats.murdermystery).toEqualTypeOf(); + + expect(data.stats.paintball).toBeDefined(); + expect(data.stats.paintball).instanceOf(Paintball); + expectTypeOf(data.stats.paintball).toEqualTypeOf(); + + expect(data.stats.pit).toBeDefined(); + expect(data.stats.pit).instanceOf(Pit); + expectTypeOf(data.stats.pit).toEqualTypeOf(); + + expect(data.stats.quakecraft).toBeDefined(); + expect(data.stats.quakecraft).instanceOf(Quakecraft); + expectTypeOf(data.stats.quakecraft).toEqualTypeOf(); + + expect(data.stats.skywars).toBeDefined(); + expect(data.stats.skywars).instanceOf(SkyWars); + expectTypeOf(data.stats.skywars).toEqualTypeOf(); + + expect(data.stats.smashheroes).toBeDefined(); + expect(data.stats.smashheroes).instanceOf(SmashHeroes); + expectTypeOf(data.stats.smashheroes).toEqualTypeOf(); + + expect(data.stats.speeduhc).toBeDefined(); + expect(data.stats.speeduhc).instanceOf(SpeedUHC); + expectTypeOf(data.stats.speeduhc).toEqualTypeOf(); + + expect(data.stats.tntgames).toBeDefined(); + expect(data.stats.tntgames).instanceOf(TNTGames); + expectTypeOf(data.stats.tntgames).toEqualTypeOf(); + + expect(data.stats.turbokartracers).toBeDefined(); + expect(data.stats.turbokartracers).instanceOf(TurboKartRacers); + expectTypeOf(data.stats.turbokartracers).toEqualTypeOf(); + + expect(data.stats.uhc).toBeDefined(); + expect(data.stats.uhc).instanceOf(UHC); + expectTypeOf(data.stats.uhc).toEqualTypeOf(); + + expect(data.stats.vampirez).toBeDefined(); + expect(data.stats.vampirez).instanceOf(VampireZ); + expectTypeOf(data.stats.vampirez).toEqualTypeOf(); + + expect(data.stats.walls).toBeDefined(); + expect(data.stats.walls).instanceOf(Walls); + expectTypeOf(data.stats.walls).toEqualTypeOf(); + + expect(data.stats.warlords).toBeDefined(); + expect(data.stats.warlords).instanceOf(Warlords); + expectTypeOf(data.stats.warlords).toEqualTypeOf(); + + expect(data.stats.woolgames).toBeDefined(); + expect(data.stats.woolgames).toBeInstanceOf(WoolGames); + expectTypeOf(data.stats.woolgames).toEqualTypeOf(); + expect(data.userLanguage).toBeDefined(); expectTypeOf(data.userLanguage).toEqualTypeOf(); expect(data.claimedLevelingRewards).toBeDefined(); diff --git a/src/API/getPlayerHouses.test.ts b/src/API/getPlayerHouses.test.ts index e43c3cee..5c6d237a 100644 --- a/src/API/getPlayerHouses.test.ts +++ b/src/API/getPlayerHouses.test.ts @@ -3,7 +3,7 @@ import House from '../structures/House'; import { expect, expectTypeOf, test } from 'vitest'; test('getPlayerHouses (No input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getPlayerHouses()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); @@ -11,7 +11,7 @@ test('getPlayerHouses (No input)', () => { }); test('getPlayerHouses (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getPlayerHouses('69e04609da2a4e7dabb83546a971969e', { raw: true }); @@ -21,7 +21,7 @@ test('getPlayerHouses (raw)', async () => { }); test('getPlayerHouses', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getPlayerHouses('69e04609da2a4e7dabb83546a971969e'); @@ -38,9 +38,9 @@ test('getPlayerHouses', async () => { expect(house.owner).toBeDefined(); expectTypeOf(house.owner).toEqualTypeOf(); expect(house.createdAtTimestamp).toBeDefined(); - expectTypeOf(house.createdAtTimestamp).toEqualTypeOf(); + expectTypeOf(house.createdAtTimestamp).toEqualTypeOf(); expect(house.createdAt).toBeDefined(); - expectTypeOf(house.createdAt).toEqualTypeOf(); + expectTypeOf(house.createdAt).toEqualTypeOf(); expect(house.players).toBeDefined(); expectTypeOf(house.players).toEqualTypeOf(); expect(house.cookies).toBeDefined(); diff --git a/src/API/getQuests.test.ts b/src/API/getQuests.test.ts index 85d2c855..83f0f07b 100644 --- a/src/API/getQuests.test.ts +++ b/src/API/getQuests.test.ts @@ -6,7 +6,7 @@ import { StaticGameNames } from '../typings'; import { expect, expectTypeOf, test } from 'vitest'; test('getQuests (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getQuests({ raw: true }); @@ -16,7 +16,7 @@ test('getQuests (raw)', async () => { }); test('getQuests', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getQuests(); diff --git a/src/API/getRecentGames.test.ts b/src/API/getRecentGames.test.ts index 1ace40b2..09afe66a 100644 --- a/src/API/getRecentGames.test.ts +++ b/src/API/getRecentGames.test.ts @@ -1,9 +1,10 @@ import Client from '../Client'; +import Game from '../structures/Game'; import RecentGame from '../structures/RecentGame'; import { expect, expectTypeOf, test } from 'vitest'; test('getRecentGames (no input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getRecentGames()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); @@ -11,7 +12,7 @@ test('getRecentGames (no input)', () => { }); test('getRecentGames (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getRecentGames('3b76b69ae5134296a730ed49171ad6f8', { raw: true }); @@ -21,7 +22,7 @@ test('getRecentGames (raw)', async () => { }); test('getRecentGames', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getRecentGames('ea805d40e8284d8d8e64e9fc8ac301ca'); @@ -31,6 +32,8 @@ test('getRecentGames', async () => { expect(game).toBeDefined(); expectTypeOf(game).toEqualTypeOf(); expect(game).toBeInstanceOf(RecentGame); + expect(game.game).toBeDefined(); + expectTypeOf(game.game).toEqualTypeOf(); expect(game.dateTimestamp).toBeDefined(); expectTypeOf(game.dateTimestamp).toEqualTypeOf(); expect(game.dateAt).toBeDefined(); @@ -45,6 +48,9 @@ test('getRecentGames', async () => { expectTypeOf(game.endedTimestamp).toEqualTypeOf(); expect(game.endedAt).toBeDefined(); expectTypeOf(game.endedAt).toEqualTypeOf(); + expect(game.toString()).toBeDefined(); + expect(game.toString()).toEqual(game.mode); + expectTypeOf(game.toString()).toEqualTypeOf(); }); client.destroy(); }); diff --git a/src/API/getSkyblockAuction.test.ts b/src/API/getSkyblockAuction.test.ts index 1abdf269..03b086a9 100644 --- a/src/API/getSkyblockAuction.test.ts +++ b/src/API/getSkyblockAuction.test.ts @@ -2,11 +2,11 @@ import Auction from '../structures/SkyBlock/Auctions/Auction'; import Bid from '../structures/SkyBlock/Auctions/Bid'; import Client from '../Client'; import ItemBytes from '../structures/ItemBytes'; -import { SkyblockRarity } from '../utils/SkyblockUtils'; +import { Rarity } from '../structures/SkyBlock/SkyblockMemberTypes'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockAuction (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -19,15 +19,15 @@ test('getSkyblockAuction (raw)', async () => { }); test('getSkyblockAuction (No Query)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error - expect(() => client.getSkyblockAuction('player')).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); + expect(() => client.getSkyblockAuction('auction', '')).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); client.destroy(); }); test('getSkyblockAuction (Bad Filter)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockAuction('meow')).rejects.toThrowError(client.errors.BAD_AUCTION_FILTER); @@ -35,7 +35,7 @@ test('getSkyblockAuction (Bad Filter)', () => { }); test('getSkyblockAuction (Auction)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -62,6 +62,7 @@ test('getSkyblockAuction (Auction)', async () => { expect(auction.bin).toBeDefined(); expectTypeOf(auction.bin).toEqualTypeOf(); expect(auction.itemBytes).toBeDefined(); + expect(auction.itemBytes).toBeNull(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); @@ -81,7 +82,7 @@ test('getSkyblockAuction (Auction)', async () => { expect(auction.itemLoreRaw).toBeDefined(); expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); expect(auction.highestBid).toBeDefined(); @@ -93,18 +94,18 @@ test('getSkyblockAuction (Auction)', async () => { expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); @@ -121,7 +122,7 @@ test('getSkyblockAuction (Auction)', async () => { }); test('getSkyblockAuction (Player)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -147,6 +148,7 @@ test('getSkyblockAuction (Player)', async () => { expectTypeOf(auction.auctioneerProfile).toEqualTypeOf(); expect(auction.bin).toBeDefined(); expectTypeOf(auction.bin).toEqualTypeOf(); + expect(auction.itemBytes).toBeNull(); expect(auction.itemBytes).toBeDefined(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); expect(auction.coop).toBeDefined(); @@ -167,7 +169,7 @@ test('getSkyblockAuction (Player)', async () => { expect(auction.itemLoreRaw).toBeDefined(); expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); expect(auction.highestBid).toBeDefined(); @@ -179,18 +181,18 @@ test('getSkyblockAuction (Player)', async () => { expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); @@ -207,7 +209,7 @@ test('getSkyblockAuction (Player)', async () => { }); test('getSkyblockAuction (Profile)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -234,6 +236,7 @@ test('getSkyblockAuction (Profile)', async () => { expect(auction.bin).toBeDefined(); expectTypeOf(auction.bin).toEqualTypeOf(); expect(auction.itemBytes).toBeDefined(); + expect(auction.itemBytes).toBeNull(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); @@ -253,7 +256,7 @@ test('getSkyblockAuction (Profile)', async () => { expect(auction.itemLoreRaw).toBeDefined(); expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); expect(auction.highestBid).toBeDefined(); @@ -265,18 +268,116 @@ test('getSkyblockAuction (Profile)', async () => { expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); + expectTypeOf(bid.bidder).toEqualTypeOf(); + expect(bid.toString()).toBeDefined(); + expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); + expectTypeOf(bid.toString()).toEqualTypeOf(); + }); + expect(auction.claimed).toBeDefined(); + expectTypeOf(auction.claimed).toEqualTypeOf(); + expect(auction.claimedBidders).toBeDefined(); + expectTypeOf(auction.claimedBidders).toEqualTypeOf(); + expect(auction.toString()).toBeDefined(); + expect(auction.toString()).toEqual(auction.item); + expectTypeOf(auction.toString()).toEqualTypeOf(); + }); + client.destroy(); +}); + +test('getSkyblockAuction (Include Item Bytes)', async () => { + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-expect-error + const auctions = await client.getSkyblockAuctions(1); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-expect-error + const data = await client.getSkyblockAuction('profile', auctions.auctions[0].auctioneerProfile, { + includeItemBytes: true + }); + expect(data).toBeDefined(); + expectTypeOf(data).toEqualTypeOf(); + + expect(data).toBeDefined(); + expectTypeOf(data).toEqualTypeOf(); + expect(data.length).greaterThanOrEqual(0); + expectTypeOf(data.length).toEqualTypeOf(); + data.forEach((auction: Auction) => { + expect(auction).toBeDefined(); + expect(auction).toBeInstanceOf(Auction); + expectTypeOf(auction).toEqualTypeOf(); + expect(auction.auctionId).toBeDefined(); + expectTypeOf(auction.auctionId).toEqualTypeOf(); + expect(auction.auctioneerUuid).toBeDefined(); + expectTypeOf(auction.auctioneerUuid).toEqualTypeOf(); + expect(auction.auctioneerProfile).toBeDefined(); + expectTypeOf(auction.auctioneerProfile).toEqualTypeOf(); + expect(auction.bin).toBeDefined(); + expectTypeOf(auction.bin).toEqualTypeOf(); + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + expect(auction.itemBytes).toBeDefined(); + if (auction.itemBytes) { + expect(auction.itemBytes).instanceOf(ItemBytes); + expect(auction.itemBytes.bytesBuffer).toBeDefined(); + expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf(); + expect(auction.itemBytes.base64).toBeDefined(); + expectTypeOf(auction.itemBytes.base64).toEqualTypeOf<() => string>(); + expect(auction.itemBytes.base64()).toBeDefined(); + expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf(); + } + expect(auction.coop).toBeDefined(); + expectTypeOf(auction.coop).toEqualTypeOf(); + expect(auction.auctionStartTimestamp).toBeDefined(); + expect(auction.auctionStartTimestamp).greaterThanOrEqual(0); + expectTypeOf(auction.auctionStartTimestamp).toEqualTypeOf(); + expect(auction.auctionStart).toBeDefined(); + expectTypeOf(auction.auctionStart).toEqualTypeOf(); + expect(auction.auctionEndTimestamp).toBeDefined(); + expectTypeOf(auction.auctionEndTimestamp).toEqualTypeOf(); + expect(auction.auctionEnd).toBeDefined(); + expectTypeOf(auction.auctionEnd).toEqualTypeOf(); + expect(auction.item).toBeDefined(); + expectTypeOf(auction.item).toEqualTypeOf(); + expect(auction.itemLore).toBeDefined(); + expectTypeOf(auction.itemLore).toEqualTypeOf(); + expect(auction.itemLoreRaw).toBeDefined(); + expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); + expect(auction.rarity).toBeDefined(); + expectTypeOf(auction.rarity).toEqualTypeOf(); + expect(auction.startingBid).toBeDefined(); + expectTypeOf(auction.startingBid).toEqualTypeOf(); + expect(auction.highestBid).toBeDefined(); + expectTypeOf(auction.highestBid).toEqualTypeOf(); + expect(auction.bids).toBeDefined(); + expectTypeOf(auction.bids).toEqualTypeOf(); + auction.bids.forEach((bid: Bid) => { + expect(bid).toBeDefined(); + expect(bid).toBeInstanceOf(Bid); + expectTypeOf(bid).toEqualTypeOf(); + expect(bid.auctionId).toBeDefined(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); + expect(bid.profileId).toBeDefined(); + expectTypeOf(bid.profileId).toEqualTypeOf(); + expect(bid.amount).toBeDefined(); + expect(bid.amount).greaterThanOrEqual(0); + expectTypeOf(bid.amount).toEqualTypeOf(); + expect(bid.timestamp).toBeDefined(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); + expect(bid.at).toBeDefined(); + expectTypeOf(bid.at).toEqualTypeOf(); + expect(bid.bidder).toBeDefined(); + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); diff --git a/src/API/getSkyblockAuction.ts b/src/API/getSkyblockAuction.ts index a797f173..d5da391e 100644 --- a/src/API/getSkyblockAuction.ts +++ b/src/API/getSkyblockAuction.ts @@ -18,7 +18,7 @@ class getSkyblockAction extends Endpoint { let filter; if ('profile' === type) { filter = 'profile'; - } else if ('player' === type) { + } else if ('player' === type && query) { query = await this.client.requestHandler.toUUID(query); filter = 'player'; } else if ('auction' === type) { diff --git a/src/API/getSkyblockAuctions.test.ts b/src/API/getSkyblockAuctions.test.ts index 8474afc5..0403b38c 100644 --- a/src/API/getSkyblockAuctions.test.ts +++ b/src/API/getSkyblockAuctions.test.ts @@ -3,11 +3,11 @@ import AuctionInfo from '../structures/SkyBlock/Auctions/AuctionInfo'; import Bid from '../structures/SkyBlock/Auctions/Bid'; import Client from '../Client'; import ItemBytes from '../structures/ItemBytes'; -import { SkyblockRarity } from '../utils/SkyblockUtils'; +import { Rarity } from '../structures/SkyBlock/SkyblockMemberTypes'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockAuctions (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockAuctions(1, { raw: true }); @@ -17,7 +17,7 @@ test('getSkyblockAuctions (raw)', async () => { }); test('getSkyblockAuctions (No input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockAuctions()).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE); @@ -25,7 +25,7 @@ test('getSkyblockAuctions (No input)', () => { }); test('getSkyblockAuctions (Negative Input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockAuctions(-1)).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE); @@ -33,7 +33,7 @@ test('getSkyblockAuctions (Negative Input)', () => { }); test('getSkyblockAuctions (Page 0)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockAuctions(0)).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE); @@ -41,7 +41,7 @@ test('getSkyblockAuctions (Page 0)', () => { }); test('getSkyblockAuctions (String Input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockAuctions('hi')).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE); @@ -49,7 +49,7 @@ test('getSkyblockAuctions (String Input)', () => { }); test('getSkyblockAuctions (One Page)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockAuctions(1); @@ -90,6 +90,16 @@ test('getSkyblockAuctions (One Page)', async () => { expectTypeOf(auction.bin).toEqualTypeOf(); expect(auction.itemBytes).toBeDefined(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); + if (auction.itemBytes) { + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + expect(auction.itemBytes.bytesBuffer).toBeDefined(); + expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf(); + expect(auction.itemBytes.base64).toBeDefined(); + expectTypeOf(auction.itemBytes.base64).toEqualTypeOf<() => string>(); + expect(auction.itemBytes.base64()).toBeDefined(); + expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf(); + } expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); expect(auction.auctionStartTimestamp).toBeDefined(); @@ -108,7 +118,7 @@ test('getSkyblockAuctions (One Page)', async () => { expect(auction.itemLoreRaw).toBeDefined(); expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); expect(auction.highestBid).toBeDefined(); @@ -120,18 +130,18 @@ test('getSkyblockAuctions (One Page)', async () => { expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); @@ -148,7 +158,7 @@ test('getSkyblockAuctions (One Page)', async () => { }); test('getSkyblockAuctions (One Page Include Item Bytes)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockAuctions(1, { includeItemBytes: true }); @@ -189,6 +199,16 @@ test('getSkyblockAuctions (One Page Include Item Bytes)', async () => { expectTypeOf(auction.bin).toEqualTypeOf(); expect(auction.itemBytes).toBeDefined(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); + if (auction.itemBytes) { + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + expect(auction.itemBytes.bytesBuffer).toBeDefined(); + expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf(); + expect(auction.itemBytes.base64).toBeDefined(); + expectTypeOf(auction.itemBytes.base64).toEqualTypeOf<() => string>(); + expect(auction.itemBytes.base64()).toBeDefined(); + expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf(); + } expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); expect(auction.auctionStartTimestamp).toBeDefined(); @@ -207,7 +227,7 @@ test('getSkyblockAuctions (One Page Include Item Bytes)', async () => { expect(auction.itemLoreRaw).toBeDefined(); expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); expect(auction.highestBid).toBeDefined(); @@ -219,18 +239,18 @@ test('getSkyblockAuctions (One Page Include Item Bytes)', async () => { expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); @@ -246,7 +266,7 @@ test('getSkyblockAuctions (One Page Include Item Bytes)', async () => { client.destroy(); }); -test.skip('getSkyblockAuctions (All Pages)', async () => { +test('getSkyblockAuctions (All Pages)', async () => { const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error @@ -288,6 +308,16 @@ test.skip('getSkyblockAuctions (All Pages)', async () => { expectTypeOf(auction.bin).toEqualTypeOf(); expect(auction.itemBytes).toBeDefined(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); + if (auction.itemBytes) { + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + expect(auction.itemBytes.bytesBuffer).toBeDefined(); + expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf(); + expect(auction.itemBytes.base64).toBeDefined(); + expectTypeOf(auction.itemBytes.base64).toEqualTypeOf<() => string>(); + expect(auction.itemBytes.base64()).toBeDefined(); + expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf(); + } expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); expect(auction.auctionStartTimestamp).toBeDefined(); @@ -306,7 +336,7 @@ test.skip('getSkyblockAuctions (All Pages)', async () => { expect(auction.itemLoreRaw).toBeDefined(); expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); expect(auction.highestBid).toBeDefined(); @@ -318,18 +348,18 @@ test.skip('getSkyblockAuctions (All Pages)', async () => { expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); diff --git a/src/API/getSkyblockAuctionsByPlayer.test.ts b/src/API/getSkyblockAuctionsByPlayer.test.ts index 29bab135..2d539365 100644 --- a/src/API/getSkyblockAuctionsByPlayer.test.ts +++ b/src/API/getSkyblockAuctionsByPlayer.test.ts @@ -2,11 +2,11 @@ import Auction from '../structures/SkyBlock/Auctions/Auction'; import Bid from '../structures/SkyBlock/Auctions/Bid'; import Client from '../Client'; import ItemBytes from '../structures/ItemBytes'; -import { SkyblockRarity } from '../utils/SkyblockUtils'; +import { Rarity } from '../structures/SkyBlock/SkyblockMemberTypes'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockAuctionsByPlayer (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -19,7 +19,7 @@ test('getSkyblockAuctionsByPlayer (raw)', async () => { }); test('getSkyblockAuctionsByPlayer (No Input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockAuctionsByPlayer()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); @@ -27,7 +27,7 @@ test('getSkyblockAuctionsByPlayer (No Input)', () => { }); test('getSkyblockAuctionsByPlayer', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -56,7 +56,18 @@ test('getSkyblockAuctionsByPlayer', async () => { expect(auction.itemBytes).toBeDefined(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); - + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + if (auction.itemBytes) { + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + expect(auction.itemBytes.bytesBuffer).toBeDefined(); + expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf(); + expect(auction.itemBytes.base64).toBeDefined(); + expectTypeOf(auction.itemBytes.base64).toEqualTypeOf<() => string>(); + expect(auction.itemBytes.base64()).toBeDefined(); + expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf(); + } expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); @@ -83,7 +94,7 @@ test('getSkyblockAuctionsByPlayer', async () => { expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); @@ -97,26 +108,19 @@ test('getSkyblockAuctionsByPlayer', async () => { expect(bid).toBeDefined(); expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); - expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); - + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); - + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); - expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); - + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); - + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); - + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); @@ -137,7 +141,7 @@ test('getSkyblockAuctionsByPlayer', async () => { }); test('getSkyblockAuctionsByPlayer (Item Bytes)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const auctions = await client.getSkyblockAuctions(1); @@ -168,6 +172,16 @@ test('getSkyblockAuctionsByPlayer (Item Bytes)', async () => { expect(auction.itemBytes).toBeDefined(); expectTypeOf(auction.itemBytes).toEqualTypeOf(); + if (auction.itemBytes) { + expect(auction.itemBytes).toBeDefined(); + expectTypeOf(auction.itemBytes).toEqualTypeOf(); + expect(auction.itemBytes.bytesBuffer).toBeDefined(); + expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf(); + expect(auction.itemBytes.base64).toBeDefined(); + expectTypeOf(auction.itemBytes.base64).toEqualTypeOf<() => string>(); + expect(auction.itemBytes.base64()).toBeDefined(); + expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf(); + } expect(auction.coop).toBeDefined(); expectTypeOf(auction.coop).toEqualTypeOf(); @@ -195,7 +209,7 @@ test('getSkyblockAuctionsByPlayer (Item Bytes)', async () => { expectTypeOf(auction.itemLoreRaw).toEqualTypeOf(); expect(auction.rarity).toBeDefined(); - expectTypeOf(auction.rarity).toEqualTypeOf(); + expectTypeOf(auction.rarity).toEqualTypeOf(); expect(auction.startingBid).toBeDefined(); expectTypeOf(auction.startingBid).toEqualTypeOf(); @@ -209,26 +223,19 @@ test('getSkyblockAuctionsByPlayer (Item Bytes)', async () => { expect(bid).toBeDefined(); expect(bid).toBeInstanceOf(Bid); expectTypeOf(bid).toEqualTypeOf(); - expect(bid.auctionId).toBeDefined(); - expectTypeOf(bid.auctionId).toEqualTypeOf(); - + expectTypeOf(bid.auctionId).toEqualTypeOf(); expect(bid.profileId).toBeDefined(); - expectTypeOf(bid.profileId).toEqualTypeOf(); - + expectTypeOf(bid.profileId).toEqualTypeOf(); expect(bid.amount).toBeDefined(); expect(bid.amount).greaterThanOrEqual(0); expectTypeOf(bid.amount).toEqualTypeOf(); - expect(bid.timestamp).toBeDefined(); - expectTypeOf(bid.timestamp).toEqualTypeOf(); - + expectTypeOf(bid.timestamp).toEqualTypeOf(); expect(bid.at).toBeDefined(); - expectTypeOf(bid.at).toEqualTypeOf(); - + expectTypeOf(bid.at).toEqualTypeOf(); expect(bid.bidder).toBeDefined(); - expectTypeOf(bid.bidder).toEqualTypeOf(); - + expectTypeOf(bid.bidder).toEqualTypeOf(); expect(bid.toString()).toBeDefined(); expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`); expectTypeOf(bid.toString()).toEqualTypeOf(); diff --git a/src/API/getSkyblockAuctionsByPlayer.ts b/src/API/getSkyblockAuctionsByPlayer.ts index 7aa9611f..dcfa4f2c 100644 --- a/src/API/getSkyblockAuctionsByPlayer.ts +++ b/src/API/getSkyblockAuctionsByPlayer.ts @@ -13,7 +13,7 @@ class getSkyblockActionsByPlayer extends Endpoint { async execute(query: string, options?: AuctionRequestOptions): Promise { if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID); query = await this.client.requestHandler.toUUID(query); - const res = await this.client.requestHandler.request(`/skyblock/auction?player=${query}`); + const res = await this.client.requestHandler.request(`/skyblock/auction?player=${query}`, options); if (res.options.raw) return res.data; return res.data.auctions.map((a: any) => new Auction(a, options?.includeItemBytes ?? false)); } diff --git a/src/API/getSkyblockBazaar.test.ts b/src/API/getSkyblockBazaar.test.ts index ba3b94a3..70e23111 100644 --- a/src/API/getSkyblockBazaar.test.ts +++ b/src/API/getSkyblockBazaar.test.ts @@ -1,10 +1,10 @@ import Client from '../Client'; -import Order from '../structures/SkyBlock/Bazzar/Order'; -import Product from '../structures/SkyBlock/Bazzar/Product'; +import Order from '../structures/SkyBlock/Bazaar/Order'; +import Product from '../structures/SkyBlock/Bazaar/Product'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockBazarr (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockBazaar({ raw: true }); @@ -13,7 +13,7 @@ test('getSkyblockBazarr (raw)', async () => { client.destroy(); }); test('getSkyblockBazarr', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockBazaar(); diff --git a/src/API/getSkyblockBazaar.ts b/src/API/getSkyblockBazaar.ts index 2747b1ba..c22cf0d4 100644 --- a/src/API/getSkyblockBazaar.ts +++ b/src/API/getSkyblockBazaar.ts @@ -1,6 +1,6 @@ import Client from '../Client'; import Endpoint from '../Private/Endpoint'; -import Product from '../structures/SkyBlock/Bazzar/Product'; +import Product from '../structures/SkyBlock/Bazaar/Product'; import { RequestOptions } from '../Private/RequestHandler'; class getSkyblockBazaar extends Endpoint { diff --git a/src/API/getSkyblockBingo.test.ts b/src/API/getSkyblockBingo.test.ts index 3240fc80..f86ec670 100644 --- a/src/API/getSkyblockBingo.test.ts +++ b/src/API/getSkyblockBingo.test.ts @@ -4,7 +4,7 @@ import Client from '../Client'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockBingo (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockBingo({ raw: true }); @@ -14,7 +14,7 @@ test('getSkyblockBingo (raw)', async () => { }); test('getSkyblockBingo', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockBingo(); diff --git a/src/API/getSkyblockFireSales.test.ts b/src/API/getSkyblockFireSales.test.ts index 19fb1e71..2c203d33 100644 --- a/src/API/getSkyblockFireSales.test.ts +++ b/src/API/getSkyblockFireSales.test.ts @@ -1,9 +1,8 @@ import Client from '../Client'; -import FireSale from '../structures/SkyBlock/Static/FireSale'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockFireSales (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockFireSales({ raw: true }); @@ -12,32 +11,45 @@ test('getSkyblockFireSales (raw)', async () => { client.destroy(); }); -test('getSkyblockFireSales', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); - // eslint-disable-next-line @typescript-eslint/ban-ts-comment - // @ts-expect-error - const data = await client.getSkyblockFireSales(); - expect(data).toBeDefined(); - expectTypeOf(data).toEqualTypeOf(); - data.forEach((firesale: FireSale) => { - expect(firesale).toBeDefined(); - expect(firesale).toBeInstanceOf(FireSale); - expectTypeOf(firesale).toEqualTypeOf(); - expect(firesale.itemId).toBeDefined(); - expectTypeOf(firesale.itemId).toEqualTypeOf(); - expect(firesale.startTimestamp).toBeDefined(); - expect(firesale.startTimestamp).toBeGreaterThanOrEqual(0); - expectTypeOf(firesale.startTimestamp).toEqualTypeOf(); - expect(firesale.startAt).toBeDefined(); - expectTypeOf(firesale.startAt).toEqualTypeOf(); - expect(firesale.endTimestamp).toBeDefined(); - expectTypeOf(firesale.endTimestamp).toEqualTypeOf(); - expect(firesale.endTimestamp).toBeGreaterThanOrEqual(0); - expect(firesale.endAt).toBeDefined(); - expectTypeOf(firesale.endAt).toEqualTypeOf(); - expect(firesale.amount).toBeDefined(); - expectTypeOf(firesale.amount).toEqualTypeOf(); - expect(firesale.amount).toBeGreaterThanOrEqual(0); - }); - client.destroy(); -}); +// test('getSkyblockFireSales', async () => { +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); +// vi.spyOn(axios, 'get').mockResolvedValue({ +// status: 200, +// data: { +// success: true, +// sales: [ +// { item_id: 'PET_SKIN_LION_WHITE', start: 1725120000000, end: 1725552000000, amount: 6500, price: 650 }, +// { item_id: 'PET_SKIN_LION_BLACK', start: 1725120000000, end: 1725552000000, amount: 6500, price: 650 } +// ] +// } +// }); +// // eslint-disable-next-line @typescript-eslint/ban-ts-comment +// // @ts-expect-error +// const data = await client.getSkyblockFireSales(); +// expect(data).toBeDefined(); +// expectTypeOf(data).toEqualTypeOf(); +// data.forEach((firesale: FireSale) => { +// expect(firesale).toBeDefined(); +// expect(firesale).toBeInstanceOf(FireSale); +// expectTypeOf(firesale).toEqualTypeOf(); +// expect(firesale.itemId).toBeDefined(); +// expectTypeOf(firesale.itemId).toEqualTypeOf(); +// expect(firesale.startTimestamp).toBeDefined(); +// expect(firesale.startTimestamp).toBeGreaterThanOrEqual(0); +// expectTypeOf(firesale.startTimestamp).toEqualTypeOf(); +// expect(firesale.startAt).toBeDefined(); +// expectTypeOf(firesale.startAt).toEqualTypeOf(); +// expect(firesale.endTimestamp).toBeDefined(); +// expectTypeOf(firesale.endTimestamp).toEqualTypeOf(); +// expect(firesale.endTimestamp).toBeGreaterThanOrEqual(0); +// expect(firesale.endAt).toBeDefined(); +// expectTypeOf(firesale.endAt).toEqualTypeOf(); +// expect(firesale.amount).toBeDefined(); +// expectTypeOf(firesale.amount).toEqualTypeOf(); +// expect(firesale.amount).toBeGreaterThanOrEqual(0); +// expect(firesale.toString()).toBeDefined(); +// expectTypeOf(firesale.toString()).toEqualTypeOf(); +// expect(firesale.toString()).toBe(firesale.itemId); +// }); +// client.destroy(); +// }); diff --git a/src/API/getSkyblockGarden.test.ts b/src/API/getSkyblockGarden.test.ts index 38cf0d6c..b5bbf03e 100644 --- a/src/API/getSkyblockGarden.test.ts +++ b/src/API/getSkyblockGarden.test.ts @@ -5,11 +5,11 @@ import SkyblockGarden, { SkyblockGardenVisitor, SkyblockGarenCrops } from '../structures/SkyBlock/SkyblockGarden'; -import { SkyblockSkillLevel } from '../utils/SkyblockUtils'; +import { SkillLevel } from '../structures/SkyBlock/SkyblockMemberTypes'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockGarden (no input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockGarden()).rejects.toThrowError(client.errors.NO_UUID); @@ -17,7 +17,7 @@ test('getSkyblockGarden (no input)', () => { }); test('getSkyblockGarden (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockGarden('805c9751-0ff1-4cb6-8e9c-1067bf3bc601', { raw: true }); @@ -27,7 +27,7 @@ test('getSkyblockGarden (raw)', async () => { }); test('getSkyblockGarden', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockGarden('805c9751-0ff1-4cb6-8e9c-1067bf3bc601'); @@ -36,7 +36,7 @@ test('getSkyblockGarden', async () => { expectTypeOf(data).toEqualTypeOf(); expect(data.level).toBeDefined(); - expectTypeOf(data.level).toEqualTypeOf(); + expectTypeOf(data.level).toEqualTypeOf(); expect(data.barnSkin).toBeDefined(); expectTypeOf(data.barnSkin).toEqualTypeOf(); diff --git a/src/API/getSkyblockGovernment.test.ts b/src/API/getSkyblockGovernment.test.ts index 452e322c..9f91fa76 100644 --- a/src/API/getSkyblockGovernment.test.ts +++ b/src/API/getSkyblockGovernment.test.ts @@ -5,7 +5,7 @@ import Perk from '../structures/SkyBlock/Static/Perk'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockGovernment (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockGovernment({ raw: true }); @@ -15,7 +15,7 @@ test('getSkyblockGovernment (raw)', async () => { }); test('getSkyblockGovernment', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockGovernment(); diff --git a/src/API/getSkyblockMember.test.ts b/src/API/getSkyblockMember.test.ts index 332fbf5d..8ce72506 100644 --- a/src/API/getSkyblockMember.test.ts +++ b/src/API/getSkyblockMember.test.ts @@ -1,25 +1,26 @@ import Client from '../Client'; import SkyblockGarden from '../structures/SkyBlock/SkyblockGarden'; import SkyblockInventoryItem, { SkyblockGemstone } from '../structures/SkyBlock/SkyblockInventoryItem'; -import SkyblockMember, { SkyblockMemberArmor, SkyblockMemberEquipment } from '../structures/SkyBlock/SkyblockMember'; +import SkyblockMember, { MemberStats } from '../structures/SkyBlock/SkyblockMember'; import SkyblockMuseum from '../structures/SkyBlock/SkyblockMuseum'; import SkyblockPet from '../structures/SkyBlock/SkyblockPet'; -import { NetworthResult } from 'skyhelper-networth'; import { - SkyblockMemberChocolateFactoryData, - SkyblockMemberDungeons, - SkyblockMemberHOTM, - SkyblockMemberJacobData, - SkyblockMemberSkills, - SkyblockMemberSlayer, - SkyblockMemberStats, - SkyblockMemberTrophyFishRank, - SkyblockRarity -} from '../utils/SkyblockUtils'; + Armor, + ChocolateFactoryData, + CrimsonIsle, + Dungeons, + Equipment, + HOTM, + JacobData, + Rarity, + Skills, + Slayer +} from '../structures/SkyBlock/SkyblockMemberTypes'; +import { NetworthResult } from 'skyhelper-networth'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockMember (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e', { raw: true }); @@ -29,7 +30,7 @@ test('getSkyblockMember (raw)', async () => { }); test('getSkyblockMember (no input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockMember()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); @@ -37,7 +38,7 @@ test('getSkyblockMember (no input)', () => { }); test('getSkyblockMember (no profiles)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockMember('b45add7b081443909fb00aa9a3e15eb0')).rejects.toThrowError( @@ -46,263 +47,614 @@ test('getSkyblockMember (no profiles)', () => { client.destroy(); }); +test('getSkyblockMember (museum)', async () => { + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-expect-error + const data = await client.getSkyblockMember('add71246c46e455c8345c129ea6f146c', { museum: true }); + expect(data).toBeDefined(); + expectTypeOf(data).toEqualTypeOf(); + data.forEach(async (member: SkyblockMember) => { + expect(member).toBeDefined(); + expect(member).toBeInstanceOf(SkyblockMember); + expectTypeOf(member).toEqualTypeOf(); + expect(member.uuid).toBeDefined(); + expectTypeOf(member.uuid).toEqualTypeOf(); + expect(member.gameMode).toBeDefined(); + expectTypeOf(member.gameMode).toEqualTypeOf(); + expect(member.selected).toBeDefined(); + expectTypeOf(member.selected).toEqualTypeOf(); + expect(member.garden).toBeDefined(); + expect(member.garden).toBeNull(); + expectTypeOf(member.garden).toEqualTypeOf(); + expect(member.museum).toBeDefined(); + expectTypeOf(member.museum).toEqualTypeOf(); + expect(member.profileName).toBeDefined(); + expectTypeOf(member.profileName).toEqualTypeOf(); + expect(member.profileId).toBeDefined(); + expectTypeOf(member.profileId).toEqualTypeOf(); + expect(member.firstJoinTimestamp).toBeDefined(); + expectTypeOf(member.firstJoinTimestamp).toEqualTypeOf(); + expect(member.firstJoinAt).toBeDefined(); + expectTypeOf(member.firstJoinAt).toEqualTypeOf(); + expect(member.experience).toBeDefined(); + expect(member.experience).toBeGreaterThanOrEqual(0); + expectTypeOf(member.experience).toEqualTypeOf(); + expect(member.level).toBeDefined(); + expectTypeOf(member.level).toEqualTypeOf(); + expect(member.hotm).toBeDefined(); + expectTypeOf(member.hotm).toEqualTypeOf(); + expect(member.highestMagicalPower).toBeDefined(); + expectTypeOf(member.highestMagicalPower).toEqualTypeOf(); + expect(member.fairySouls).toBeDefined(); + expectTypeOf(member.fairySouls).toEqualTypeOf(); + expect(member.fairyExchanges).toBeDefined(); + expectTypeOf(member.fairyExchanges).toEqualTypeOf(); + expect(member.skills).toBeDefined(); + expectTypeOf(member.skills).toEqualTypeOf(); + expect(member.bestiary).toBeDefined(); + expectTypeOf(member.bestiary).toEqualTypeOf(); + expect(member.slayer).toBeDefined(); + expectTypeOf(member.slayer).toEqualTypeOf(); + expect(member.crimsonIsle).toBeDefined(); + expectTypeOf(member.crimsonIsle).toEqualTypeOf(); + expect(member.dungeons).toBeDefined(); + expectTypeOf(member.dungeons).toEqualTypeOf(); + expect(member.collections).toBeDefined(); + expectTypeOf(member.collections).toEqualTypeOf>(); + expect(member.purse).toBeDefined(); + expectTypeOf(member.purse).toEqualTypeOf(); + expect(member.stats).toBeDefined(); + expectTypeOf(member.stats).toEqualTypeOf(); + expect(member.pets).toBeDefined(); + expectTypeOf(member.pets).toEqualTypeOf(); + member.pets.forEach((pet: SkyblockPet) => { + expect(pet).toBeDefined(); + expect(pet).toBeInstanceOf(SkyblockPet); + expectTypeOf(pet).toEqualTypeOf(); + expect(pet.uuid).toBeDefined(); + expectTypeOf(pet.uuid).toEqualTypeOf(); + expect(pet.name).toBeDefined(); + expectTypeOf(pet.name).toEqualTypeOf(); + expect(pet.xp).toBeDefined(); + expect(pet.xp).toBeGreaterThanOrEqual(0); + expectTypeOf(pet.xp).toEqualTypeOf(); + expect(pet.active).toBeDefined(); + expectTypeOf(pet.active).toEqualTypeOf(); + expect(pet.rarity).toBeDefined(); + expectTypeOf(pet.rarity).toEqualTypeOf(); + expect(pet.petScore).toBeDefined(); + expect(pet.petScore).toBeGreaterThanOrEqual(0); + expectTypeOf(pet.petScore).toEqualTypeOf(); + expect(pet.heldItem).toBeDefined(); + expectTypeOf(pet.heldItem).toEqualTypeOf(); + expect(pet.candyUsed).toBeDefined(); + expect(pet.candyUsed).toBeGreaterThanOrEqual(0); + expectTypeOf(pet.candyUsed).toEqualTypeOf(); + expect(pet.skin).toBeDefined(); + expectTypeOf(pet.skin).toEqualTypeOf(); + expect(pet.toString()).toBeDefined(); + expect(pet.toString()).toBe(pet.name); + expectTypeOf(pet.toString()).toEqualTypeOf(); + }); + expect(member.jacob).toBeDefined(); + expectTypeOf(member.jacob).toEqualTypeOf(); + expect(member.chocolate).toBeDefined(); + expectTypeOf(member.chocolate).toEqualTypeOf(); + expect(member.getArmor()).toBeDefined(); + expectTypeOf(member.getArmor).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getArmor()).toEqualTypeOf>(); + expect(member.getWardrobe()).toBeDefined(); + expectTypeOf(member.getWardrobe).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getWardrobe()).toEqualTypeOf>(); + expect(member.getEnderChest()).toBeDefined(); + expectTypeOf(member.getEnderChest).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getEnderChest()).toEqualTypeOf>(); + expect(member.getInventory()).toBeDefined(); + expectTypeOf(member.getInventory).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getInventory()).toEqualTypeOf>(); + const inv = await member.getInventory(); + inv.forEach((item: SkyblockInventoryItem) => { + expect(item.itemId).toBeDefined(); + expect(item.itemId).toBeGreaterThanOrEqual(0); + expectTypeOf(item.itemId).toEqualTypeOf(); + expect(item.count).toBeDefined(); + expect(item.count).toBeGreaterThanOrEqual(0); + expectTypeOf(item.count).toEqualTypeOf(); + expect(item.name).toBeDefined(); + expectTypeOf(item.name).toEqualTypeOf(); + expect(item.lore).toBeDefined(); + expectTypeOf(item.lore).toEqualTypeOf(); + expect(item.loreArray).toBeDefined(); + expectTypeOf(item.loreArray).toEqualTypeOf(); + expect(item.loreForEmbed).toBeDefined(); + expectTypeOf(item.loreForEmbed).toEqualTypeOf(); + expect(item.color).toBeDefined(); + expectTypeOf(item.color).toEqualTypeOf(); + expect(item.enchantments).toBeDefined(); + expectTypeOf(item.enchantments).toEqualTypeOf>(); + expect(item.reforge).toBeDefined(); + expectTypeOf(item.reforge).toEqualTypeOf(); + expect(item.gemstones).toBeDefined(); + expectTypeOf(item.gemstones).toEqualTypeOf(); + expect(item.damage).toBeDefined(); + expect(item.damage).toBeGreaterThanOrEqual(0); + expectTypeOf(item.damage).toEqualTypeOf(); + expect(item.rarity).toBeDefined(); + expectTypeOf(item.rarity).toEqualTypeOf(); + expect(item.dungeonStars).toBeDefined(); + expect(item.dungeonStars).toBeGreaterThanOrEqual(0); + expectTypeOf(item.dungeonStars).toEqualTypeOf(); + expect(item.gearScore).toBeDefined(); + expect(item.gearScore).toBeGreaterThanOrEqual(0); + expectTypeOf(item.gearScore).toEqualTypeOf(); + expect(item.uuid).toBeDefined(); + expectTypeOf(item.uuid).toEqualTypeOf(); + expect(item.soulbound).toBeDefined(); + expectTypeOf(item.soulbound).toEqualTypeOf(); + expect(item.artOfWar).toBeDefined(); + expect(item.artOfWar).toBeGreaterThanOrEqual(0); + expectTypeOf(item.artOfWar).toEqualTypeOf(); + expect(item.rune).toBeDefined(); + expectTypeOf(item.rune).toEqualTypeOf(); + expect(item.hotPotatoBooks).toBeDefined(); + expect(item.hotPotatoBooks).toBeGreaterThanOrEqual(0); + expectTypeOf(item.hotPotatoBooks).toEqualTypeOf(); + expect(item.recombobulated).toBeDefined(); + expectTypeOf(item.recombobulated).toEqualTypeOf(); + expect(item.attributes).toBeDefined(); + expectTypeOf(item.attributes).toEqualTypeOf(); + expect(item.hecatomb).toBeDefined(); + expect(item.hecatomb).toBeGreaterThanOrEqual(0); + expectTypeOf(item.hecatomb).toEqualTypeOf(); + expect(item.champion).toBeDefined(); + expect(item.champion).toBeGreaterThanOrEqual(0); + expectTypeOf(item.champion).toEqualTypeOf(); + expect(item.cultivating).toBeDefined(); + expect(item.cultivating).toBeGreaterThanOrEqual(0); + expectTypeOf(item.cultivating).toEqualTypeOf(); + expect(item.expertise).toBeDefined(); + expect(item.expertise).toBeGreaterThanOrEqual(0); + expectTypeOf(item.expertise).toEqualTypeOf(); + expect(item.compact).toBeDefined(); + expect(item.compact).toBeGreaterThanOrEqual(0); + expectTypeOf(item.compact).toEqualTypeOf(); + expect(item.blocksWalked).toBeDefined(); + expect(item.blocksWalked).toBeGreaterThanOrEqual(0); + expectTypeOf(item.blocksWalked).toEqualTypeOf(); + expect(item.toString()).toBeDefined(); + expect(item.toString()).toBe(item.name); + expectTypeOf(item.toString()).toEqualTypeOf(); + }); + expect(member.getPetScore()).toBeDefined(); + expectTypeOf(member.getPetScore).toEqualTypeOf<() => number>(); + expect(member.getPetScore()).toBeGreaterThanOrEqual(0); + expectTypeOf(member.getPetScore()).toEqualTypeOf(); + expect(member.getEquipment()).toBeDefined(); + expectTypeOf(member.getEquipment).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getEquipment()).toEqualTypeOf>(); + expect(member.getPersonalVault()).toBeDefined(); + expectTypeOf(member.getPersonalVault).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getPersonalVault()).toEqualTypeOf>(); + expect(member.getNetworth()).toBeDefined(); + expectTypeOf(member.getNetworth).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getNetworth()).toEqualTypeOf>(); + expect(member.getFarmingWeight()).toBeDefined(); + expectTypeOf(member.getFarmingWeight).toEqualTypeOf<() => number>(); + expect(member.getFarmingWeight()).toBeGreaterThanOrEqual(0); + expectTypeOf(member.getFarmingWeight()).toEqualTypeOf(); + expect(member.getFarmingWeight()).greaterThanOrEqual(0); + expect(member.toString()).toBeDefined(); + expect(member.toString()).toBe(member.uuid); + expectTypeOf(member.toString()).toEqualTypeOf(); + }); + client.destroy(); +}); + +test('getSkyblockMember (garden)', async () => { + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-expect-error + const data = await client.getSkyblockMember('add71246c46e455c8345c129ea6f146c', { garden: true }); + expect(data).toBeDefined(); + expectTypeOf(data).toEqualTypeOf(); + data.forEach(async (member: SkyblockMember) => { + expect(member).toBeDefined(); + expect(member).toBeInstanceOf(SkyblockMember); + expectTypeOf(member).toEqualTypeOf(); + expect(member.uuid).toBeDefined(); + expectTypeOf(member.uuid).toEqualTypeOf(); + expect(member.gameMode).toBeDefined(); + expectTypeOf(member.gameMode).toEqualTypeOf(); + expect(member.selected).toBeDefined(); + expectTypeOf(member.selected).toEqualTypeOf(); + expect(member.garden).toBeDefined(); + expectTypeOf(member.garden).toEqualTypeOf(); + expect(member.museum).toBeDefined(); + expect(member.museum).toBeNull(); + expectTypeOf(member.museum).toEqualTypeOf(); + expect(member.profileName).toBeDefined(); + expectTypeOf(member.profileName).toEqualTypeOf(); + expect(member.profileId).toBeDefined(); + expectTypeOf(member.profileId).toEqualTypeOf(); + expect(member.firstJoinTimestamp).toBeDefined(); + expectTypeOf(member.firstJoinTimestamp).toEqualTypeOf(); + expect(member.firstJoinAt).toBeDefined(); + expectTypeOf(member.firstJoinAt).toEqualTypeOf(); + expect(member.experience).toBeDefined(); + expect(member.experience).toBeGreaterThanOrEqual(0); + expectTypeOf(member.experience).toEqualTypeOf(); + expect(member.level).toBeDefined(); + expectTypeOf(member.level).toEqualTypeOf(); + expect(member.hotm).toBeDefined(); + expectTypeOf(member.hotm).toEqualTypeOf(); + expect(member.highestMagicalPower).toBeDefined(); + expectTypeOf(member.highestMagicalPower).toEqualTypeOf(); + expect(member.fairySouls).toBeDefined(); + expectTypeOf(member.fairySouls).toEqualTypeOf(); + expect(member.fairyExchanges).toBeDefined(); + expectTypeOf(member.fairyExchanges).toEqualTypeOf(); + expect(member.skills).toBeDefined(); + expectTypeOf(member.skills).toEqualTypeOf(); + expect(member.bestiary).toBeDefined(); + expectTypeOf(member.bestiary).toEqualTypeOf(); + expect(member.slayer).toBeDefined(); + expectTypeOf(member.slayer).toEqualTypeOf(); + expect(member.crimsonIsle).toBeDefined(); + expectTypeOf(member.crimsonIsle).toEqualTypeOf(); + expect(member.dungeons).toBeDefined(); + expectTypeOf(member.dungeons).toEqualTypeOf(); + expect(member.collections).toBeDefined(); + expectTypeOf(member.collections).toEqualTypeOf>(); + expect(member.purse).toBeDefined(); + expectTypeOf(member.purse).toEqualTypeOf(); + expect(member.stats).toBeDefined(); + expectTypeOf(member.stats).toEqualTypeOf(); + expect(member.pets).toBeDefined(); + expectTypeOf(member.pets).toEqualTypeOf(); + member.pets.forEach((pet: SkyblockPet) => { + expect(pet).toBeDefined(); + expect(pet).toBeInstanceOf(SkyblockPet); + expectTypeOf(pet).toEqualTypeOf(); + expect(pet.uuid).toBeDefined(); + expectTypeOf(pet.uuid).toEqualTypeOf(); + expect(pet.name).toBeDefined(); + expectTypeOf(pet.name).toEqualTypeOf(); + expect(pet.xp).toBeDefined(); + expect(pet.xp).toBeGreaterThanOrEqual(0); + expectTypeOf(pet.xp).toEqualTypeOf(); + expect(pet.active).toBeDefined(); + expectTypeOf(pet.active).toEqualTypeOf(); + expect(pet.rarity).toBeDefined(); + expectTypeOf(pet.rarity).toEqualTypeOf(); + expect(pet.petScore).toBeDefined(); + expect(pet.petScore).toBeGreaterThanOrEqual(0); + expectTypeOf(pet.petScore).toEqualTypeOf(); + expect(pet.heldItem).toBeDefined(); + expectTypeOf(pet.heldItem).toEqualTypeOf(); + expect(pet.candyUsed).toBeDefined(); + expect(pet.candyUsed).toBeGreaterThanOrEqual(0); + expectTypeOf(pet.candyUsed).toEqualTypeOf(); + expect(pet.skin).toBeDefined(); + expectTypeOf(pet.skin).toEqualTypeOf(); + expect(pet.toString()).toBeDefined(); + expect(pet.toString()).toBe(pet.name); + expectTypeOf(pet.toString()).toEqualTypeOf(); + }); + expect(member.jacob).toBeDefined(); + expectTypeOf(member.jacob).toEqualTypeOf(); + expect(member.chocolate).toBeDefined(); + expectTypeOf(member.chocolate).toEqualTypeOf(); + expect(member.getArmor()).toBeDefined(); + expectTypeOf(member.getArmor).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getArmor()).toEqualTypeOf>(); + expect(member.getWardrobe()).toBeDefined(); + expectTypeOf(member.getWardrobe).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getWardrobe()).toEqualTypeOf>(); + expect(member.getEnderChest()).toBeDefined(); + expectTypeOf(member.getEnderChest).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getEnderChest()).toEqualTypeOf>(); + expect(member.getInventory()).toBeDefined(); + expectTypeOf(member.getInventory).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getInventory()).toEqualTypeOf>(); + const inv = await member.getInventory(); + inv.forEach((item: SkyblockInventoryItem) => { + expect(item.itemId).toBeDefined(); + expect(item.itemId).toBeGreaterThanOrEqual(0); + expectTypeOf(item.itemId).toEqualTypeOf(); + expect(item.count).toBeDefined(); + expect(item.count).toBeGreaterThanOrEqual(0); + expectTypeOf(item.count).toEqualTypeOf(); + expect(item.name).toBeDefined(); + expectTypeOf(item.name).toEqualTypeOf(); + expect(item.lore).toBeDefined(); + expectTypeOf(item.lore).toEqualTypeOf(); + expect(item.loreArray).toBeDefined(); + expectTypeOf(item.loreArray).toEqualTypeOf(); + expect(item.loreForEmbed).toBeDefined(); + expectTypeOf(item.loreForEmbed).toEqualTypeOf(); + expect(item.color).toBeDefined(); + expectTypeOf(item.color).toEqualTypeOf(); + expect(item.enchantments).toBeDefined(); + expectTypeOf(item.enchantments).toEqualTypeOf>(); + expect(item.reforge).toBeDefined(); + expectTypeOf(item.reforge).toEqualTypeOf(); + expect(item.gemstones).toBeDefined(); + expectTypeOf(item.gemstones).toEqualTypeOf(); + expect(item.damage).toBeDefined(); + expect(item.damage).toBeGreaterThanOrEqual(0); + expectTypeOf(item.damage).toEqualTypeOf(); + expect(item.rarity).toBeDefined(); + expectTypeOf(item.rarity).toEqualTypeOf(); + expect(item.dungeonStars).toBeDefined(); + expect(item.dungeonStars).toBeGreaterThanOrEqual(0); + expectTypeOf(item.dungeonStars).toEqualTypeOf(); + expect(item.gearScore).toBeDefined(); + expect(item.gearScore).toBeGreaterThanOrEqual(0); + expectTypeOf(item.gearScore).toEqualTypeOf(); + expect(item.uuid).toBeDefined(); + expectTypeOf(item.uuid).toEqualTypeOf(); + expect(item.soulbound).toBeDefined(); + expectTypeOf(item.soulbound).toEqualTypeOf(); + expect(item.artOfWar).toBeDefined(); + expect(item.artOfWar).toBeGreaterThanOrEqual(0); + expectTypeOf(item.artOfWar).toEqualTypeOf(); + expect(item.rune).toBeDefined(); + expectTypeOf(item.rune).toEqualTypeOf(); + expect(item.hotPotatoBooks).toBeDefined(); + expect(item.hotPotatoBooks).toBeGreaterThanOrEqual(0); + expectTypeOf(item.hotPotatoBooks).toEqualTypeOf(); + expect(item.recombobulated).toBeDefined(); + expectTypeOf(item.recombobulated).toEqualTypeOf(); + expect(item.attributes).toBeDefined(); + expectTypeOf(item.attributes).toEqualTypeOf(); + expect(item.hecatomb).toBeDefined(); + expect(item.hecatomb).toBeGreaterThanOrEqual(0); + expectTypeOf(item.hecatomb).toEqualTypeOf(); + expect(item.champion).toBeDefined(); + expect(item.champion).toBeGreaterThanOrEqual(0); + expectTypeOf(item.champion).toEqualTypeOf(); + expect(item.cultivating).toBeDefined(); + expect(item.cultivating).toBeGreaterThanOrEqual(0); + expectTypeOf(item.cultivating).toEqualTypeOf(); + expect(item.expertise).toBeDefined(); + expect(item.expertise).toBeGreaterThanOrEqual(0); + expectTypeOf(item.expertise).toEqualTypeOf(); + expect(item.compact).toBeDefined(); + expect(item.compact).toBeGreaterThanOrEqual(0); + expectTypeOf(item.compact).toEqualTypeOf(); + expect(item.blocksWalked).toBeDefined(); + expect(item.blocksWalked).toBeGreaterThanOrEqual(0); + expectTypeOf(item.blocksWalked).toEqualTypeOf(); + expect(item.toString()).toBeDefined(); + expect(item.toString()).toBe(item.name); + expectTypeOf(item.toString()).toEqualTypeOf(); + }); + expect(member.getPetScore()).toBeDefined(); + expectTypeOf(member.getPetScore).toEqualTypeOf<() => number>(); + expect(member.getPetScore()).toBeGreaterThanOrEqual(0); + expectTypeOf(member.getPetScore()).toEqualTypeOf(); + expect(member.getEquipment()).toBeDefined(); + expectTypeOf(member.getEquipment).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getEquipment()).toEqualTypeOf>(); + expect(member.getPersonalVault()).toBeDefined(); + expectTypeOf(member.getPersonalVault).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getPersonalVault()).toEqualTypeOf>(); + expect(member.getNetworth()).toBeDefined(); + expectTypeOf(member.getNetworth).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getNetworth()).toEqualTypeOf>(); + expect(member.getFarmingWeight()).toBeDefined(); + expectTypeOf(member.getFarmingWeight).toEqualTypeOf<() => number>(); + expect(member.getFarmingWeight()).toBeGreaterThanOrEqual(0); + expectTypeOf(member.getFarmingWeight()).toEqualTypeOf(); + expect(member.getFarmingWeight()).greaterThanOrEqual(0); + expect(member.toString()).toBeDefined(); + expect(member.toString()).toBe(member.uuid); + expectTypeOf(member.toString()).toEqualTypeOf(); + }); + client.destroy(); +}); test('getSkyblockMember', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e'); expect(data).toBeDefined(); expectTypeOf(data).toEqualTypeOf(); - data.forEach(async (member: SkyblockMember) => { expect(member).toBeDefined(); expect(member).toBeInstanceOf(SkyblockMember); expectTypeOf(member).toEqualTypeOf(); - expect(member.uuid).toBeDefined(); expectTypeOf(member.uuid).toEqualTypeOf(); - expect(member.gameMode).toBeDefined(); expectTypeOf(member.gameMode).toEqualTypeOf(); - expect(member.selected).toBeDefined(); expectTypeOf(member.selected).toEqualTypeOf(); - expect(member.garden).toBeDefined(); expect(member.garden).toBeNull(); expectTypeOf(member.garden).toEqualTypeOf(); - expect(member.museum).toBeDefined(); + expect(member.museum).toBeNull(); expectTypeOf(member.museum).toEqualTypeOf(); - expect(member.profileName).toBeDefined(); expectTypeOf(member.profileName).toEqualTypeOf(); - expect(member.profileId).toBeDefined(); expectTypeOf(member.profileId).toEqualTypeOf(); - expect(member.firstJoinTimestamp).toBeDefined(); - expectTypeOf(member.firstJoinTimestamp).toEqualTypeOf(); - + expectTypeOf(member.firstJoinTimestamp).toEqualTypeOf(); expect(member.firstJoinAt).toBeDefined(); - expectTypeOf(member.firstJoinAt).toEqualTypeOf(); - + expectTypeOf(member.firstJoinAt).toEqualTypeOf(); expect(member.experience).toBeDefined(); + expect(member.experience).toBeGreaterThanOrEqual(0); expectTypeOf(member.experience).toEqualTypeOf(); - expect(member.level).toBeDefined(); expectTypeOf(member.level).toEqualTypeOf(); - expect(member.hotm).toBeDefined(); - expectTypeOf(member.hotm).toEqualTypeOf(); - - expect(member.trophyFish).toBeDefined(); - expectTypeOf(member.trophyFish).toEqualTypeOf(); - + expectTypeOf(member.hotm).toEqualTypeOf(); expect(member.highestMagicalPower).toBeDefined(); expectTypeOf(member.highestMagicalPower).toEqualTypeOf(); - expect(member.fairySouls).toBeDefined(); expectTypeOf(member.fairySouls).toEqualTypeOf(); - expect(member.fairyExchanges).toBeDefined(); expectTypeOf(member.fairyExchanges).toEqualTypeOf(); - expect(member.skills).toBeDefined(); - expectTypeOf(member.skills).toEqualTypeOf(); - + expectTypeOf(member.skills).toEqualTypeOf(); expect(member.bestiary).toBeDefined(); expectTypeOf(member.bestiary).toEqualTypeOf(); - expect(member.slayer).toBeDefined(); - expectTypeOf(member.slayer).toEqualTypeOf(); - + expectTypeOf(member.slayer).toEqualTypeOf(); + expect(member.crimsonIsle).toBeDefined(); + expectTypeOf(member.crimsonIsle).toEqualTypeOf(); expect(member.dungeons).toBeDefined(); - expectTypeOf(member.dungeons).toEqualTypeOf(); - + expectTypeOf(member.dungeons).toEqualTypeOf(); expect(member.collections).toBeDefined(); expectTypeOf(member.collections).toEqualTypeOf>(); - expect(member.purse).toBeDefined(); expectTypeOf(member.purse).toEqualTypeOf(); - expect(member.stats).toBeDefined(); - expectTypeOf(member.stats).toEqualTypeOf(); - + expectTypeOf(member.stats).toEqualTypeOf(); expect(member.pets).toBeDefined(); expectTypeOf(member.pets).toEqualTypeOf(); member.pets.forEach((pet: SkyblockPet) => { expect(pet).toBeDefined(); expect(pet).toBeInstanceOf(SkyblockPet); expectTypeOf(pet).toEqualTypeOf(); - expect(pet.uuid).toBeDefined(); expectTypeOf(pet.uuid).toEqualTypeOf(); - expect(pet.name).toBeDefined(); expectTypeOf(pet.name).toEqualTypeOf(); - expect(pet.xp).toBeDefined(); + expect(pet.xp).toBeGreaterThanOrEqual(0); expectTypeOf(pet.xp).toEqualTypeOf(); - expect(pet.active).toBeDefined(); expectTypeOf(pet.active).toEqualTypeOf(); - expect(pet.rarity).toBeDefined(); - expectTypeOf(pet.rarity).toEqualTypeOf(); - + expectTypeOf(pet.rarity).toEqualTypeOf(); expect(pet.petScore).toBeDefined(); + expect(pet.petScore).toBeGreaterThanOrEqual(0); expectTypeOf(pet.petScore).toEqualTypeOf(); - expect(pet.heldItem).toBeDefined(); expectTypeOf(pet.heldItem).toEqualTypeOf(); - expect(pet.candyUsed).toBeDefined(); + expect(pet.candyUsed).toBeGreaterThanOrEqual(0); expectTypeOf(pet.candyUsed).toEqualTypeOf(); - expect(pet.skin).toBeDefined(); expectTypeOf(pet.skin).toEqualTypeOf(); - expect(pet.toString()).toBeDefined(); expect(pet.toString()).toBe(pet.name); expectTypeOf(pet.toString()).toEqualTypeOf(); }); - expect(member.jacob).toBeDefined(); - expectTypeOf(member.jacob).toEqualTypeOf(); - + expectTypeOf(member.jacob).toEqualTypeOf(); expect(member.chocolate).toBeDefined(); - expectTypeOf(member.chocolate).toEqualTypeOf(); - + expectTypeOf(member.chocolate).toEqualTypeOf(); expect(member.getArmor()).toBeDefined(); - expectTypeOf(member.getArmor).toEqualTypeOf<() => Promise>(); - expectTypeOf(member.getArmor()).toEqualTypeOf>(); - + expectTypeOf(member.getArmor).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getArmor()).toEqualTypeOf>(); expect(member.getWardrobe()).toBeDefined(); expectTypeOf(member.getWardrobe).toEqualTypeOf<() => Promise>(); expectTypeOf(member.getWardrobe()).toEqualTypeOf>(); - expect(member.getEnderChest()).toBeDefined(); expectTypeOf(member.getEnderChest).toEqualTypeOf<() => Promise>(); expectTypeOf(member.getEnderChest()).toEqualTypeOf>(); - expect(member.getInventory()).toBeDefined(); expectTypeOf(member.getInventory).toEqualTypeOf<() => Promise>(); expectTypeOf(member.getInventory()).toEqualTypeOf>(); - const inv = await member.getInventory(); inv.forEach((item: SkyblockInventoryItem) => { expect(item.itemId).toBeDefined(); + expect(item.itemId).toBeGreaterThanOrEqual(0); expectTypeOf(item.itemId).toEqualTypeOf(); - expect(item.count).toBeDefined(); + expect(item.count).toBeGreaterThanOrEqual(0); expectTypeOf(item.count).toEqualTypeOf(); - expect(item.name).toBeDefined(); expectTypeOf(item.name).toEqualTypeOf(); - expect(item.lore).toBeDefined(); expectTypeOf(item.lore).toEqualTypeOf(); - expect(item.loreArray).toBeDefined(); expectTypeOf(item.loreArray).toEqualTypeOf(); - expect(item.loreForEmbed).toBeDefined(); expectTypeOf(item.loreForEmbed).toEqualTypeOf(); - expect(item.color).toBeDefined(); expectTypeOf(item.color).toEqualTypeOf(); - expect(item.enchantments).toBeDefined(); expectTypeOf(item.enchantments).toEqualTypeOf>(); - expect(item.reforge).toBeDefined(); expectTypeOf(item.reforge).toEqualTypeOf(); - expect(item.gemstones).toBeDefined(); expectTypeOf(item.gemstones).toEqualTypeOf(); - expect(item.damage).toBeDefined(); + expect(item.damage).toBeGreaterThanOrEqual(0); expectTypeOf(item.damage).toEqualTypeOf(); - expect(item.rarity).toBeDefined(); expectTypeOf(item.rarity).toEqualTypeOf(); - expect(item.dungeonStars).toBeDefined(); + expect(item.dungeonStars).toBeGreaterThanOrEqual(0); expectTypeOf(item.dungeonStars).toEqualTypeOf(); - expect(item.gearScore).toBeDefined(); + expect(item.gearScore).toBeGreaterThanOrEqual(0); expectTypeOf(item.gearScore).toEqualTypeOf(); - expect(item.uuid).toBeDefined(); expectTypeOf(item.uuid).toEqualTypeOf(); - expect(item.soulbound).toBeDefined(); expectTypeOf(item.soulbound).toEqualTypeOf(); - expect(item.artOfWar).toBeDefined(); + expect(item.artOfWar).toBeGreaterThanOrEqual(0); expectTypeOf(item.artOfWar).toEqualTypeOf(); - expect(item.rune).toBeDefined(); expectTypeOf(item.rune).toEqualTypeOf(); - expect(item.hotPotatoBooks).toBeDefined(); + expect(item.hotPotatoBooks).toBeGreaterThanOrEqual(0); expectTypeOf(item.hotPotatoBooks).toEqualTypeOf(); - expect(item.recombobulated).toBeDefined(); expectTypeOf(item.recombobulated).toEqualTypeOf(); - expect(item.attributes).toBeDefined(); expectTypeOf(item.attributes).toEqualTypeOf(); - expect(item.hecatomb).toBeDefined(); + expect(item.hecatomb).toBeGreaterThanOrEqual(0); expectTypeOf(item.hecatomb).toEqualTypeOf(); - expect(item.champion).toBeDefined(); + expect(item.champion).toBeGreaterThanOrEqual(0); expectTypeOf(item.champion).toEqualTypeOf(); - expect(item.cultivating).toBeDefined(); + expect(item.cultivating).toBeGreaterThanOrEqual(0); expectTypeOf(item.cultivating).toEqualTypeOf(); - expect(item.expertise).toBeDefined(); + expect(item.expertise).toBeGreaterThanOrEqual(0); expectTypeOf(item.expertise).toEqualTypeOf(); - expect(item.compact).toBeDefined(); + expect(item.compact).toBeGreaterThanOrEqual(0); expectTypeOf(item.compact).toEqualTypeOf(); - expect(item.blocksWalked).toBeDefined(); + expect(item.blocksWalked).toBeGreaterThanOrEqual(0); expectTypeOf(item.blocksWalked).toEqualTypeOf(); - expect(item.toString()).toBeDefined(); expect(item.toString()).toBe(item.name); expectTypeOf(item.toString()).toEqualTypeOf(); }); - expect(member.getPetScore()).toBeDefined(); expectTypeOf(member.getPetScore).toEqualTypeOf<() => number>(); + expect(member.getPetScore()).toBeGreaterThanOrEqual(0); expectTypeOf(member.getPetScore()).toEqualTypeOf(); - expect(member.getEquipment()).toBeDefined(); - expectTypeOf(member.getEquipment).toEqualTypeOf<() => Promise>(); - expectTypeOf(member.getEquipment()).toEqualTypeOf>(); - + expectTypeOf(member.getEquipment).toEqualTypeOf<() => Promise>(); + expectTypeOf(member.getEquipment()).toEqualTypeOf>(); expect(member.getPersonalVault()).toBeDefined(); expectTypeOf(member.getPersonalVault).toEqualTypeOf<() => Promise>(); expectTypeOf(member.getPersonalVault()).toEqualTypeOf>(); - expect(member.getNetworth()).toBeDefined(); expectTypeOf(member.getNetworth).toEqualTypeOf<() => Promise>(); expectTypeOf(member.getNetworth()).toEqualTypeOf>(); - expect(member.getFarmingWeight()).toBeDefined(); expectTypeOf(member.getFarmingWeight).toEqualTypeOf<() => number>(); + expect(member.getFarmingWeight()).toBeGreaterThanOrEqual(0); expectTypeOf(member.getFarmingWeight()).toEqualTypeOf(); expect(member.getFarmingWeight()).greaterThanOrEqual(0); - expect(member.toString()).toBeDefined(); expect(member.toString()).toBe(member.uuid); expectTypeOf(member.toString()).toEqualTypeOf(); }); - client.destroy(); }); diff --git a/src/API/getSkyblockMember.ts b/src/API/getSkyblockMember.ts index 8b174288..d9c64ebe 100644 --- a/src/API/getSkyblockMember.ts +++ b/src/API/getSkyblockMember.ts @@ -28,7 +28,7 @@ class getSkyblockMember extends Endpoint { garden: options?.garden ? await this.client.getSkyblockGarden(profile.profile_id) : null, // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error - museum: options?.garden ? await this.client.getSkyblockMuseum(query, profile.profile_id) : null, + museum: options?.museum ? await this.client.getSkyblockMuseum(query, profile.profile_id) : null, profileName: profile.cute_name, gameMode: profile.game_mode || null, m: profile.members[query], diff --git a/src/API/getSkyblockMuseum.test.ts b/src/API/getSkyblockMuseum.test.ts index f3e42654..d198ec91 100644 --- a/src/API/getSkyblockMuseum.test.ts +++ b/src/API/getSkyblockMuseum.test.ts @@ -5,8 +5,16 @@ import SkyblockMuseumItem from '../structures/SkyBlock/SkyblockMuseumItem'; import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile'; import { expect, expectTypeOf, test } from 'vitest'; +test('getSkyblockMuseum (no input)', () => { + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-expect-error + expect(() => client.getSkyblockMuseum()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); + client.destroy(); +}); + test('getSkyblockMuseum (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const profiles = await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41'); @@ -20,7 +28,7 @@ test('getSkyblockMuseum (raw)', async () => { }); test('getSkyblockMuseum', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const profiles = await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41'); diff --git a/src/API/getSkyblockNews.test.ts b/src/API/getSkyblockNews.test.ts index 1ea1aa24..424dbc71 100644 --- a/src/API/getSkyblockNews.test.ts +++ b/src/API/getSkyblockNews.test.ts @@ -3,7 +3,7 @@ import SkyblockNews from '../structures/SkyBlock/News/SkyblockNews'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockNews (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockNews({ raw: true }); @@ -13,7 +13,7 @@ test('getSkyblockNews (raw)', async () => { }); test('getSkyblockNews', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockNews(); diff --git a/src/API/getSkyblockProfiles.test.ts b/src/API/getSkyblockProfiles.test.ts index 81bdf50e..9a77dd6f 100644 --- a/src/API/getSkyblockProfiles.test.ts +++ b/src/API/getSkyblockProfiles.test.ts @@ -4,7 +4,7 @@ import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile'; import { expect, expectTypeOf, test } from 'vitest'; test('getSkyblockProfiles (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e', { raw: true }); @@ -14,7 +14,7 @@ test('getSkyblockProfiles (raw)', async () => { }); test('getSkyblockProfiles (no input)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockProfiles()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID); @@ -22,7 +22,7 @@ test('getSkyblockProfiles (no input)', () => { }); test('getSkyblockProfiles (no profiles)', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error expect(() => client.getSkyblockProfiles('b45add7b081443909fb00aa9a3e15eb0')).rejects.toThrowError( @@ -32,7 +32,7 @@ test('getSkyblockProfiles (no profiles)', () => { }); test('getSkyblockProfiles', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e'); @@ -76,7 +76,7 @@ test('getSkyblockProfiles', async () => { }); test('getSkyblockProfiles (garden)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockProfiles('add71246c46e455c8345c129ea6f146c', { garden: true }); @@ -120,7 +120,7 @@ test('getSkyblockProfiles (garden)', async () => { }); test('getSkyblockProfiles (museum)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41', { museum: true }); diff --git a/src/API/getStatus.test.ts b/src/API/getStatus.test.ts index 8be3ed67..bf6e3573 100644 --- a/src/API/getStatus.test.ts +++ b/src/API/getStatus.test.ts @@ -1,10 +1,10 @@ import Client from '../Client'; -import Game from '../structures/Game'; +import Game, { GameCode, GameID, GameString } from '../structures/Game'; import Status from '../structures/Status'; import { expect, expectTypeOf, test } from 'vitest'; test('getStatus (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getStatus('4982eac19ae7422891b61a17a74c87a2', { raw: true }); @@ -14,7 +14,7 @@ test('getStatus (raw)', async () => { }); test('getStatus', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getStatus('370d6421b761456fadf28c43fe5c4bcf'); @@ -27,6 +27,29 @@ test('getStatus', async () => { expect(data.game).toBeDefined(); expectTypeOf(data.game).toEqualTypeOf(); + if (data.game) { + expect(data.game).toBeDefined(); + expectTypeOf(data.game).toEqualTypeOf(); + expect(data.game.game).toBeDefined(); + expectTypeOf(data.game.game).toEqualTypeOf(); + expect(data.game.id).toBeDefined(); + expectTypeOf(data.game.id).toEqualTypeOf(); + expect(data.game.code).toBeDefined(); + expectTypeOf(data.game.code).toEqualTypeOf(); + expect(data.game.name).toBeDefined(); + expectTypeOf(data.game.name).toEqualTypeOf(); + expect(data.game.found).toBeDefined(); + expectTypeOf(data.game.found).toEqualTypeOf(); + expect(data.game.toString()).toBeDefined(); + expect(data.game.toString()).toBe(data.game.name); + expectTypeOf(data.game.toString()).toEqualTypeOf(); + expect(Game.IDS).toBeDefined(); + expectTypeOf(Game.IDS).toEqualTypeOf(); + expect(Game.CODES).toBeDefined(); + expectTypeOf(Game.CODES).toEqualTypeOf(); + expect(Game.NAMES).toBeDefined(); + expectTypeOf(Game.NAMES).toEqualTypeOf(); + } expect(data.mode).toBeDefined(); expectTypeOf(data.mode).toEqualTypeOf(); diff --git a/src/API/getWatchdogStats.test.ts b/src/API/getWatchdogStats.test.ts index a2704aa5..886244ba 100644 --- a/src/API/getWatchdogStats.test.ts +++ b/src/API/getWatchdogStats.test.ts @@ -1,9 +1,9 @@ import Client from '../Client'; -import WatchdogStats from '../structures/Watchdog/Stats'; +import WatchdogStats from '../structures/WatchdogStats'; import { expect, expectTypeOf, test } from 'vitest'; test('getWatchdogStats (raw)', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getWatchdogStats({ raw: true }); @@ -13,7 +13,7 @@ test('getWatchdogStats (raw)', async () => { }); test('getWatchdogStats', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false }); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // eslint-disable-next-line @typescript-eslint/ban-ts-comment // @ts-expect-error const data = await client.getWatchdogStats(); diff --git a/src/API/getWatchdogStats.ts b/src/API/getWatchdogStats.ts index ba734934..718491e6 100644 --- a/src/API/getWatchdogStats.ts +++ b/src/API/getWatchdogStats.ts @@ -1,6 +1,6 @@ import Client from '../Client'; import Endpoint from '../Private/Endpoint'; -import WatchdogStats from '../structures/Watchdog/Stats'; +import WatchdogStats from '../structures/WatchdogStats'; import { RequestOptions } from '../Private/RequestHandler'; class getWatchdogStats extends Endpoint { diff --git a/src/Private/CacheHandler.test.ts b/src/Private/CacheHandler.test.ts index df9f8339..9a2aa2a0 100644 --- a/src/Private/CacheHandler.test.ts +++ b/src/Private/CacheHandler.test.ts @@ -4,7 +4,7 @@ import NodeCache from 'node-cache'; import { expect, expectTypeOf, test } from 'vitest'; test('CacheHandler', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? ''); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); expect(client).toBeDefined(); expectTypeOf(client).toEqualTypeOf(); diff --git a/src/Private/Endpoint.test.ts b/src/Private/Endpoint.test.ts index 19c2fe31..321ea0b8 100644 --- a/src/Private/Endpoint.test.ts +++ b/src/Private/Endpoint.test.ts @@ -3,7 +3,7 @@ import Endpoint from './Endpoint'; import { expect, expectTypeOf, test } from 'vitest'; test('Endpoint', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? ''); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); expect(client).toBeDefined(); expectTypeOf(client).toEqualTypeOf(); diff --git a/src/Private/RateLimit.test.ts b/src/Private/RateLimit.test.ts index d2e5b241..bfb4b81a 100644 --- a/src/Private/RateLimit.test.ts +++ b/src/Private/RateLimit.test.ts @@ -66,15 +66,11 @@ test('RateLimit (Auto)', async () => { // test('Ratelimit (Sync)', async () => { // const client = new Client(process.env.HYPIXEL_KEY ?? ''); // client.updater.currentVersion = '1.0.0'; -// const mockRequest = { +// vi.spyOn(axios, 'get').mockResolvedValue({ // status: 200, // data: { success: true }, -// headers: { -// 'ratelimit-limit': 30, -// 'ratelimit-remaining': 27 -// } -// }; -// vi.spyOn(axios, 'get').mockResolvedValue(mockRequest); +// headers: { 'ratelimit-limit': 30, 'ratelimit-remaining': 27 } +// }); // expect(() => client.rateLimit.sync()).not.toThrowError(); // await client.rateLimit.sync(); // expect(client.rateLimit.requests).toBe(3); @@ -86,12 +82,7 @@ test('RateLimit (Auto)', async () => { // test('Ratelimit (Bad Sync Data)', () => { // const client = new Client(process.env.HYPIXEL_KEY ?? ''); // client.updater.currentVersion = '1.0.0'; -// const mockRequest = { -// status: 200, -// data: { success: true }, -// headers: { hello: 100 } -// }; -// vi.spyOn(axios, 'get').mockResolvedValue(mockRequest); +// vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { success: true }, headers: { hello: 100 } }); // expect(() => client.rateLimit.sync()).rejects.toThrowError(client.errors.RATE_LIMIT_INIT_ERROR); // vi.restoreAllMocks(); // client.destroy(); diff --git a/src/Private/RequestHandler.test.ts b/src/Private/RequestHandler.test.ts index b5719b78..daa113b2 100644 --- a/src/Private/RequestHandler.test.ts +++ b/src/Private/RequestHandler.test.ts @@ -3,7 +3,7 @@ import RequestHandler from './RequestHandler'; import { expect, expectTypeOf, test } from 'vitest'; test('RequestHandler', async () => { - const client = new Client(process.env.HYPIXEL_KEY ?? ''); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); expect(client).toBeDefined(); expectTypeOf(client).toEqualTypeOf(); @@ -25,7 +25,7 @@ test('RequestHandler', async () => { }); // test('RequestHandler (Invalid API Key)', () => { -// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // expect(client.requestHandler.request).toBeDefined(); // expectTypeOf(client.requestHandler.request).toBeFunction(); // vi.spyOn(axios, 'get').mockResolvedValue({ status: 403, data: {} }); @@ -34,8 +34,32 @@ test('RequestHandler', async () => { // client.destroy(); // }); +// test('RequestHandler (400 Bad Request)', () => { +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); +// expect(client.requestHandler.request).toBeDefined(); +// expectTypeOf(client.requestHandler.request).toBeFunction(); +// vi.spyOn(axios, 'get').mockResolvedValue({ status: 400, data: { cause: 'meow' } }); +// expect(() => client.requestHandler.request('/boosters')).rejects.toThrowError( +// client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace(/{cause}/, 'meow') +// ); +// vi.restoreAllMocks(); +// client.destroy(); +// }); + +// test('RequestHandler (400 Bad Request No Cause)', () => { +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); +// expect(client.requestHandler.request).toBeDefined(); +// expectTypeOf(client.requestHandler.request).toBeFunction(); +// vi.spyOn(axios, 'get').mockResolvedValue({ status: 400, data: {} }); +// expect(() => client.requestHandler.request('/boosters')).rejects.toThrowError( +// client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace(/{cause}/, 'Unknown') +// ); +// vi.restoreAllMocks(); +// client.destroy(); +// }); + // test('RequestHandler (Unprocessable Entity)', () => { -// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // expect(client.requestHandler.request).toBeDefined(); // expectTypeOf(client.requestHandler.request).toBeFunction(); // vi.spyOn(axios, 'get').mockResolvedValue({ status: 422, data: {} }); @@ -45,7 +69,7 @@ test('RequestHandler', async () => { // }); // test('RequestHandler (Rate Limited)', () => { -// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // expect(client.requestHandler.request).toBeDefined(); // expectTypeOf(client.requestHandler.request).toBeFunction(); // vi.spyOn(axios, 'get').mockResolvedValue({ status: 429, data: {} }); diff --git a/src/Private/RequestHandler.ts b/src/Private/RequestHandler.ts index 9c32a06e..0d76894d 100644 --- a/src/Private/RequestHandler.ts +++ b/src/Private/RequestHandler.ts @@ -62,7 +62,7 @@ class RequestHandler { throw new Error( this.client.errors.ERROR_CODE_CAUSE.replace(/{code}/, '400 Bad Request').replace( /{cause}/, - parsedRes.cause || '' + parsedRes.cause || 'Unknown' ) ); } diff --git a/src/Private/Updater.test.ts b/src/Private/Updater.test.ts index d7e51e99..f6d42a5b 100644 --- a/src/Private/Updater.test.ts +++ b/src/Private/Updater.test.ts @@ -4,7 +4,7 @@ import { expect, expectTypeOf, test } from 'vitest'; import { version } from '../../package.json'; test('Updater', () => { - const client = new Client(process.env.HYPIXEL_KEY ?? ''); + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); expect(client).toBeDefined(); expectTypeOf(client).toEqualTypeOf(); @@ -34,7 +34,7 @@ test('Updater', () => { }); // test('Updater (get latest version)', async () => { -// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { 'dist-tags': { latest: '1.0.0' } } }); // const data = await client.updater.getLatestVersion(); // expect(data).toBe('1.0.0'); @@ -43,7 +43,7 @@ test('Updater', () => { // }); // test('Updater (get latest version error)', () => { -// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // vi.spyOn(axios, 'get').mockResolvedValue({ status: 404, data: { 'dist-tags': { latest: '1.0.0' } } }); // expect(() => client.updater.getLatestVersion()).rejects.toThrowError(client.errors.UPDATER_REQUEST_NOT_OK); // vi.restoreAllMocks(); @@ -51,7 +51,7 @@ test('Updater', () => { // }); // test('Updater (check version)', async () => { -// const client = new Client(process.env.HYPIXEL_KEY ?? ''); +// const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); // const consoleLogSpy = vi.spyOn(console, 'log'); // client.updater.currentVersion = '1.0.0'; // vi.spyOn(axios, 'get').mockResolvedValue({ status: 200, data: { 'dist-tags': { latest: version } } }); diff --git a/src/index.ts b/src/index.ts index 7d5174eb..ea30c8c0 100644 --- a/src/index.ts +++ b/src/index.ts @@ -71,13 +71,12 @@ export * from './structures/Pets'; export * from './structures/Player'; export * from './structures/PlayerCosmetics'; export * from './structures/RecentGame'; -export * from './structures/ServerInfo'; export * from './structures/SkyBlock/Auctions/Auction'; export * from './structures/SkyBlock/Auctions/AuctionInfo'; export * from './structures/SkyBlock/Auctions/BaseAuction'; export * from './structures/SkyBlock/Auctions/Bid'; -export * from './structures/SkyBlock/Bazzar/Order'; -export * from './structures/SkyBlock/Bazzar/Product'; +export * from './structures/SkyBlock/Bazaar/Order'; +export * from './structures/SkyBlock/Bazaar/Product'; export * from './structures/SkyBlock/News/SkyblockNews'; export * from './structures/SkyBlock/SkyblockGarden'; export * from './structures/SkyBlock/SkyblockInventoryItem'; @@ -103,7 +102,7 @@ export * from './structures/Static/GuildAchievements'; export * from './structures/Static/Quest'; export * from './structures/Static/Quests'; export * from './structures/Status'; -export * from './structures/Watchdog/Stats'; +export * from './structures/WatchdogStats'; export * from './utils/Constants'; export * from './utils/Guild'; diff --git a/src/structures/Boosters/Booster.test.ts b/src/structures/Boosters/Booster.test.ts new file mode 100644 index 00000000..69dc8a98 --- /dev/null +++ b/src/structures/Boosters/Booster.test.ts @@ -0,0 +1,8 @@ +import { expect, test } from 'vitest'; +import { parseType } from './Booster'; + +test('Booster (parseType)', () => { + expect(parseType({ stacked: true })).toBe('STACKED'); + expect(parseType({ stacked: false })).toBe('QUEUED'); + expect(parseType({ stacked: 'meow' })).toBe('ACTIVE'); +}); diff --git a/src/structures/Boosters/Booster.ts b/src/structures/Boosters/Booster.ts index 89f72175..7c676e6b 100644 --- a/src/structures/Boosters/Booster.ts +++ b/src/structures/Boosters/Booster.ts @@ -1,6 +1,6 @@ import Game from '../Game'; -function parseType(data: Record): 'STACKED' | 'QUEUED' | 'ACTIVE' { +export function parseType(data: Record): 'STACKED' | 'QUEUED' | 'ACTIVE' { if (true === data.stacked) return 'STACKED'; if (!data.stacked) return 'QUEUED'; return 'ACTIVE'; @@ -13,7 +13,7 @@ class Booster { remaining: number; activatedTimestamp: number; activated: Date; - game: Game | null; + game: Game; isActive: boolean; type: 'STACKED' | 'QUEUED' | 'ACTIVE'; stackers: string[]; @@ -25,7 +25,7 @@ class Booster { this.remaining = data.length; this.activatedTimestamp = data.dateActivated; this.activated = new Date(data.dateActivated); - this.game = data.gameType ? new Game(data.gameType) : null; + this.game = new Game(data.gameType); this.isActive = Array.isArray(data.stacked); this.type = parseType(data); this.stackers = Array.isArray(data.stacked) ? Array.from(data.stacked) : []; diff --git a/src/structures/Color.test.ts b/src/structures/Color.test.ts new file mode 100644 index 00000000..f9c6daf4 --- /dev/null +++ b/src/structures/Color.test.ts @@ -0,0 +1,24 @@ +import Color, { ColorCode, ColorHex, ColorString, InGameCode } from './Color'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Color', () => { + const data = new Color('BLACK'); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Color); + expectTypeOf(data).toEqualTypeOf(); + expect(data.color).toBeDefined(); + expectTypeOf(data.color).toEqualTypeOf(); + expect(data.color).toBe('BLACK'); + expect(data.toString()).toBeDefined(); + expectTypeOf(data.toString()).toEqualTypeOf(); + expect(data.toString()).toBe('Black'); + expect(data.toHex()).toBeDefined(); + expectTypeOf(data.toHex()).toEqualTypeOf(); + expect(data.toHex()).toBe('#000000'); + expect(data.toCode()).toBeDefined(); + expectTypeOf(data.toCode()).toEqualTypeOf(); + expect(data.toCode()).toBe('BLACK'); + expect(data.toInGameCode()).toBeDefined(); + expectTypeOf(data.toInGameCode()).toEqualTypeOf(); + expect(data.toInGameCode()).toBe('§0'); +}); diff --git a/src/structures/Color.ts b/src/structures/Color.ts index 26311bf7..26684c6a 100644 --- a/src/structures/Color.ts +++ b/src/structures/Color.ts @@ -1,4 +1,38 @@ -const ColorStrings: { [key: string]: string } = { +export type ColorCode = + | 'BLACK' + | 'DARK_BLUE' + | 'DARK_GREEN' + | 'DARK_AQUA' + | 'DARK_RED' + | 'DARK_PURPLE' + | 'GOLD' + | 'GRAY' + | 'DARK_GRAY' + | 'BLUE' + | 'GREEN' + | 'AQUA' + | 'RED' + | 'LIGHT_PURPLE' + | 'YELLOW' + | 'WHITE'; +export type ColorString = + | 'Black' + | 'Dark Blue' + | 'Dark Green' + | 'Dark Aqua' + | 'Dark Red' + | 'Dark Purple' + | 'Gold' + | 'Gray' + | 'Dark Gray' + | 'Blue' + | 'Green' + | 'Aqua' + | 'Red' + | 'Light Purple' + | 'Yellow' + | 'White'; +const ColorStrings: { [key: string]: ColorString } = { BLACK: 'Black', DARK_BLUE: 'Dark Blue', DARK_GREEN: 'Dark Green', @@ -16,7 +50,24 @@ const ColorStrings: { [key: string]: string } = { YELLOW: 'Yellow', WHITE: 'White' }; -const ColorHex: { [key: string]: string } = { +export type ColorHex = + | '#000000' + | '#0000AA' + | '#008000' + | '#00AAAA' + | '#AA0000' + | '#AA00AA' + | '#FFAA00' + | '#AAAAAA' + | '#555555' + | '#5555FF' + | '#3CE63C' + | '#3CE6E6' + | '#FF5555' + | '#FF55FF' + | '#FFFF55' + | '#FFFFFF'; +const ColorHexs: { [key: string]: ColorHex } = { BLACK: '#000000', DARK_BLUE: '#0000AA', DARK_GREEN: '#008000', @@ -34,7 +85,24 @@ const ColorHex: { [key: string]: string } = { YELLOW: '#FFFF55', WHITE: '#FFFFFF' }; -const InGameCodes: { [key: string]: string } = { +export type InGameCode = + | '§0' + | '§1' + | '§2' + | '§3' + | '§4' + | '§5' + | '§6' + | '§7' + | '§8' + | '§9' + | '§a' + | '§b' + | '§c' + | '§d' + | '§e' + | '§f'; +const InGameCodes: { [key: string]: InGameCode } = { BLACK: '§0', DARK_BLUE: '§1', DARK_GREEN: '§2', @@ -54,24 +122,24 @@ const InGameCodes: { [key: string]: string } = { }; class Color { - color: string; - constructor(color: string) { + color: ColorCode; + constructor(color: ColorCode) { this.color = color; } - toString(): string { + toString(): ColorString { return ColorStrings[this.color]; } - toHex(): string { - return ColorHex[this.color]; + toHex(): ColorHex { + return ColorHexs[this.color]; } - toCode(): string { + toCode(): ColorCode { return this.color; } - toInGameCode() { + toInGameCode(): InGameCode { return InGameCodes[this.color]; } } diff --git a/src/structures/Game.ts b/src/structures/Game.ts index 6742fc25..0dc8d03b 100644 --- a/src/structures/Game.ts +++ b/src/structures/Game.ts @@ -1,4 +1,4 @@ -import Constants from '../utils/Constants'; +import { games } from '../utils/Constants'; export type GameString = | 'Quake Craft' | 'Walls' @@ -118,13 +118,17 @@ class Game { found: boolean; constructor(game: GameID | GameCode) { this.game = game; - const result = Constants.games.find( - (g) => g.code.toLowerCase() === this.game || g.id.toString() === this.game || g.name.toLowerCase() === this.game - ) as any; - this.id = result ? result.id : null; - this.code = result ? result.code : null; - this.name = result ? result.name : null; - this.found = Boolean(result); + const result = + games.find( + (Game) => + Game.code.toLowerCase() === this.game || + Game.id.toString() === this.game || + Game.name.toLowerCase() === this.game + ) || null; + this.id = result?.id || null; + this.code = result?.code || null; + this.name = result?.name || null; + this.found = null !== result; } toString(): GameString | null { @@ -132,15 +136,15 @@ class Game { } static get IDS(): GameID[] { - return Constants.games.map((x) => x.id as GameID); + return games.map((x) => x.id as GameID); } static get CODES(): GameCode[] { - return Constants.games.map((x) => x.code) as GameCode[]; + return games.map((x) => x.code) as GameCode[]; } static get NAMES(): GameString[] { - return Constants.games.map((x) => x.name) as GameString[]; + return games.map((x) => x.name) as GameString[]; } } diff --git a/src/structures/House.test.ts b/src/structures/House.test.ts new file mode 100644 index 00000000..9e54d5e4 --- /dev/null +++ b/src/structures/House.test.ts @@ -0,0 +1,25 @@ +import House from './House'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('House', () => { + const data = new House({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(House); + expectTypeOf(data).toEqualTypeOf(); + expect(data.name).toBeDefined(); + expectTypeOf(data.name).toEqualTypeOf(); + expect(data.uuid).toBeDefined(); + expectTypeOf(data.uuid).toEqualTypeOf(); + expect(data.owner).toBeDefined(); + expectTypeOf(data.owner).toEqualTypeOf(); + expect(data.createdAtTimestamp).toBeDefined(); + expectTypeOf(data.createdAtTimestamp).toEqualTypeOf(); + expect(data.createdAt).toBeDefined(); + expectTypeOf(data.createdAt).toEqualTypeOf(); + expect(data.players).toBeDefined(); + expect(data.players).greaterThanOrEqual(0); + expectTypeOf(data.players).toEqualTypeOf(); + expect(data.cookies).toBeDefined(); + expect(data.cookies).greaterThanOrEqual(0); + expectTypeOf(data.cookies).toEqualTypeOf(); +}); diff --git a/src/structures/House.ts b/src/structures/House.ts index bcc6071d..e3b6652c 100644 --- a/src/structures/House.ts +++ b/src/structures/House.ts @@ -2,16 +2,16 @@ class House { name: string; uuid: string; owner: string; - createdAtTimestamp: number; - createdAt: Date; + createdAtTimestamp: number | null; + createdAt: Date | null; players: number; cookies: number; constructor(data: Record) { this.name = data.name || ''; this.uuid = data.uuid || ''; this.owner = data.owner || ''; - this.createdAtTimestamp = data.createdAt || 0; - this.createdAt = new Date(this.createdAtTimestamp); + this.createdAtTimestamp = data.createdAt || null; + this.createdAt = this.createdAtTimestamp ? new Date(this.createdAtTimestamp) : null; this.players = data.players || 0; this.cookies = data.cookies?.current || 0; } diff --git a/src/structures/ItemBytes.ts b/src/structures/ItemBytes.ts index 1e5891fd..8076a3ba 100644 --- a/src/structures/ItemBytes.ts +++ b/src/structures/ItemBytes.ts @@ -1,5 +1,3 @@ -import { decode } from '../utils/SkyblockUtils'; - class ItemBytes { bytesBuffer: Buffer; constructor(data: Record) { @@ -9,10 +7,6 @@ class ItemBytes { base64(): string { return this.bytesBuffer.toString('base64'); } - - async readNBT(): Promise { - return await decode(this.bytesBuffer, true); - } } export default ItemBytes; diff --git a/src/structures/Leaderboard.test.ts b/src/structures/Leaderboard.test.ts new file mode 100644 index 00000000..10c1fda8 --- /dev/null +++ b/src/structures/Leaderboard.test.ts @@ -0,0 +1,27 @@ +import Leaderboard from './Leaderboard'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Leaderboard', () => { + const data = new Leaderboard({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Leaderboard); + expectTypeOf(data).toEqualTypeOf(); + expect(data.path).toBeDefined(); + expectTypeOf(data.path).toEqualTypeOf(); + expect(data.prefix).toBeDefined(); + expectTypeOf(data.prefix).toEqualTypeOf(); + expect(data.title).toBeDefined(); + expectTypeOf(data.title).toEqualTypeOf(); + expect(data.location).toBeDefined(); + expectTypeOf(data.location).toEqualTypeOf(); + expect(data.count).toBeDefined(); + expect(data.count).toBeGreaterThanOrEqual(0); + expectTypeOf(data.count).toEqualTypeOf(); + expect(data.leaders).toBeDefined(); + expectTypeOf(data.leaders).toEqualTypeOf(); + + data.leaders.forEach((leader: string) => { + expect(leader).toBeDefined(); + expectTypeOf(leader).toEqualTypeOf(); + }); +}); diff --git a/src/structures/Leaderboard.ts b/src/structures/Leaderboard.ts index 0040ae18..5780035b 100644 --- a/src/structures/Leaderboard.ts +++ b/src/structures/Leaderboard.ts @@ -1,13 +1,17 @@ class Leaderboard { - name: string | null; + path: string; + prefix: string; title: string; - playerCount: number; + location: string; + count: number; leaders: string[]; constructor(data: Record) { - this.name = data.prefix || null; - this.title = data.title || null; - this.playerCount = data.count || 0; - this.leaders = data.leaders || []; + this.path = data?.path || ''; + this.prefix = data?.prefix || ''; + this.title = data?.title || ''; + this.location = data?.location || '0,0,0'; + this.count = data?.count || 0; + this.leaders = data?.leaders || []; } } diff --git a/src/structures/MiniGames/Arcade.test.ts b/src/structures/MiniGames/Arcade.test.ts new file mode 100644 index 00000000..1a582b82 --- /dev/null +++ b/src/structures/MiniGames/Arcade.test.ts @@ -0,0 +1,629 @@ +import Arcade, { + BlockingDead, + BountyHunters, + DragonWars, + Dropper, + DropperMap, + EnderSpleef, + FarmHunt, + Football, + GalaxyWars, + HideAndSeek, + HoleInTheWall, + HypixelSays, + MiniWalls, + PartyGames, + PartyPooper, + PixelParty, + PixelPartyGameMode, + PropHunt, + ThrowOut, + Zombies, + ZombiesStats +} from './Arcade'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Arcade (DropperMap)', () => { + const data = new DropperMap({ stats: 'meow' }, 'meow'); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(DropperMap); + expectTypeOf(data).toEqualTypeOf(); + expect(data.bestTime).toBeDefined(); + expect(data.bestTime).greaterThanOrEqual(0); + expectTypeOf(data.bestTime).toEqualTypeOf(); + expect(data.completions).toBeDefined(); + expect(data.completions).greaterThanOrEqual(0); + expectTypeOf(data.completions).toEqualTypeOf(); +}); + +test('Arcade', () => { + const data = new Arcade({ stats: 'meow', achievements: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Arcade); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.weeklyCoins).toBeDefined(); + expectTypeOf(data.weeklyCoins).toEqualTypeOf(); + expect(data.monthlyCoins).toBeDefined(); + expectTypeOf(data.monthlyCoins).toEqualTypeOf(); + expect(data.hintsDisabled).toBeDefined(); + expectTypeOf(data.hintsDisabled).toEqualTypeOf(); + expect(data.flashDisabled).toBeDefined(); + expectTypeOf(data.flashDisabled).toEqualTypeOf(); + expect(data.blockingDead).toBeDefined(); + expectTypeOf(data.blockingDead).toEqualTypeOf(); + expect(data.blockingDead.wins).toBeDefined(); + expect(data.blockingDead.wins).greaterThanOrEqual(0); + expectTypeOf(data.blockingDead.wins).toEqualTypeOf(); + expect(data.blockingDead.kills).toBeDefined(); + expect(data.blockingDead.kills).greaterThanOrEqual(0); + expectTypeOf(data.blockingDead.kills).toEqualTypeOf(); + expect(data.blockingDead.headshots).toBeDefined(); + expect(data.blockingDead.headshots).greaterThanOrEqual(0); + expectTypeOf(data.blockingDead.headshots).toEqualTypeOf(); + expect(data.bountyHunters).toBeDefined(); + expectTypeOf(data.bountyHunters).toEqualTypeOf(); + expect(data.bountyHunters.wins).toBeDefined(); + expect(data.bountyHunters.wins).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.wins).toEqualTypeOf(); + expect(data.bountyHunters.kills).toBeDefined(); + expect(data.bountyHunters.kills).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.kills).toEqualTypeOf(); + expect(data.bountyHunters.deaths).toBeDefined(); + expect(data.bountyHunters.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.deaths).toEqualTypeOf(); + expect(data.bountyHunters.KDR).toBeDefined(); + expect(data.bountyHunters.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.KDR).toEqualTypeOf(); + expect(data.bountyHunters.bountyKills).toBeDefined(); + expect(data.bountyHunters.bountyKills).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.bountyKills).toEqualTypeOf(); + expect(data.bountyHunters.bowKills).toBeDefined(); + expect(data.bountyHunters.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.bowKills).toEqualTypeOf(); + expect(data.bountyHunters.swordKills).toBeDefined(); + expect(data.bountyHunters.swordKills).greaterThanOrEqual(0); + expectTypeOf(data.bountyHunters.swordKills).toEqualTypeOf(); + expect(data.dragonWars).toBeDefined(); + expectTypeOf(data.dragonWars).toEqualTypeOf(); + expect(data.dragonWars.wins).toBeDefined(); + expect(data.dragonWars.wins).greaterThanOrEqual(0); + expectTypeOf(data.dragonWars.wins).toEqualTypeOf(); + expect(data.dragonWars.kills).toBeDefined(); + expect(data.dragonWars.kills).greaterThanOrEqual(0); + expectTypeOf(data.dragonWars.kills).toEqualTypeOf(); + expect(data.dropper).toBeDefined(); + expectTypeOf(data.dropper).toEqualTypeOf(); + expect(data.dropper.wins).toBeDefined(); + expect(data.dropper.wins).greaterThanOrEqual(0); + expectTypeOf(data.dropper.wins).toEqualTypeOf(); + expect(data.dropper.fails).toBeDefined(); + expect(data.dropper.fails).greaterThanOrEqual(0); + expectTypeOf(data.dropper.fails).toEqualTypeOf(); + expect(data.dropper.fastestGame).toBeDefined(); + expect(data.dropper.fastestGame).greaterThanOrEqual(0); + expectTypeOf(data.dropper.fastestGame).toEqualTypeOf(); + expect(data.dropper.flawlessGames).toBeDefined(); + expect(data.dropper.flawlessGames).greaterThanOrEqual(0); + expectTypeOf(data.dropper.flawlessGames).toEqualTypeOf(); + expect(data.dropper.gamesPlayed).toBeDefined(); + expect(data.dropper.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.dropper.gamesPlayed).toEqualTypeOf(); + expect(data.dropper.mapsCompleted).toBeDefined(); + expect(data.dropper.mapsCompleted).greaterThanOrEqual(0); + expectTypeOf(data.dropper.mapsCompleted).toEqualTypeOf(); + expect(data.dropper.gamesFinished).toBeDefined(); + expect(data.dropper.gamesFinished).greaterThanOrEqual(0); + expectTypeOf(data.dropper.gamesFinished).toEqualTypeOf(); + expect(data.dropper.maps).toBeDefined(); + expectTypeOf(data.dropper.maps).toEqualTypeOf>(); + Object.keys(data.dropper.maps).forEach((map: string) => { + expect(data.dropper.maps[map]).toBeDefined(); + expect(data.dropper.maps[map]).instanceOf(DropperMap); + expectTypeOf(data.dropper.maps[map]).toEqualTypeOf(); + expect(data.dropper.maps[map].bestTime).toBeDefined(); + expect(data.dropper.maps[map].bestTime).greaterThanOrEqual(0); + expectTypeOf(data.dropper.maps[map].bestTime).toEqualTypeOf(); + expect(data.dropper.maps[map].completions).toBeDefined(); + expect(data.dropper.maps[map].completions).greaterThanOrEqual(0); + expectTypeOf(data.dropper.maps[map].completions).toEqualTypeOf(); + }); + expect(data.enderSpleef).toBeDefined(); + expectTypeOf(data.enderSpleef).toEqualTypeOf(); + expect(data.enderSpleef.wins).toBeDefined(); + expect(data.enderSpleef.wins).greaterThanOrEqual(0); + expectTypeOf(data.enderSpleef.wins).toEqualTypeOf(); + expect(data.enderSpleef.kills).toBeDefined(); + expect(data.enderSpleef.kills).greaterThanOrEqual(0); + expectTypeOf(data.enderSpleef.kills).toEqualTypeOf(); + expect(data.enderSpleef.trail).toBeDefined(); + expectTypeOf(data.enderSpleef.trail).toEqualTypeOf(); + expect(data.enderSpleef.blocksDestroyed).toBeDefined(); + expect(data.enderSpleef.blocksDestroyed).greaterThanOrEqual(0); + expectTypeOf(data.enderSpleef.blocksDestroyed).toEqualTypeOf(); + expect(data.enderSpleef.bigShotActivations).toBeDefined(); + expect(data.enderSpleef.bigShotActivations).greaterThanOrEqual(0); + expectTypeOf(data.enderSpleef.bigShotActivations).toEqualTypeOf(); + expect(data.enderSpleef.tripleShotActivations).toBeDefined(); + expect(data.enderSpleef.tripleShotActivations).greaterThanOrEqual(0); + expectTypeOf(data.enderSpleef.tripleShotActivations).toEqualTypeOf(); + expect(data.enderSpleef.totalPowerUpActivations).toBeDefined(); + expect(data.enderSpleef.totalPowerUpActivations).greaterThanOrEqual(0); + expectTypeOf(data.enderSpleef.totalPowerUpActivations).toEqualTypeOf(); + expect(data.farmHunt).toBeDefined(); + expectTypeOf(data.farmHunt).toEqualTypeOf(); + expect(data.farmHunt.wins).toBeDefined(); + expect(data.farmHunt.wins).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.wins).toEqualTypeOf(); + expect(data.farmHunt.winsAsAnimal).toBeDefined(); + expect(data.farmHunt.winsAsAnimal).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.winsAsAnimal).toEqualTypeOf(); + expect(data.farmHunt.winsAsHunter).toBeDefined(); + expect(data.farmHunt.winsAsHunter).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.winsAsHunter).toEqualTypeOf(); + expect(data.farmHunt.kills).toBeDefined(); + expect(data.farmHunt.kills).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.kills).toEqualTypeOf(); + expect(data.farmHunt.killsAsAnimal).toBeDefined(); + expect(data.farmHunt.killsAsAnimal).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.killsAsAnimal).toEqualTypeOf(); + expect(data.farmHunt.killsAsHunter).toBeDefined(); + expect(data.farmHunt.killsAsHunter).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.killsAsHunter).toEqualTypeOf(); + expect(data.farmHunt.tauntsUsed).toBeDefined(); + expect(data.farmHunt.tauntsUsed).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.tauntsUsed).toEqualTypeOf(); + expect(data.farmHunt.riskyTauntsUsed).toBeDefined(); + expect(data.farmHunt.riskyTauntsUsed).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.riskyTauntsUsed).toEqualTypeOf(); + expect(data.farmHunt.safeTauntsUsed).toBeDefined(); + expect(data.farmHunt.safeTauntsUsed).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.safeTauntsUsed).toEqualTypeOf(); + expect(data.farmHunt.dangerousTauntsUsed).toBeDefined(); + expect(data.farmHunt.dangerousTauntsUsed).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.dangerousTauntsUsed).toEqualTypeOf(); + expect(data.farmHunt.fireworkTauntsUsed).toBeDefined(); + expect(data.farmHunt.fireworkTauntsUsed).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.fireworkTauntsUsed).toEqualTypeOf(); + expect(data.farmHunt.poop).toBeDefined(); + expect(data.farmHunt.poop).greaterThanOrEqual(0); + expectTypeOf(data.farmHunt.poop).toEqualTypeOf(); + expect(data.football).toBeDefined(); + expectTypeOf(data.football).toEqualTypeOf(); + expect(data.football.wins).toBeDefined(); + expect(data.football.wins).greaterThanOrEqual(0); + expectTypeOf(data.football.wins).toEqualTypeOf(); + expect(data.football.goals).toBeDefined(); + expect(data.football.goals).greaterThanOrEqual(0); + expectTypeOf(data.football.goals).toEqualTypeOf(); + expect(data.football.kicks).toBeDefined(); + expect(data.football.kicks).greaterThanOrEqual(0); + expectTypeOf(data.football.kicks).toEqualTypeOf(); + expect(data.football.powerKicks).toBeDefined(); + expect(data.football.powerKicks).greaterThanOrEqual(0); + expectTypeOf(data.football.powerKicks).toEqualTypeOf(); + expect(data.galaxyWars).toBeDefined(); + expectTypeOf(data.galaxyWars).toEqualTypeOf(); + expect(data.galaxyWars.wins).toBeDefined(); + expect(data.galaxyWars.wins).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.wins).toEqualTypeOf(); + expect(data.galaxyWars.kills).toBeDefined(); + expect(data.galaxyWars.kills).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.kills).toEqualTypeOf(); + expect(data.galaxyWars.deaths).toBeDefined(); + expect(data.galaxyWars.deaths).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.deaths).toEqualTypeOf(); + expect(data.galaxyWars.shotsFired).toBeDefined(); + expect(data.galaxyWars.shotsFired).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.shotsFired).toEqualTypeOf(); + expect(data.galaxyWars.weeklyKills).toBeDefined(); + expect(data.galaxyWars.weeklyKills).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.weeklyKills).toEqualTypeOf(); + expect(data.galaxyWars.monthlyKills).toBeDefined(); + expect(data.galaxyWars.monthlyKills).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.monthlyKills).toEqualTypeOf(); + expect(data.galaxyWars.attackerKills).toBeDefined(); + expect(data.galaxyWars.attackerKills).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.attackerKills).toEqualTypeOf(); + expect(data.galaxyWars.defenderKills).toBeDefined(); + expect(data.galaxyWars.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.galaxyWars.defenderKills).toEqualTypeOf(); + expect(data.hideAndSeek).toBeDefined(); + expectTypeOf(data.hideAndSeek).toEqualTypeOf(); + expect(data.hideAndSeek.partyPooper).toBeDefined(); + expectTypeOf(data.hideAndSeek.partyPooper).toEqualTypeOf(); + expect(data.hideAndSeek.partyPooper.winsAsSeeker).toBeDefined(); + expect(data.hideAndSeek.partyPooper.winsAsSeeker).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.partyPooper.winsAsSeeker).toEqualTypeOf(); + expect(data.hideAndSeek.partyPooper.winsAsHider).toBeDefined(); + expect(data.hideAndSeek.partyPooper.winsAsHider).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.partyPooper.winsAsHider).toEqualTypeOf(); + expect(data.hideAndSeek.partyPooper.wins).toBeDefined(); + expect(data.hideAndSeek.partyPooper.wins).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.partyPooper.wins).toEqualTypeOf(); + expect(data.hideAndSeek.propHunt).toBeDefined(); + expectTypeOf(data.hideAndSeek.propHunt).toEqualTypeOf(); + expect(data.hideAndSeek.propHunt.winsAsSeeker).toBeDefined(); + expect(data.hideAndSeek.propHunt.winsAsSeeker).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.propHunt.winsAsSeeker).toEqualTypeOf(); + expect(data.hideAndSeek.propHunt.winsAsHider).toBeDefined(); + expect(data.hideAndSeek.propHunt.winsAsHider).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.propHunt.winsAsHider).toEqualTypeOf(); + expect(data.hideAndSeek.propHunt.wins).toBeDefined(); + expect(data.hideAndSeek.propHunt.wins).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.propHunt.wins).toEqualTypeOf(); + expect(data.hideAndSeek.winsAsSeeker).toBeDefined(); + expect(data.hideAndSeek.winsAsSeeker).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.winsAsSeeker).toEqualTypeOf(); + expect(data.hideAndSeek.winsAsHider).toBeDefined(); + expect(data.hideAndSeek.winsAsHider).greaterThanOrEqual(0); + expectTypeOf(data.hideAndSeek.winsAsHider).toEqualTypeOf(); + expect(data.holeInTheWall).toBeDefined(); + expectTypeOf(data.holeInTheWall).toEqualTypeOf(); + expect(data.holeInTheWall.wins).toBeDefined(); + expect(data.holeInTheWall.wins).greaterThanOrEqual(0); + expectTypeOf(data.holeInTheWall.wins).toEqualTypeOf(); + expect(data.holeInTheWall.rounds).toBeDefined(); + expect(data.holeInTheWall.rounds).greaterThanOrEqual(0); + expectTypeOf(data.holeInTheWall.rounds).toEqualTypeOf(); + expect(data.holeInTheWall.scoreRecordFinals).toBeDefined(); + expect(data.holeInTheWall.scoreRecordFinals).greaterThanOrEqual(0); + expectTypeOf(data.holeInTheWall.scoreRecordFinals).toEqualTypeOf(); + expect(data.holeInTheWall.scoreRecordNormal).toBeDefined(); + expect(data.holeInTheWall.scoreRecordNormal).greaterThanOrEqual(0); + expectTypeOf(data.holeInTheWall.scoreRecordNormal).toEqualTypeOf(); + expect(data.holeInTheWall.scoreRecordOverall).toBeDefined(); + expect(data.holeInTheWall.scoreRecordOverall).greaterThanOrEqual(0); + expectTypeOf(data.holeInTheWall.scoreRecordOverall).toEqualTypeOf(); + expect(data.hypixelSays).toBeDefined(); + expectTypeOf(data.hypixelSays).toEqualTypeOf(); + expect(data.hypixelSays.wins).toBeDefined(); + expect(data.hypixelSays.wins).greaterThanOrEqual(0); + expectTypeOf(data.hypixelSays.wins).toEqualTypeOf(); + expect(data.hypixelSays.rounds).toBeDefined(); + expect(data.hypixelSays.rounds).greaterThanOrEqual(0); + expectTypeOf(data.hypixelSays.rounds).toEqualTypeOf(); + expect(data.hypixelSays.roundWins).toBeDefined(); + expect(data.hypixelSays.roundWins).greaterThanOrEqual(0); + expectTypeOf(data.hypixelSays.roundWins).toEqualTypeOf(); + expect(data.hypixelSays.topScore).toBeDefined(); + expect(data.hypixelSays.topScore).greaterThanOrEqual(0); + expectTypeOf(data.hypixelSays.topScore).toEqualTypeOf(); + expect(data.miniWalls).toBeDefined(); + expectTypeOf(data.miniWalls).toEqualTypeOf(); + expect(data.miniWalls.kit).toBeDefined(); + expectTypeOf(data.miniWalls.kit).toEqualTypeOf(); + expect(data.miniWalls.wins).toBeDefined(); + expect(data.miniWalls.wins).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.wins).toEqualTypeOf(); + expect(data.miniWalls.kills).toBeDefined(); + expect(data.miniWalls.kills).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.kills).toEqualTypeOf(); + expect(data.miniWalls.deaths).toBeDefined(); + expect(data.miniWalls.deaths).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.deaths).toEqualTypeOf(); + expect(data.miniWalls.KDR).toBeDefined(); + expect(data.miniWalls.KDR).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.KDR).toEqualTypeOf(); + expect(data.miniWalls.finalKills).toBeDefined(); + expect(data.miniWalls.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.finalKills).toEqualTypeOf(); + expect(data.miniWalls.witherKills).toBeDefined(); + expect(data.miniWalls.witherKills).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.witherKills).toEqualTypeOf(); + expect(data.miniWalls.witherDamage).toBeDefined(); + expect(data.miniWalls.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.witherDamage).toEqualTypeOf(); + expect(data.miniWalls.arrowsShot).toBeDefined(); + expect(data.miniWalls.arrowsShot).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.arrowsShot).toEqualTypeOf(); + expect(data.miniWalls.arrowsHit).toBeDefined(); + expect(data.miniWalls.arrowsHit).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.arrowsHit).toEqualTypeOf(); + expect(data.miniWalls.bowAccuracy).toBeDefined(); + expect(data.miniWalls.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.miniWalls.bowAccuracy).toEqualTypeOf(); + expect(data.partyGames).toBeDefined(); + expectTypeOf(data.partyGames).toEqualTypeOf(); + expect(data.partyGames.wins).toBeDefined(); + expect(data.partyGames.wins).greaterThanOrEqual(0); + expectTypeOf(data.partyGames.wins).toEqualTypeOf(); + expect(data.partyGames.roundWins).toBeDefined(); + expect(data.partyGames.roundWins).greaterThanOrEqual(0); + expectTypeOf(data.partyGames.roundWins).toEqualTypeOf(); + expect(data.partyGames.stars).toBeDefined(); + expect(data.partyGames.stars).greaterThanOrEqual(0); + expectTypeOf(data.partyGames.stars).toEqualTypeOf(); + expect(data.pixelParty).toBeDefined(); + expectTypeOf(data.pixelParty).toEqualTypeOf(); + expect(data.pixelParty.wins).toBeDefined(); + expect(data.pixelParty.wins).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.wins).toEqualTypeOf(); + expect(data.pixelParty.gamesPlayed).toBeDefined(); + expect(data.pixelParty.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.gamesPlayed).toEqualTypeOf(); + expect(data.pixelParty.losses).toBeDefined(); + expect(data.pixelParty.losses).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.losses).toEqualTypeOf(); + expect(data.pixelParty.WLR).toBeDefined(); + expect(data.pixelParty.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.WLR).toEqualTypeOf(); + expect(data.pixelParty.roundsPlayed).toBeDefined(); + expect(data.pixelParty.roundsPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.roundsPlayed).toEqualTypeOf(); + expect(data.pixelParty.powerUpsCollected).toBeDefined(); + expect(data.pixelParty.powerUpsCollected).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.powerUpsCollected).toEqualTypeOf(); + expect(data.pixelParty.normal).toBeDefined(); + expectTypeOf(data.pixelParty.normal).toEqualTypeOf(); + expect(data.pixelParty.normal.wins).toBeDefined(); + expect(data.pixelParty.normal.wins).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.normal.wins).toEqualTypeOf(); + expect(data.pixelParty.normal.gamesPlayed).toBeDefined(); + expect(data.pixelParty.normal.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.normal.gamesPlayed).toEqualTypeOf(); + expect(data.pixelParty.normal.losses).toBeDefined(); + expect(data.pixelParty.normal.losses).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.normal.losses).toEqualTypeOf(); + expect(data.pixelParty.normal.WLR).toBeDefined(); + expect(data.pixelParty.normal.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.normal.WLR).toEqualTypeOf(); + expect(data.pixelParty.normal.roundsPlayed).toBeDefined(); + expect(data.pixelParty.normal.roundsPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.normal.roundsPlayed).toEqualTypeOf(); + expect(data.pixelParty.normal.powerUpsCollected).toBeDefined(); + expect(data.pixelParty.normal.powerUpsCollected).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.normal.powerUpsCollected).toEqualTypeOf(); + expect(data.pixelParty.hyper).toBeDefined(); + expectTypeOf(data.pixelParty.hyper).toEqualTypeOf(); + expect(data.pixelParty.hyper.wins).toBeDefined(); + expect(data.pixelParty.hyper.wins).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.hyper.wins).toEqualTypeOf(); + expect(data.pixelParty.hyper.gamesPlayed).toBeDefined(); + expect(data.pixelParty.hyper.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.hyper.gamesPlayed).toEqualTypeOf(); + expect(data.pixelParty.hyper.losses).toBeDefined(); + expect(data.pixelParty.hyper.losses).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.hyper.losses).toEqualTypeOf(); + expect(data.pixelParty.hyper.WLR).toBeDefined(); + expect(data.pixelParty.hyper.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.hyper.WLR).toEqualTypeOf(); + expect(data.pixelParty.hyper.roundsPlayed).toBeDefined(); + expect(data.pixelParty.hyper.roundsPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.hyper.roundsPlayed).toEqualTypeOf(); + expect(data.pixelParty.hyper.powerUpsCollected).toBeDefined(); + expect(data.pixelParty.hyper.powerUpsCollected).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.hyper.powerUpsCollected).toEqualTypeOf(); + expect(data.pixelParty.highestRound).toBeDefined(); + expect(data.pixelParty.highestRound).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.highestRound).toEqualTypeOf(); + expect(data.pixelParty.musicVolume).toBeDefined(); + expect(data.pixelParty.musicVolume).greaterThanOrEqual(0); + expectTypeOf(data.pixelParty.musicVolume).toEqualTypeOf(); + expect(data.pixelParty.colorBlind).toBeDefined(); + expectTypeOf(data.pixelParty.colorBlind).toEqualTypeOf(); + expect(data.throwOut).toBeDefined(); + expectTypeOf(data.throwOut).toEqualTypeOf(); + expect(data.throwOut.wins).toBeDefined(); + expect(data.throwOut.wins).greaterThanOrEqual(0); + expectTypeOf(data.throwOut.wins).toEqualTypeOf(); + expect(data.throwOut.kills).toBeDefined(); + expect(data.throwOut.kills).greaterThanOrEqual(0); + expectTypeOf(data.throwOut.kills).toEqualTypeOf(); + expect(data.throwOut.deaths).toBeDefined(); + expect(data.throwOut.deaths).greaterThanOrEqual(0); + expectTypeOf(data.throwOut.deaths).toEqualTypeOf(); + expect(data.throwOut.KDR).toBeDefined(); + expect(data.throwOut.KDR).greaterThanOrEqual(0); + expectTypeOf(data.throwOut.KDR).toEqualTypeOf(); + expect(data.zombies).toBeDefined(); + expectTypeOf(data.zombies).toEqualTypeOf(); + expect(data.zombies.overall).toBeDefined(); + expectTypeOf(data.zombies.overall).toEqualTypeOf(); + expect(data.zombies.overall.bestRound).toBeDefined(); + expect(data.zombies.overall.bestRound).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.bestRound).toEqualTypeOf(); + expect(data.zombies.overall.deaths).toBeDefined(); + expect(data.zombies.overall.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.deaths).toEqualTypeOf(); + expect(data.zombies.overall.doorsOpened).toBeDefined(); + expect(data.zombies.overall.doorsOpened).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.doorsOpened).toEqualTypeOf(); + expect(data.zombies.overall.fastestRound10).toBeDefined(); + expect(data.zombies.overall.fastestRound10).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.fastestRound10).toEqualTypeOf(); + expect(data.zombies.overall.fastestRound20).toBeDefined(); + expect(data.zombies.overall.fastestRound20).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.fastestRound20).toEqualTypeOf(); + expect(data.zombies.overall.fastestRound30).toBeDefined(); + expect(data.zombies.overall.fastestRound30).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.fastestRound30).toEqualTypeOf(); + expect(data.zombies.overall.playersRevived).toBeDefined(); + expect(data.zombies.overall.playersRevived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.playersRevived).toEqualTypeOf(); + expect(data.zombies.overall.timesKnockedDown).toBeDefined(); + expect(data.zombies.overall.timesKnockedDown).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.timesKnockedDown).toEqualTypeOf(); + expect(data.zombies.overall.roundsSurvived).toBeDefined(); + expect(data.zombies.overall.roundsSurvived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.roundsSurvived).toEqualTypeOf(); + expect(data.zombies.overall.windowsRepaired).toBeDefined(); + expect(data.zombies.overall.windowsRepaired).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.windowsRepaired).toEqualTypeOf(); + expect(data.zombies.overall.wins).toBeDefined(); + expect(data.zombies.overall.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.wins).toEqualTypeOf(); + expect(data.zombies.overall.zombieKills).toBeDefined(); + expect(data.zombies.overall.zombieKills).greaterThanOrEqual(0); + expectTypeOf(data.zombies.overall.zombieKills).toEqualTypeOf(); + expect(data.zombies.deadEnd).toBeDefined(); + expectTypeOf(data.zombies.deadEnd).toEqualTypeOf(); + expect(data.zombies.deadEnd.bestRound).toBeDefined(); + expect(data.zombies.deadEnd.bestRound).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.bestRound).toEqualTypeOf(); + expect(data.zombies.deadEnd.deaths).toBeDefined(); + expect(data.zombies.deadEnd.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.deaths).toEqualTypeOf(); + expect(data.zombies.deadEnd.doorsOpened).toBeDefined(); + expect(data.zombies.deadEnd.doorsOpened).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.doorsOpened).toEqualTypeOf(); + expect(data.zombies.deadEnd.fastestRound10).toBeDefined(); + expect(data.zombies.deadEnd.fastestRound10).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.fastestRound10).toEqualTypeOf(); + expect(data.zombies.deadEnd.fastestRound20).toBeDefined(); + expect(data.zombies.deadEnd.fastestRound20).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.fastestRound20).toEqualTypeOf(); + expect(data.zombies.deadEnd.fastestRound30).toBeDefined(); + expect(data.zombies.deadEnd.fastestRound30).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.fastestRound30).toEqualTypeOf(); + expect(data.zombies.deadEnd.playersRevived).toBeDefined(); + expect(data.zombies.deadEnd.playersRevived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.playersRevived).toEqualTypeOf(); + expect(data.zombies.deadEnd.timesKnockedDown).toBeDefined(); + expect(data.zombies.deadEnd.timesKnockedDown).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.timesKnockedDown).toEqualTypeOf(); + expect(data.zombies.deadEnd.roundsSurvived).toBeDefined(); + expect(data.zombies.deadEnd.roundsSurvived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.roundsSurvived).toEqualTypeOf(); + expect(data.zombies.deadEnd.windowsRepaired).toBeDefined(); + expect(data.zombies.deadEnd.windowsRepaired).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.windowsRepaired).toEqualTypeOf(); + expect(data.zombies.deadEnd.wins).toBeDefined(); + expect(data.zombies.deadEnd.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.wins).toEqualTypeOf(); + expect(data.zombies.deadEnd.zombieKills).toBeDefined(); + expect(data.zombies.deadEnd.zombieKills).greaterThanOrEqual(0); + expectTypeOf(data.zombies.deadEnd.zombieKills).toEqualTypeOf(); + expect(data.zombies.badBlood).toBeDefined(); + expectTypeOf(data.zombies.badBlood).toEqualTypeOf(); + expect(data.zombies.badBlood.bestRound).toBeDefined(); + expect(data.zombies.badBlood.bestRound).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.bestRound).toEqualTypeOf(); + expect(data.zombies.badBlood.deaths).toBeDefined(); + expect(data.zombies.badBlood.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.deaths).toEqualTypeOf(); + expect(data.zombies.badBlood.doorsOpened).toBeDefined(); + expect(data.zombies.badBlood.doorsOpened).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.doorsOpened).toEqualTypeOf(); + expect(data.zombies.badBlood.fastestRound10).toBeDefined(); + expect(data.zombies.badBlood.fastestRound10).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.fastestRound10).toEqualTypeOf(); + expect(data.zombies.badBlood.fastestRound20).toBeDefined(); + expect(data.zombies.badBlood.fastestRound20).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.fastestRound20).toEqualTypeOf(); + expect(data.zombies.badBlood.fastestRound30).toBeDefined(); + expect(data.zombies.badBlood.fastestRound30).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.fastestRound30).toEqualTypeOf(); + expect(data.zombies.badBlood.playersRevived).toBeDefined(); + expect(data.zombies.badBlood.playersRevived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.playersRevived).toEqualTypeOf(); + expect(data.zombies.badBlood.timesKnockedDown).toBeDefined(); + expect(data.zombies.badBlood.timesKnockedDown).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.timesKnockedDown).toEqualTypeOf(); + expect(data.zombies.badBlood.roundsSurvived).toBeDefined(); + expect(data.zombies.badBlood.roundsSurvived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.roundsSurvived).toEqualTypeOf(); + expect(data.zombies.badBlood.windowsRepaired).toBeDefined(); + expect(data.zombies.badBlood.windowsRepaired).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.windowsRepaired).toEqualTypeOf(); + expect(data.zombies.badBlood.wins).toBeDefined(); + expect(data.zombies.badBlood.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.wins).toEqualTypeOf(); + expect(data.zombies.badBlood.zombieKills).toBeDefined(); + expect(data.zombies.badBlood.zombieKills).greaterThanOrEqual(0); + expectTypeOf(data.zombies.badBlood.zombieKills).toEqualTypeOf(); + expect(data.zombies.alienArcadium).toBeDefined(); + expectTypeOf(data.zombies.alienArcadium).toEqualTypeOf(); + expect(data.zombies.alienArcadium.bestRound).toBeDefined(); + expect(data.zombies.alienArcadium.bestRound).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.bestRound).toEqualTypeOf(); + expect(data.zombies.alienArcadium.deaths).toBeDefined(); + expect(data.zombies.alienArcadium.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.deaths).toEqualTypeOf(); + expect(data.zombies.alienArcadium.doorsOpened).toBeDefined(); + expect(data.zombies.alienArcadium.doorsOpened).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.doorsOpened).toEqualTypeOf(); + expect(data.zombies.alienArcadium.fastestRound10).toBeDefined(); + expect(data.zombies.alienArcadium.fastestRound10).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.fastestRound10).toEqualTypeOf(); + expect(data.zombies.alienArcadium.fastestRound20).toBeDefined(); + expect(data.zombies.alienArcadium.fastestRound20).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.fastestRound20).toEqualTypeOf(); + expect(data.zombies.alienArcadium.fastestRound30).toBeDefined(); + expect(data.zombies.alienArcadium.fastestRound30).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.fastestRound30).toEqualTypeOf(); + expect(data.zombies.alienArcadium.playersRevived).toBeDefined(); + expect(data.zombies.alienArcadium.playersRevived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.playersRevived).toEqualTypeOf(); + expect(data.zombies.alienArcadium.timesKnockedDown).toBeDefined(); + expect(data.zombies.alienArcadium.timesKnockedDown).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.timesKnockedDown).toEqualTypeOf(); + expect(data.zombies.alienArcadium.roundsSurvived).toBeDefined(); + expect(data.zombies.alienArcadium.roundsSurvived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.roundsSurvived).toEqualTypeOf(); + expect(data.zombies.alienArcadium.windowsRepaired).toBeDefined(); + expect(data.zombies.alienArcadium.windowsRepaired).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.windowsRepaired).toEqualTypeOf(); + expect(data.zombies.alienArcadium.wins).toBeDefined(); + expect(data.zombies.alienArcadium.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.wins).toEqualTypeOf(); + expect(data.zombies.alienArcadium.zombieKills).toBeDefined(); + expect(data.zombies.alienArcadium.zombieKills).greaterThanOrEqual(0); + expectTypeOf(data.zombies.alienArcadium.zombieKills).toEqualTypeOf(); + expect(data.zombies.prison).toBeDefined(); + expectTypeOf(data.zombies.prison).toEqualTypeOf(); + expect(data.zombies.prison.bestRound).toBeDefined(); + expect(data.zombies.prison.bestRound).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.bestRound).toEqualTypeOf(); + expect(data.zombies.prison.deaths).toBeDefined(); + expect(data.zombies.prison.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.deaths).toEqualTypeOf(); + expect(data.zombies.prison.doorsOpened).toBeDefined(); + expect(data.zombies.prison.doorsOpened).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.doorsOpened).toEqualTypeOf(); + expect(data.zombies.prison.fastestRound10).toBeDefined(); + expect(data.zombies.prison.fastestRound10).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.fastestRound10).toEqualTypeOf(); + expect(data.zombies.prison.fastestRound20).toBeDefined(); + expect(data.zombies.prison.fastestRound20).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.fastestRound20).toEqualTypeOf(); + expect(data.zombies.prison.fastestRound30).toBeDefined(); + expect(data.zombies.prison.fastestRound30).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.fastestRound30).toEqualTypeOf(); + expect(data.zombies.prison.playersRevived).toBeDefined(); + expect(data.zombies.prison.playersRevived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.playersRevived).toEqualTypeOf(); + expect(data.zombies.prison.timesKnockedDown).toBeDefined(); + expect(data.zombies.prison.timesKnockedDown).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.timesKnockedDown).toEqualTypeOf(); + expect(data.zombies.prison.roundsSurvived).toBeDefined(); + expect(data.zombies.prison.roundsSurvived).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.roundsSurvived).toEqualTypeOf(); + expect(data.zombies.prison.windowsRepaired).toBeDefined(); + expect(data.zombies.prison.windowsRepaired).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.windowsRepaired).toEqualTypeOf(); + expect(data.zombies.prison.wins).toBeDefined(); + expect(data.zombies.prison.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.wins).toEqualTypeOf(); + expect(data.zombies.prison.zombieKills).toBeDefined(); + expect(data.zombies.prison.zombieKills).greaterThanOrEqual(0); + expectTypeOf(data.zombies.prison.zombieKills).toEqualTypeOf(); + expect(data.zombies.killsByZombie).toBeDefined(); + expectTypeOf(data.zombies.killsByZombie).toEqualTypeOf>(); + expect(data.zombies.bulletsHit).toBeDefined(); + expect(data.zombies.bulletsHit).greaterThanOrEqual(0); + expectTypeOf(data.zombies.bulletsHit).toEqualTypeOf(); + expect(data.zombies.bulletsShot).toBeDefined(); + expect(data.zombies.bulletsShot).greaterThanOrEqual(0); + expectTypeOf(data.zombies.bulletsShot).toEqualTypeOf(); + expect(data.zombies.gunAccuracy).toBeDefined(); + expect(data.zombies.gunAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.zombies.gunAccuracy).toEqualTypeOf(); + expect(data.zombies.headshots).toBeDefined(); + expect(data.zombies.headshots).greaterThanOrEqual(0); + expectTypeOf(data.zombies.headshots).toEqualTypeOf(); + expect(data.zombies.headshotAccuracy).toBeDefined(); + expect(data.zombies.headshotAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.zombies.headshotAccuracy).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/Arcade.ts b/src/structures/MiniGames/Arcade.ts index 51ecfc54..1d268e69 100644 --- a/src/structures/MiniGames/Arcade.ts +++ b/src/structures/MiniGames/Arcade.ts @@ -2,13 +2,6 @@ import divide from '../../utils/divide'; import { monthAB, weekAB } from '../../utils/oscillation'; import { removeSnakeCaseString } from '../../utils/removeSnakeCase'; -function parseZombiesKills(data: Record): Record { - const matches = Array.from(Object.keys(data)) - .map((x) => x.match(/^([A-Za-z]+)_zombie_kills_zombies$/)) - .filter((x) => x); - // From entries might be broken - return Object.fromEntries(matches.map((x: any) => [removeSnakeCaseString(x[1]), data[x[0]] || 0])); -} export class ZombiesStats { bestRound: number; @@ -25,18 +18,18 @@ export class ZombiesStats { zombieKills: number; constructor(data: Record, type: string = '') { if (type) type = `_${type}`; - this.bestRound = data[`best_round_zombies${type}`] || 0; - this.deaths = data[`deaths_zombies${type}`] || 0; - this.doorsOpened = data[`doors_opened_zombies${type}`] || 0; - this.fastestRound10 = data[`fastest_time_10_zombies${type}_normal`] || 0; - this.fastestRound20 = data[`fastest_time_20_zombies${type}_normal`] || 0; - this.fastestRound30 = data[`fastest_time_30_zombies${type}_normal`] || 0; - this.playersRevived = data[`players_revived_zombies${type}`] || 0; - this.timesKnockedDown = data[`times_knocked_down_zombies${type}`] || 0; - this.roundsSurvived = data[`total_rounds_survived_zombies${type}`] || 0; - this.windowsRepaired = data[`windows_repaired_zombies${type}`] || 0; - this.wins = data[`wins_zombies${type}`] || 0; - this.zombieKills = data[`zombie_kills_zombies${type}`] || 0; + this.bestRound = data?.[`best_round_zombies${type}`] || 0; + this.deaths = data?.[`deaths_zombies${type}`] || 0; + this.doorsOpened = data?.[`doors_opened_zombies${type}`] || 0; + this.fastestRound10 = data?.[`fastest_time_10_zombies${type}_normal`] || 0; + this.fastestRound20 = data?.[`fastest_time_20_zombies${type}_normal`] || 0; + this.fastestRound30 = data?.[`fastest_time_30_zombies${type}_normal`] || 0; + this.playersRevived = data?.[`players_revived_zombies${type}`] || 0; + this.timesKnockedDown = data?.[`times_knocked_down_zombies${type}`] || 0; + this.roundsSurvived = data?.[`total_rounds_survived_zombies${type}`] || 0; + this.windowsRepaired = data?.[`windows_repaired_zombies${type}`] || 0; + this.wins = data?.[`wins_zombies${type}`] || 0; + this.zombieKills = data?.[`zombie_kills_zombies${type}`] || 0; } } @@ -58,21 +51,28 @@ export class Zombies { this.badBlood = new ZombiesStats(data, 'badblood'); this.alienArcadium = new ZombiesStats(data, 'alienarcadium'); this.prison = new ZombiesStats(data, 'prison'); - this.killsByZombie = parseZombiesKills(data); - this.bulletsHit = data.bullets_hit_zombies || 0; - this.bulletsShot = data.bullets_shot_zombies || 0; + this.killsByZombie = this.parseZombiesKills(data); + this.bulletsHit = data?.bullets_hit_zombies || 0; + this.bulletsShot = data?.bullets_shot_zombies || 0; this.gunAccuracy = divide(this.bulletsHit, this.bulletsShot); - this.headshots = data.headshots_zombies || 0; + this.headshots = data?.headshots_zombies || 0; this.headshotAccuracy = divide(this.headshots, this.bulletsShot); } + private parseZombiesKills(data: Record): Record { + const matches = Array.from(Object.keys(data)) + .map((x) => x.match(/^([A-Za-z]+)_zombie_kills_zombies$/)) + .filter((x) => x); + // From entries might be broken + return Object.fromEntries(matches.map((x: any) => [removeSnakeCaseString(x[1]), data[x[0]]])); + } } export class DropperMap { bestTime: number; completions: number; constructor(data: Record, mapName: string) { - this.bestTime = data?.[mapName]?.best_time ?? 0; - this.completions = data?.[mapName]?.completions ?? 0; + this.bestTime = data?.[mapName]?.best_time || 0; + this.completions = data?.[mapName]?.completions || 0; } } @@ -81,9 +81,9 @@ export class BlockingDead { kills: number; headshots: number; constructor(data: Record) { - this.wins = data.wins_dayone || 0; - this.kills = data.kills_dayone || 0; - this.headshots = data.headshots_dayone || 0; + this.wins = data?.wins_dayone || 0; + this.kills = data?.kills_dayone || 0; + this.headshots = data?.headshots_dayone || 0; } } @@ -96,13 +96,13 @@ export class BountyHunters { bowKills: number; swordKills: number; constructor(data: Record) { - this.wins = data.wins_oneinthequiver || 0; - this.kills = data.kills_oneinthequiver || 0; - this.deaths = data.deaths_oneinthequiver || 0; + this.wins = data?.wins_oneinthequiver || 0; + this.kills = data?.kills_oneinthequiver || 0; + this.deaths = data?.deaths_oneinthequiver || 0; this.KDR = divide(this.kills, this.deaths); - this.bountyKills = data.bounty_kills_oneinthequiver || 0; - this.bowKills = data.bow_kills_oneinthequiver || 0; - this.swordKills = data.sword_kills_oneinthequiver || 0; + this.bountyKills = data?.bounty_kills_oneinthequiver || 0; + this.bowKills = data?.bow_kills_oneinthequiver || 0; + this.swordKills = data?.sword_kills_oneinthequiver || 0; } } @@ -110,8 +110,8 @@ export class DragonWars { wins: number; kills: number; constructor(data: Record) { - this.wins = data.wins_dragonwars2 || 0; - this.kills = data.kills_dragonwars2 || 0; + this.wins = data?.wins_dragonwars2 || 0; + this.kills = data?.kills_dragonwars2 || 0; } } @@ -133,7 +133,7 @@ export class Dropper { this.mapsCompleted = data?.maps_completed ?? 0; this.gamesFinished = data?.games_finished ?? 0; this.maps = {}; - Object.keys(data?.map_stats ?? {}).forEach((map) => { + Object?.keys(data?.map_stats ?? {})?.forEach((map) => { this.maps[map] = new DropperMap(data?.map_stats, map); }); } @@ -148,12 +148,12 @@ export class EnderSpleef { tripleShotActivations: number; totalPowerUpActivations: number; constructor(data: Record) { - this.wins = data.wins_ender || 0; - this.kills = data.kills_dragonwars2 || 0; - this.trail = data.enderspleef_trail || ''; - this.blocksDestroyed = data.blocks_destroyed_ender || 0; - this.bigShotActivations = data.bigshot_powerup_activations_ender || 0; - this.tripleShotActivations = data.tripleshot_powerup_activations_ender || 0; + this.wins = data?.wins_ender || 0; + this.kills = data?.kills_dragonwars2 || 0; + this.trail = data?.enderspleef_trail || ''; + this.blocksDestroyed = data?.blocks_destroyed_ender || 0; + this.bigShotActivations = data?.bigshot_powerup_activations_ender || 0; + this.tripleShotActivations = data?.tripleshot_powerup_activations_ender || 0; this.totalPowerUpActivations = this.bigShotActivations + this.tripleShotActivations; } } @@ -172,18 +172,18 @@ export class FarmHunt { fireworkTauntsUsed: number; poop: number; constructor(data: Record) { - this.wins = data.wins_farm_hunt || 0; - this.winsAsAnimal = data.animal_wins_farm_hunt || 0; - this.winsAsHunter = data.hunter_wins_farm_hunt || 0; - this.kills = data.kills_farm_hunt || 0; - this.killsAsAnimal = data.animal_kills_farm_hunt || 0; - this.killsAsHunter = data.hunter_kills_farm_hunt || 0; - this.tauntsUsed = data.taunts_used_farm_hunt || 0; - this.riskyTauntsUsed = data.risky_taunts_used_farm_hunt || 0; - this.safeTauntsUsed = data.safe_taunts_used_farm_hunt || 0; - this.dangerousTauntsUsed = data.dangerous_taunts_used_farm_hunt || 0; - this.fireworkTauntsUsed = data.firework_taunts_used_farm_hunt || 0; - this.poop = (data.poop_collected_farm_hunt || 0) + (data.poop_collected || 0); + this.wins = data?.wins_farm_hunt || 0; + this.winsAsAnimal = data?.animal_wins_farm_hunt || 0; + this.winsAsHunter = data?.hunter_wins_farm_hunt || 0; + this.kills = data?.kills_farm_hunt || 0; + this.killsAsAnimal = data?.animal_kills_farm_hunt || 0; + this.killsAsHunter = data?.hunter_kills_farm_hunt || 0; + this.tauntsUsed = data?.taunts_used_farm_hunt || 0; + this.riskyTauntsUsed = data?.risky_taunts_used_farm_hunt || 0; + this.safeTauntsUsed = data?.safe_taunts_used_farm_hunt || 0; + this.dangerousTauntsUsed = data?.dangerous_taunts_used_farm_hunt || 0; + this.fireworkTauntsUsed = data?.firework_taunts_used_farm_hunt || 0; + this.poop = (data?.poop_collected_farm_hunt || 0) + (data?.poop_collected || 0); } } @@ -193,10 +193,10 @@ export class Football { kicks: number; powerKicks: number; constructor(data: Record) { - this.wins = data.wins_soccer || 0; - this.goals = data.goals_soccer || 0; - this.kicks = data.kicks_soccer || 0; - this.powerKicks = data.powerkicks_soccer || 0; + this.wins = data?.wins_soccer || 0; + this.goals = data?.goals_soccer || 0; + this.kicks = data?.kicks_soccer || 0; + this.powerKicks = data?.powerkicks_soccer || 0; } } @@ -210,14 +210,14 @@ export class GalaxyWars { attackerKills: number; defenderKills: number; constructor(data: Record) { - this.wins = data.sw_game_wins || 0; - this.kills = data.sw_kills || 0; - this.deaths = data.sw_deaths || 0; - this.shotsFired = data.sw_shots_fired || 0; - this.weeklyKills = parseInt(data[`weekly_kills_${weekAB()}`] || 0, 10); - this.monthlyKills = parseInt(data[`monthly_kills_${monthAB()}`] || 0, 10); - this.attackerKills = data.sw_rebel_kills || 0; - this.defenderKills = data.sw_empire_kills || 0; + this.wins = data?.sw_game_wins || 0; + this.kills = data?.sw_kills || 0; + this.deaths = data?.sw_deaths || 0; + this.shotsFired = data?.sw_shots_fired || 0; + this.weeklyKills = parseInt(data?.[`weekly_kills_${weekAB()}`] || 0, 10); + this.monthlyKills = parseInt(data?.[`monthly_kills_${monthAB()}`] || 0, 10); + this.attackerKills = data?.sw_rebel_kills || 0; + this.defenderKills = data?.sw_empire_kills || 0; } } @@ -226,8 +226,8 @@ export class PartyPooper { winsAsHider: number; wins: number; constructor(data: Record) { - this.winsAsSeeker = data.party_pooper_seeker_wins_hide_and_seek || 0; - this.winsAsHider = data.party_pooper_hider_wins_hide_and_seek || 0; + this.winsAsSeeker = data?.party_pooper_seeker_wins_hide_and_seek || 0; + this.winsAsHider = data?.party_pooper_hider_wins_hide_and_seek || 0; this.wins = this.winsAsSeeker + this.winsAsHider; } } @@ -237,8 +237,8 @@ export class PropHunt { winsAsHider: number; wins: number; constructor(data: Record) { - this.winsAsSeeker = data.prop_hunt_seeker_wins_hide_and_seek || 0; - this.winsAsHider = data.prop_hunt_hider_wins_hide_and_seek || 0; + this.winsAsSeeker = data?.prop_hunt_seeker_wins_hide_and_seek || 0; + this.winsAsHider = data?.prop_hunt_hider_wins_hide_and_seek || 0; this.wins = this.winsAsSeeker + this.winsAsHider; } } @@ -251,8 +251,8 @@ export class HideAndSeek { constructor(data: Record) { this.partyPooper = new PartyPooper(data); this.propHunt = new PropHunt(data); - this.winsAsSeeker = data.seeker_wins_hide_and_seek || 0; - this.winsAsHider = data.hider_wins_hide_and_seek || 0; + this.winsAsSeeker = data?.seeker_wins_hide_and_seek || 0; + this.winsAsHider = data?.hider_wins_hide_and_seek || 0; } } @@ -263,10 +263,10 @@ export class HoleInTheWall { scoreRecordNormal: number; scoreRecordOverall: number; constructor(data: Record) { - this.wins = data.wins_hole_in_the_wall || 0; - this.rounds = data.rounds_hole_in_the_wall || 0; - this.scoreRecordFinals = data.hitw_record_f || 0; - this.scoreRecordNormal = data.hitw_record_q || 0; + this.wins = data?.wins_hole_in_the_wall || 0; + this.rounds = data?.rounds_hole_in_the_wall || 0; + this.scoreRecordFinals = data?.hitw_record_f || 0; + this.scoreRecordNormal = data?.hitw_record_q || 0; this.scoreRecordOverall = this.scoreRecordFinals + this.scoreRecordNormal; } } @@ -277,10 +277,10 @@ export class HypixelSays { roundWins: number; topScore: number; constructor(data: Record) { - this.wins = data.wins_simon_says || 0; - this.rounds = data.rounds_simon_says || 0; - this.roundWins = data.round_wins_simon_says || 0; - this.topScore = data.top_score_simon_says || 0; + this.wins = data?.wins_simon_says || 0; + this.rounds = data?.rounds_simon_says || 0; + this.roundWins = data?.round_wins_simon_says || 0; + this.topScore = data?.top_score_simon_says || 0; } } @@ -297,16 +297,16 @@ export class MiniWalls { arrowsHit: number; bowAccuracy: number; constructor(data: Record) { - this.kit = data.miniWalls_activeKit || ''; - this.wins = data.wins_mini_walls || 0; - this.kills = data.kills_mini_walls || 0; - this.deaths = data.deaths_mini_walls || 0; + this.kit = data?.miniWalls_activeKit || ''; + this.wins = data?.wins_mini_walls || 0; + this.kills = data?.kills_mini_walls || 0; + this.deaths = data?.deaths_mini_walls || 0; this.KDR = divide(this.kills, this.deaths); - this.finalKills = data.final_kills_mini_walls || 0; - this.witherKills = data.wither_kills_mini_walls || 0; - this.witherDamage = data.wither_damage_mini_walls || 0; - this.arrowsShot = data.arrows_shot_mini_walls || 0; - this.arrowsHit = data.arrows_hit_mini_walls || 0; + this.finalKills = data?.final_kills_mini_walls || 0; + this.witherKills = data?.wither_kills_mini_walls || 0; + this.witherDamage = data?.wither_damage_mini_walls || 0; + this.arrowsShot = data?.arrows_shot_mini_walls || 0; + this.arrowsHit = data?.arrows_hit_mini_walls || 0; this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot); } } @@ -316,9 +316,9 @@ export class PartyGames { roundWins: number; stars: number; constructor(data: Record) { - this.wins = data.wins_party || 0; - this.roundWins = data.round_wins_party || 0; - this.stars = data.total_stars_party || 0; + this.wins = data?.wins_party || 0; + this.roundWins = data?.round_wins_party || 0; + this.stars = data?.total_stars_party || 0; } } @@ -358,11 +358,11 @@ export class PixelParty { this.WLR = divide(this.wins, this.losses); this.roundsPlayed = data?.pixel_party?.rounds_completed || 0; this.powerUpsCollected = data?.pixel_party?.power_ups_collected || 0; - this.normal = new PixelPartyGameMode(data.pixel_party, 'normal'); - this.hyper = new PixelPartyGameMode(data.pixel_party, 'hyper'); + this.normal = new PixelPartyGameMode(data?.pixel_party, 'normal'); + this.hyper = new PixelPartyGameMode(data?.pixel_party, 'hyper'); this.highestRound = data?.pixel_party?.highest_round || 0; - this.musicVolume = data.pixel_party_music_volume || 0; - this.colorBlind = data.pixelparty || {}; + this.musicVolume = data?.pixel_party_music_volume || 0; + this.colorBlind = data?.pixelparty || {}; } } @@ -372,9 +372,9 @@ export class ThrowOut { deaths: number; KDR: number; constructor(data: Record) { - this.wins = data.wins_throw_out || 0; - this.kills = data.kills_throw_out || 0; - this.deaths = data.deaths_throw_out || 0; + this.wins = data?.wins_throw_out || 0; + this.kills = data?.kills_throw_out || 0; + this.deaths = data?.deaths_throw_out || 0; this.KDR = divide(this.kills, this.deaths); } } @@ -402,15 +402,15 @@ class Arcade { throwOut: ThrowOut; zombies: Zombies; constructor(data: Record = {}) { - this.coins = data.coins || 0; - this.weeklyCoins = parseInt(data[`weekly_coins_${weekAB()}`] || 0, 10); - this.monthlyCoins = parseInt(data[`monthly_coins_${monthAB()}`] || 0, 10); - this.hintsDisabled = !data.hints; - this.flashDisabled = !data.flash; + this.coins = data?.coins || 0; + this.weeklyCoins = parseInt(data?.[`weekly_coins_${weekAB()}`] || 0, 10); + this.monthlyCoins = parseInt(data?.[`monthly_coins_${monthAB()}`] || 0, 10); + this.hintsDisabled = !data?.hints; + this.flashDisabled = !data?.flash; this.blockingDead = new BlockingDead(data); this.bountyHunters = new BountyHunters(data); this.dragonWars = new DragonWars(data); - this.dropper = new Dropper(data.dropper); + this.dropper = new Dropper(data?.dropper); this.enderSpleef = new EnderSpleef(data); this.farmHunt = new FarmHunt(data); this.football = new Football(data); diff --git a/src/structures/MiniGames/ArenaBrawl.test.ts b/src/structures/MiniGames/ArenaBrawl.test.ts new file mode 100644 index 00000000..2f164e9e --- /dev/null +++ b/src/structures/MiniGames/ArenaBrawl.test.ts @@ -0,0 +1,121 @@ +import ArenaBrawl, { ArenaBrawlMode } from './ArenaBrawl'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('ArenaBrawl', () => { + const data = new ArenaBrawl({ stats: 'meow' }); + expect(data).toBeInstanceOf(ArenaBrawl); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.coinsSpent).toBeDefined(); + expect(data.coinsSpent).greaterThanOrEqual(0); + expectTypeOf(data.coinsSpent).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.keys).toBeDefined(); + expect(data.keys).greaterThanOrEqual(0); + expectTypeOf(data.keys).toEqualTypeOf(); + expect(data.chests).toBeDefined(); + expect(data.chests).greaterThanOrEqual(0); + expectTypeOf(data.chests).toEqualTypeOf(); + expect(data.rune).toBeDefined(); + expectTypeOf(data.rune).toEqualTypeOf(); + expect(data['1v1']).toBeDefined(); + expectTypeOf(data['1v1']).toEqualTypeOf(); + expect(data['1v1'].damage).toBeDefined(); + expect(data['1v1'].damage).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].damage).toEqualTypeOf(); + expect(data['1v1'].kills).toBeDefined(); + expect(data['1v1'].kills).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].kills).toEqualTypeOf(); + expect(data['1v1'].deaths).toBeDefined(); + expect(data['1v1'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].deaths).toEqualTypeOf(); + expect(data['1v1'].KDR).toBeDefined(); + expect(data['1v1'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].KDR).toEqualTypeOf(); + expect(data['1v1'].healed).toBeDefined(); + expect(data['1v1'].healed).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].healed).toEqualTypeOf(); + expect(data['1v1'].wins).toBeDefined(); + expect(data['1v1'].wins).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].wins).toEqualTypeOf(); + expect(data['1v1'].losses).toBeDefined(); + expect(data['1v1'].losses).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].losses).toEqualTypeOf(); + expect(data['1v1'].WLR).toBeDefined(); + expect(data['1v1'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].WLR).toEqualTypeOf(); + expect(data['1v1'].games).toBeDefined(); + expect(data['1v1'].games).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].games).toEqualTypeOf(); + expect(data['1v1'].winstreak).toBeDefined(); + expect(data['1v1'].winstreak).greaterThanOrEqual(0); + expectTypeOf(data['1v1'].winstreak).toEqualTypeOf(); + expect(data['2v2']).toBeDefined(); + expectTypeOf(data['2v2']).toEqualTypeOf(); + expect(data['2v2'].damage).toBeDefined(); + expect(data['2v2'].damage).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].damage).toEqualTypeOf(); + expect(data['2v2'].kills).toBeDefined(); + expect(data['2v2'].kills).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].kills).toEqualTypeOf(); + expect(data['2v2'].deaths).toBeDefined(); + expect(data['2v2'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].deaths).toEqualTypeOf(); + expect(data['2v2'].KDR).toBeDefined(); + expect(data['2v2'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].KDR).toEqualTypeOf(); + expect(data['2v2'].healed).toBeDefined(); + expect(data['2v2'].healed).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].healed).toEqualTypeOf(); + expect(data['2v2'].wins).toBeDefined(); + expect(data['2v2'].wins).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].wins).toEqualTypeOf(); + expect(data['2v2'].losses).toBeDefined(); + expect(data['2v2'].losses).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].losses).toEqualTypeOf(); + expect(data['2v2'].WLR).toBeDefined(); + expect(data['2v2'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].WLR).toEqualTypeOf(); + expect(data['2v2'].games).toBeDefined(); + expect(data['2v2'].games).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].games).toEqualTypeOf(); + expect(data['2v2'].winstreak).toBeDefined(); + expect(data['2v2'].winstreak).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].winstreak).toEqualTypeOf(); + expect(data['4v4']).toBeDefined(); + expectTypeOf(data['4v4']).toEqualTypeOf(); + expect(data['4v4'].damage).toBeDefined(); + expect(data['4v4'].damage).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].damage).toEqualTypeOf(); + expect(data['4v4'].kills).toBeDefined(); + expect(data['4v4'].kills).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].kills).toEqualTypeOf(); + expect(data['4v4'].deaths).toBeDefined(); + expect(data['4v4'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].deaths).toEqualTypeOf(); + expect(data['4v4'].KDR).toBeDefined(); + expect(data['4v4'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].KDR).toEqualTypeOf(); + expect(data['4v4'].healed).toBeDefined(); + expect(data['4v4'].healed).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].healed).toEqualTypeOf(); + expect(data['4v4'].wins).toBeDefined(); + expect(data['4v4'].wins).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].wins).toEqualTypeOf(); + expect(data['4v4'].losses).toBeDefined(); + expect(data['4v4'].losses).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].losses).toEqualTypeOf(); + expect(data['4v4'].WLR).toBeDefined(); + expect(data['4v4'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].WLR).toEqualTypeOf(); + expect(data['4v4'].games).toBeDefined(); + expect(data['4v4'].games).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].games).toEqualTypeOf(); + expect(data['4v4'].winstreak).toBeDefined(); + expect(data['4v4'].winstreak).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].winstreak).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/ArenaBrawl.ts b/src/structures/MiniGames/ArenaBrawl.ts index 02e2aa4c..a0a0a0d8 100644 --- a/src/structures/MiniGames/ArenaBrawl.ts +++ b/src/structures/MiniGames/ArenaBrawl.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class ArenaBrawlMode { +export class ArenaBrawlMode { damage: number; kills: number; deaths: number; @@ -12,16 +12,16 @@ class ArenaBrawlMode { games: number; winstreak: number; constructor(data: Record, mode: string) { - this.damage = data[`damage_${mode}`]; - this.kills = data[`kills_${mode}`]; - this.deaths = data[`deaths_${mode}`]; + this.damage = data?.[`damage_${mode}`] || 0; + this.kills = data?.[`kills_${mode}`] || 0; + this.deaths = data?.[`deaths_${mode}`] || 0; this.KDR = divide(this.kills, this.deaths); - this.healed = data[`healed_${mode}`]; - this.wins = data[`wins_${mode}`]; - this.losses = data[`losses_${mode}`]; + this.healed = data?.[`healed_${mode}`] || 0; + this.wins = data?.[`wins_${mode}`] || 0; + this.losses = data?.[`losses_${mode}`] || 0; this.WLR = divide(this.wins, this.losses); - this.games = data[`games_${mode}`]; - this.winstreak = data[`win_streaks_${mode}`]; + this.games = data?.[`games_${mode}`] || 0; + this.winstreak = data?.[`win_streaks_${mode}`] || 0; } } @@ -36,12 +36,12 @@ class ArenaBrawl { '2v2': ArenaBrawlMode; '4v4': ArenaBrawlMode; constructor(data: Record) { - this.coins = data.coins || 0; - this.coinsSpent = data.coins_spent || 0; - this.wins = data.wins || 0; - this.keys = data.keys || 0; - this.chests = data.magical_chest || 0; - this.rune = data.active_rune || ''; + this.coins = data?.coins || 0; + this.coinsSpent = data?.coins_spent || 0; + this.wins = data?.wins || 0; + this.keys = data?.keys || 0; + this.chests = data?.magical_chest || 0; + this.rune = data?.active_rune || ''; this['1v1'] = new ArenaBrawlMode(data, '1v1'); this['2v2'] = new ArenaBrawlMode(data, '2v2'); this['4v4'] = new ArenaBrawlMode(data, '4v4'); diff --git a/src/structures/MiniGames/BedWars.test.ts b/src/structures/MiniGames/BedWars.test.ts new file mode 100644 index 00000000..d7f99737 --- /dev/null +++ b/src/structures/MiniGames/BedWars.test.ts @@ -0,0 +1,949 @@ +import BedWars, { + BedWarsBeds, + BedWarsCollectedItems, + BedWarsPracticeStats, + BedWarsPrestige, + BedwarsDreamMode, + BedwarsDreamStats, + BedwarsMode, + getBedWarsPrestige, + getExpForLevel +} from './BedWars'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('BedWars (getBedWarsPrestige)', () => { + expect(getBedWarsPrestige(6000)).toBe('Eternal'); +}); + +test('BedWars (getExpForLevel)', () => { + expect(getExpForLevel(0)).toBe(0); + expectTypeOf(getExpForLevel(0)).toEqualTypeOf(); + expect(getExpForLevel(1)).toBe(500); + expectTypeOf(getExpForLevel(1)).toEqualTypeOf(); + expect(getExpForLevel(2)).toBe(1000); + expectTypeOf(getExpForLevel(2)).toEqualTypeOf(); + expect(getExpForLevel(3)).toBe(2000); + expectTypeOf(getExpForLevel(3)).toEqualTypeOf(); + expect(getExpForLevel(4)).toBe(3500); + expectTypeOf(getExpForLevel(4)).toEqualTypeOf(); + expect(getExpForLevel(5)).toBe(5000); + expectTypeOf(getExpForLevel(5)).toEqualTypeOf(); + expect(getExpForLevel(6)).toBe(5000); + expectTypeOf(getExpForLevel(6)).toEqualTypeOf(); +}); + +test('BedWars', () => { + const data = new BedWars({ stats: 'meow' }); + expect(data).toBeInstanceOf(BedWars); + expectTypeOf(data).toEqualTypeOf(); + expect(data.tokens).toBeDefined(); + expect(data.tokens).greaterThanOrEqual(0); + expectTypeOf(data.tokens).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expect(data.level).greaterThanOrEqual(0); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.experience).toBeDefined(); + expect(data.experience).greaterThanOrEqual(0); + expectTypeOf(data.experience).toEqualTypeOf(); + expect(data.prestige).toBeDefined(); + expectTypeOf(data.prestige).toEqualTypeOf(); + expect(data.playedGames).toBeDefined(); + expect(data.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.playedGames).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.winstreak).toBeDefined(); + expect(data.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.winstreak).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.finalKills).toBeDefined(); + expect(data.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.finalKills).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.finalDeaths).toBeDefined(); + expect(data.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.finalDeaths).toEqualTypeOf(); + expect(data.collectedItemsTotal).toBeDefined(); + expectTypeOf(data.collectedItemsTotal).toEqualTypeOf(); + expect(data.collectedItemsTotal.iron).toBeDefined(); + expect(data.collectedItemsTotal.iron).greaterThanOrEqual(0); + expectTypeOf(data.collectedItemsTotal.iron).toEqualTypeOf(); + expect(data.collectedItemsTotal.gold).toBeDefined(); + expect(data.collectedItemsTotal.gold).greaterThanOrEqual(0); + expectTypeOf(data.collectedItemsTotal.gold).toEqualTypeOf(); + expect(data.collectedItemsTotal.diamond).toBeDefined(); + expect(data.collectedItemsTotal.diamond).greaterThanOrEqual(0); + expectTypeOf(data.collectedItemsTotal.diamond).toEqualTypeOf(); + expect(data.collectedItemsTotal.emerald).toBeDefined(); + expect(data.collectedItemsTotal.emerald).greaterThanOrEqual(0); + expectTypeOf(data.collectedItemsTotal.emerald).toEqualTypeOf(); + expect(data.beds).toBeDefined(); + expectTypeOf(data.beds).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.FKDR).toBeDefined(); + expect(data.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.FKDR).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.solo).toBeDefined(); + expectTypeOf(data.solo).toEqualTypeOf(); + expect(data.solo.winstreak).toBeDefined(); + expect(data.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.solo.winstreak).toEqualTypeOf(); + expect(data.solo.playedGames).toBeDefined(); + expect(data.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.solo.playedGames).toEqualTypeOf(); + expect(data.solo.kills).toBeDefined(); + expect(data.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.kills).toEqualTypeOf(); + expect(data.solo.deaths).toBeDefined(); + expect(data.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.deaths).toEqualTypeOf(); + expect(data.solo.wins).toBeDefined(); + expect(data.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.wins).toEqualTypeOf(); + expect(data.solo.losses).toBeDefined(); + expect(data.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.solo.losses).toEqualTypeOf(); + expect(data.solo.finalKills).toBeDefined(); + expect(data.solo.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.solo.finalKills).toEqualTypeOf(); + expect(data.solo.finalDeaths).toBeDefined(); + expect(data.solo.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.finalDeaths).toEqualTypeOf(); + expect(data.solo.beds).toBeDefined(); + expectTypeOf(data.solo.beds).toEqualTypeOf(); + expect(data.solo.beds.lost).toBeDefined(); + expect(data.solo.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.solo.beds.lost).toEqualTypeOf(); + expect(data.solo.beds.broken).toBeDefined(); + expect(data.solo.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.solo.beds.broken).toEqualTypeOf(); + expect(data.solo.beds.BLRatio).toBeDefined(); + expect(data.solo.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.solo.beds.BLRatio).toEqualTypeOf(); + expect(data.solo.KDR).toBeDefined(); + expect(data.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.KDR).toEqualTypeOf(); + expect(data.solo.WLR).toBeDefined(); + expect(data.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.solo.WLR).toEqualTypeOf(); + expect(data.solo.FKDR).toBeDefined(); + expect(data.solo.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.FKDR).toEqualTypeOf(); + expect(data.doubles).toBeDefined(); + expectTypeOf(data.doubles).toEqualTypeOf(); + expect(data.doubles.winstreak).toBeDefined(); + expect(data.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.doubles.winstreak).toEqualTypeOf(); + expect(data.doubles.playedGames).toBeDefined(); + expect(data.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.doubles.playedGames).toEqualTypeOf(); + expect(data.doubles.kills).toBeDefined(); + expect(data.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.doubles.kills).toEqualTypeOf(); + expect(data.doubles.deaths).toBeDefined(); + expect(data.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.doubles.deaths).toEqualTypeOf(); + expect(data.doubles.wins).toBeDefined(); + expect(data.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.doubles.wins).toEqualTypeOf(); + expect(data.doubles.losses).toBeDefined(); + expect(data.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.doubles.losses).toEqualTypeOf(); + expect(data.doubles.finalKills).toBeDefined(); + expect(data.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.doubles.finalKills).toEqualTypeOf(); + expect(data.doubles.finalDeaths).toBeDefined(); + expect(data.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.doubles.finalDeaths).toEqualTypeOf(); + expect(data.doubles.beds).toBeDefined(); + expectTypeOf(data.doubles.beds).toEqualTypeOf(); + expect(data.doubles.beds.lost).toBeDefined(); + expect(data.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.doubles.beds.lost).toEqualTypeOf(); + expect(data.doubles.beds.broken).toBeDefined(); + expect(data.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.doubles.beds.broken).toEqualTypeOf(); + expect(data.doubles.beds.BLRatio).toBeDefined(); + expect(data.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.doubles.KDR).toBeDefined(); + expect(data.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.doubles.KDR).toEqualTypeOf(); + expect(data.doubles.WLR).toBeDefined(); + expect(data.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.doubles.WLR).toEqualTypeOf(); + expect(data.doubles.FKDR).toBeDefined(); + expect(data.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.doubles.FKDR).toEqualTypeOf(); + expect(data.threes).toBeDefined(); + expectTypeOf(data.threes).toEqualTypeOf(); + expect(data.threes.winstreak).toBeDefined(); + expect(data.threes.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.threes.winstreak).toEqualTypeOf(); + expect(data.threes.playedGames).toBeDefined(); + expect(data.threes.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.threes.playedGames).toEqualTypeOf(); + expect(data.threes.kills).toBeDefined(); + expect(data.threes.kills).greaterThanOrEqual(0); + expectTypeOf(data.threes.kills).toEqualTypeOf(); + expect(data.threes.deaths).toBeDefined(); + expect(data.threes.deaths).greaterThanOrEqual(0); + expectTypeOf(data.threes.deaths).toEqualTypeOf(); + expect(data.threes.wins).toBeDefined(); + expect(data.threes.wins).greaterThanOrEqual(0); + expectTypeOf(data.threes.wins).toEqualTypeOf(); + expect(data.threes.losses).toBeDefined(); + expect(data.threes.losses).greaterThanOrEqual(0); + expectTypeOf(data.threes.losses).toEqualTypeOf(); + expect(data.threes.finalKills).toBeDefined(); + expect(data.threes.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.threes.finalKills).toEqualTypeOf(); + expect(data.threes.finalDeaths).toBeDefined(); + expect(data.threes.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.threes.finalDeaths).toEqualTypeOf(); + expect(data.threes.beds).toBeDefined(); + expectTypeOf(data.threes.beds).toEqualTypeOf(); + expect(data.threes.beds.lost).toBeDefined(); + expect(data.threes.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.threes.beds.lost).toEqualTypeOf(); + expect(data.threes.beds.broken).toBeDefined(); + expect(data.threes.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.threes.beds.broken).toEqualTypeOf(); + expect(data.threes.beds.BLRatio).toBeDefined(); + expect(data.threes.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.threes.beds.BLRatio).toEqualTypeOf(); + expect(data.threes.KDR).toBeDefined(); + expect(data.threes.KDR).greaterThanOrEqual(0); + expectTypeOf(data.threes.KDR).toEqualTypeOf(); + expect(data.threes.WLR).toBeDefined(); + expect(data.threes.WLR).greaterThanOrEqual(0); + expectTypeOf(data.threes.WLR).toEqualTypeOf(); + expect(data.threes.FKDR).toBeDefined(); + expect(data.threes.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.threes.FKDR).toEqualTypeOf(); + expect(data.fours).toBeDefined(); + expectTypeOf(data.fours).toEqualTypeOf(); + expect(data.fours.winstreak).toBeDefined(); + expect(data.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.fours.winstreak).toEqualTypeOf(); + expect(data.fours.playedGames).toBeDefined(); + expect(data.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.fours.playedGames).toEqualTypeOf(); + expect(data.fours.kills).toBeDefined(); + expect(data.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.fours.kills).toEqualTypeOf(); + expect(data.fours.deaths).toBeDefined(); + expect(data.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.fours.deaths).toEqualTypeOf(); + expect(data.fours.wins).toBeDefined(); + expect(data.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.fours.wins).toEqualTypeOf(); + expect(data.fours.losses).toBeDefined(); + expect(data.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.fours.losses).toEqualTypeOf(); + expect(data.fours.finalKills).toBeDefined(); + expect(data.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.fours.finalKills).toEqualTypeOf(); + expect(data.fours.finalDeaths).toBeDefined(); + expect(data.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.fours.finalDeaths).toEqualTypeOf(); + expect(data.fours.beds).toBeDefined(); + expectTypeOf(data.fours.beds).toEqualTypeOf(); + expect(data.fours.beds.lost).toBeDefined(); + expect(data.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.fours.beds.lost).toEqualTypeOf(); + expect(data.fours.beds.broken).toBeDefined(); + expect(data.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.fours.beds.broken).toEqualTypeOf(); + expect(data.fours.beds.BLRatio).toBeDefined(); + expect(data.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.fours.KDR).toBeDefined(); + expect(data.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.fours.KDR).toEqualTypeOf(); + expect(data.fours.WLR).toBeDefined(); + expect(data.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.fours.WLR).toEqualTypeOf(); + expect(data.fours.FKDR).toBeDefined(); + expect(data.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.fours.FKDR).toEqualTypeOf(); + expect(data['4v4']).toBeDefined(); + expectTypeOf(data['4v4']).toEqualTypeOf(); + expect(data['4v4'].winstreak).toBeDefined(); + expect(data['4v4'].winstreak).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].winstreak).toEqualTypeOf(); + expect(data['4v4'].playedGames).toBeDefined(); + expect(data['4v4'].playedGames).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].playedGames).toEqualTypeOf(); + expect(data['4v4'].kills).toBeDefined(); + expect(data['4v4'].kills).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].kills).toEqualTypeOf(); + expect(data['4v4'].deaths).toBeDefined(); + expect(data['4v4'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].deaths).toEqualTypeOf(); + expect(data['4v4'].wins).toBeDefined(); + expect(data['4v4'].wins).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].wins).toEqualTypeOf(); + expect(data['4v4'].losses).toBeDefined(); + expect(data['4v4'].losses).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].losses).toEqualTypeOf(); + expect(data['4v4'].finalKills).toBeDefined(); + expect(data['4v4'].finalKills).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].finalKills).toEqualTypeOf(); + expect(data['4v4'].finalDeaths).toBeDefined(); + expect(data['4v4'].finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].finalDeaths).toEqualTypeOf(); + expect(data['4v4'].beds).toBeDefined(); + expectTypeOf(data['4v4'].beds).toEqualTypeOf(); + expect(data['4v4'].beds.lost).toBeDefined(); + expect(data['4v4'].beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data['4v4'].beds.lost).toEqualTypeOf(); + expect(data['4v4'].beds.broken).toBeDefined(); + expect(data['4v4'].beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data['4v4'].beds.broken).toEqualTypeOf(); + expect(data['4v4'].beds.BLRatio).toBeDefined(); + expect(data['4v4'].beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data['4v4'].beds.BLRatio).toEqualTypeOf(); + expect(data['4v4'].KDR).toBeDefined(); + expect(data['4v4'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].KDR).toEqualTypeOf(); + expect(data['4v4'].WLR).toBeDefined(); + expect(data['4v4'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].WLR).toEqualTypeOf(); + expect(data['4v4'].FKDR).toBeDefined(); + expect(data['4v4'].FKDR).greaterThanOrEqual(0); + expectTypeOf(data['4v4'].FKDR).toEqualTypeOf(); + expect(data.dream).toBeDefined(); + expectTypeOf(data.dream).toEqualTypeOf(); + expect(data.dream.ultimate).toBeDefined(); + expectTypeOf(data.dream.ultimate).toEqualTypeOf(); + expect(data.dream.ultimate.doubles).toBeDefined(); + expectTypeOf(data.dream.ultimate.doubles).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.winstreak).toBeDefined(); + expect(data.dream.ultimate.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.winstreak).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.playedGames).toBeDefined(); + expect(data.dream.ultimate.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.playedGames).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.kills).toBeDefined(); + expect(data.dream.ultimate.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.kills).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.deaths).toBeDefined(); + expect(data.dream.ultimate.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.deaths).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.wins).toBeDefined(); + expect(data.dream.ultimate.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.wins).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.losses).toBeDefined(); + expect(data.dream.ultimate.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.losses).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.finalKills).toBeDefined(); + expect(data.dream.ultimate.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.finalKills).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.finalDeaths).toBeDefined(); + expect(data.dream.ultimate.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.finalDeaths).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.beds).toBeDefined(); + expectTypeOf(data.dream.ultimate.doubles.beds).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.beds.lost).toBeDefined(); + expect(data.dream.ultimate.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.beds.lost).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.beds.broken).toBeDefined(); + expect(data.dream.ultimate.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.beds.broken).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.beds.BLRatio).toBeDefined(); + expect(data.dream.ultimate.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.KDR).toBeDefined(); + expect(data.dream.ultimate.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.KDR).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.WLR).toBeDefined(); + expect(data.dream.ultimate.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.WLR).toEqualTypeOf(); + expect(data.dream.ultimate.doubles.FKDR).toBeDefined(); + expect(data.dream.ultimate.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.doubles.FKDR).toEqualTypeOf(); + expect(data.dream.ultimate.fours).toBeDefined(); + expectTypeOf(data.dream.ultimate.fours).toEqualTypeOf(); + expect(data.dream.ultimate.fours.winstreak).toBeDefined(); + expect(data.dream.ultimate.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.winstreak).toEqualTypeOf(); + expect(data.dream.ultimate.fours.playedGames).toBeDefined(); + expect(data.dream.ultimate.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.playedGames).toEqualTypeOf(); + expect(data.dream.ultimate.fours.kills).toBeDefined(); + expect(data.dream.ultimate.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.kills).toEqualTypeOf(); + expect(data.dream.ultimate.fours.deaths).toBeDefined(); + expect(data.dream.ultimate.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.deaths).toEqualTypeOf(); + expect(data.dream.ultimate.fours.wins).toBeDefined(); + expect(data.dream.ultimate.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.wins).toEqualTypeOf(); + expect(data.dream.ultimate.fours.losses).toBeDefined(); + expect(data.dream.ultimate.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.losses).toEqualTypeOf(); + expect(data.dream.ultimate.fours.finalKills).toBeDefined(); + expect(data.dream.ultimate.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.finalKills).toEqualTypeOf(); + expect(data.dream.ultimate.fours.finalDeaths).toBeDefined(); + expect(data.dream.ultimate.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.finalDeaths).toEqualTypeOf(); + expect(data.dream.ultimate.fours.beds).toBeDefined(); + expectTypeOf(data.dream.ultimate.fours.beds).toEqualTypeOf(); + expect(data.dream.ultimate.fours.beds.lost).toBeDefined(); + expect(data.dream.ultimate.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.beds.lost).toEqualTypeOf(); + expect(data.dream.ultimate.fours.beds.broken).toBeDefined(); + expect(data.dream.ultimate.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.beds.broken).toEqualTypeOf(); + expect(data.dream.ultimate.fours.beds.BLRatio).toBeDefined(); + expect(data.dream.ultimate.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.ultimate.fours.KDR).toBeDefined(); + expect(data.dream.ultimate.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.KDR).toEqualTypeOf(); + expect(data.dream.ultimate.fours.WLR).toBeDefined(); + expect(data.dream.ultimate.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.WLR).toEqualTypeOf(); + expect(data.dream.ultimate.fours.FKDR).toBeDefined(); + expect(data.dream.ultimate.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.ultimate.fours.FKDR).toEqualTypeOf(); + expect(data.dream.rush).toBeDefined(); + expectTypeOf(data.dream.rush).toEqualTypeOf(); + expect(data.dream.rush.doubles).toBeDefined(); + expectTypeOf(data.dream.rush.doubles).toEqualTypeOf(); + expect(data.dream.rush.doubles.winstreak).toBeDefined(); + expect(data.dream.rush.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.winstreak).toEqualTypeOf(); + expect(data.dream.rush.doubles.playedGames).toBeDefined(); + expect(data.dream.rush.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.playedGames).toEqualTypeOf(); + expect(data.dream.rush.doubles.kills).toBeDefined(); + expect(data.dream.rush.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.kills).toEqualTypeOf(); + expect(data.dream.rush.doubles.deaths).toBeDefined(); + expect(data.dream.rush.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.deaths).toEqualTypeOf(); + expect(data.dream.rush.doubles.wins).toBeDefined(); + expect(data.dream.rush.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.wins).toEqualTypeOf(); + expect(data.dream.rush.doubles.losses).toBeDefined(); + expect(data.dream.rush.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.losses).toEqualTypeOf(); + expect(data.dream.rush.doubles.finalKills).toBeDefined(); + expect(data.dream.rush.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.finalKills).toEqualTypeOf(); + expect(data.dream.rush.doubles.finalDeaths).toBeDefined(); + expect(data.dream.rush.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.finalDeaths).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds).toBeDefined(); + expectTypeOf(data.dream.rush.doubles.beds).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds.lost).toBeDefined(); + expect(data.dream.rush.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.beds.lost).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds.broken).toBeDefined(); + expect(data.dream.rush.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.beds.broken).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds.BLRatio).toBeDefined(); + expect(data.dream.rush.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.rush.doubles.KDR).toBeDefined(); + expect(data.dream.rush.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.KDR).toEqualTypeOf(); + expect(data.dream.rush.doubles.WLR).toBeDefined(); + expect(data.dream.rush.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.WLR).toEqualTypeOf(); + expect(data.dream.rush.doubles.FKDR).toBeDefined(); + expect(data.dream.rush.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.FKDR).toEqualTypeOf(); + expect(data.dream.rush.fours).toBeDefined(); + expectTypeOf(data.dream.rush.fours).toEqualTypeOf(); + expect(data.dream.rush.fours.winstreak).toBeDefined(); + expect(data.dream.rush.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.winstreak).toEqualTypeOf(); + expect(data.dream.rush.fours.playedGames).toBeDefined(); + expect(data.dream.rush.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.playedGames).toEqualTypeOf(); + expect(data.dream.rush.fours.kills).toBeDefined(); + expect(data.dream.rush.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.kills).toEqualTypeOf(); + expect(data.dream.rush.fours.deaths).toBeDefined(); + expect(data.dream.rush.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.deaths).toEqualTypeOf(); + expect(data.dream.rush.fours.wins).toBeDefined(); + expect(data.dream.rush.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.wins).toEqualTypeOf(); + expect(data.dream.rush.fours.losses).toBeDefined(); + expect(data.dream.rush.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.losses).toEqualTypeOf(); + expect(data.dream.rush.fours.finalKills).toBeDefined(); + expect(data.dream.rush.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.finalKills).toEqualTypeOf(); + expect(data.dream.rush.fours.finalDeaths).toBeDefined(); + expect(data.dream.rush.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.finalDeaths).toEqualTypeOf(); + expect(data.dream.rush.fours.beds).toBeDefined(); + expectTypeOf(data.dream.rush.fours.beds).toEqualTypeOf(); + expect(data.dream.rush.fours.beds.lost).toBeDefined(); + expect(data.dream.rush.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.beds.lost).toEqualTypeOf(); + expect(data.dream.rush.fours.beds.broken).toBeDefined(); + expect(data.dream.rush.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.beds.broken).toEqualTypeOf(); + expect(data.dream.rush.fours.beds.BLRatio).toBeDefined(); + expect(data.dream.rush.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.rush.fours.KDR).toBeDefined(); + expect(data.dream.rush.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.KDR).toEqualTypeOf(); + expect(data.dream.rush.fours.WLR).toBeDefined(); + expect(data.dream.rush.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.WLR).toEqualTypeOf(); + expect(data.dream.rush.fours.FKDR).toBeDefined(); + expect(data.dream.rush.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.FKDR).toEqualTypeOf(); + expect(data.dream.rush).toBeDefined(); + expectTypeOf(data.dream.rush).toEqualTypeOf(); + expect(data.dream.rush.doubles).toBeDefined(); + expectTypeOf(data.dream.rush.doubles).toEqualTypeOf(); + expect(data.dream.rush.doubles.winstreak).toBeDefined(); + expect(data.dream.rush.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.winstreak).toEqualTypeOf(); + expect(data.dream.rush.doubles.playedGames).toBeDefined(); + expect(data.dream.rush.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.playedGames).toEqualTypeOf(); + expect(data.dream.rush.doubles.kills).toBeDefined(); + expect(data.dream.rush.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.kills).toEqualTypeOf(); + expect(data.dream.rush.doubles.deaths).toBeDefined(); + expect(data.dream.rush.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.deaths).toEqualTypeOf(); + expect(data.dream.rush.doubles.wins).toBeDefined(); + expect(data.dream.rush.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.wins).toEqualTypeOf(); + expect(data.dream.rush.doubles.losses).toBeDefined(); + expect(data.dream.rush.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.losses).toEqualTypeOf(); + expect(data.dream.rush.doubles.finalKills).toBeDefined(); + expect(data.dream.rush.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.finalKills).toEqualTypeOf(); + expect(data.dream.rush.doubles.finalDeaths).toBeDefined(); + expect(data.dream.rush.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.finalDeaths).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds).toBeDefined(); + expectTypeOf(data.dream.rush.doubles.beds).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds.lost).toBeDefined(); + expect(data.dream.rush.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.beds.lost).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds.broken).toBeDefined(); + expect(data.dream.rush.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.beds.broken).toEqualTypeOf(); + expect(data.dream.rush.doubles.beds.BLRatio).toBeDefined(); + expect(data.dream.rush.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.rush.doubles.KDR).toBeDefined(); + expect(data.dream.rush.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.KDR).toEqualTypeOf(); + expect(data.dream.rush.doubles.WLR).toBeDefined(); + expect(data.dream.rush.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.WLR).toEqualTypeOf(); + expect(data.dream.rush.doubles.FKDR).toBeDefined(); + expect(data.dream.rush.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.doubles.FKDR).toEqualTypeOf(); + expect(data.dream.rush.fours).toBeDefined(); + expectTypeOf(data.dream.rush.fours).toEqualTypeOf(); + expect(data.dream.rush.fours.winstreak).toBeDefined(); + expect(data.dream.rush.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.winstreak).toEqualTypeOf(); + expect(data.dream.rush.fours.playedGames).toBeDefined(); + expect(data.dream.rush.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.playedGames).toEqualTypeOf(); + expect(data.dream.rush.fours.kills).toBeDefined(); + expect(data.dream.rush.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.kills).toEqualTypeOf(); + expect(data.dream.rush.fours.deaths).toBeDefined(); + expect(data.dream.rush.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.deaths).toEqualTypeOf(); + expect(data.dream.rush.fours.wins).toBeDefined(); + expect(data.dream.rush.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.wins).toEqualTypeOf(); + expect(data.dream.rush.fours.losses).toBeDefined(); + expect(data.dream.rush.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.losses).toEqualTypeOf(); + expect(data.dream.rush.fours.finalKills).toBeDefined(); + expect(data.dream.rush.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.finalKills).toEqualTypeOf(); + expect(data.dream.rush.fours.finalDeaths).toBeDefined(); + expect(data.dream.rush.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.finalDeaths).toEqualTypeOf(); + expect(data.dream.rush.fours.beds).toBeDefined(); + expectTypeOf(data.dream.rush.fours.beds).toEqualTypeOf(); + expect(data.dream.rush.fours.beds.lost).toBeDefined(); + expect(data.dream.rush.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.beds.lost).toEqualTypeOf(); + expect(data.dream.rush.fours.beds.broken).toBeDefined(); + expect(data.dream.rush.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.beds.broken).toEqualTypeOf(); + expect(data.dream.rush.fours.beds.BLRatio).toBeDefined(); + expect(data.dream.rush.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.rush.fours.KDR).toBeDefined(); + expect(data.dream.rush.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.KDR).toEqualTypeOf(); + expect(data.dream.rush.fours.WLR).toBeDefined(); + expect(data.dream.rush.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.WLR).toEqualTypeOf(); + expect(data.dream.rush.fours.FKDR).toBeDefined(); + expect(data.dream.rush.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.rush.fours.FKDR).toEqualTypeOf(); + expect(data.dream.armed).toBeDefined(); + expectTypeOf(data.dream.armed).toEqualTypeOf(); + expect(data.dream.armed.doubles).toBeDefined(); + expectTypeOf(data.dream.armed.doubles).toEqualTypeOf(); + expect(data.dream.armed.doubles.winstreak).toBeDefined(); + expect(data.dream.armed.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.winstreak).toEqualTypeOf(); + expect(data.dream.armed.doubles.playedGames).toBeDefined(); + expect(data.dream.armed.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.playedGames).toEqualTypeOf(); + expect(data.dream.armed.doubles.kills).toBeDefined(); + expect(data.dream.armed.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.kills).toEqualTypeOf(); + expect(data.dream.armed.doubles.deaths).toBeDefined(); + expect(data.dream.armed.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.deaths).toEqualTypeOf(); + expect(data.dream.armed.doubles.wins).toBeDefined(); + expect(data.dream.armed.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.wins).toEqualTypeOf(); + expect(data.dream.armed.doubles.losses).toBeDefined(); + expect(data.dream.armed.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.losses).toEqualTypeOf(); + expect(data.dream.armed.doubles.finalKills).toBeDefined(); + expect(data.dream.armed.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.finalKills).toEqualTypeOf(); + expect(data.dream.armed.doubles.finalDeaths).toBeDefined(); + expect(data.dream.armed.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.finalDeaths).toEqualTypeOf(); + expect(data.dream.armed.doubles.beds).toBeDefined(); + expectTypeOf(data.dream.armed.doubles.beds).toEqualTypeOf(); + expect(data.dream.armed.doubles.beds.lost).toBeDefined(); + expect(data.dream.armed.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.beds.lost).toEqualTypeOf(); + expect(data.dream.armed.doubles.beds.broken).toBeDefined(); + expect(data.dream.armed.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.beds.broken).toEqualTypeOf(); + expect(data.dream.armed.doubles.beds.BLRatio).toBeDefined(); + expect(data.dream.armed.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.armed.doubles.KDR).toBeDefined(); + expect(data.dream.armed.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.KDR).toEqualTypeOf(); + expect(data.dream.armed.doubles.WLR).toBeDefined(); + expect(data.dream.armed.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.WLR).toEqualTypeOf(); + expect(data.dream.armed.doubles.FKDR).toBeDefined(); + expect(data.dream.armed.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.doubles.FKDR).toEqualTypeOf(); + expect(data.dream.armed.fours).toBeDefined(); + expectTypeOf(data.dream.armed.fours).toEqualTypeOf(); + expect(data.dream.armed.fours.winstreak).toBeDefined(); + expect(data.dream.armed.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.winstreak).toEqualTypeOf(); + expect(data.dream.armed.fours.playedGames).toBeDefined(); + expect(data.dream.armed.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.playedGames).toEqualTypeOf(); + expect(data.dream.armed.fours.kills).toBeDefined(); + expect(data.dream.armed.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.kills).toEqualTypeOf(); + expect(data.dream.armed.fours.deaths).toBeDefined(); + expect(data.dream.armed.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.deaths).toEqualTypeOf(); + expect(data.dream.armed.fours.wins).toBeDefined(); + expect(data.dream.armed.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.wins).toEqualTypeOf(); + expect(data.dream.armed.fours.losses).toBeDefined(); + expect(data.dream.armed.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.losses).toEqualTypeOf(); + expect(data.dream.armed.fours.finalKills).toBeDefined(); + expect(data.dream.armed.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.finalKills).toEqualTypeOf(); + expect(data.dream.armed.fours.finalDeaths).toBeDefined(); + expect(data.dream.armed.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.finalDeaths).toEqualTypeOf(); + expect(data.dream.armed.fours.beds).toBeDefined(); + expectTypeOf(data.dream.armed.fours.beds).toEqualTypeOf(); + expect(data.dream.armed.fours.beds.lost).toBeDefined(); + expect(data.dream.armed.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.beds.lost).toEqualTypeOf(); + expect(data.dream.armed.fours.beds.broken).toBeDefined(); + expect(data.dream.armed.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.beds.broken).toEqualTypeOf(); + expect(data.dream.armed.fours.beds.BLRatio).toBeDefined(); + expect(data.dream.armed.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.armed.fours.KDR).toBeDefined(); + expect(data.dream.armed.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.KDR).toEqualTypeOf(); + expect(data.dream.armed.fours.WLR).toBeDefined(); + expect(data.dream.armed.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.WLR).toEqualTypeOf(); + expect(data.dream.armed.fours.FKDR).toBeDefined(); + expect(data.dream.armed.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.armed.fours.FKDR).toEqualTypeOf(); + expect(data.dream.lucky).toBeDefined(); + expectTypeOf(data.dream.lucky).toEqualTypeOf(); + expect(data.dream.lucky.doubles).toBeDefined(); + expectTypeOf(data.dream.lucky.doubles).toEqualTypeOf(); + expect(data.dream.lucky.doubles.winstreak).toBeDefined(); + expect(data.dream.lucky.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.winstreak).toEqualTypeOf(); + expect(data.dream.lucky.doubles.playedGames).toBeDefined(); + expect(data.dream.lucky.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.playedGames).toEqualTypeOf(); + expect(data.dream.lucky.doubles.kills).toBeDefined(); + expect(data.dream.lucky.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.kills).toEqualTypeOf(); + expect(data.dream.lucky.doubles.deaths).toBeDefined(); + expect(data.dream.lucky.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.deaths).toEqualTypeOf(); + expect(data.dream.lucky.doubles.wins).toBeDefined(); + expect(data.dream.lucky.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.wins).toEqualTypeOf(); + expect(data.dream.lucky.doubles.losses).toBeDefined(); + expect(data.dream.lucky.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.losses).toEqualTypeOf(); + expect(data.dream.lucky.doubles.finalKills).toBeDefined(); + expect(data.dream.lucky.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.finalKills).toEqualTypeOf(); + expect(data.dream.lucky.doubles.finalDeaths).toBeDefined(); + expect(data.dream.lucky.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.finalDeaths).toEqualTypeOf(); + expect(data.dream.lucky.doubles.beds).toBeDefined(); + expectTypeOf(data.dream.lucky.doubles.beds).toEqualTypeOf(); + expect(data.dream.lucky.doubles.beds.lost).toBeDefined(); + expect(data.dream.lucky.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.beds.lost).toEqualTypeOf(); + expect(data.dream.lucky.doubles.beds.broken).toBeDefined(); + expect(data.dream.lucky.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.beds.broken).toEqualTypeOf(); + expect(data.dream.lucky.doubles.beds.BLRatio).toBeDefined(); + expect(data.dream.lucky.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.lucky.doubles.KDR).toBeDefined(); + expect(data.dream.lucky.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.KDR).toEqualTypeOf(); + expect(data.dream.lucky.doubles.WLR).toBeDefined(); + expect(data.dream.lucky.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.WLR).toEqualTypeOf(); + expect(data.dream.lucky.doubles.FKDR).toBeDefined(); + expect(data.dream.lucky.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.doubles.FKDR).toEqualTypeOf(); + expect(data.dream.lucky.fours).toBeDefined(); + expectTypeOf(data.dream.lucky.fours).toEqualTypeOf(); + expect(data.dream.lucky.fours.winstreak).toBeDefined(); + expect(data.dream.lucky.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.winstreak).toEqualTypeOf(); + expect(data.dream.lucky.fours.playedGames).toBeDefined(); + expect(data.dream.lucky.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.playedGames).toEqualTypeOf(); + expect(data.dream.lucky.fours.kills).toBeDefined(); + expect(data.dream.lucky.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.kills).toEqualTypeOf(); + expect(data.dream.lucky.fours.deaths).toBeDefined(); + expect(data.dream.lucky.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.deaths).toEqualTypeOf(); + expect(data.dream.lucky.fours.wins).toBeDefined(); + expect(data.dream.lucky.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.wins).toEqualTypeOf(); + expect(data.dream.lucky.fours.losses).toBeDefined(); + expect(data.dream.lucky.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.losses).toEqualTypeOf(); + expect(data.dream.lucky.fours.finalKills).toBeDefined(); + expect(data.dream.lucky.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.finalKills).toEqualTypeOf(); + expect(data.dream.lucky.fours.finalDeaths).toBeDefined(); + expect(data.dream.lucky.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.finalDeaths).toEqualTypeOf(); + expect(data.dream.lucky.fours.beds).toBeDefined(); + expectTypeOf(data.dream.lucky.fours.beds).toEqualTypeOf(); + expect(data.dream.lucky.fours.beds.lost).toBeDefined(); + expect(data.dream.lucky.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.beds.lost).toEqualTypeOf(); + expect(data.dream.lucky.fours.beds.broken).toBeDefined(); + expect(data.dream.lucky.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.beds.broken).toEqualTypeOf(); + expect(data.dream.lucky.fours.beds.BLRatio).toBeDefined(); + expect(data.dream.lucky.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.lucky.fours.KDR).toBeDefined(); + expect(data.dream.lucky.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.KDR).toEqualTypeOf(); + expect(data.dream.lucky.fours.WLR).toBeDefined(); + expect(data.dream.lucky.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.WLR).toEqualTypeOf(); + expect(data.dream.lucky.fours.FKDR).toBeDefined(); + expect(data.dream.lucky.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.lucky.fours.FKDR).toEqualTypeOf(); + expect(data.dream.voidless).toBeDefined(); + expectTypeOf(data.dream.voidless).toEqualTypeOf(); + expect(data.dream.voidless.doubles).toBeDefined(); + expectTypeOf(data.dream.voidless.doubles).toEqualTypeOf(); + expect(data.dream.voidless.doubles.winstreak).toBeDefined(); + expect(data.dream.voidless.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.winstreak).toEqualTypeOf(); + expect(data.dream.voidless.doubles.playedGames).toBeDefined(); + expect(data.dream.voidless.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.playedGames).toEqualTypeOf(); + expect(data.dream.voidless.doubles.kills).toBeDefined(); + expect(data.dream.voidless.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.kills).toEqualTypeOf(); + expect(data.dream.voidless.doubles.deaths).toBeDefined(); + expect(data.dream.voidless.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.deaths).toEqualTypeOf(); + expect(data.dream.voidless.doubles.wins).toBeDefined(); + expect(data.dream.voidless.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.wins).toEqualTypeOf(); + expect(data.dream.voidless.doubles.losses).toBeDefined(); + expect(data.dream.voidless.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.losses).toEqualTypeOf(); + expect(data.dream.voidless.doubles.finalKills).toBeDefined(); + expect(data.dream.voidless.doubles.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.finalKills).toEqualTypeOf(); + expect(data.dream.voidless.doubles.finalDeaths).toBeDefined(); + expect(data.dream.voidless.doubles.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.finalDeaths).toEqualTypeOf(); + expect(data.dream.voidless.doubles.beds).toBeDefined(); + expectTypeOf(data.dream.voidless.doubles.beds).toEqualTypeOf(); + expect(data.dream.voidless.doubles.beds.lost).toBeDefined(); + expect(data.dream.voidless.doubles.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.beds.lost).toEqualTypeOf(); + expect(data.dream.voidless.doubles.beds.broken).toBeDefined(); + expect(data.dream.voidless.doubles.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.beds.broken).toEqualTypeOf(); + expect(data.dream.voidless.doubles.beds.BLRatio).toBeDefined(); + expect(data.dream.voidless.doubles.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.voidless.doubles.KDR).toBeDefined(); + expect(data.dream.voidless.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.KDR).toEqualTypeOf(); + expect(data.dream.voidless.doubles.WLR).toBeDefined(); + expect(data.dream.voidless.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.WLR).toEqualTypeOf(); + expect(data.dream.voidless.doubles.FKDR).toBeDefined(); + expect(data.dream.voidless.doubles.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.doubles.FKDR).toEqualTypeOf(); + expect(data.dream.voidless.fours).toBeDefined(); + expectTypeOf(data.dream.voidless.fours).toEqualTypeOf(); + expect(data.dream.voidless.fours.winstreak).toBeDefined(); + expect(data.dream.voidless.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.winstreak).toEqualTypeOf(); + expect(data.dream.voidless.fours.playedGames).toBeDefined(); + expect(data.dream.voidless.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.playedGames).toEqualTypeOf(); + expect(data.dream.voidless.fours.kills).toBeDefined(); + expect(data.dream.voidless.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.kills).toEqualTypeOf(); + expect(data.dream.voidless.fours.deaths).toBeDefined(); + expect(data.dream.voidless.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.deaths).toEqualTypeOf(); + expect(data.dream.voidless.fours.wins).toBeDefined(); + expect(data.dream.voidless.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.wins).toEqualTypeOf(); + expect(data.dream.voidless.fours.losses).toBeDefined(); + expect(data.dream.voidless.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.losses).toEqualTypeOf(); + expect(data.dream.voidless.fours.finalKills).toBeDefined(); + expect(data.dream.voidless.fours.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.finalKills).toEqualTypeOf(); + expect(data.dream.voidless.fours.finalDeaths).toBeDefined(); + expect(data.dream.voidless.fours.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.finalDeaths).toEqualTypeOf(); + expect(data.dream.voidless.fours.beds).toBeDefined(); + expectTypeOf(data.dream.voidless.fours.beds).toEqualTypeOf(); + expect(data.dream.voidless.fours.beds.lost).toBeDefined(); + expect(data.dream.voidless.fours.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.beds.lost).toEqualTypeOf(); + expect(data.dream.voidless.fours.beds.broken).toBeDefined(); + expect(data.dream.voidless.fours.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.beds.broken).toEqualTypeOf(); + expect(data.dream.voidless.fours.beds.BLRatio).toBeDefined(); + expect(data.dream.voidless.fours.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.beds.BLRatio).toEqualTypeOf(); + expect(data.dream.voidless.fours.KDR).toBeDefined(); + expect(data.dream.voidless.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.KDR).toEqualTypeOf(); + expect(data.dream.voidless.fours.WLR).toBeDefined(); + expect(data.dream.voidless.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.WLR).toEqualTypeOf(); + expect(data.dream.voidless.fours.FKDR).toBeDefined(); + expect(data.dream.voidless.fours.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.dream.voidless.fours.FKDR).toEqualTypeOf(); + expect(data.castle).toBeDefined(); + expectTypeOf(data.castle).toEqualTypeOf(); + expect(data.castle.winstreak).toBeDefined(); + expect(data.castle.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.castle.winstreak).toEqualTypeOf(); + expect(data.castle.playedGames).toBeDefined(); + expect(data.castle.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.castle.playedGames).toEqualTypeOf(); + expect(data.castle.kills).toBeDefined(); + expect(data.castle.kills).greaterThanOrEqual(0); + expectTypeOf(data.castle.kills).toEqualTypeOf(); + expect(data.castle.deaths).toBeDefined(); + expect(data.castle.deaths).greaterThanOrEqual(0); + expectTypeOf(data.castle.deaths).toEqualTypeOf(); + expect(data.castle.wins).toBeDefined(); + expect(data.castle.wins).greaterThanOrEqual(0); + expectTypeOf(data.castle.wins).toEqualTypeOf(); + expect(data.castle.losses).toBeDefined(); + expect(data.castle.losses).greaterThanOrEqual(0); + expectTypeOf(data.castle.losses).toEqualTypeOf(); + expect(data.castle.finalKills).toBeDefined(); + expect(data.castle.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.castle.finalKills).toEqualTypeOf(); + expect(data.castle.finalDeaths).toBeDefined(); + expect(data.castle.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.castle.finalDeaths).toEqualTypeOf(); + expect(data.castle.beds).toBeDefined(); + expectTypeOf(data.castle.beds).toEqualTypeOf(); + expect(data.castle.beds.lost).toBeDefined(); + expect(data.castle.beds.lost).toBeGreaterThanOrEqual(0); + expectTypeOf(data.castle.beds.lost).toEqualTypeOf(); + expect(data.castle.beds.broken).toBeDefined(); + expect(data.castle.beds.broken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.castle.beds.broken).toEqualTypeOf(); + expect(data.castle.beds.BLRatio).toBeDefined(); + expect(data.castle.beds.BLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.castle.beds.BLRatio).toEqualTypeOf(); + expect(data.castle.KDR).toBeDefined(); + expect(data.castle.KDR).greaterThanOrEqual(0); + expectTypeOf(data.castle.KDR).toEqualTypeOf(); + expect(data.castle.WLR).toBeDefined(); + expect(data.castle.WLR).greaterThanOrEqual(0); + expectTypeOf(data.castle.WLR).toEqualTypeOf(); + expect(data.castle.FKDR).toBeDefined(); + expect(data.castle.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.castle.FKDR).toEqualTypeOf(); + expect(data.practice).toBeDefined(); + expectTypeOf(data.practice).toEqualTypeOf(); + expect(data.slumberTickets).toBeDefined(); + expect(data.slumberTickets).greaterThanOrEqual(0); + expectTypeOf(data.slumberTickets).toEqualTypeOf(); + expect(data.totalSlumberTicket).toBeDefined(); + expect(data.totalSlumberTicket).greaterThanOrEqual(0); + expectTypeOf(data.totalSlumberTicket).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/BedWars.ts b/src/structures/MiniGames/BedWars.ts index 14d1cab0..3572c482 100644 --- a/src/structures/MiniGames/BedWars.ts +++ b/src/structures/MiniGames/BedWars.ts @@ -60,19 +60,13 @@ export interface BedWarsCollectedItems { emerald: number; } -export interface BedWarsAvg { - kills: number; - finalKills: number; - bedsBroken: number; -} - export interface BedWarsBeds { lost: number; broken: number; BLRatio: number; } -export interface BedWarsModeStats { +export class BedwarsMode { winstreak: number; playedGames: number; kills: number; @@ -82,23 +76,36 @@ export interface BedWarsModeStats { finalKills: number; finalDeaths: number; beds: BedWarsBeds; - avg: BedWarsAvg; KDR: number; WLR: number; FKDR: number; + constructor(data: Record, mode: string) { + this.winstreak = data?.[`${mode}_winstreak`] || 0; + this.playedGames = data?.[`${mode}_games_played_bedwars`] || 0; + this.kills = data?.[`${mode}_kills_bedwars`] || 0; + this.deaths = data?.[`${mode}_deaths_bedwars`] || 0; + this.wins = data?.[`${mode}_wins_bedwars`] || 0; + this.losses = data?.[`${mode}_losses_bedwars`] || 0; + this.finalKills = data?.[`${mode}_final_kills_bedwars`] || 0; + this.finalDeaths = data?.[`${mode}_final_deaths_bedwars`] || 0; + this.beds = { + broken: data?.[`${mode}_beds_broken_bedwars`] || 0, + lost: data?.[`${mode}_beds_lost_bedwars`] || 0, + BLRatio: divide(data?.[`${mode}_beds_broken_bedwars`], data?.[`${mode}_beds_lost_bedwars`]) + }; + this.KDR = divide(data?.[`${mode}_kills_bedwars`], data?.[`${mode}_deaths_bedwars`]); + this.WLR = divide(data?.[`${mode}_wins_bedwars`], data?.[`${mode}_losses_bedwars`]); + this.FKDR = divide(data?.[`${mode}_final_kills_bedwars`], data?.[`${mode}_final_deaths_bedwars`]); + } } -export interface BedwarsDreamModeStats { - doubles: BedWarsModeStats; - fours: BedWarsModeStats; -} - -export interface BedwarsDreamStats { - ultimate: BedwarsDreamModeStats; - rush: BedwarsDreamModeStats; - armed: BedwarsDreamModeStats; - lucky: BedwarsDreamModeStats; - voidless: BedwarsDreamModeStats; +export class BedwarsDreamMode { + doubles: BedwarsMode; + fours: BedwarsMode; + constructor(data: Record, mode: string) { + this.doubles = new BedwarsMode(data, `eight_two_${mode}`); + this.fours = new BedwarsMode(data, `four_four_${mode}`); + } } export interface BedWarsPracticeAttempts { @@ -151,90 +158,63 @@ export interface BedWarsPracticeStats { mlg: BedWarsPracticeBase; } -function generateStatsForMode(data: Record, mode: string): BedWarsModeStats { - return { - winstreak: data[`${mode}_winstreak`] || 0, - playedGames: data[`${mode}_games_played_bedwars`] || 0, - kills: data[`${mode}_kills_bedwars`] || 0, - deaths: data[`${mode}_deaths_bedwars`] || 0, - wins: data[`${mode}_wins_bedwars`] || 0, - losses: data[`${mode}_losses_bedwars`] || 0, - finalKills: data[`${mode}_final_kills_bedwars`] || 0, - finalDeaths: data[`${mode}_final_deaths_bedwars`] || 0, - beds: { - broken: data[`${mode}_beds_broken_bedwars`] || 0, - lost: data[`${mode}_beds_lost_bedwars`] || 0, - BLRatio: divide(data[`${mode}_beds_broken_bedwars`], data[`${mode}_beds_lost_bedwars`]) - }, - avg: { - kills: divide(data[`${mode}_kills_bedwars`], data[`${mode}_games_played_bedwars`]), - finalKills: divide(data[`${mode}_final_kills_bedwars`], data[`${mode}_games_played_bedwars`]), - bedsBroken: divide(data[`${mode}_beds_broken_bedwars`], data[`${mode}_games_played_bedwars`]) - }, - KDR: divide(data[`${mode}_kills_bedwars`], data[`${mode}_deaths_bedwars`]), - WLR: divide(data[`${mode}_wins_bedwars`], data[`${mode}_losses_bedwars`]), - FKDR: divide(data[`${mode}_final_kills_bedwars`], data[`${mode}_final_deaths_bedwars`]) - }; -} - -function getBedWarsPrestige(level: number): BedWarsPrestige | string { +export function getBedWarsPrestige(level: number): BedWarsPrestige { if (5000 <= level) return 'Eternal'; - return ( - [ - 'Stone', - 'Iron', - 'Gold', - 'Diamond', - 'Emerald', - 'Sapphire', - 'Ruby', - 'Crystal', - 'Opal', - 'Amethyst', - 'Rainbow', - 'Iron Prime', - 'Gold Prime', - 'Diamond Prime', - 'Emerald Prime', - 'Sapphire Prime', - 'Ruby Prime', - 'Crystal Prime', - 'Opal Prime', - 'Amethyst Prime', - 'Mirror', - 'Light', - 'Dawn', - 'Dusk', - 'Air', - 'Wind', - 'Nebula', - 'Thunder', - 'Earth', - 'Water', - 'Fire', - 'Sunrise', - 'Eclipse', - 'Gamma', - 'Majestic', - 'Andesine', - 'Marine', - 'Element', - 'Galaxy', - 'Atomic', - 'Sunset', - 'Time', - 'Winter', - 'Obsidian', - 'Spring', - 'Ice', - 'Summer', - 'Spinel', - 'Autumn', - 'Mystic', - 'Eternal' - ][Math.floor(level / 100)] || 'Eternal' - ); + return ([ + 'Stone', + 'Iron', + 'Gold', + 'Diamond', + 'Emerald', + 'Sapphire', + 'Ruby', + 'Crystal', + 'Opal', + 'Amethyst', + 'Rainbow', + 'Iron Prime', + 'Gold Prime', + 'Diamond Prime', + 'Emerald Prime', + 'Sapphire Prime', + 'Ruby Prime', + 'Crystal Prime', + 'Opal Prime', + 'Amethyst Prime', + 'Mirror', + 'Light', + 'Dawn', + 'Dusk', + 'Air', + 'Wind', + 'Nebula', + 'Thunder', + 'Earth', + 'Water', + 'Fire', + 'Sunrise', + 'Eclipse', + 'Gamma', + 'Majestic', + 'Andesine', + 'Marine', + 'Element', + 'Galaxy', + 'Atomic', + 'Sunset', + 'Time', + 'Winter', + 'Obsidian', + 'Spring', + 'Ice', + 'Summer', + 'Spinel', + 'Autumn', + 'Mystic', + 'Eternal' + ][Math.floor(level / 100)] || 'Eternal') as BedWarsPrestige; } + const EASY_LEVELS = 4; const EASY_LEVELS_XP = 7000; const XP_PER_PRESTIGE = 96 * 5000 + EASY_LEVELS_XP; @@ -247,11 +227,9 @@ function getLevelRespectingPrestige(level: number) { return level % LEVELS_PER_PRESTIGE; } -function getExpForLevel(level: number) { +export function getExpForLevel(level: number) { if (0 === level) return 0; - const respectedLevel = getLevelRespectingPrestige(level); - if (respectedLevel > EASY_LEVELS) return 5000; - switch (respectedLevel) { + switch (getLevelRespectingPrestige(level)) { case 1: return 500; case 2: @@ -260,9 +238,8 @@ function getExpForLevel(level: number) { return 2000; case 4: return 3500; - default: { + default: return 5000; - } } } @@ -368,11 +345,19 @@ function generateStatsForPractice(data: Record): BedWarsPracticeSta }; } +export interface BedwarsDreamStats { + ultimate: BedwarsDreamMode; + rush: BedwarsDreamMode; + armed: BedwarsDreamMode; + lucky: BedwarsDreamMode; + voidless: BedwarsDreamMode; +} + class BedWars { tokens: number; level: number; experience: number; - prestige: BedWarsPrestige | string; + prestige: BedWarsPrestige; playedGames: number; wins: number; winstreak: number; @@ -383,71 +368,62 @@ class BedWars { finalDeaths: number; collectedItemsTotal: BedWarsCollectedItems; beds: BedWarsBeds; - avg: BedWarsAvg; KDR: number; FKDR: number; WLR: number; - solo: BedWarsModeStats; - doubles: BedWarsModeStats; - threes: BedWarsModeStats; - fours: BedWarsModeStats; - '4v4': BedWarsModeStats; - dream: BedwarsDreamStats | object; - castle: BedWarsModeStats; + solo: BedwarsMode; + doubles: BedwarsMode; + threes: BedwarsMode; + fours: BedwarsMode; + '4v4': BedwarsMode; + dream: BedwarsDreamStats; + castle: BedwarsMode; practice: BedWarsPracticeStats; slumberTickets: number; totalSlumberTicket: number; constructor(data: Record) { - this.tokens = data.coins || 0; - this.level = data.Experience ? getLevelForExp(data.Experience) : 0; - this.experience = data.Experience || 0; - this.prestige = getBedWarsPrestige(getLevelForExp(data.Experience)); - this.playedGames = data.games_played_bedwars || 0; - this.wins = data.wins_bedwars || 0; - this.winstreak = data.winstreak || 0; - this.kills = data.kills_bedwars || 0; - this.finalKills = data.final_kills_bedwars || 0; - this.losses = data.losses_bedwars || 0; - this.deaths = data.deaths_bedwars || 0; - this.finalDeaths = data.final_deaths_bedwars || 0; + this.tokens = data?.coins || 0; + this.level = data?.Experience ? getLevelForExp(data?.Experience) : 0; + this.experience = data?.Experience || 0; + this.prestige = getBedWarsPrestige(getLevelForExp(data?.Experience)); + this.playedGames = data?.games_played_bedwars || 0; + this.wins = data?.wins_bedwars || 0; + this.winstreak = data?.winstreak || 0; + this.kills = data?.kills_bedwars || 0; + this.finalKills = data?.final_kills_bedwars || 0; + this.losses = data?.losses_bedwars || 0; + this.deaths = data?.deaths_bedwars || 0; + this.finalDeaths = data?.final_deaths_bedwars || 0; this.collectedItemsTotal = { - iron: data.iron_resources_collected_bedwars || 0, - gold: data.gold_resources_collected_bedwars || 0, - diamond: data.diamond_resources_collected_bedwars || 0, - emerald: data.emerald_resources_collected_bedwars || 0 + iron: data?.iron_resources_collected_bedwars || 0, + gold: data?.gold_resources_collected_bedwars || 0, + diamond: data?.diamond_resources_collected_bedwars || 0, + emerald: data?.emerald_resources_collected_bedwars || 0 }; this.beds = { - lost: data.beds_lost_bedwars || 0, - broken: data.beds_broken_bedwars || 0, - BLRatio: divide(data.beds_broken_bedwars, data.beds_lost_bedwars) - }; - this.avg = { - kills: divide(this.kills, this.playedGames), - finalKills: divide(this.finalKills, this.playedGames), - bedsBroken: divide(this.beds.broken, this.playedGames) + lost: data?.beds_lost_bedwars || 0, + broken: data?.beds_broken_bedwars || 0, + BLRatio: divide(data?.beds_broken_bedwars, data?.beds_lost_bedwars) }; this.KDR = divide(this.kills, this.deaths); this.FKDR = divide(this.finalKills, this.finalDeaths); this.WLR = divide(this.wins, this.losses); - this.solo = generateStatsForMode(data, 'eight_one'); - this.doubles = generateStatsForMode(data, 'eight_two'); - this.threes = generateStatsForMode(data, 'four_three'); - this.fours = generateStatsForMode(data, 'four_four'); - this['4v4'] = generateStatsForMode(data, 'two_four'); - this.dream = ['ultimate', 'rush', 'armed', 'lucky', 'voidless'].reduce( - (ac, mode) => ({ - [mode]: { - doubles: generateStatsForMode(data, `eight_two_${mode}`), - fours: generateStatsForMode(data, `four_four_${mode}`) - }, - ...ac - }), - {} - ); - this.castle = generateStatsForMode(data, 'castle'); + this.solo = new BedwarsMode(data, 'eight_one'); + this.doubles = new BedwarsMode(data, 'eight_two'); + this.threes = new BedwarsMode(data, 'four_three'); + this.fours = new BedwarsMode(data, 'four_four'); + this['4v4'] = new BedwarsMode(data, 'two_four'); + this.dream = { + ultimate: new BedwarsDreamMode(data, 'ultimate'), + rush: new BedwarsDreamMode(data, 'rush'), + armed: new BedwarsDreamMode(data, 'armed'), + lucky: new BedwarsDreamMode(data, 'lucky'), + voidless: new BedwarsDreamMode(data, 'voidless') + }; + this.castle = new BedwarsMode(data, 'castle'); this.practice = generateStatsForPractice(data); - this.slumberTickets = data.slumber?.tickets ?? 0; - this.totalSlumberTicket = data.slumber?.total_tickets ?? 0; + this.slumberTickets = data?.slumber?.tickets || 0; + this.totalSlumberTicket = data?.slumber?.total_tickets || 0; } } diff --git a/src/structures/MiniGames/BlitzSurvivalGames.test.ts b/src/structures/MiniGames/BlitzSurvivalGames.test.ts new file mode 100644 index 00000000..fcc9b847 --- /dev/null +++ b/src/structures/MiniGames/BlitzSurvivalGames.test.ts @@ -0,0 +1,2239 @@ +import BlitzSurvivalGames, { BlitzSGKit } 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(); +}); diff --git a/src/structures/MiniGames/BlitzSurvivalGames.ts b/src/structures/MiniGames/BlitzSurvivalGames.ts index b2adb74f..57095b99 100644 --- a/src/structures/MiniGames/BlitzSurvivalGames.ts +++ b/src/structures/MiniGames/BlitzSurvivalGames.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class BlitzSGKit { +export class BlitzSGKit { level: number; exp: number; kills: number; @@ -21,25 +21,25 @@ class BlitzSGKit { mobsSpawned: number; chestsOpened: number; constructor(data: Record, kitName: string) { - this.level = data[kitName] || 0; - this.exp = data[`exp_${kitName}`] || 0; - this.kills = data[`kills_${kitName}`] || 0; - this.deaths = data[`deaths_${kitName}`] || 0; + this.level = data?.[kitName] || 0; + this.exp = data?.[`exp_${kitName}`] || 0; + this.kills = data?.[`kills_${kitName}`] || 0; + this.deaths = data?.[`deaths_${kitName}`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`wins_${kitName}`] || 0; - this.gamesPlayed = data[`games_played_${kitName}`] || 0; + this.wins = data?.[`wins_${kitName}`] || 0; + this.gamesPlayed = data?.[`games_played_${kitName}`] || 0; this.losses = this.gamesPlayed - this.wins; this.WLR = divide(this.wins, this.losses); - this.arrowsShot = data[`arrows_fired_${kitName}`] || 0; - this.arrowsHit = data[`arrows_hit_${kitName}`] || 0; + this.arrowsShot = data?.[`arrows_fired_${kitName}`] || 0; + this.arrowsHit = data?.[`arrows_hit_${kitName}`] || 0; this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot); - this.damage = data[`damage_${kitName}`] || 0; - this.damageTaken = data[`damage_taken_${kitName}`] || 0; - this.potionsDrunk = data[`potions_drunk_${kitName}`] || 0; - this.potionsThrown = data[`potions_thrown_${kitName}`] || 0; - this.playTime = data[`time_played_${kitName}`] || 0; - this.mobsSpawned = data[`mobs_spawned_${kitName}`] || 0; - this.chestsOpened = data[`chests_opened_${kitName}`] || 0; + this.damage = data?.[`damage_${kitName}`] || 0; + this.damageTaken = data?.[`damage_taken_${kitName}`] || 0; + this.potionsDrunk = data?.[`potions_drunk_${kitName}`] || 0; + this.potionsThrown = data?.[`potions_thrown_${kitName}`] || 0; + this.playTime = data?.[`time_played_${kitName}`] || 0; + this.mobsSpawned = data?.[`mobs_spawned_${kitName}`] || 0; + this.chestsOpened = data?.[`chests_opened_${kitName}`] || 0; } } @@ -106,30 +106,30 @@ class BlitzSurvivalGames { creepertamer: BlitzSGKit; snowman: BlitzSGKit; constructor(data: Record) { - this.coins = data.coins || 0; - this.kills = data.kills || 0; - this.kit = data.defaultkit || ''; - this.killsSolo = data.kills_solo_normal || 0; - this.killsTeams = data.kills_teams_normal || 0; - this.deaths = data.deaths || 0; + this.coins = data?.coins || 0; + this.kills = data?.kills || 0; + this.kit = data?.defaultkit || ''; + this.killsSolo = data?.kills_solo_normal || 0; + this.killsTeams = data?.kills_teams_normal || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.winsSolo = data.wins_solo_normal || 0; - this.winsTeam = data.wins_teams || 0; - this.gamesPlayed = data.games_played || 0; + this.wins = data?.wins || 0; + this.winsSolo = data?.wins_solo_normal || 0; + this.winsTeam = data?.wins_teams || 0; + this.gamesPlayed = data?.games_played || 0; this.losses = this.gamesPlayed - this.wins; this.WLR = divide(this.wins, this.losses); - this.arrowsShot = data.arrows_fired || 0; - this.arrowsHit = data.arrows_hit || 0; + this.arrowsShot = data?.arrows_fired || 0; + this.arrowsHit = data?.arrows_hit || 0; this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot); - this.damage = data.damage || 0; - this.damageTaken = data.damage_taken || 0; - this.potionsDrunk = data.potions_drunk || 0; - this.potionsThrown = data.potions_thrown || 0; - this.mobsSpawned = data.mobs_spawned || 0; - this.playTime = data.time_played || 0; - this.blitzUses = data.blitz_uses || 0; - this.chestsOpened = data.chests_opened || 0; + this.damage = data?.damage || 0; + this.damageTaken = data?.damage_taken || 0; + this.potionsDrunk = data?.potions_drunk || 0; + this.potionsThrown = data?.potions_thrown || 0; + this.mobsSpawned = data?.mobs_spawned || 0; + this.playTime = data?.time_played || 0; + this.blitzUses = data?.blitz_uses || 0; + this.chestsOpened = data?.chests_opened || 0; this.archer = new BlitzSGKit(data, 'archer'); this.meatmaster = new BlitzSGKit(data, 'meatmaster'); this.speleologist = new BlitzSGKit(data, 'speleologist'); diff --git a/src/structures/MiniGames/BuildBattle.test.ts b/src/structures/MiniGames/BuildBattle.test.ts new file mode 100644 index 00000000..bd8dc700 --- /dev/null +++ b/src/structures/MiniGames/BuildBattle.test.ts @@ -0,0 +1,43 @@ +import BuildBattle, { BuildBattleWins } from './BuildBattle'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('BuildBattle', () => { + const data = new BuildBattle({ stats: 'meow' }); + expect(data).toBeInstanceOf(BuildBattle); + expectTypeOf(data).toEqualTypeOf(); + expect(data.score).toBeDefined(); + expect(data.score).greaterThanOrEqual(0); + expectTypeOf(data.score).toEqualTypeOf(); + expect(data.totalWins).toBeDefined(); + expect(data.totalWins).greaterThanOrEqual(0); + expectTypeOf(data.totalWins).toEqualTypeOf(); + expect(data.games).toBeDefined(); + expect(data.games).greaterThanOrEqual(0); + expectTypeOf(data.games).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.superVotes).toBeDefined(); + expect(data.superVotes).greaterThanOrEqual(0); + expectTypeOf(data.superVotes).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.totalVotes).toBeDefined(); + expect(data.totalVotes).greaterThanOrEqual(0); + expectTypeOf(data.totalVotes).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.wins.solo).toBeDefined(); + expect(data.wins.solo).greaterThanOrEqual(0); + expectTypeOf(data.wins.solo).toEqualTypeOf(); + expect(data.wins.teams).toBeDefined(); + expect(data.wins.teams).greaterThanOrEqual(0); + expectTypeOf(data.wins.teams).toEqualTypeOf(); + expect(data.wins.pro).toBeDefined(); + expect(data.wins.pro).greaterThanOrEqual(0); + expectTypeOf(data.wins.pro).toEqualTypeOf(); + expect(data.wins.gtb).toBeDefined(); + expect(data.wins.gtb).greaterThanOrEqual(0); + expectTypeOf(data.wins.gtb).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/BuildBattle.ts b/src/structures/MiniGames/BuildBattle.ts index c5a8473f..ec951a83 100644 --- a/src/structures/MiniGames/BuildBattle.ts +++ b/src/structures/MiniGames/BuildBattle.ts @@ -17,18 +17,18 @@ class BuildBattle { totalVotes: number; wins: BuildBattleWins; constructor(data: Record) { - this.score = data.score || 0; - this.totalWins = data.wins || 0; - this.games = data.games_played || 0; + this.score = data?.score || 0; + this.totalWins = data?.wins || 0; + this.games = data?.games_played || 0; this.WLR = divide(this.totalWins, this.games); - this.superVotes = data.super_votes || 0; - this.coins = data.coins || 0; - this.totalVotes = data.total_votes || 0; + this.superVotes = data?.super_votes || 0; + this.coins = data?.coins || 0; + this.totalVotes = data?.total_votes || 0; this.wins = { - solo: data.wins_solo_normal || 0, - teams: data.wins_teams_normal || 0, - pro: data.wins_solo_pro || 0, - gtb: data.wins_guess_the_build || 0 + solo: data?.wins_solo_normal || 0, + teams: data?.wins_teams_normal || 0, + pro: data?.wins_solo_pro || 0, + gtb: data?.wins_guess_the_build || 0 }; } } diff --git a/src/structures/MiniGames/CopsAndCrims.test.ts b/src/structures/MiniGames/CopsAndCrims.test.ts new file mode 100644 index 00000000..940c87d5 --- /dev/null +++ b/src/structures/MiniGames/CopsAndCrims.test.ts @@ -0,0 +1,163 @@ +import CopsAndCrims, { CopsAndCrimsDeathmatch, CopsAndCrimsDefusal, CopsAndCrimsGunGame } from './CopsAndCrims'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('CopsAndCrims', () => { + const data = new CopsAndCrims({ stats: 'meow' }); + expect(data).toBeInstanceOf(CopsAndCrims); + expectTypeOf(data).toEqualTypeOf(); + expect(data.defusal).toBeDefined(); + expectTypeOf(data.defusal).toEqualTypeOf(); + expect(data.defusal.kills).toBeDefined(); + expect(data.defusal.kills).greaterThanOrEqual(0); + expectTypeOf(data.defusal.kills).toEqualTypeOf(); + expect(data.defusal.headshotKills).toBeDefined(); + expect(data.defusal.headshotKills).greaterThanOrEqual(0); + expectTypeOf(data.defusal.headshotKills).toEqualTypeOf(); + expect(data.defusal.assists).toBeDefined(); + expect(data.defusal.assists).greaterThanOrEqual(0); + expectTypeOf(data.defusal.assists).toEqualTypeOf(); + expect(data.defusal.deaths).toBeDefined(); + expect(data.defusal.deaths).greaterThanOrEqual(0); + expectTypeOf(data.defusal.deaths).toEqualTypeOf(); + expect(data.defusal.KDR).toBeDefined(); + expect(data.defusal.KDR).greaterThanOrEqual(0); + expectTypeOf(data.defusal.KDR).toEqualTypeOf(); + expect(data.defusal.wins).toBeDefined(); + expect(data.defusal.wins).greaterThanOrEqual(0); + expectTypeOf(data.defusal.wins).toEqualTypeOf(); + expect(data.defusal.gamesPlayed).toBeDefined(); + expect(data.defusal.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.defusal.gamesPlayed).toEqualTypeOf(); + expect(data.defusal.losses).toBeDefined(); + expect(data.defusal.losses).greaterThanOrEqual(0); + expectTypeOf(data.defusal.losses).toEqualTypeOf(); + expect(data.defusal.WLR).toBeDefined(); + expect(data.defusal.WLR).greaterThanOrEqual(0); + expectTypeOf(data.defusal.WLR).toEqualTypeOf(); + expect(data.defusal.roundWins).toBeDefined(); + expect(data.defusal.roundWins).greaterThanOrEqual(0); + expectTypeOf(data.defusal.roundWins).toEqualTypeOf(); + expect(data.defusal.shotsFired).toBeDefined(); + expect(data.defusal.shotsFired).greaterThanOrEqual(0); + expectTypeOf(data.defusal.shotsFired).toEqualTypeOf(); + expect(data.defusal.bombsDefused).toBeDefined(); + expect(data.defusal.bombsDefused).greaterThanOrEqual(0); + expectTypeOf(data.defusal.bombsDefused).toEqualTypeOf(); + expect(data.defusal.bombsPlanted).toBeDefined(); + expect(data.defusal.bombsPlanted).greaterThanOrEqual(0); + expectTypeOf(data.defusal.bombsPlanted).toEqualTypeOf(); + expect(data.defusal.killsAsCrim).toBeDefined(); + expect(data.defusal.killsAsCrim).greaterThanOrEqual(0); + expectTypeOf(data.defusal.killsAsCrim).toEqualTypeOf(); + expect(data.defusal.killsAsCop).toBeDefined(); + expect(data.defusal.killsAsCop).greaterThanOrEqual(0); + expectTypeOf(data.defusal.killsAsCop).toEqualTypeOf(); + expect(data.deathmath).toBeDefined(); + expectTypeOf(data.deathmath).toEqualTypeOf(); + expect(data.deathmath.kills).toBeDefined(); + expect(data.deathmath.kills).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.kills).toEqualTypeOf(); + expect(data.deathmath.assists).toBeDefined(); + expect(data.deathmath.assists).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.assists).toEqualTypeOf(); + expect(data.deathmath.deaths).toBeDefined(); + expect(data.deathmath.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.deaths).toEqualTypeOf(); + expect(data.deathmath.KDR).toBeDefined(); + expect(data.deathmath.KDR).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.KDR).toEqualTypeOf(); + expect(data.deathmath.wins).toBeDefined(); + expect(data.deathmath.wins).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.wins).toEqualTypeOf(); + expect(data.deathmath.gamesPlayed).toBeDefined(); + expect(data.deathmath.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.gamesPlayed).toEqualTypeOf(); + expect(data.deathmath.losses).toBeDefined(); + expect(data.deathmath.losses).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.losses).toEqualTypeOf(); + expect(data.deathmath.WLR).toBeDefined(); + expect(data.deathmath.WLR).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.WLR).toEqualTypeOf(); + expect(data.deathmath.killsAsCrim).toBeDefined(); + expect(data.deathmath.killsAsCrim).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.killsAsCrim).toEqualTypeOf(); + expect(data.deathmath.killsAsCop).toBeDefined(); + expect(data.deathmath.killsAsCop).greaterThanOrEqual(0); + expectTypeOf(data.deathmath.killsAsCop).toEqualTypeOf(); + expect(data.gunGame).toBeDefined(); + expectTypeOf(data.gunGame).toEqualTypeOf(); + expect(data.gunGame.kills).toBeDefined(); + expect(data.gunGame.kills).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.kills).toEqualTypeOf(); + expect(data.gunGame.assists).toBeDefined(); + expect(data.gunGame.assists).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.assists).toEqualTypeOf(); + expect(data.gunGame.deaths).toBeDefined(); + expect(data.gunGame.deaths).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.deaths).toEqualTypeOf(); + expect(data.gunGame.KDR).toBeDefined(); + expect(data.gunGame.KDR).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.KDR).toEqualTypeOf(); + expect(data.gunGame.wins).toBeDefined(); + expect(data.gunGame.wins).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.wins).toEqualTypeOf(); + expect(data.gunGame.gamesPlayed).toBeDefined(); + expect(data.gunGame.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.gamesPlayed).toEqualTypeOf(); + expect(data.gunGame.losses).toBeDefined(); + expect(data.gunGame.losses).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.losses).toEqualTypeOf(); + expect(data.gunGame.WLR).toBeDefined(); + expect(data.gunGame.WLR).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.WLR).toEqualTypeOf(); + expect(data.gunGame.killsAsCrim).toBeDefined(); + expect(data.gunGame.killsAsCrim).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.killsAsCrim).toEqualTypeOf(); + expect(data.gunGame.killsAsCop).toBeDefined(); + expect(data.gunGame.killsAsCop).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.killsAsCop).toEqualTypeOf(); + expect(data.gunGame.fastestWin).toBeDefined(); + expect(data.gunGame.fastestWin).greaterThanOrEqual(0); + expectTypeOf(data.gunGame.fastestWin).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.assists).toBeDefined(); + expect(data.assists).greaterThanOrEqual(0); + expectTypeOf(data.assists).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.gamesPlayed).toBeDefined(); + expect(data.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.gamesPlayed).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.killsAsCrim).toBeDefined(); + expect(data.killsAsCrim).greaterThanOrEqual(0); + expectTypeOf(data.killsAsCrim).toEqualTypeOf(); + expect(data.killsAsCop).toBeDefined(); + expect(data.killsAsCop).greaterThanOrEqual(0); + expectTypeOf(data.killsAsCop).toEqualTypeOf(); + expect(data.prefixColor).toBeDefined(); + expectTypeOf(data.prefixColor).toEqualTypeOf(); + expect(data.showPrefix).toBeDefined(); + expectTypeOf(data.showPrefix).toEqualTypeOf(); + expect(data.selectedPrefix).toBeDefined(); + expectTypeOf(data.selectedPrefix).toEqualTypeOf(); + expect(data.killsInPrefix).toBeDefined(); + expectTypeOf(data.killsInPrefix).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/CopsAndCrims.ts b/src/structures/MiniGames/CopsAndCrims.ts index 2c0ffa6f..c61c5b03 100644 --- a/src/structures/MiniGames/CopsAndCrims.ts +++ b/src/structures/MiniGames/CopsAndCrims.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class CopsAndCrimsDefusal { +export class CopsAndCrimsDefusal { kills: number; headshotKills: number; assists: number; @@ -17,25 +17,25 @@ class CopsAndCrimsDefusal { killsAsCrim: number; killsAsCop: number; constructor(data: Record) { - this.kills = data.kills || 0; - this.headshotKills = data.headshot_kills || 0; - this.assists = data.assists || 0; - this.deaths = data.deaths || 0; + this.kills = data?.kills || 0; + this.headshotKills = data?.headshot_kills || 0; + this.assists = data?.assists || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.game_wins || 0; - this.gamesPlayed = data.game_plays || 0; + this.wins = data?.game_wins || 0; + this.gamesPlayed = data?.game_plays || 0; this.losses = this.gamesPlayed - this.wins; this.WLR = divide(this.wins, this.losses); - this.roundWins = data.round_wins || 0; - this.shotsFired = data.shots_fired || 0; - this.bombsDefused = data.bombs_defused || 0; - this.bombsPlanted = data.bombs_planted || 0; - this.killsAsCrim = data.criminal_kills || 0; - this.killsAsCop = data.cop_kills || 0; + this.roundWins = data?.round_wins || 0; + this.shotsFired = data?.shots_fired || 0; + this.bombsDefused = data?.bombs_defused || 0; + this.bombsPlanted = data?.bombs_planted || 0; + this.killsAsCrim = data?.criminal_kills || 0; + this.killsAsCop = data?.cop_kills || 0; } } -class CopsAndCrimsDeathmatch { +export class CopsAndCrimsDeathmatch { kills: number; assists: number; deaths: number; @@ -47,20 +47,20 @@ class CopsAndCrimsDeathmatch { killsAsCrim: number; killsAsCop: number; constructor(data: Record) { - this.kills = data.kills_deathmatch || 0; - this.assists = data.assists_deathmatch || 0; - this.deaths = data.deaths_deathmatch || 0; + this.kills = data?.kills_deathmatch || 0; + this.assists = data?.assists_deathmatch || 0; + this.deaths = data?.deaths_deathmatch || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.game_wins_deathmatch || 0; - this.gamesPlayed = data.game_plays_deathmatch || 0; + this.wins = data?.game_wins_deathmatch || 0; + this.gamesPlayed = data?.game_plays_deathmatch || 0; this.losses = this.gamesPlayed - this.wins; this.WLR = divide(this.wins, this.losses); - this.killsAsCrim = data.criminal_kills_deathmatch || 0; - this.killsAsCop = data.cop_kills_deathmatch || 0; + this.killsAsCrim = data?.criminal_kills_deathmatch || 0; + this.killsAsCop = data?.cop_kills_deathmatch || 0; } } -class CopsAndCrimsGunGame { +export class CopsAndCrimsGunGame { kills: number; assists: number; deaths: number; @@ -73,17 +73,17 @@ class CopsAndCrimsGunGame { killsAsCop: number; fastestWin: number; constructor(data: Record) { - this.kills = data.kills_gungame || 0; - this.assists = data.assists_gungame || 0; - this.deaths = data.deaths_gungame || 0; + this.kills = data?.kills_gungame || 0; + this.assists = data?.assists_gungame || 0; + this.deaths = data?.deaths_gungame || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.game_wins_gungame || 0; - this.gamesPlayed = data.game_plays_gungame || 0; + this.wins = data?.game_wins_gungame || 0; + this.gamesPlayed = data?.game_plays_gungame || 0; this.losses = this.gamesPlayed - this.wins; this.WLR = divide(this.wins, this.losses); - this.killsAsCrim = data.criminal_kills_gungame || 0; - this.killsAsCop = data.cop_kills_gungame || 0; - this.fastestWin = data.fastest_win_gungame || 0; + this.killsAsCrim = data?.criminal_kills_gungame || 0; + this.killsAsCop = data?.cop_kills_gungame || 0; + this.fastestWin = data?.fastest_win_gungame || 0; } } @@ -110,7 +110,7 @@ class CopsAndCrims { this.defusal = new CopsAndCrimsDefusal(data); this.deathmath = new CopsAndCrimsDeathmatch(data); this.gunGame = new CopsAndCrimsGunGame(data); - this.coins = data.coins || 0; + this.coins = data?.coins || 0; this.kills = this.defusal.kills + this.deathmath.kills + this.gunGame.kills; this.assists = this.defusal.assists + this.deathmath.assists + this.gunGame.assists; this.deaths = this.defusal.deaths + this.deathmath.deaths + this.gunGame.deaths; @@ -121,10 +121,10 @@ class CopsAndCrims { this.WLR = divide(this.wins, this.losses); this.killsAsCrim = this.defusal.killsAsCrim + this.deathmath.killsAsCrim + this.gunGame.killsAsCrim; this.killsAsCop = this.defusal.killsAsCop + this.deathmath.killsAsCop + this.gunGame.killsAsCop; - this.prefixColor = data.lobbyPrefixColor || ''; - this.showPrefix = data.show_lobby_prefix || false; - this.selectedPrefix = data.selected_lobby_prefix || ''; - this.killsInPrefix = data.show_kills_in_prefix || false; + this.prefixColor = data?.lobbyPrefixColor || ''; + this.showPrefix = data?.show_lobby_prefix || false; + this.selectedPrefix = data?.selected_lobby_prefix || ''; + this.killsInPrefix = data?.show_kills_in_prefix || false; } } diff --git a/src/structures/MiniGames/Duels.test.ts b/src/structures/MiniGames/Duels.test.ts new file mode 100644 index 00000000..2e72e032 --- /dev/null +++ b/src/structures/MiniGames/Duels.test.ts @@ -0,0 +1,1854 @@ +import Duels, { DuelsBridge, DuelsGamemode, DuelsMegaWalls, DuelsOP, DuelsSkyWars, DuelsUHC } from './Duels'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Duels', () => { + const data = new Duels({ stats: 'meow' }); + expect(data).toBeInstanceOf(Duels); + expectTypeOf(data).toEqualTypeOf(); + expect(data.tokens).toBeDefined(); + expect(data.tokens).greaterThanOrEqual(0); + expectTypeOf(data.tokens).toEqualTypeOf(); + expect(data.title).toBeDefined(); + expectTypeOf(data.title).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.playedGames).toBeDefined(); + expect(data.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.playedGames).toEqualTypeOf(); + expect(data.winstreak).toBeDefined(); + expect(data.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.winstreak).toEqualTypeOf(); + expect(data.bestWinstreak).toBeDefined(); + expect(data.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bestWinstreak).toEqualTypeOf(); + expect(data.ping).toBeDefined(); + expect(data.ping).greaterThanOrEqual(0); + expectTypeOf(data.ping).toEqualTypeOf(); + expect(data.blocksPlaced).toBeDefined(); + expect(data.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blocksPlaced).toEqualTypeOf(); + expect(data.swings).toBeDefined(); + expect(data.swings).greaterThanOrEqual(0); + expectTypeOf(data.swings).toEqualTypeOf(); + expect(data.hits).toBeDefined(); + expect(data.hits).greaterThanOrEqual(0); + expectTypeOf(data.hits).toEqualTypeOf(); + expect(data.meleeAccuracy).toBeDefined(); + expect(data.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.meleeAccuracy).toEqualTypeOf(); + expect(data.bowShots).toBeDefined(); + expect(data.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bowShots).toEqualTypeOf(); + expect(data.bowHits).toBeDefined(); + expect(data.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bowHits).toEqualTypeOf(); + expect(data.bowAccuracy).toBeDefined(); + expect(data.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bowAccuracy).toEqualTypeOf(); + expect(data.healthRegenerated).toBeDefined(); + expect(data.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.healthRegenerated).toEqualTypeOf(); + expect(data.goldenApplesEatan).toBeDefined(); + expect(data.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.goldenApplesEatan).toEqualTypeOf(); + expect(data.uhc).toBeDefined(); + expectTypeOf(data.uhc).toEqualTypeOf(); + expectTypeOf(data.uhc.title).toEqualTypeOf(); + expect(data.uhc.winstreak).toBeDefined(); + expect(data.uhc.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.winstreak).toEqualTypeOf(); + expect(data.uhc.bestWinstreak).toBeDefined(); + expect(data.uhc.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.bestWinstreak).toEqualTypeOf(); + expect(data.uhc.solo).toBeDefined(); + expectTypeOf(data.uhc.solo).toEqualTypeOf(); + expectTypeOf(data.uhc.solo.title).toEqualTypeOf(); + expect(data.uhc.solo.winstreak).toBeDefined(); + expect(data.uhc.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.winstreak).toEqualTypeOf(); + expect(data.uhc.solo.bestWinstreak).toBeDefined(); + expect(data.uhc.solo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.bestWinstreak).toEqualTypeOf(); + expect(data.uhc.solo.kills).toBeDefined(); + expect(data.uhc.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.kills).toEqualTypeOf(); + expect(data.uhc.solo.deaths).toBeDefined(); + expect(data.uhc.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.deaths).toEqualTypeOf(); + expect(data.uhc.solo.KDR).toBeDefined(); + expect(data.uhc.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.KDR).toEqualTypeOf(); + expect(data.uhc.solo.wins).toBeDefined(); + expect(data.uhc.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.wins).toEqualTypeOf(); + expect(data.uhc.solo.losses).toBeDefined(); + expect(data.uhc.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.losses).toEqualTypeOf(); + expect(data.uhc.solo.WLR).toBeDefined(); + expect(data.uhc.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.WLR).toEqualTypeOf(); + expect(data.uhc.solo.playedGames).toBeDefined(); + expect(data.uhc.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.playedGames).toEqualTypeOf(); + expect(data.uhc.solo.swings).toBeDefined(); + expect(data.uhc.solo.swings).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.swings).toEqualTypeOf(); + expect(data.uhc.solo.hits).toBeDefined(); + expect(data.uhc.solo.hits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.hits).toEqualTypeOf(); + expect(data.uhc.solo.meleeAccuracy).toBeDefined(); + expect(data.uhc.solo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.meleeAccuracy).toEqualTypeOf(); + expect(data.uhc.solo.bowShots).toBeDefined(); + expect(data.uhc.solo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.bowShots).toEqualTypeOf(); + expect(data.uhc.solo.bowHits).toBeDefined(); + expect(data.uhc.solo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.bowHits).toEqualTypeOf(); + expect(data.uhc.solo.bowAccuracy).toBeDefined(); + expect(data.uhc.solo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.bowAccuracy).toEqualTypeOf(); + expect(data.uhc.solo.blocksPlaced).toBeDefined(); + expect(data.uhc.solo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.blocksPlaced).toEqualTypeOf(); + expect(data.uhc.solo.healthRegenerated).toBeDefined(); + expect(data.uhc.solo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.healthRegenerated).toEqualTypeOf(); + expect(data.uhc.solo.goldenApplesEatan).toBeDefined(); + expect(data.uhc.solo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.uhc.solo.goldenApplesEatan).toEqualTypeOf(); + expect(data.uhc.doubles).toBeDefined(); + expectTypeOf(data.uhc.doubles).toEqualTypeOf(); + expectTypeOf(data.uhc.doubles.title).toEqualTypeOf(); + expect(data.uhc.doubles.winstreak).toBeDefined(); + expect(data.uhc.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.winstreak).toEqualTypeOf(); + expect(data.uhc.doubles.bestWinstreak).toBeDefined(); + expect(data.uhc.doubles.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.bestWinstreak).toEqualTypeOf(); + expect(data.uhc.doubles.kills).toBeDefined(); + expect(data.uhc.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.kills).toEqualTypeOf(); + expect(data.uhc.doubles.deaths).toBeDefined(); + expect(data.uhc.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.deaths).toEqualTypeOf(); + expect(data.uhc.doubles.KDR).toBeDefined(); + expect(data.uhc.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.KDR).toEqualTypeOf(); + expect(data.uhc.doubles.wins).toBeDefined(); + expect(data.uhc.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.wins).toEqualTypeOf(); + expect(data.uhc.doubles.losses).toBeDefined(); + expect(data.uhc.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.losses).toEqualTypeOf(); + expect(data.uhc.doubles.WLR).toBeDefined(); + expect(data.uhc.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.WLR).toEqualTypeOf(); + expect(data.uhc.doubles.playedGames).toBeDefined(); + expect(data.uhc.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.playedGames).toEqualTypeOf(); + expect(data.uhc.doubles.swings).toBeDefined(); + expect(data.uhc.doubles.swings).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.swings).toEqualTypeOf(); + expect(data.uhc.doubles.hits).toBeDefined(); + expect(data.uhc.doubles.hits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.hits).toEqualTypeOf(); + expect(data.uhc.doubles.meleeAccuracy).toBeDefined(); + expect(data.uhc.doubles.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.meleeAccuracy).toEqualTypeOf(); + expect(data.uhc.doubles.bowShots).toBeDefined(); + expect(data.uhc.doubles.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.bowShots).toEqualTypeOf(); + expect(data.uhc.doubles.bowHits).toBeDefined(); + expect(data.uhc.doubles.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.bowHits).toEqualTypeOf(); + expect(data.uhc.doubles.bowAccuracy).toBeDefined(); + expect(data.uhc.doubles.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.bowAccuracy).toEqualTypeOf(); + expect(data.uhc.doubles.blocksPlaced).toBeDefined(); + expect(data.uhc.doubles.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.blocksPlaced).toEqualTypeOf(); + expect(data.uhc.doubles.healthRegenerated).toBeDefined(); + expect(data.uhc.doubles.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.healthRegenerated).toEqualTypeOf(); + expect(data.uhc.doubles.goldenApplesEatan).toBeDefined(); + expect(data.uhc.doubles.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.uhc.doubles.goldenApplesEatan).toEqualTypeOf(); + expect(data.uhc.fours).toBeDefined(); + expectTypeOf(data.uhc.fours).toEqualTypeOf(); + expectTypeOf(data.uhc.fours.title).toEqualTypeOf(); + expect(data.uhc.fours.winstreak).toBeDefined(); + expect(data.uhc.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.winstreak).toEqualTypeOf(); + expect(data.uhc.fours.bestWinstreak).toBeDefined(); + expect(data.uhc.fours.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.bestWinstreak).toEqualTypeOf(); + expect(data.uhc.fours.kills).toBeDefined(); + expect(data.uhc.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.kills).toEqualTypeOf(); + expect(data.uhc.fours.deaths).toBeDefined(); + expect(data.uhc.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.deaths).toEqualTypeOf(); + expect(data.uhc.fours.KDR).toBeDefined(); + expect(data.uhc.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.KDR).toEqualTypeOf(); + expect(data.uhc.fours.wins).toBeDefined(); + expect(data.uhc.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.wins).toEqualTypeOf(); + expect(data.uhc.fours.losses).toBeDefined(); + expect(data.uhc.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.losses).toEqualTypeOf(); + expect(data.uhc.fours.WLR).toBeDefined(); + expect(data.uhc.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.WLR).toEqualTypeOf(); + expect(data.uhc.fours.playedGames).toBeDefined(); + expect(data.uhc.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.playedGames).toEqualTypeOf(); + expect(data.uhc.fours.swings).toBeDefined(); + expect(data.uhc.fours.swings).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.swings).toEqualTypeOf(); + expect(data.uhc.fours.hits).toBeDefined(); + expect(data.uhc.fours.hits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.hits).toEqualTypeOf(); + expect(data.uhc.fours.meleeAccuracy).toBeDefined(); + expect(data.uhc.fours.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.meleeAccuracy).toEqualTypeOf(); + expect(data.uhc.fours.bowShots).toBeDefined(); + expect(data.uhc.fours.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.bowShots).toEqualTypeOf(); + expect(data.uhc.fours.bowHits).toBeDefined(); + expect(data.uhc.fours.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.bowHits).toEqualTypeOf(); + expect(data.uhc.fours.bowAccuracy).toBeDefined(); + expect(data.uhc.fours.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.bowAccuracy).toEqualTypeOf(); + expect(data.uhc.fours.blocksPlaced).toBeDefined(); + expect(data.uhc.fours.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.blocksPlaced).toEqualTypeOf(); + expect(data.uhc.fours.healthRegenerated).toBeDefined(); + expect(data.uhc.fours.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.healthRegenerated).toEqualTypeOf(); + expect(data.uhc.fours.goldenApplesEatan).toBeDefined(); + expect(data.uhc.fours.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.uhc.fours.goldenApplesEatan).toEqualTypeOf(); + expect(data.uhc.deathmatch).toBeDefined(); + expectTypeOf(data.uhc.deathmatch).toEqualTypeOf(); + expectTypeOf(data.uhc.deathmatch.title).toEqualTypeOf(); + expect(data.uhc.deathmatch.winstreak).toBeDefined(); + expect(data.uhc.deathmatch.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.winstreak).toEqualTypeOf(); + expect(data.uhc.deathmatch.bestWinstreak).toBeDefined(); + expect(data.uhc.deathmatch.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.bestWinstreak).toEqualTypeOf(); + expect(data.uhc.deathmatch.kills).toBeDefined(); + expect(data.uhc.deathmatch.kills).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.kills).toEqualTypeOf(); + expect(data.uhc.deathmatch.deaths).toBeDefined(); + expect(data.uhc.deathmatch.deaths).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.deaths).toEqualTypeOf(); + expect(data.uhc.deathmatch.KDR).toBeDefined(); + expect(data.uhc.deathmatch.KDR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.KDR).toEqualTypeOf(); + expect(data.uhc.deathmatch.wins).toBeDefined(); + expect(data.uhc.deathmatch.wins).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.wins).toEqualTypeOf(); + expect(data.uhc.deathmatch.losses).toBeDefined(); + expect(data.uhc.deathmatch.losses).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.losses).toEqualTypeOf(); + expect(data.uhc.deathmatch.WLR).toBeDefined(); + expect(data.uhc.deathmatch.WLR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.WLR).toEqualTypeOf(); + expect(data.uhc.deathmatch.playedGames).toBeDefined(); + expect(data.uhc.deathmatch.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.playedGames).toEqualTypeOf(); + expect(data.uhc.deathmatch.swings).toBeDefined(); + expect(data.uhc.deathmatch.swings).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.swings).toEqualTypeOf(); + expect(data.uhc.deathmatch.hits).toBeDefined(); + expect(data.uhc.deathmatch.hits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.hits).toEqualTypeOf(); + expect(data.uhc.deathmatch.meleeAccuracy).toBeDefined(); + expect(data.uhc.deathmatch.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.meleeAccuracy).toEqualTypeOf(); + expect(data.uhc.deathmatch.bowShots).toBeDefined(); + expect(data.uhc.deathmatch.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.bowShots).toEqualTypeOf(); + expect(data.uhc.deathmatch.bowHits).toBeDefined(); + expect(data.uhc.deathmatch.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.bowHits).toEqualTypeOf(); + expect(data.uhc.deathmatch.bowAccuracy).toBeDefined(); + expect(data.uhc.deathmatch.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.bowAccuracy).toEqualTypeOf(); + expect(data.uhc.deathmatch.blocksPlaced).toBeDefined(); + expect(data.uhc.deathmatch.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.blocksPlaced).toEqualTypeOf(); + expect(data.uhc.deathmatch.healthRegenerated).toBeDefined(); + expect(data.uhc.deathmatch.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.healthRegenerated).toEqualTypeOf(); + expect(data.uhc.deathmatch.goldenApplesEatan).toBeDefined(); + expect(data.uhc.deathmatch.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deathmatch.goldenApplesEatan).toEqualTypeOf(); + expect(data.uhc.kills).toBeDefined(); + expect(data.uhc.kills).greaterThanOrEqual(0); + expectTypeOf(data.uhc.kills).toEqualTypeOf(); + expect(data.uhc.deaths).toBeDefined(); + expect(data.uhc.deaths).greaterThanOrEqual(0); + expectTypeOf(data.uhc.deaths).toEqualTypeOf(); + expect(data.uhc.KDR).toBeDefined(); + expect(data.uhc.KDR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.KDR).toEqualTypeOf(); + expect(data.uhc.wins).toBeDefined(); + expect(data.uhc.wins).greaterThanOrEqual(0); + expectTypeOf(data.uhc.wins).toEqualTypeOf(); + expect(data.uhc.losses).toBeDefined(); + expect(data.uhc.losses).greaterThanOrEqual(0); + expectTypeOf(data.uhc.losses).toEqualTypeOf(); + expect(data.uhc.WLR).toBeDefined(); + expect(data.uhc.WLR).greaterThanOrEqual(0); + expectTypeOf(data.uhc.WLR).toEqualTypeOf(); + expect(data.uhc.playedGames).toBeDefined(); + expect(data.uhc.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.uhc.playedGames).toEqualTypeOf(); + expect(data.uhc.swings).toBeDefined(); + expect(data.uhc.swings).greaterThanOrEqual(0); + expectTypeOf(data.uhc.swings).toEqualTypeOf(); + expect(data.uhc.hits).toBeDefined(); + expect(data.uhc.hits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.hits).toEqualTypeOf(); + expect(data.uhc.meleeAccuracy).toBeDefined(); + expect(data.uhc.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.meleeAccuracy).toEqualTypeOf(); + expect(data.uhc.bowShots).toBeDefined(); + expect(data.uhc.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.uhc.bowShots).toEqualTypeOf(); + expect(data.uhc.bowHits).toBeDefined(); + expect(data.uhc.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.uhc.bowHits).toEqualTypeOf(); + expect(data.uhc.bowAccuracy).toBeDefined(); + expect(data.uhc.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.uhc.bowAccuracy).toEqualTypeOf(); + expect(data.uhc.blocksPlaced).toBeDefined(); + expect(data.uhc.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.uhc.blocksPlaced).toEqualTypeOf(); + expect(data.uhc.healthRegenerated).toBeDefined(); + expect(data.uhc.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.uhc.healthRegenerated).toEqualTypeOf(); + expect(data.uhc.goldenApplesEatan).toBeDefined(); + expect(data.uhc.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.uhc.goldenApplesEatan).toEqualTypeOf(); + expect(data.skywars).toBeDefined(); + expectTypeOf(data.skywars).toEqualTypeOf(); + expect(data.skywars.title).toBeDefined(); + expectTypeOf(data.skywars.title).toEqualTypeOf(); + expect(data.skywars.winstreak).toBeDefined(); + expect(data.skywars.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.skywars.winstreak).toEqualTypeOf(); + expect(data.skywars.bestWinstreak).toBeDefined(); + expect(data.skywars.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.skywars.bestWinstreak).toEqualTypeOf(); + expect(data.skywars.solo).toBeDefined(); + expectTypeOf(data.skywars.solo).toEqualTypeOf(); + expect(data.skywars.solo.title).toBeDefined(); + expectTypeOf(data.skywars.solo.title).toEqualTypeOf(); + expect(data.skywars.solo.winstreak).toBeDefined(); + expect(data.skywars.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.winstreak).toEqualTypeOf(); + expect(data.skywars.solo.bestWinstreak).toBeDefined(); + expect(data.skywars.solo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.bestWinstreak).toEqualTypeOf(); + expect(data.skywars.solo.kills).toBeDefined(); + expect(data.skywars.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.kills).toEqualTypeOf(); + expect(data.skywars.solo.deaths).toBeDefined(); + expect(data.skywars.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.deaths).toEqualTypeOf(); + expect(data.skywars.solo.KDR).toBeDefined(); + expect(data.skywars.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.KDR).toEqualTypeOf(); + expect(data.skywars.solo.wins).toBeDefined(); + expect(data.skywars.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.wins).toEqualTypeOf(); + expect(data.skywars.solo.losses).toBeDefined(); + expect(data.skywars.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.losses).toEqualTypeOf(); + expect(data.skywars.solo.WLR).toBeDefined(); + expect(data.skywars.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.WLR).toEqualTypeOf(); + expect(data.skywars.solo.playedGames).toBeDefined(); + expect(data.skywars.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.playedGames).toEqualTypeOf(); + expect(data.skywars.solo.swings).toBeDefined(); + expect(data.skywars.solo.swings).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.swings).toEqualTypeOf(); + expect(data.skywars.solo.hits).toBeDefined(); + expect(data.skywars.solo.hits).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.hits).toEqualTypeOf(); + expect(data.skywars.solo.meleeAccuracy).toBeDefined(); + expect(data.skywars.solo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.meleeAccuracy).toEqualTypeOf(); + expect(data.skywars.solo.bowShots).toBeDefined(); + expect(data.skywars.solo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.bowShots).toEqualTypeOf(); + expect(data.skywars.solo.bowHits).toBeDefined(); + expect(data.skywars.solo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.bowHits).toEqualTypeOf(); + expect(data.skywars.solo.bowAccuracy).toBeDefined(); + expect(data.skywars.solo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.bowAccuracy).toEqualTypeOf(); + expect(data.skywars.solo.blocksPlaced).toBeDefined(); + expect(data.skywars.solo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.blocksPlaced).toEqualTypeOf(); + expect(data.skywars.solo.healthRegenerated).toBeDefined(); + expect(data.skywars.solo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.healthRegenerated).toEqualTypeOf(); + expect(data.skywars.solo.goldenApplesEatan).toBeDefined(); + expect(data.skywars.solo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.skywars.solo.goldenApplesEatan).toEqualTypeOf(); + expect(data.skywars.doubles).toBeDefined(); + expectTypeOf(data.skywars.doubles).toEqualTypeOf(); + expect(data.skywars.doubles.title).toBeDefined(); + expectTypeOf(data.skywars.doubles.title).toEqualTypeOf(); + expect(data.skywars.doubles.winstreak).toBeDefined(); + expect(data.skywars.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.winstreak).toEqualTypeOf(); + expect(data.skywars.doubles.bestWinstreak).toBeDefined(); + expect(data.skywars.doubles.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.bestWinstreak).toEqualTypeOf(); + expect(data.skywars.doubles.kills).toBeDefined(); + expect(data.skywars.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.kills).toEqualTypeOf(); + expect(data.skywars.doubles.deaths).toBeDefined(); + expect(data.skywars.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.deaths).toEqualTypeOf(); + expect(data.skywars.doubles.KDR).toBeDefined(); + expect(data.skywars.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.KDR).toEqualTypeOf(); + expect(data.skywars.doubles.wins).toBeDefined(); + expect(data.skywars.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.wins).toEqualTypeOf(); + expect(data.skywars.doubles.losses).toBeDefined(); + expect(data.skywars.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.losses).toEqualTypeOf(); + expect(data.skywars.doubles.WLR).toBeDefined(); + expect(data.skywars.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.WLR).toEqualTypeOf(); + expect(data.skywars.doubles.playedGames).toBeDefined(); + expect(data.skywars.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.playedGames).toEqualTypeOf(); + expect(data.skywars.doubles.swings).toBeDefined(); + expect(data.skywars.doubles.swings).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.swings).toEqualTypeOf(); + expect(data.skywars.doubles.hits).toBeDefined(); + expect(data.skywars.doubles.hits).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.hits).toEqualTypeOf(); + expect(data.skywars.doubles.meleeAccuracy).toBeDefined(); + expect(data.skywars.doubles.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.meleeAccuracy).toEqualTypeOf(); + expect(data.skywars.doubles.bowShots).toBeDefined(); + expect(data.skywars.doubles.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.bowShots).toEqualTypeOf(); + expect(data.skywars.doubles.bowHits).toBeDefined(); + expect(data.skywars.doubles.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.bowHits).toEqualTypeOf(); + expect(data.skywars.doubles.bowAccuracy).toBeDefined(); + expect(data.skywars.doubles.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.bowAccuracy).toEqualTypeOf(); + expect(data.skywars.doubles.blocksPlaced).toBeDefined(); + expect(data.skywars.doubles.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.blocksPlaced).toEqualTypeOf(); + expect(data.skywars.doubles.healthRegenerated).toBeDefined(); + expect(data.skywars.doubles.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.healthRegenerated).toEqualTypeOf(); + expect(data.skywars.doubles.goldenApplesEatan).toBeDefined(); + expect(data.skywars.doubles.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.skywars.doubles.goldenApplesEatan).toEqualTypeOf(); + expect(data.skywars.kills).toBeDefined(); + expect(data.skywars.kills).greaterThanOrEqual(0); + expectTypeOf(data.skywars.kills).toEqualTypeOf(); + expect(data.skywars.deaths).toBeDefined(); + expect(data.skywars.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skywars.deaths).toEqualTypeOf(); + expect(data.skywars.KDR).toBeDefined(); + expect(data.skywars.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skywars.KDR).toEqualTypeOf(); + expect(data.skywars.wins).toBeDefined(); + expect(data.skywars.wins).greaterThanOrEqual(0); + expectTypeOf(data.skywars.wins).toEqualTypeOf(); + expect(data.skywars.losses).toBeDefined(); + expect(data.skywars.losses).greaterThanOrEqual(0); + expectTypeOf(data.skywars.losses).toEqualTypeOf(); + expect(data.skywars.WLR).toBeDefined(); + expect(data.skywars.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skywars.WLR).toEqualTypeOf(); + expect(data.skywars.playedGames).toBeDefined(); + expect(data.skywars.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skywars.playedGames).toEqualTypeOf(); + expect(data.skywars.swings).toBeDefined(); + expect(data.skywars.swings).greaterThanOrEqual(0); + expectTypeOf(data.skywars.swings).toEqualTypeOf(); + expect(data.skywars.hits).toBeDefined(); + expect(data.skywars.hits).greaterThanOrEqual(0); + expectTypeOf(data.skywars.hits).toEqualTypeOf(); + expect(data.skywars.meleeAccuracy).toBeDefined(); + expect(data.skywars.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.skywars.meleeAccuracy).toEqualTypeOf(); + expect(data.skywars.bowShots).toBeDefined(); + expect(data.skywars.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.skywars.bowShots).toEqualTypeOf(); + expect(data.skywars.bowHits).toBeDefined(); + expect(data.skywars.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.skywars.bowHits).toEqualTypeOf(); + expect(data.skywars.bowAccuracy).toBeDefined(); + expect(data.skywars.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.skywars.bowAccuracy).toEqualTypeOf(); + expect(data.skywars.blocksPlaced).toBeDefined(); + expect(data.skywars.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.skywars.blocksPlaced).toEqualTypeOf(); + expect(data.skywars.healthRegenerated).toBeDefined(); + expect(data.skywars.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.skywars.healthRegenerated).toEqualTypeOf(); + expect(data.skywars.goldenApplesEatan).toBeDefined(); + expect(data.skywars.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.skywars.goldenApplesEatan).toEqualTypeOf(); + expect(data.megawalls).toBeDefined(); + expectTypeOf(data.megawalls).toEqualTypeOf(); + expect(data.megawalls.title).toBeDefined(); + expectTypeOf(data.megawalls.title).toEqualTypeOf(); + expect(data.megawalls.winstreak).toBeDefined(); + expect(data.megawalls.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.winstreak).toEqualTypeOf(); + expect(data.megawalls.bestWinstreak).toBeDefined(); + expect(data.megawalls.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.bestWinstreak).toEqualTypeOf(); + expect(data.megawalls.solo).toBeDefined(); + expectTypeOf(data.megawalls.solo).toEqualTypeOf(); + expect(data.megawalls.solo.title).toBeDefined(); + expectTypeOf(data.megawalls.solo.title).toEqualTypeOf(); + expect(data.megawalls.solo.winstreak).toBeDefined(); + expect(data.megawalls.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.winstreak).toEqualTypeOf(); + expect(data.megawalls.solo.bestWinstreak).toBeDefined(); + expect(data.megawalls.solo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.bestWinstreak).toEqualTypeOf(); + expect(data.megawalls.solo.kills).toBeDefined(); + expect(data.megawalls.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.kills).toEqualTypeOf(); + expect(data.megawalls.solo.deaths).toBeDefined(); + expect(data.megawalls.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.deaths).toEqualTypeOf(); + expect(data.megawalls.solo.KDR).toBeDefined(); + expect(data.megawalls.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.KDR).toEqualTypeOf(); + expect(data.megawalls.solo.wins).toBeDefined(); + expect(data.megawalls.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.wins).toEqualTypeOf(); + expect(data.megawalls.solo.losses).toBeDefined(); + expect(data.megawalls.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.losses).toEqualTypeOf(); + expect(data.megawalls.solo.WLR).toBeDefined(); + expect(data.megawalls.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.WLR).toEqualTypeOf(); + expect(data.megawalls.solo.playedGames).toBeDefined(); + expect(data.megawalls.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.playedGames).toEqualTypeOf(); + expect(data.megawalls.solo.swings).toBeDefined(); + expect(data.megawalls.solo.swings).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.swings).toEqualTypeOf(); + expect(data.megawalls.solo.hits).toBeDefined(); + expect(data.megawalls.solo.hits).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.hits).toEqualTypeOf(); + expect(data.megawalls.solo.meleeAccuracy).toBeDefined(); + expect(data.megawalls.solo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.meleeAccuracy).toEqualTypeOf(); + expect(data.megawalls.solo.bowShots).toBeDefined(); + expect(data.megawalls.solo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.bowShots).toEqualTypeOf(); + expect(data.megawalls.solo.bowHits).toBeDefined(); + expect(data.megawalls.solo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.bowHits).toEqualTypeOf(); + expect(data.megawalls.solo.bowAccuracy).toBeDefined(); + expect(data.megawalls.solo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.bowAccuracy).toEqualTypeOf(); + expect(data.megawalls.solo.blocksPlaced).toBeDefined(); + expect(data.megawalls.solo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.blocksPlaced).toEqualTypeOf(); + expect(data.megawalls.solo.healthRegenerated).toBeDefined(); + expect(data.megawalls.solo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.healthRegenerated).toEqualTypeOf(); + expect(data.megawalls.solo.goldenApplesEatan).toBeDefined(); + expect(data.megawalls.solo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.solo.goldenApplesEatan).toEqualTypeOf(); + expect(data.megawalls.doubles).toBeDefined(); + expectTypeOf(data.megawalls.doubles).toEqualTypeOf(); + expect(data.megawalls.doubles.title).toBeDefined(); + expectTypeOf(data.megawalls.doubles.title).toEqualTypeOf(); + expect(data.megawalls.doubles.winstreak).toBeDefined(); + expect(data.megawalls.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.winstreak).toEqualTypeOf(); + expect(data.megawalls.doubles.bestWinstreak).toBeDefined(); + expect(data.megawalls.doubles.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.bestWinstreak).toEqualTypeOf(); + expect(data.megawalls.doubles.kills).toBeDefined(); + expect(data.megawalls.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.kills).toEqualTypeOf(); + expect(data.megawalls.doubles.deaths).toBeDefined(); + expect(data.megawalls.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.deaths).toEqualTypeOf(); + expect(data.megawalls.doubles.KDR).toBeDefined(); + expect(data.megawalls.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.KDR).toEqualTypeOf(); + expect(data.megawalls.doubles.wins).toBeDefined(); + expect(data.megawalls.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.wins).toEqualTypeOf(); + expect(data.megawalls.doubles.losses).toBeDefined(); + expect(data.megawalls.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.losses).toEqualTypeOf(); + expect(data.megawalls.doubles.WLR).toBeDefined(); + expect(data.megawalls.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.WLR).toEqualTypeOf(); + expect(data.megawalls.doubles.playedGames).toBeDefined(); + expect(data.megawalls.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.playedGames).toEqualTypeOf(); + expect(data.megawalls.doubles.swings).toBeDefined(); + expect(data.megawalls.doubles.swings).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.swings).toEqualTypeOf(); + expect(data.megawalls.doubles.hits).toBeDefined(); + expect(data.megawalls.doubles.hits).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.hits).toEqualTypeOf(); + expect(data.megawalls.doubles.meleeAccuracy).toBeDefined(); + expect(data.megawalls.doubles.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.meleeAccuracy).toEqualTypeOf(); + expect(data.megawalls.doubles.bowShots).toBeDefined(); + expect(data.megawalls.doubles.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.bowShots).toEqualTypeOf(); + expect(data.megawalls.doubles.bowHits).toBeDefined(); + expect(data.megawalls.doubles.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.bowHits).toEqualTypeOf(); + expect(data.megawalls.doubles.bowAccuracy).toBeDefined(); + expect(data.megawalls.doubles.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.bowAccuracy).toEqualTypeOf(); + expect(data.megawalls.doubles.blocksPlaced).toBeDefined(); + expect(data.megawalls.doubles.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.blocksPlaced).toEqualTypeOf(); + expect(data.megawalls.doubles.healthRegenerated).toBeDefined(); + expect(data.megawalls.doubles.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.healthRegenerated).toEqualTypeOf(); + expect(data.megawalls.doubles.goldenApplesEatan).toBeDefined(); + expect(data.megawalls.doubles.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.doubles.goldenApplesEatan).toEqualTypeOf(); + expect(data.megawalls.kills).toBeDefined(); + expect(data.megawalls.kills).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.kills).toEqualTypeOf(); + expect(data.megawalls.deaths).toBeDefined(); + expect(data.megawalls.deaths).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.deaths).toEqualTypeOf(); + expect(data.megawalls.KDR).toBeDefined(); + expect(data.megawalls.KDR).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.KDR).toEqualTypeOf(); + expect(data.megawalls.wins).toBeDefined(); + expect(data.megawalls.wins).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.wins).toEqualTypeOf(); + expect(data.megawalls.losses).toBeDefined(); + expect(data.megawalls.losses).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.losses).toEqualTypeOf(); + expect(data.megawalls.WLR).toBeDefined(); + expect(data.megawalls.WLR).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.WLR).toEqualTypeOf(); + expect(data.megawalls.playedGames).toBeDefined(); + expect(data.megawalls.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.playedGames).toEqualTypeOf(); + expect(data.megawalls.swings).toBeDefined(); + expect(data.megawalls.swings).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.swings).toEqualTypeOf(); + expect(data.megawalls.hits).toBeDefined(); + expect(data.megawalls.hits).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.hits).toEqualTypeOf(); + expect(data.megawalls.meleeAccuracy).toBeDefined(); + expect(data.megawalls.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.meleeAccuracy).toEqualTypeOf(); + expect(data.megawalls.bowShots).toBeDefined(); + expect(data.megawalls.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.bowShots).toEqualTypeOf(); + expect(data.megawalls.bowHits).toBeDefined(); + expect(data.megawalls.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.bowHits).toEqualTypeOf(); + expect(data.megawalls.bowAccuracy).toBeDefined(); + expect(data.megawalls.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.bowAccuracy).toEqualTypeOf(); + expect(data.megawalls.blocksPlaced).toBeDefined(); + expect(data.megawalls.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.blocksPlaced).toEqualTypeOf(); + expect(data.megawalls.healthRegenerated).toBeDefined(); + expect(data.megawalls.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.healthRegenerated).toEqualTypeOf(); + expect(data.megawalls.goldenApplesEatan).toBeDefined(); + expect(data.megawalls.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.megawalls.goldenApplesEatan).toEqualTypeOf(); + expect(data.blitz).toBeDefined(); + expectTypeOf(data.blitz).toEqualTypeOf(); + expectTypeOf(data.blitz.title).toEqualTypeOf(); + expect(data.blitz.winstreak).toBeDefined(); + expect(data.blitz.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.blitz.winstreak).toEqualTypeOf(); + expect(data.blitz.bestWinstreak).toBeDefined(); + expect(data.blitz.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.blitz.bestWinstreak).toEqualTypeOf(); + expect(data.blitz.kills).toBeDefined(); + expect(data.blitz.kills).greaterThanOrEqual(0); + expectTypeOf(data.blitz.kills).toEqualTypeOf(); + expect(data.blitz.deaths).toBeDefined(); + expect(data.blitz.deaths).greaterThanOrEqual(0); + expectTypeOf(data.blitz.deaths).toEqualTypeOf(); + expect(data.blitz.KDR).toBeDefined(); + expect(data.blitz.KDR).greaterThanOrEqual(0); + expectTypeOf(data.blitz.KDR).toEqualTypeOf(); + expect(data.blitz.wins).toBeDefined(); + expect(data.blitz.wins).greaterThanOrEqual(0); + expectTypeOf(data.blitz.wins).toEqualTypeOf(); + expect(data.blitz.losses).toBeDefined(); + expect(data.blitz.losses).greaterThanOrEqual(0); + expectTypeOf(data.blitz.losses).toEqualTypeOf(); + expect(data.blitz.WLR).toBeDefined(); + expect(data.blitz.WLR).greaterThanOrEqual(0); + expectTypeOf(data.blitz.WLR).toEqualTypeOf(); + expect(data.blitz.playedGames).toBeDefined(); + expect(data.blitz.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.blitz.playedGames).toEqualTypeOf(); + expect(data.blitz.swings).toBeDefined(); + expect(data.blitz.swings).greaterThanOrEqual(0); + expectTypeOf(data.blitz.swings).toEqualTypeOf(); + expect(data.blitz.hits).toBeDefined(); + expect(data.blitz.hits).greaterThanOrEqual(0); + expectTypeOf(data.blitz.hits).toEqualTypeOf(); + expect(data.blitz.meleeAccuracy).toBeDefined(); + expect(data.blitz.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.blitz.meleeAccuracy).toEqualTypeOf(); + expect(data.blitz.bowShots).toBeDefined(); + expect(data.blitz.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.blitz.bowShots).toEqualTypeOf(); + expect(data.blitz.bowHits).toBeDefined(); + expect(data.blitz.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.blitz.bowHits).toEqualTypeOf(); + expect(data.blitz.bowAccuracy).toBeDefined(); + expect(data.blitz.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.blitz.bowAccuracy).toEqualTypeOf(); + expect(data.blitz.blocksPlaced).toBeDefined(); + expect(data.blitz.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blitz.blocksPlaced).toEqualTypeOf(); + expect(data.blitz.healthRegenerated).toBeDefined(); + expect(data.blitz.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.blitz.healthRegenerated).toEqualTypeOf(); + expect(data.blitz.goldenApplesEatan).toBeDefined(); + expect(data.blitz.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.blitz.goldenApplesEatan).toEqualTypeOf(); + expect(data.op).toBeDefined(); + expectTypeOf(data.op).toEqualTypeOf(); + expect(data.op.title).toBeDefined(); + expectTypeOf(data.op.title).toEqualTypeOf(); + expect(data.op.winstreak).toBeDefined(); + expect(data.op.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.op.winstreak).toEqualTypeOf(); + expect(data.op.bestWinstreak).toBeDefined(); + expect(data.op.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.op.bestWinstreak).toEqualTypeOf(); + expect(data.op.solo).toBeDefined(); + expectTypeOf(data.op.solo).toEqualTypeOf(); + expect(data.op.solo.title).toBeDefined(); + expectTypeOf(data.op.solo.title).toEqualTypeOf(); + expect(data.op.solo.winstreak).toBeDefined(); + expect(data.op.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.winstreak).toEqualTypeOf(); + expect(data.op.solo.bestWinstreak).toBeDefined(); + expect(data.op.solo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.bestWinstreak).toEqualTypeOf(); + expect(data.op.solo.kills).toBeDefined(); + expect(data.op.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.kills).toEqualTypeOf(); + expect(data.op.solo.deaths).toBeDefined(); + expect(data.op.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.deaths).toEqualTypeOf(); + expect(data.op.solo.KDR).toBeDefined(); + expect(data.op.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.KDR).toEqualTypeOf(); + expect(data.op.solo.wins).toBeDefined(); + expect(data.op.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.wins).toEqualTypeOf(); + expect(data.op.solo.losses).toBeDefined(); + expect(data.op.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.losses).toEqualTypeOf(); + expect(data.op.solo.WLR).toBeDefined(); + expect(data.op.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.WLR).toEqualTypeOf(); + expect(data.op.solo.playedGames).toBeDefined(); + expect(data.op.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.playedGames).toEqualTypeOf(); + expect(data.op.solo.swings).toBeDefined(); + expect(data.op.solo.swings).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.swings).toEqualTypeOf(); + expect(data.op.solo.hits).toBeDefined(); + expect(data.op.solo.hits).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.hits).toEqualTypeOf(); + expect(data.op.solo.meleeAccuracy).toBeDefined(); + expect(data.op.solo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.meleeAccuracy).toEqualTypeOf(); + expect(data.op.solo.bowShots).toBeDefined(); + expect(data.op.solo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.bowShots).toEqualTypeOf(); + expect(data.op.solo.bowHits).toBeDefined(); + expect(data.op.solo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.bowHits).toEqualTypeOf(); + expect(data.op.solo.bowAccuracy).toBeDefined(); + expect(data.op.solo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.bowAccuracy).toEqualTypeOf(); + expect(data.op.solo.blocksPlaced).toBeDefined(); + expect(data.op.solo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.blocksPlaced).toEqualTypeOf(); + expect(data.op.solo.healthRegenerated).toBeDefined(); + expect(data.op.solo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.healthRegenerated).toEqualTypeOf(); + expect(data.op.solo.goldenApplesEatan).toBeDefined(); + expect(data.op.solo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.op.solo.goldenApplesEatan).toEqualTypeOf(); + expect(data.op.doubles).toBeDefined(); + expectTypeOf(data.op.doubles).toEqualTypeOf(); + expect(data.op.doubles.title).toBeDefined(); + expectTypeOf(data.op.doubles.title).toEqualTypeOf(); + expect(data.op.doubles.winstreak).toBeDefined(); + expect(data.op.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.winstreak).toEqualTypeOf(); + expect(data.op.doubles.bestWinstreak).toBeDefined(); + expect(data.op.doubles.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.bestWinstreak).toEqualTypeOf(); + expect(data.op.doubles.kills).toBeDefined(); + expect(data.op.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.kills).toEqualTypeOf(); + expect(data.op.doubles.deaths).toBeDefined(); + expect(data.op.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.deaths).toEqualTypeOf(); + expect(data.op.doubles.KDR).toBeDefined(); + expect(data.op.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.KDR).toEqualTypeOf(); + expect(data.op.doubles.wins).toBeDefined(); + expect(data.op.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.wins).toEqualTypeOf(); + expect(data.op.doubles.losses).toBeDefined(); + expect(data.op.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.losses).toEqualTypeOf(); + expect(data.op.doubles.WLR).toBeDefined(); + expect(data.op.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.WLR).toEqualTypeOf(); + expect(data.op.doubles.playedGames).toBeDefined(); + expect(data.op.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.playedGames).toEqualTypeOf(); + expect(data.op.doubles.swings).toBeDefined(); + expect(data.op.doubles.swings).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.swings).toEqualTypeOf(); + expect(data.op.doubles.hits).toBeDefined(); + expect(data.op.doubles.hits).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.hits).toEqualTypeOf(); + expect(data.op.doubles.meleeAccuracy).toBeDefined(); + expect(data.op.doubles.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.meleeAccuracy).toEqualTypeOf(); + expect(data.op.doubles.bowShots).toBeDefined(); + expect(data.op.doubles.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.bowShots).toEqualTypeOf(); + expect(data.op.doubles.bowHits).toBeDefined(); + expect(data.op.doubles.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.bowHits).toEqualTypeOf(); + expect(data.op.doubles.bowAccuracy).toBeDefined(); + expect(data.op.doubles.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.bowAccuracy).toEqualTypeOf(); + expect(data.op.doubles.blocksPlaced).toBeDefined(); + expect(data.op.doubles.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.blocksPlaced).toEqualTypeOf(); + expect(data.op.doubles.healthRegenerated).toBeDefined(); + expect(data.op.doubles.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.healthRegenerated).toEqualTypeOf(); + expect(data.op.doubles.goldenApplesEatan).toBeDefined(); + expect(data.op.doubles.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.op.doubles.goldenApplesEatan).toEqualTypeOf(); + expect(data.op.kills).toBeDefined(); + expect(data.op.kills).greaterThanOrEqual(0); + expectTypeOf(data.op.kills).toEqualTypeOf(); + expect(data.op.deaths).toBeDefined(); + expect(data.op.deaths).greaterThanOrEqual(0); + expectTypeOf(data.op.deaths).toEqualTypeOf(); + expect(data.op.KDR).toBeDefined(); + expect(data.op.KDR).greaterThanOrEqual(0); + expectTypeOf(data.op.KDR).toEqualTypeOf(); + expect(data.op.wins).toBeDefined(); + expect(data.op.wins).greaterThanOrEqual(0); + expectTypeOf(data.op.wins).toEqualTypeOf(); + expect(data.op.losses).toBeDefined(); + expect(data.op.losses).greaterThanOrEqual(0); + expectTypeOf(data.op.losses).toEqualTypeOf(); + expect(data.op.WLR).toBeDefined(); + expect(data.op.WLR).greaterThanOrEqual(0); + expectTypeOf(data.op.WLR).toEqualTypeOf(); + expect(data.op.playedGames).toBeDefined(); + expect(data.op.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.op.playedGames).toEqualTypeOf(); + expect(data.op.swings).toBeDefined(); + expect(data.op.swings).greaterThanOrEqual(0); + expectTypeOf(data.op.swings).toEqualTypeOf(); + expect(data.op.hits).toBeDefined(); + expect(data.op.hits).greaterThanOrEqual(0); + expectTypeOf(data.op.hits).toEqualTypeOf(); + expect(data.op.meleeAccuracy).toBeDefined(); + expect(data.op.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.op.meleeAccuracy).toEqualTypeOf(); + expect(data.op.bowShots).toBeDefined(); + expect(data.op.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.op.bowShots).toEqualTypeOf(); + expect(data.op.bowHits).toBeDefined(); + expect(data.op.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.op.bowHits).toEqualTypeOf(); + expect(data.op.bowAccuracy).toBeDefined(); + expect(data.op.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.op.bowAccuracy).toEqualTypeOf(); + expect(data.op.blocksPlaced).toBeDefined(); + expect(data.op.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.op.blocksPlaced).toEqualTypeOf(); + expect(data.op.healthRegenerated).toBeDefined(); + expect(data.op.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.op.healthRegenerated).toEqualTypeOf(); + expect(data.op.goldenApplesEatan).toBeDefined(); + expect(data.op.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.op.goldenApplesEatan).toEqualTypeOf(); + expect(data.classic).toBeDefined(); + expectTypeOf(data.classic).toEqualTypeOf(); + expectTypeOf(data.classic.title).toEqualTypeOf(); + expect(data.classic.winstreak).toBeDefined(); + expect(data.classic.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.classic.winstreak).toEqualTypeOf(); + expect(data.classic.bestWinstreak).toBeDefined(); + expect(data.classic.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.classic.bestWinstreak).toEqualTypeOf(); + expect(data.classic.kills).toBeDefined(); + expect(data.classic.kills).greaterThanOrEqual(0); + expectTypeOf(data.classic.kills).toEqualTypeOf(); + expect(data.classic.deaths).toBeDefined(); + expect(data.classic.deaths).greaterThanOrEqual(0); + expectTypeOf(data.classic.deaths).toEqualTypeOf(); + expect(data.classic.KDR).toBeDefined(); + expect(data.classic.KDR).greaterThanOrEqual(0); + expectTypeOf(data.classic.KDR).toEqualTypeOf(); + expect(data.classic.wins).toBeDefined(); + expect(data.classic.wins).greaterThanOrEqual(0); + expectTypeOf(data.classic.wins).toEqualTypeOf(); + expect(data.classic.losses).toBeDefined(); + expect(data.classic.losses).greaterThanOrEqual(0); + expectTypeOf(data.classic.losses).toEqualTypeOf(); + expect(data.classic.WLR).toBeDefined(); + expect(data.classic.WLR).greaterThanOrEqual(0); + expectTypeOf(data.classic.WLR).toEqualTypeOf(); + expect(data.classic.playedGames).toBeDefined(); + expect(data.classic.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.classic.playedGames).toEqualTypeOf(); + expect(data.classic.swings).toBeDefined(); + expect(data.classic.swings).greaterThanOrEqual(0); + expectTypeOf(data.classic.swings).toEqualTypeOf(); + expect(data.classic.hits).toBeDefined(); + expect(data.classic.hits).greaterThanOrEqual(0); + expectTypeOf(data.classic.hits).toEqualTypeOf(); + expect(data.classic.meleeAccuracy).toBeDefined(); + expect(data.classic.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.classic.meleeAccuracy).toEqualTypeOf(); + expect(data.classic.bowShots).toBeDefined(); + expect(data.classic.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.classic.bowShots).toEqualTypeOf(); + expect(data.classic.bowHits).toBeDefined(); + expect(data.classic.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.classic.bowHits).toEqualTypeOf(); + expect(data.classic.bowAccuracy).toBeDefined(); + expect(data.classic.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.classic.bowAccuracy).toEqualTypeOf(); + expect(data.classic.blocksPlaced).toBeDefined(); + expect(data.classic.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.classic.blocksPlaced).toEqualTypeOf(); + expect(data.classic.healthRegenerated).toBeDefined(); + expect(data.classic.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.classic.healthRegenerated).toEqualTypeOf(); + expect(data.classic.goldenApplesEatan).toBeDefined(); + expect(data.classic.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.classic.goldenApplesEatan).toEqualTypeOf(); + expect(data.bow).toBeDefined(); + expectTypeOf(data.bow).toEqualTypeOf(); + expectTypeOf(data.bow.title).toEqualTypeOf(); + expect(data.bow.winstreak).toBeDefined(); + expect(data.bow.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bow.winstreak).toEqualTypeOf(); + expect(data.bow.bestWinstreak).toBeDefined(); + expect(data.bow.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bow.bestWinstreak).toEqualTypeOf(); + expect(data.bow.kills).toBeDefined(); + expect(data.bow.kills).greaterThanOrEqual(0); + expectTypeOf(data.bow.kills).toEqualTypeOf(); + expect(data.bow.deaths).toBeDefined(); + expect(data.bow.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bow.deaths).toEqualTypeOf(); + expect(data.bow.KDR).toBeDefined(); + expect(data.bow.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bow.KDR).toEqualTypeOf(); + expect(data.bow.wins).toBeDefined(); + expect(data.bow.wins).greaterThanOrEqual(0); + expectTypeOf(data.bow.wins).toEqualTypeOf(); + expect(data.bow.losses).toBeDefined(); + expect(data.bow.losses).greaterThanOrEqual(0); + expectTypeOf(data.bow.losses).toEqualTypeOf(); + expect(data.bow.WLR).toBeDefined(); + expect(data.bow.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bow.WLR).toEqualTypeOf(); + expect(data.bow.playedGames).toBeDefined(); + expect(data.bow.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bow.playedGames).toEqualTypeOf(); + expect(data.bow.swings).toBeDefined(); + expect(data.bow.swings).greaterThanOrEqual(0); + expectTypeOf(data.bow.swings).toEqualTypeOf(); + expect(data.bow.hits).toBeDefined(); + expect(data.bow.hits).greaterThanOrEqual(0); + expectTypeOf(data.bow.hits).toEqualTypeOf(); + expect(data.bow.meleeAccuracy).toBeDefined(); + expect(data.bow.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bow.meleeAccuracy).toEqualTypeOf(); + expect(data.bow.bowShots).toBeDefined(); + expect(data.bow.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bow.bowShots).toEqualTypeOf(); + expect(data.bow.bowHits).toBeDefined(); + expect(data.bow.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bow.bowHits).toEqualTypeOf(); + expect(data.bow.bowAccuracy).toBeDefined(); + expect(data.bow.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bow.bowAccuracy).toEqualTypeOf(); + expect(data.bow.blocksPlaced).toBeDefined(); + expect(data.bow.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bow.blocksPlaced).toEqualTypeOf(); + expect(data.bow.healthRegenerated).toBeDefined(); + expect(data.bow.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bow.healthRegenerated).toEqualTypeOf(); + expect(data.bow.goldenApplesEatan).toBeDefined(); + expect(data.bow.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bow.goldenApplesEatan).toEqualTypeOf(); + expect(data.noDebuff).toBeDefined(); + expectTypeOf(data.noDebuff).toEqualTypeOf(); + expectTypeOf(data.noDebuff.title).toEqualTypeOf(); + expect(data.noDebuff.winstreak).toBeDefined(); + expect(data.noDebuff.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.winstreak).toEqualTypeOf(); + expect(data.noDebuff.bestWinstreak).toBeDefined(); + expect(data.noDebuff.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.bestWinstreak).toEqualTypeOf(); + expect(data.noDebuff.kills).toBeDefined(); + expect(data.noDebuff.kills).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.kills).toEqualTypeOf(); + expect(data.noDebuff.deaths).toBeDefined(); + expect(data.noDebuff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.deaths).toEqualTypeOf(); + expect(data.noDebuff.KDR).toBeDefined(); + expect(data.noDebuff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.KDR).toEqualTypeOf(); + expect(data.noDebuff.wins).toBeDefined(); + expect(data.noDebuff.wins).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.wins).toEqualTypeOf(); + expect(data.noDebuff.losses).toBeDefined(); + expect(data.noDebuff.losses).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.losses).toEqualTypeOf(); + expect(data.noDebuff.WLR).toBeDefined(); + expect(data.noDebuff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.WLR).toEqualTypeOf(); + expect(data.noDebuff.playedGames).toBeDefined(); + expect(data.noDebuff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.playedGames).toEqualTypeOf(); + expect(data.noDebuff.swings).toBeDefined(); + expect(data.noDebuff.swings).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.swings).toEqualTypeOf(); + expect(data.noDebuff.hits).toBeDefined(); + expect(data.noDebuff.hits).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.hits).toEqualTypeOf(); + expect(data.noDebuff.meleeAccuracy).toBeDefined(); + expect(data.noDebuff.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.meleeAccuracy).toEqualTypeOf(); + expect(data.noDebuff.bowShots).toBeDefined(); + expect(data.noDebuff.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.bowShots).toEqualTypeOf(); + expect(data.noDebuff.bowHits).toBeDefined(); + expect(data.noDebuff.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.bowHits).toEqualTypeOf(); + expect(data.noDebuff.bowAccuracy).toBeDefined(); + expect(data.noDebuff.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.bowAccuracy).toEqualTypeOf(); + expect(data.noDebuff.blocksPlaced).toBeDefined(); + expect(data.noDebuff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.blocksPlaced).toEqualTypeOf(); + expect(data.noDebuff.healthRegenerated).toBeDefined(); + expect(data.noDebuff.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.healthRegenerated).toEqualTypeOf(); + expect(data.noDebuff.goldenApplesEatan).toBeDefined(); + expect(data.noDebuff.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.noDebuff.goldenApplesEatan).toEqualTypeOf(); + expect(data.combo).toBeDefined(); + expectTypeOf(data.combo).toEqualTypeOf(); + expectTypeOf(data.combo.title).toEqualTypeOf(); + expect(data.combo.winstreak).toBeDefined(); + expect(data.combo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.combo.winstreak).toEqualTypeOf(); + expect(data.combo.bestWinstreak).toBeDefined(); + expect(data.combo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.combo.bestWinstreak).toEqualTypeOf(); + expect(data.combo.kills).toBeDefined(); + expect(data.combo.kills).greaterThanOrEqual(0); + expectTypeOf(data.combo.kills).toEqualTypeOf(); + expect(data.combo.deaths).toBeDefined(); + expect(data.combo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.combo.deaths).toEqualTypeOf(); + expect(data.combo.KDR).toBeDefined(); + expect(data.combo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.combo.KDR).toEqualTypeOf(); + expect(data.combo.wins).toBeDefined(); + expect(data.combo.wins).greaterThanOrEqual(0); + expectTypeOf(data.combo.wins).toEqualTypeOf(); + expect(data.combo.losses).toBeDefined(); + expect(data.combo.losses).greaterThanOrEqual(0); + expectTypeOf(data.combo.losses).toEqualTypeOf(); + expect(data.combo.WLR).toBeDefined(); + expect(data.combo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.combo.WLR).toEqualTypeOf(); + expect(data.combo.playedGames).toBeDefined(); + expect(data.combo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.combo.playedGames).toEqualTypeOf(); + expect(data.combo.swings).toBeDefined(); + expect(data.combo.swings).greaterThanOrEqual(0); + expectTypeOf(data.combo.swings).toEqualTypeOf(); + expect(data.combo.hits).toBeDefined(); + expect(data.combo.hits).greaterThanOrEqual(0); + expectTypeOf(data.combo.hits).toEqualTypeOf(); + expect(data.combo.meleeAccuracy).toBeDefined(); + expect(data.combo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.combo.meleeAccuracy).toEqualTypeOf(); + expect(data.combo.bowShots).toBeDefined(); + expect(data.combo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.combo.bowShots).toEqualTypeOf(); + expect(data.combo.bowHits).toBeDefined(); + expect(data.combo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.combo.bowHits).toEqualTypeOf(); + expect(data.combo.bowAccuracy).toBeDefined(); + expect(data.combo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.combo.bowAccuracy).toEqualTypeOf(); + expect(data.combo.blocksPlaced).toBeDefined(); + expect(data.combo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.combo.blocksPlaced).toEqualTypeOf(); + expect(data.combo.healthRegenerated).toBeDefined(); + expect(data.combo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.combo.healthRegenerated).toEqualTypeOf(); + expect(data.combo.goldenApplesEatan).toBeDefined(); + expect(data.combo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.combo.goldenApplesEatan).toEqualTypeOf(); + expect(data.bowSpleef).toBeDefined(); + expectTypeOf(data.bowSpleef).toEqualTypeOf(); + expectTypeOf(data.bowSpleef.title).toEqualTypeOf(); + expect(data.bowSpleef.winstreak).toBeDefined(); + expect(data.bowSpleef.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.winstreak).toEqualTypeOf(); + expect(data.bowSpleef.bestWinstreak).toBeDefined(); + expect(data.bowSpleef.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.bestWinstreak).toEqualTypeOf(); + expect(data.bowSpleef.kills).toBeDefined(); + expect(data.bowSpleef.kills).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.kills).toEqualTypeOf(); + expect(data.bowSpleef.deaths).toBeDefined(); + expect(data.bowSpleef.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.deaths).toEqualTypeOf(); + expect(data.bowSpleef.KDR).toBeDefined(); + expect(data.bowSpleef.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.KDR).toEqualTypeOf(); + expect(data.bowSpleef.wins).toBeDefined(); + expect(data.bowSpleef.wins).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.wins).toEqualTypeOf(); + expect(data.bowSpleef.losses).toBeDefined(); + expect(data.bowSpleef.losses).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.losses).toEqualTypeOf(); + expect(data.bowSpleef.WLR).toBeDefined(); + expect(data.bowSpleef.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.WLR).toEqualTypeOf(); + expect(data.bowSpleef.playedGames).toBeDefined(); + expect(data.bowSpleef.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.playedGames).toEqualTypeOf(); + expect(data.bowSpleef.swings).toBeDefined(); + expect(data.bowSpleef.swings).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.swings).toEqualTypeOf(); + expect(data.bowSpleef.hits).toBeDefined(); + expect(data.bowSpleef.hits).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.hits).toEqualTypeOf(); + expect(data.bowSpleef.meleeAccuracy).toBeDefined(); + expect(data.bowSpleef.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.meleeAccuracy).toEqualTypeOf(); + expect(data.bowSpleef.bowShots).toBeDefined(); + expect(data.bowSpleef.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.bowShots).toEqualTypeOf(); + expect(data.bowSpleef.bowHits).toBeDefined(); + expect(data.bowSpleef.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.bowHits).toEqualTypeOf(); + expect(data.bowSpleef.bowAccuracy).toBeDefined(); + expect(data.bowSpleef.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.bowAccuracy).toEqualTypeOf(); + expect(data.bowSpleef.blocksPlaced).toBeDefined(); + expect(data.bowSpleef.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.blocksPlaced).toEqualTypeOf(); + expect(data.bowSpleef.healthRegenerated).toBeDefined(); + expect(data.bowSpleef.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.healthRegenerated).toEqualTypeOf(); + expect(data.bowSpleef.goldenApplesEatan).toBeDefined(); + expect(data.bowSpleef.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.goldenApplesEatan).toEqualTypeOf(); + expect(data.sumo).toBeDefined(); + expectTypeOf(data.sumo).toEqualTypeOf(); + expectTypeOf(data.sumo.title).toEqualTypeOf(); + expect(data.sumo.winstreak).toBeDefined(); + expect(data.sumo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.sumo.winstreak).toEqualTypeOf(); + expect(data.sumo.bestWinstreak).toBeDefined(); + expect(data.sumo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.sumo.bestWinstreak).toEqualTypeOf(); + expect(data.sumo.kills).toBeDefined(); + expect(data.sumo.kills).greaterThanOrEqual(0); + expectTypeOf(data.sumo.kills).toEqualTypeOf(); + expect(data.sumo.deaths).toBeDefined(); + expect(data.sumo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.sumo.deaths).toEqualTypeOf(); + expect(data.sumo.KDR).toBeDefined(); + expect(data.sumo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.sumo.KDR).toEqualTypeOf(); + expect(data.sumo.wins).toBeDefined(); + expect(data.sumo.wins).greaterThanOrEqual(0); + expectTypeOf(data.sumo.wins).toEqualTypeOf(); + expect(data.sumo.losses).toBeDefined(); + expect(data.sumo.losses).greaterThanOrEqual(0); + expectTypeOf(data.sumo.losses).toEqualTypeOf(); + expect(data.sumo.WLR).toBeDefined(); + expect(data.sumo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.sumo.WLR).toEqualTypeOf(); + expect(data.sumo.playedGames).toBeDefined(); + expect(data.sumo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.sumo.playedGames).toEqualTypeOf(); + expect(data.sumo.swings).toBeDefined(); + expect(data.sumo.swings).greaterThanOrEqual(0); + expectTypeOf(data.sumo.swings).toEqualTypeOf(); + expect(data.sumo.hits).toBeDefined(); + expect(data.sumo.hits).greaterThanOrEqual(0); + expectTypeOf(data.sumo.hits).toEqualTypeOf(); + expect(data.sumo.meleeAccuracy).toBeDefined(); + expect(data.sumo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.sumo.meleeAccuracy).toEqualTypeOf(); + expect(data.sumo.bowShots).toBeDefined(); + expect(data.sumo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.sumo.bowShots).toEqualTypeOf(); + expect(data.sumo.bowHits).toBeDefined(); + expect(data.sumo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.sumo.bowHits).toEqualTypeOf(); + expect(data.sumo.bowAccuracy).toBeDefined(); + expect(data.sumo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.sumo.bowAccuracy).toEqualTypeOf(); + expect(data.sumo.blocksPlaced).toBeDefined(); + expect(data.sumo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.sumo.blocksPlaced).toEqualTypeOf(); + expect(data.sumo.healthRegenerated).toBeDefined(); + expect(data.sumo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.sumo.healthRegenerated).toEqualTypeOf(); + expect(data.sumo.goldenApplesEatan).toBeDefined(); + expect(data.sumo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.sumo.goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge).toBeDefined(); + expectTypeOf(data.bridge).toEqualTypeOf(); + expect(data.bridge.title).toBeDefined(); + expectTypeOf(data.bridge.title).toEqualTypeOf(); + expect(data.bridge.winstreak).toBeDefined(); + expect(data.bridge.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.winstreak).toEqualTypeOf(); + expect(data.bridge.bestWinstreak).toBeDefined(); + expect(data.bridge.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.bestWinstreak).toEqualTypeOf(); + expect(data.bridge.solo).toBeDefined(); + expectTypeOf(data.bridge.solo).toEqualTypeOf(); + expect(data.bridge.solo.title).toBeDefined(); + expectTypeOf(data.bridge.solo.title).toEqualTypeOf(); + expect(data.bridge.solo.winstreak).toBeDefined(); + expect(data.bridge.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.winstreak).toEqualTypeOf(); + expect(data.bridge.solo.bestWinstreak).toBeDefined(); + expect(data.bridge.solo.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.bestWinstreak).toEqualTypeOf(); + expect(data.bridge.solo.kills).toBeDefined(); + expect(data.bridge.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.kills).toEqualTypeOf(); + expect(data.bridge.solo.deaths).toBeDefined(); + expect(data.bridge.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.deaths).toEqualTypeOf(); + expect(data.bridge.solo.KDR).toBeDefined(); + expect(data.bridge.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.KDR).toEqualTypeOf(); + expect(data.bridge.solo.wins).toBeDefined(); + expect(data.bridge.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.wins).toEqualTypeOf(); + expect(data.bridge.solo.losses).toBeDefined(); + expect(data.bridge.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.losses).toEqualTypeOf(); + expect(data.bridge.solo.WLR).toBeDefined(); + expect(data.bridge.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.WLR).toEqualTypeOf(); + expect(data.bridge.solo.playedGames).toBeDefined(); + expect(data.bridge.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.playedGames).toEqualTypeOf(); + expect(data.bridge.solo.swings).toBeDefined(); + expect(data.bridge.solo.swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.swings).toEqualTypeOf(); + expect(data.bridge.solo.hits).toBeDefined(); + expect(data.bridge.solo.hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.hits).toEqualTypeOf(); + expect(data.bridge.solo.meleeAccuracy).toBeDefined(); + expect(data.bridge.solo.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.meleeAccuracy).toEqualTypeOf(); + expect(data.bridge.solo.bowShots).toBeDefined(); + expect(data.bridge.solo.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.bowShots).toEqualTypeOf(); + expect(data.bridge.solo.bowHits).toBeDefined(); + expect(data.bridge.solo.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.bowHits).toEqualTypeOf(); + expect(data.bridge.solo.bowAccuracy).toBeDefined(); + expect(data.bridge.solo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.bowAccuracy).toEqualTypeOf(); + expect(data.bridge.solo.blocksPlaced).toBeDefined(); + expect(data.bridge.solo.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.blocksPlaced).toEqualTypeOf(); + expect(data.bridge.solo.healthRegenerated).toBeDefined(); + expect(data.bridge.solo.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.healthRegenerated).toEqualTypeOf(); + expect(data.bridge.solo.goldenApplesEatan).toBeDefined(); + expect(data.bridge.solo.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge.solo.goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge.doubles).toBeDefined(); + expectTypeOf(data.bridge.doubles).toEqualTypeOf(); + expect(data.bridge.doubles.title).toBeDefined(); + expectTypeOf(data.bridge.doubles.title).toEqualTypeOf(); + expect(data.bridge.doubles.winstreak).toBeDefined(); + expect(data.bridge.doubles.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.winstreak).toEqualTypeOf(); + expect(data.bridge.doubles.bestWinstreak).toBeDefined(); + expect(data.bridge.doubles.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.bestWinstreak).toEqualTypeOf(); + expect(data.bridge.doubles.kills).toBeDefined(); + expect(data.bridge.doubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.kills).toEqualTypeOf(); + expect(data.bridge.doubles.deaths).toBeDefined(); + expect(data.bridge.doubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.deaths).toEqualTypeOf(); + expect(data.bridge.doubles.KDR).toBeDefined(); + expect(data.bridge.doubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.KDR).toEqualTypeOf(); + expect(data.bridge.doubles.wins).toBeDefined(); + expect(data.bridge.doubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.wins).toEqualTypeOf(); + expect(data.bridge.doubles.losses).toBeDefined(); + expect(data.bridge.doubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.losses).toEqualTypeOf(); + expect(data.bridge.doubles.WLR).toBeDefined(); + expect(data.bridge.doubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.WLR).toEqualTypeOf(); + expect(data.bridge.doubles.playedGames).toBeDefined(); + expect(data.bridge.doubles.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.playedGames).toEqualTypeOf(); + expect(data.bridge.doubles.swings).toBeDefined(); + expect(data.bridge.doubles.swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.swings).toEqualTypeOf(); + expect(data.bridge.doubles.hits).toBeDefined(); + expect(data.bridge.doubles.hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.hits).toEqualTypeOf(); + expect(data.bridge.doubles.meleeAccuracy).toBeDefined(); + expect(data.bridge.doubles.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.meleeAccuracy).toEqualTypeOf(); + expect(data.bridge.doubles.bowShots).toBeDefined(); + expect(data.bridge.doubles.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.bowShots).toEqualTypeOf(); + expect(data.bridge.doubles.bowHits).toBeDefined(); + expect(data.bridge.doubles.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.bowHits).toEqualTypeOf(); + expect(data.bridge.doubles.bowAccuracy).toBeDefined(); + expect(data.bridge.doubles.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.bowAccuracy).toEqualTypeOf(); + expect(data.bridge.doubles.blocksPlaced).toBeDefined(); + expect(data.bridge.doubles.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.blocksPlaced).toEqualTypeOf(); + expect(data.bridge.doubles.healthRegenerated).toBeDefined(); + expect(data.bridge.doubles.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.healthRegenerated).toEqualTypeOf(); + expect(data.bridge.doubles.goldenApplesEatan).toBeDefined(); + expect(data.bridge.doubles.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge.doubles.goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge.threes).toBeDefined(); + expectTypeOf(data.bridge.threes).toEqualTypeOf(); + expect(data.bridge.threes.title).toBeDefined(); + expectTypeOf(data.bridge.threes.title).toEqualTypeOf(); + expect(data.bridge.threes.winstreak).toBeDefined(); + expect(data.bridge.threes.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.winstreak).toEqualTypeOf(); + expect(data.bridge.threes.bestWinstreak).toBeDefined(); + expect(data.bridge.threes.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.bestWinstreak).toEqualTypeOf(); + expect(data.bridge.threes.kills).toBeDefined(); + expect(data.bridge.threes.kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.kills).toEqualTypeOf(); + expect(data.bridge.threes.deaths).toBeDefined(); + expect(data.bridge.threes.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.deaths).toEqualTypeOf(); + expect(data.bridge.threes.KDR).toBeDefined(); + expect(data.bridge.threes.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.KDR).toEqualTypeOf(); + expect(data.bridge.threes.wins).toBeDefined(); + expect(data.bridge.threes.wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.wins).toEqualTypeOf(); + expect(data.bridge.threes.losses).toBeDefined(); + expect(data.bridge.threes.losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.losses).toEqualTypeOf(); + expect(data.bridge.threes.WLR).toBeDefined(); + expect(data.bridge.threes.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.WLR).toEqualTypeOf(); + expect(data.bridge.threes.playedGames).toBeDefined(); + expect(data.bridge.threes.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.playedGames).toEqualTypeOf(); + expect(data.bridge.threes.swings).toBeDefined(); + expect(data.bridge.threes.swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.swings).toEqualTypeOf(); + expect(data.bridge.threes.hits).toBeDefined(); + expect(data.bridge.threes.hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.hits).toEqualTypeOf(); + expect(data.bridge.threes.meleeAccuracy).toBeDefined(); + expect(data.bridge.threes.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.meleeAccuracy).toEqualTypeOf(); + expect(data.bridge.threes.bowShots).toBeDefined(); + expect(data.bridge.threes.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.bowShots).toEqualTypeOf(); + expect(data.bridge.threes.bowHits).toBeDefined(); + expect(data.bridge.threes.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.bowHits).toEqualTypeOf(); + expect(data.bridge.threes.bowAccuracy).toBeDefined(); + expect(data.bridge.threes.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.bowAccuracy).toEqualTypeOf(); + expect(data.bridge.threes.blocksPlaced).toBeDefined(); + expect(data.bridge.threes.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.blocksPlaced).toEqualTypeOf(); + expect(data.bridge.threes.healthRegenerated).toBeDefined(); + expect(data.bridge.threes.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.healthRegenerated).toEqualTypeOf(); + expect(data.bridge.threes.goldenApplesEatan).toBeDefined(); + expect(data.bridge.threes.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge.threes.goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge.fours).toBeDefined(); + expectTypeOf(data.bridge.fours).toEqualTypeOf(); + expect(data.bridge.fours.title).toBeDefined(); + expectTypeOf(data.bridge.fours.title).toEqualTypeOf(); + expect(data.bridge.fours.winstreak).toBeDefined(); + expect(data.bridge.fours.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.winstreak).toEqualTypeOf(); + expect(data.bridge.fours.bestWinstreak).toBeDefined(); + expect(data.bridge.fours.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.bestWinstreak).toEqualTypeOf(); + expect(data.bridge.fours.kills).toBeDefined(); + expect(data.bridge.fours.kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.kills).toEqualTypeOf(); + expect(data.bridge.fours.deaths).toBeDefined(); + expect(data.bridge.fours.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.deaths).toEqualTypeOf(); + expect(data.bridge.fours.KDR).toBeDefined(); + expect(data.bridge.fours.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.KDR).toEqualTypeOf(); + expect(data.bridge.fours.wins).toBeDefined(); + expect(data.bridge.fours.wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.wins).toEqualTypeOf(); + expect(data.bridge.fours.losses).toBeDefined(); + expect(data.bridge.fours.losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.losses).toEqualTypeOf(); + expect(data.bridge.fours.WLR).toBeDefined(); + expect(data.bridge.fours.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.WLR).toEqualTypeOf(); + expect(data.bridge.fours.playedGames).toBeDefined(); + expect(data.bridge.fours.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.playedGames).toEqualTypeOf(); + expect(data.bridge.fours.swings).toBeDefined(); + expect(data.bridge.fours.swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.swings).toEqualTypeOf(); + expect(data.bridge.fours.hits).toBeDefined(); + expect(data.bridge.fours.hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.hits).toEqualTypeOf(); + expect(data.bridge.fours.meleeAccuracy).toBeDefined(); + expect(data.bridge.fours.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.meleeAccuracy).toEqualTypeOf(); + expect(data.bridge.fours.bowShots).toBeDefined(); + expect(data.bridge.fours.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.bowShots).toEqualTypeOf(); + expect(data.bridge.fours.bowHits).toBeDefined(); + expect(data.bridge.fours.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.bowHits).toEqualTypeOf(); + expect(data.bridge.fours.bowAccuracy).toBeDefined(); + expect(data.bridge.fours.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.bowAccuracy).toEqualTypeOf(); + expect(data.bridge.fours.blocksPlaced).toBeDefined(); + expect(data.bridge.fours.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.blocksPlaced).toEqualTypeOf(); + expect(data.bridge.fours.healthRegenerated).toBeDefined(); + expect(data.bridge.fours.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.healthRegenerated).toEqualTypeOf(); + expect(data.bridge.fours.goldenApplesEatan).toBeDefined(); + expect(data.bridge.fours.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge.fours.goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge['2v2v2v2']).toBeDefined(); + expectTypeOf(data.bridge['2v2v2v2']).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].title).toBeDefined(); + expectTypeOf(data.bridge['2v2v2v2'].title).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].winstreak).toBeDefined(); + expect(data.bridge['2v2v2v2'].winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].winstreak).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].bestWinstreak).toBeDefined(); + expect(data.bridge['2v2v2v2'].bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].bestWinstreak).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].kills).toBeDefined(); + expect(data.bridge['2v2v2v2'].kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].kills).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].deaths).toBeDefined(); + expect(data.bridge['2v2v2v2'].deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].deaths).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].KDR).toBeDefined(); + expect(data.bridge['2v2v2v2'].KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].KDR).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].wins).toBeDefined(); + expect(data.bridge['2v2v2v2'].wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].wins).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].losses).toBeDefined(); + expect(data.bridge['2v2v2v2'].losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].losses).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].WLR).toBeDefined(); + expect(data.bridge['2v2v2v2'].WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].WLR).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].playedGames).toBeDefined(); + expect(data.bridge['2v2v2v2'].playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].playedGames).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].swings).toBeDefined(); + expect(data.bridge['2v2v2v2'].swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].swings).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].hits).toBeDefined(); + expect(data.bridge['2v2v2v2'].hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].hits).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].meleeAccuracy).toBeDefined(); + expect(data.bridge['2v2v2v2'].meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].meleeAccuracy).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].bowShots).toBeDefined(); + expect(data.bridge['2v2v2v2'].bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].bowShots).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].bowHits).toBeDefined(); + expect(data.bridge['2v2v2v2'].bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].bowHits).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].bowAccuracy).toBeDefined(); + expect(data.bridge['2v2v2v2'].bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].bowAccuracy).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].blocksPlaced).toBeDefined(); + expect(data.bridge['2v2v2v2'].blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].blocksPlaced).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].healthRegenerated).toBeDefined(); + expect(data.bridge['2v2v2v2'].healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].healthRegenerated).toEqualTypeOf(); + expect(data.bridge['2v2v2v2'].goldenApplesEatan).toBeDefined(); + expect(data.bridge['2v2v2v2'].goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge['2v2v2v2'].goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge['3v3v3v3']).toBeDefined(); + expectTypeOf(data.bridge['3v3v3v3']).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].title).toBeDefined(); + expectTypeOf(data.bridge['3v3v3v3'].title).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].winstreak).toBeDefined(); + expect(data.bridge['3v3v3v3'].winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].winstreak).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].bestWinstreak).toBeDefined(); + expect(data.bridge['3v3v3v3'].bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].bestWinstreak).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].kills).toBeDefined(); + expect(data.bridge['3v3v3v3'].kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].kills).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].deaths).toBeDefined(); + expect(data.bridge['3v3v3v3'].deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].deaths).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].KDR).toBeDefined(); + expect(data.bridge['3v3v3v3'].KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].KDR).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].wins).toBeDefined(); + expect(data.bridge['3v3v3v3'].wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].wins).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].losses).toBeDefined(); + expect(data.bridge['3v3v3v3'].losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].losses).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].WLR).toBeDefined(); + expect(data.bridge['3v3v3v3'].WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].WLR).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].playedGames).toBeDefined(); + expect(data.bridge['3v3v3v3'].playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].playedGames).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].swings).toBeDefined(); + expect(data.bridge['3v3v3v3'].swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].swings).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].hits).toBeDefined(); + expect(data.bridge['3v3v3v3'].hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].hits).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].meleeAccuracy).toBeDefined(); + expect(data.bridge['3v3v3v3'].meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].meleeAccuracy).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].bowShots).toBeDefined(); + expect(data.bridge['3v3v3v3'].bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].bowShots).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].bowHits).toBeDefined(); + expect(data.bridge['3v3v3v3'].bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].bowHits).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].bowAccuracy).toBeDefined(); + expect(data.bridge['3v3v3v3'].bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].bowAccuracy).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].blocksPlaced).toBeDefined(); + expect(data.bridge['3v3v3v3'].blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].blocksPlaced).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].healthRegenerated).toBeDefined(); + expect(data.bridge['3v3v3v3'].healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].healthRegenerated).toEqualTypeOf(); + expect(data.bridge['3v3v3v3'].goldenApplesEatan).toBeDefined(); + expect(data.bridge['3v3v3v3'].goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge['3v3v3v3'].goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge.ctf).toBeDefined(); + expectTypeOf(data.bridge.ctf).toEqualTypeOf(); + expect(data.bridge.ctf.title).toBeDefined(); + expectTypeOf(data.bridge.ctf.title).toEqualTypeOf(); + expect(data.bridge.ctf.winstreak).toBeDefined(); + expect(data.bridge.ctf.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.winstreak).toEqualTypeOf(); + expect(data.bridge.ctf.bestWinstreak).toBeDefined(); + expect(data.bridge.ctf.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.bestWinstreak).toEqualTypeOf(); + expect(data.bridge.ctf.kills).toBeDefined(); + expect(data.bridge.ctf.kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.kills).toEqualTypeOf(); + expect(data.bridge.ctf.deaths).toBeDefined(); + expect(data.bridge.ctf.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.deaths).toEqualTypeOf(); + expect(data.bridge.ctf.KDR).toBeDefined(); + expect(data.bridge.ctf.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.KDR).toEqualTypeOf(); + expect(data.bridge.ctf.wins).toBeDefined(); + expect(data.bridge.ctf.wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.wins).toEqualTypeOf(); + expect(data.bridge.ctf.losses).toBeDefined(); + expect(data.bridge.ctf.losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.losses).toEqualTypeOf(); + expect(data.bridge.ctf.WLR).toBeDefined(); + expect(data.bridge.ctf.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.WLR).toEqualTypeOf(); + expect(data.bridge.ctf.playedGames).toBeDefined(); + expect(data.bridge.ctf.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.playedGames).toEqualTypeOf(); + expect(data.bridge.ctf.swings).toBeDefined(); + expect(data.bridge.ctf.swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.swings).toEqualTypeOf(); + expect(data.bridge.ctf.hits).toBeDefined(); + expect(data.bridge.ctf.hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.hits).toEqualTypeOf(); + expect(data.bridge.ctf.meleeAccuracy).toBeDefined(); + expect(data.bridge.ctf.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.meleeAccuracy).toEqualTypeOf(); + expect(data.bridge.ctf.bowShots).toBeDefined(); + expect(data.bridge.ctf.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.bowShots).toEqualTypeOf(); + expect(data.bridge.ctf.bowHits).toBeDefined(); + expect(data.bridge.ctf.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.bowHits).toEqualTypeOf(); + expect(data.bridge.ctf.bowAccuracy).toBeDefined(); + expect(data.bridge.ctf.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.bowAccuracy).toEqualTypeOf(); + expect(data.bridge.ctf.blocksPlaced).toBeDefined(); + expect(data.bridge.ctf.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.blocksPlaced).toEqualTypeOf(); + expect(data.bridge.ctf.healthRegenerated).toBeDefined(); + expect(data.bridge.ctf.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.healthRegenerated).toEqualTypeOf(); + expect(data.bridge.ctf.goldenApplesEatan).toBeDefined(); + expect(data.bridge.ctf.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge.ctf.goldenApplesEatan).toEqualTypeOf(); + expect(data.bridge.kills).toBeDefined(); + expect(data.bridge.kills).greaterThanOrEqual(0); + expectTypeOf(data.bridge.kills).toEqualTypeOf(); + expect(data.bridge.deaths).toBeDefined(); + expect(data.bridge.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bridge.deaths).toEqualTypeOf(); + expect(data.bridge.KDR).toBeDefined(); + expect(data.bridge.KDR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.KDR).toEqualTypeOf(); + expect(data.bridge.wins).toBeDefined(); + expect(data.bridge.wins).greaterThanOrEqual(0); + expectTypeOf(data.bridge.wins).toEqualTypeOf(); + expect(data.bridge.losses).toBeDefined(); + expect(data.bridge.losses).greaterThanOrEqual(0); + expectTypeOf(data.bridge.losses).toEqualTypeOf(); + expect(data.bridge.WLR).toBeDefined(); + expect(data.bridge.WLR).greaterThanOrEqual(0); + expectTypeOf(data.bridge.WLR).toEqualTypeOf(); + expect(data.bridge.playedGames).toBeDefined(); + expect(data.bridge.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.bridge.playedGames).toEqualTypeOf(); + expect(data.bridge.swings).toBeDefined(); + expect(data.bridge.swings).greaterThanOrEqual(0); + expectTypeOf(data.bridge.swings).toEqualTypeOf(); + expect(data.bridge.hits).toBeDefined(); + expect(data.bridge.hits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.hits).toEqualTypeOf(); + expect(data.bridge.meleeAccuracy).toBeDefined(); + expect(data.bridge.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.meleeAccuracy).toEqualTypeOf(); + expect(data.bridge.bowShots).toBeDefined(); + expect(data.bridge.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.bridge.bowShots).toEqualTypeOf(); + expect(data.bridge.bowHits).toBeDefined(); + expect(data.bridge.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.bridge.bowHits).toEqualTypeOf(); + expect(data.bridge.bowAccuracy).toBeDefined(); + expect(data.bridge.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bridge.bowAccuracy).toEqualTypeOf(); + expect(data.bridge.blocksPlaced).toBeDefined(); + expect(data.bridge.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.bridge.blocksPlaced).toEqualTypeOf(); + expect(data.bridge.healthRegenerated).toBeDefined(); + expect(data.bridge.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.bridge.healthRegenerated).toEqualTypeOf(); + expect(data.bridge.goldenApplesEatan).toBeDefined(); + expect(data.bridge.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.bridge.goldenApplesEatan).toEqualTypeOf(); + expect(data.parkour).toBeDefined(); + expectTypeOf(data.parkour).toEqualTypeOf(); + expectTypeOf(data.parkour.title).toEqualTypeOf(); + expect(data.parkour.winstreak).toBeDefined(); + expect(data.parkour.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.parkour.winstreak).toEqualTypeOf(); + expect(data.parkour.bestWinstreak).toBeDefined(); + expect(data.parkour.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.parkour.bestWinstreak).toEqualTypeOf(); + expect(data.parkour.kills).toBeDefined(); + expect(data.parkour.kills).greaterThanOrEqual(0); + expectTypeOf(data.parkour.kills).toEqualTypeOf(); + expect(data.parkour.deaths).toBeDefined(); + expect(data.parkour.deaths).greaterThanOrEqual(0); + expectTypeOf(data.parkour.deaths).toEqualTypeOf(); + expect(data.parkour.KDR).toBeDefined(); + expect(data.parkour.KDR).greaterThanOrEqual(0); + expectTypeOf(data.parkour.KDR).toEqualTypeOf(); + expect(data.parkour.wins).toBeDefined(); + expect(data.parkour.wins).greaterThanOrEqual(0); + expectTypeOf(data.parkour.wins).toEqualTypeOf(); + expect(data.parkour.losses).toBeDefined(); + expect(data.parkour.losses).greaterThanOrEqual(0); + expectTypeOf(data.parkour.losses).toEqualTypeOf(); + expect(data.parkour.WLR).toBeDefined(); + expect(data.parkour.WLR).greaterThanOrEqual(0); + expectTypeOf(data.parkour.WLR).toEqualTypeOf(); + expect(data.parkour.playedGames).toBeDefined(); + expect(data.parkour.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.parkour.playedGames).toEqualTypeOf(); + expect(data.parkour.swings).toBeDefined(); + expect(data.parkour.swings).greaterThanOrEqual(0); + expectTypeOf(data.parkour.swings).toEqualTypeOf(); + expect(data.parkour.hits).toBeDefined(); + expect(data.parkour.hits).greaterThanOrEqual(0); + expectTypeOf(data.parkour.hits).toEqualTypeOf(); + expect(data.parkour.meleeAccuracy).toBeDefined(); + expect(data.parkour.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.parkour.meleeAccuracy).toEqualTypeOf(); + expect(data.parkour.bowShots).toBeDefined(); + expect(data.parkour.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.parkour.bowShots).toEqualTypeOf(); + expect(data.parkour.bowHits).toBeDefined(); + expect(data.parkour.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.parkour.bowHits).toEqualTypeOf(); + expect(data.parkour.bowAccuracy).toBeDefined(); + expect(data.parkour.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.parkour.bowAccuracy).toEqualTypeOf(); + expect(data.parkour.blocksPlaced).toBeDefined(); + expect(data.parkour.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.parkour.blocksPlaced).toEqualTypeOf(); + expect(data.parkour.healthRegenerated).toBeDefined(); + expect(data.parkour.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.parkour.healthRegenerated).toEqualTypeOf(); + expect(data.parkour.goldenApplesEatan).toBeDefined(); + expect(data.parkour.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.parkour.goldenApplesEatan).toEqualTypeOf(); + expect(data.arena).toBeDefined(); + expectTypeOf(data.arena).toEqualTypeOf(); + expectTypeOf(data.arena.title).toEqualTypeOf(); + expect(data.arena.winstreak).toBeDefined(); + expect(data.arena.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.arena.winstreak).toEqualTypeOf(); + expect(data.arena.bestWinstreak).toBeDefined(); + expect(data.arena.bestWinstreak).greaterThanOrEqual(0); + expectTypeOf(data.arena.bestWinstreak).toEqualTypeOf(); + expect(data.arena.kills).toBeDefined(); + expect(data.arena.kills).greaterThanOrEqual(0); + expectTypeOf(data.arena.kills).toEqualTypeOf(); + expect(data.arena.deaths).toBeDefined(); + expect(data.arena.deaths).greaterThanOrEqual(0); + expectTypeOf(data.arena.deaths).toEqualTypeOf(); + expect(data.arena.KDR).toBeDefined(); + expect(data.arena.KDR).greaterThanOrEqual(0); + expectTypeOf(data.arena.KDR).toEqualTypeOf(); + expect(data.arena.wins).toBeDefined(); + expect(data.arena.wins).greaterThanOrEqual(0); + expectTypeOf(data.arena.wins).toEqualTypeOf(); + expect(data.arena.losses).toBeDefined(); + expect(data.arena.losses).greaterThanOrEqual(0); + expectTypeOf(data.arena.losses).toEqualTypeOf(); + expect(data.arena.WLR).toBeDefined(); + expect(data.arena.WLR).greaterThanOrEqual(0); + expectTypeOf(data.arena.WLR).toEqualTypeOf(); + expect(data.arena.playedGames).toBeDefined(); + expect(data.arena.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.arena.playedGames).toEqualTypeOf(); + expect(data.arena.swings).toBeDefined(); + expect(data.arena.swings).greaterThanOrEqual(0); + expectTypeOf(data.arena.swings).toEqualTypeOf(); + expect(data.arena.hits).toBeDefined(); + expect(data.arena.hits).greaterThanOrEqual(0); + expectTypeOf(data.arena.hits).toEqualTypeOf(); + expect(data.arena.meleeAccuracy).toBeDefined(); + expect(data.arena.meleeAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.arena.meleeAccuracy).toEqualTypeOf(); + expect(data.arena.bowShots).toBeDefined(); + expect(data.arena.bowShots).greaterThanOrEqual(0); + expectTypeOf(data.arena.bowShots).toEqualTypeOf(); + expect(data.arena.bowHits).toBeDefined(); + expect(data.arena.bowHits).greaterThanOrEqual(0); + expectTypeOf(data.arena.bowHits).toEqualTypeOf(); + expect(data.arena.bowAccuracy).toBeDefined(); + expect(data.arena.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.arena.bowAccuracy).toEqualTypeOf(); + expect(data.arena.blocksPlaced).toBeDefined(); + expect(data.arena.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.arena.blocksPlaced).toEqualTypeOf(); + expect(data.arena.healthRegenerated).toBeDefined(); + expect(data.arena.healthRegenerated).greaterThanOrEqual(0); + expectTypeOf(data.arena.healthRegenerated).toEqualTypeOf(); + expect(data.arena.goldenApplesEatan).toBeDefined(); + expect(data.arena.goldenApplesEatan).greaterThanOrEqual(0); + expectTypeOf(data.arena.goldenApplesEatan).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/Duels.ts b/src/structures/MiniGames/Duels.ts index e2605a7e..f940dcd9 100644 --- a/src/structures/MiniGames/Duels.ts +++ b/src/structures/MiniGames/Duels.ts @@ -1,18 +1,16 @@ -import Constants from '../../utils/Constants'; import divide from '../../utils/divide'; import romanize from '../../utils/romanize'; +import { duelsDivisions } from '../../utils/Constants'; function getTitle(data: Record, mode: string): string { - for (const div of Constants.duelsDivisions.slice().reverse()) { - const prestige = data[`${mode}_${div.key}_title_prestige`]; - if (prestige) { - return `${div.name} ${romanize(prestige)}`; - } + for (const div of duelsDivisions.slice().reverse()) { + const prestige = data?.[`${mode}_${div.key}_title_prestige`]; + if (prestige) return `${div.name} ${romanize(prestige)}`; } return ''; } -class DuelsGamemode { +export class DuelsGamemode { title: string; winstreak: number; bestWinstreak: number; @@ -34,28 +32,28 @@ class DuelsGamemode { goldenApplesEatan: number; constructor(data: Record, mode: string, title: string = '') { this.title = title; - this.winstreak = data[`current_winstreak_mode_${mode}`] || 0; - this.bestWinstreak = data[`best_winstreak_mode_${mode}`] || 0; - this.kills = data[`${mode}_kills`] || 0; - this.deaths = data[`${mode}_deaths`] || 0; + this.winstreak = data?.[`current_winstreak_mode_${mode}`] || 0; + this.bestWinstreak = data?.[`best_winstreak_mode_${mode}`] || 0; + this.kills = data?.[`${mode}_kills`] || 0; + this.deaths = data?.[`${mode}_deaths`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`${mode}_wins`] || 0; - this.losses = data[`${mode}_losses`] || 0; + this.wins = data?.[`${mode}_wins`] || 0; + this.losses = data?.[`${mode}_losses`] || 0; this.WLR = divide(this.wins, this.losses); - this.playedGames = data[`${mode}_rounds_played`] || 0; - this.swings = data[`${mode}_melee_swings`] || 0; - this.hits = data[`${mode}_melee_hits`] || 0; + this.playedGames = data?.[`${mode}_rounds_played`] || 0; + this.swings = data?.[`${mode}_melee_swings`] || 0; + this.hits = data?.[`${mode}_melee_hits`] || 0; this.meleeAccuracy = divide(this.swings, this.hits); - this.bowShots = data[`${mode}_bow_shots`] || 0; - this.bowHits = data[`${mode}_bow_hits`] || 0; + this.bowShots = data?.[`${mode}_bow_shots`] || 0; + this.bowHits = data?.[`${mode}_bow_hits`] || 0; this.bowAccuracy = divide(this.bowShots, this.bowHits); - this.blocksPlaced = data[`${mode}_blocks_placed`] || 0; - this.healthRegenerated = data[`${mode}_health_regenerated`] || 0; - this.goldenApplesEatan = data[`${mode}_golden_apples_eaten`] || 0; + this.blocksPlaced = data?.[`${mode}_blocks_placed`] || 0; + this.healthRegenerated = data?.[`${mode}_health_regenerated`] || 0; + this.goldenApplesEatan = data?.[`${mode}_golden_apples_eaten`] || 0; } } -class DuelsUHC { +export class DuelsUHC { title: string; winstreak: number; bestWinstreak: number; @@ -81,8 +79,8 @@ class DuelsUHC { goldenApplesEatan: number; constructor(data: Record) { this.title = getTitle(data, 'uhc'); - this.winstreak = data.current_uhc_winstreak || 0; - this.bestWinstreak = data.best_uhc_winstreak || 0; + this.winstreak = data?.current_uhc_winstreak || 0; + this.bestWinstreak = data?.best_uhc_winstreak || 0; this.solo = new DuelsGamemode(data, 'uhc_duel', this.title); this.doubles = new DuelsGamemode(data, 'uhc_doubles', this.title); this.fours = new DuelsGamemode(data, 'uhc_four', this.title); @@ -116,7 +114,7 @@ class DuelsUHC { } } -class DuelsSkyWars { +export class DuelsSkyWars { title: string; winstreak: number; bestWinstreak: number; @@ -140,8 +138,8 @@ class DuelsSkyWars { goldenApplesEatan: number; constructor(data: Record) { this.title = getTitle(data, 'sw'); - this.winstreak = data.current_sw_winstreak || 0; - this.bestWinstreak = data.best_sw_winstreak || 0; + this.winstreak = data?.current_sw_winstreak || 0; + this.bestWinstreak = data?.best_sw_winstreak || 0; this.solo = new DuelsGamemode(data, 'sw_duel', this.title); this.doubles = new DuelsGamemode(data, 'sw_doubles', this.title); this.kills = this.solo.kills + this.doubles.kills; @@ -163,7 +161,7 @@ class DuelsSkyWars { } } -class DuelsMegaWalls { +export class DuelsMegaWalls { title: string; winstreak: number; bestWinstreak: number; @@ -187,8 +185,8 @@ class DuelsMegaWalls { goldenApplesEatan: number; constructor(data: Record) { this.title = getTitle(data, 'mega_walls'); - this.winstreak = data.current_mega_walls_winstreak || 0; - this.bestWinstreak = data.best_mega_walls_winstreak || 0; + this.winstreak = data?.current_mega_walls_winstreak || 0; + this.bestWinstreak = data?.best_mega_walls_winstreak || 0; this.solo = new DuelsGamemode(data, 'mw_duel', this.title); this.doubles = new DuelsGamemode(data, 'mw_doubles', this.title); this.kills = this.solo.kills + this.doubles.kills; @@ -210,7 +208,7 @@ class DuelsMegaWalls { } } -class DuelsOP { +export class DuelsOP { title: string; winstreak: number; bestWinstreak: number; @@ -234,8 +232,8 @@ class DuelsOP { goldenApplesEatan: number; constructor(data: Record) { this.title = getTitle(data, 'op'); - this.winstreak = data.current_op_winstreak || 0; - this.bestWinstreak = data.best_op_winstreak || 0; + this.winstreak = data?.current_op_winstreak || 0; + this.bestWinstreak = data?.best_op_winstreak || 0; this.solo = new DuelsGamemode(data, 'op_duel', this.title); this.doubles = new DuelsGamemode(data, 'op_doubles', this.title); this.kills = this.solo.kills + this.doubles.kills; @@ -257,7 +255,7 @@ class DuelsOP { } } -class DuelsBridge { +export class DuelsBridge { title: string; winstreak: number; bestWinstreak: number; @@ -286,8 +284,8 @@ class DuelsBridge { goldenApplesEatan: number; constructor(data: Record) { this.title = getTitle(data, 'bridge'); - this.winstreak = data.current_bridge_winstreak || 0; - this.bestWinstreak = data.best_bridge_winstreak || 0; + this.winstreak = data?.current_bridge_winstreak || 0; + this.bestWinstreak = data?.best_bridge_winstreak || 0; this.solo = new DuelsGamemode(data, 'bridge_duel', this.title); this.doubles = new DuelsGamemode(data, 'bridge_doubles', this.title); this.threes = new DuelsGamemode(data, 'bridge_threes', this.title); @@ -357,8 +355,8 @@ class DuelsBridge { this.bowShots = this.solo.bowShots + this.doubles.bowShots + - this.threes.bowShots + - this.fours.bowShots + + this.threes?.bowShots + + this.fours?.bowShots + this['2v2v2v2'].bowShots + this['3v3v3v3'].bowShots + this.ctf.bowShots; @@ -398,7 +396,7 @@ class DuelsBridge { } } -class Duels { +export class Duels { tokens: number; title: string | null; kills: number; @@ -435,27 +433,27 @@ class Duels { parkour: DuelsGamemode; arena: DuelsGamemode; constructor(data: Record) { - this.tokens = data.coins || 0; + this.tokens = data?.coins || 0; this.title = getTitle(data, 'all_modes'); - this.kills = data.kills || 0; - this.deaths = data.deaths || 0; + this.kills = data?.kills || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; this.WLR = divide(this.wins, this.losses); - this.playedGames = data.games_played_duels || 0; - this.winstreak = data.current_winstreak || 0; - this.bestWinstreak = data.best_overall_winstreak || 0; - this.ping = data.pingPreference || 0; - this.blocksPlaced = data.blocks_placed || 0; - this.swings = data.melee_swings || 0; - this.hits = data.melee_hits || 0; + this.playedGames = data?.games_played_duels || 0; + this.winstreak = data?.current_winstreak || 0; + this.bestWinstreak = data?.best_overall_winstreak || 0; + this.ping = data?.pingPreference || 0; + this.blocksPlaced = data?.blocks_placed || 0; + this.swings = data?.melee_swings || 0; + this.hits = data?.melee_hits || 0; this.meleeAccuracy = divide(this.hits, this.swings); - this.bowShots = data.bow_shots || 0; - this.bowHits = data.bow_hits || 0; + this.bowShots = data?.bow_shots || 0; + this.bowHits = data?.bow_hits || 0; this.bowAccuracy = divide(this.bowHits, this.bowShots); - this.healthRegenerated = data.health_regenerated || 0; - this.goldenApplesEatan = data.golden_apples_eaten || 0; + this.healthRegenerated = data?.health_regenerated || 0; + this.goldenApplesEatan = data?.golden_apples_eaten || 0; this.uhc = new DuelsUHC(data); this.skywars = new DuelsSkyWars(data); this.megawalls = new DuelsMegaWalls(data); diff --git a/src/structures/MiniGames/MegaWalls.test.ts b/src/structures/MiniGames/MegaWalls.test.ts new file mode 100644 index 00000000..3b8dc5f6 --- /dev/null +++ b/src/structures/MiniGames/MegaWalls.test.ts @@ -0,0 +1,4792 @@ +import MegaWalls, { MegaWallsKitStats, MegaWallsModeStats } from './MegaWalls'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('MegaWalls', () => { + const data = new MegaWalls({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(MegaWalls); + expectTypeOf(data).toMatchTypeOf(); + expect(data.selectedClass).toBeDefined(); + expectTypeOf(data.selectedClass).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.assists).toBeDefined(); + expect(data.assists).greaterThanOrEqual(0); + expectTypeOf(data.assists).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.finalKills).toBeDefined(); + expect(data.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.finalKills).toEqualTypeOf(); + expect(data.finalAssists).toBeDefined(); + expect(data.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.finalAssists).toEqualTypeOf(); + expect(data.finalDeaths).toBeDefined(); + expect(data.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.finalDeaths).toEqualTypeOf(); + expect(data.FKDR).toBeDefined(); + expect(data.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.FKDR).toEqualTypeOf(); + expect(data.playedGames).toBeDefined(); + expect(data.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.playedGames).toEqualTypeOf(); + expect(data.witherDamage).toBeDefined(); + expect(data.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.witherDamage).toEqualTypeOf(); + expect(data.defenderKills).toBeDefined(); + expect(data.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.defenderKills).toEqualTypeOf(); + expect(data.walked).toBeDefined(); + expect(data.walked).greaterThanOrEqual(0); + expectTypeOf(data.walked).toEqualTypeOf(); + expect(data.blocksPlaced).toBeDefined(); + expect(data.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blocksPlaced).toEqualTypeOf(); + expect(data.blocksBroken).toBeDefined(); + expect(data.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.blocksBroken).toEqualTypeOf(); + expect(data.meleeKills).toBeDefined(); + expect(data.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.meleeKills).toEqualTypeOf(); + expect(data.damageDealt).toBeDefined(); + expect(data.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.damageDealt).toEqualTypeOf(); + expect(data.faceOff).toBeDefined(); + expectTypeOf(data.faceOff).toEqualTypeOf(); + expect(data.faceOff.kills).toBeDefined(); + expect(data.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.kills).toEqualTypeOf(); + expect(data.faceOff.assists).toBeDefined(); + expect(data.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.assists).toEqualTypeOf(); + expect(data.faceOff.deaths).toBeDefined(); + expect(data.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.deaths).toEqualTypeOf(); + expect(data.faceOff.KDR).toBeDefined(); + expect(data.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.KDR).toEqualTypeOf(); + expect(data.faceOff.wins).toBeDefined(); + expect(data.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.wins).toEqualTypeOf(); + expect(data.faceOff.losses).toBeDefined(); + expect(data.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.losses).toEqualTypeOf(); + expect(data.faceOff.WLR).toBeDefined(); + expect(data.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.WLR).toEqualTypeOf(); + expect(data.faceOff.finalKills).toBeDefined(); + expect(data.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.finalKills).toEqualTypeOf(); + expect(data.faceOff.finalAssists).toBeDefined(); + expect(data.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.finalAssists).toEqualTypeOf(); + expect(data.faceOff.finalDeaths).toBeDefined(); + expect(data.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.faceOff.FKDR).toBeDefined(); + expect(data.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.FKDR).toEqualTypeOf(); + expect(data.faceOff.playedGames).toBeDefined(); + expect(data.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.playedGames).toEqualTypeOf(); + expect(data.faceOff.witherDamage).toBeDefined(); + expect(data.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.witherDamage).toEqualTypeOf(); + expect(data.faceOff.defenderKills).toBeDefined(); + expect(data.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.defenderKills).toEqualTypeOf(); + expect(data.faceOff.walked).toBeDefined(); + expect(data.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.walked).toEqualTypeOf(); + expect(data.faceOff.blocksPlaced).toBeDefined(); + expect(data.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.faceOff.blocksBroken).toBeDefined(); + expect(data.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.faceOff.meleeKills).toBeDefined(); + expect(data.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.meleeKills).toEqualTypeOf(); + expect(data.faceOff.damageDealt).toBeDefined(); + expect(data.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.faceOff.damageDealt).toEqualTypeOf(); + expect(data.casualBrawl).toBeDefined(); + expectTypeOf(data.casualBrawl).toEqualTypeOf(); + expect(data.casualBrawl.kills).toBeDefined(); + expect(data.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.kills).toEqualTypeOf(); + expect(data.casualBrawl.assists).toBeDefined(); + expect(data.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.assists).toEqualTypeOf(); + expect(data.casualBrawl.deaths).toBeDefined(); + expect(data.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.deaths).toEqualTypeOf(); + expect(data.casualBrawl.KDR).toBeDefined(); + expect(data.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.KDR).toEqualTypeOf(); + expect(data.casualBrawl.wins).toBeDefined(); + expect(data.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.wins).toEqualTypeOf(); + expect(data.casualBrawl.losses).toBeDefined(); + expect(data.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.losses).toEqualTypeOf(); + expect(data.casualBrawl.WLR).toBeDefined(); + expect(data.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.WLR).toEqualTypeOf(); + expect(data.casualBrawl.finalKills).toBeDefined(); + expect(data.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.casualBrawl.finalAssists).toBeDefined(); + expect(data.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.casualBrawl.finalDeaths).toBeDefined(); + expect(data.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.casualBrawl.FKDR).toBeDefined(); + expect(data.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.casualBrawl.playedGames).toBeDefined(); + expect(data.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.casualBrawl.witherDamage).toBeDefined(); + expect(data.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.casualBrawl.defenderKills).toBeDefined(); + expect(data.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.casualBrawl.walked).toBeDefined(); + expect(data.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.walked).toEqualTypeOf(); + expect(data.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.casualBrawl.blocksBroken).toBeDefined(); + expect(data.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.casualBrawl.meleeKills).toBeDefined(); + expect(data.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.casualBrawl.damageDealt).toBeDefined(); + expect(data.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.cow).toBeDefined(); + expectTypeOf(data.cow).toEqualTypeOf(); + expect(data.cow.kills).toBeDefined(); + expect(data.cow.kills).greaterThanOrEqual(0); + expectTypeOf(data.cow.kills).toEqualTypeOf(); + expect(data.cow.assists).toBeDefined(); + expect(data.cow.assists).greaterThanOrEqual(0); + expectTypeOf(data.cow.assists).toEqualTypeOf(); + expect(data.cow.deaths).toBeDefined(); + expect(data.cow.deaths).greaterThanOrEqual(0); + expectTypeOf(data.cow.deaths).toEqualTypeOf(); + expect(data.cow.KDR).toBeDefined(); + expect(data.cow.KDR).greaterThanOrEqual(0); + expectTypeOf(data.cow.KDR).toEqualTypeOf(); + expect(data.cow.wins).toBeDefined(); + expect(data.cow.wins).greaterThanOrEqual(0); + expectTypeOf(data.cow.wins).toEqualTypeOf(); + expect(data.cow.losses).toBeDefined(); + expect(data.cow.losses).greaterThanOrEqual(0); + expectTypeOf(data.cow.losses).toEqualTypeOf(); + expect(data.cow.WLR).toBeDefined(); + expect(data.cow.WLR).greaterThanOrEqual(0); + expectTypeOf(data.cow.WLR).toEqualTypeOf(); + expect(data.cow.finalKills).toBeDefined(); + expect(data.cow.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.finalKills).toEqualTypeOf(); + expect(data.cow.finalAssists).toBeDefined(); + expect(data.cow.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.cow.finalAssists).toEqualTypeOf(); + expect(data.cow.finalDeaths).toBeDefined(); + expect(data.cow.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.cow.finalDeaths).toEqualTypeOf(); + expect(data.cow.FKDR).toBeDefined(); + expect(data.cow.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.cow.FKDR).toEqualTypeOf(); + expect(data.cow.playedGames).toBeDefined(); + expect(data.cow.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.cow.playedGames).toEqualTypeOf(); + expect(data.cow.witherDamage).toBeDefined(); + expect(data.cow.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.cow.witherDamage).toEqualTypeOf(); + expect(data.cow.defenderKills).toBeDefined(); + expect(data.cow.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.defenderKills).toEqualTypeOf(); + expect(data.cow.walked).toBeDefined(); + expect(data.cow.walked).greaterThanOrEqual(0); + expectTypeOf(data.cow.walked).toEqualTypeOf(); + expect(data.cow.blocksPlaced).toBeDefined(); + expect(data.cow.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.cow.blocksPlaced).toEqualTypeOf(); + expect(data.cow.blocksBroken).toBeDefined(); + expect(data.cow.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.cow.blocksBroken).toEqualTypeOf(); + expect(data.cow.meleeKills).toBeDefined(); + expect(data.cow.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.meleeKills).toEqualTypeOf(); + expect(data.cow.damageDealt).toBeDefined(); + expect(data.cow.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.cow.damageDealt).toEqualTypeOf(); + expect(data.cow.faceOff).toBeDefined(); + expectTypeOf(data.cow.faceOff).toEqualTypeOf(); + expect(data.cow.faceOff.kills).toBeDefined(); + expect(data.cow.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.kills).toEqualTypeOf(); + expect(data.cow.faceOff.assists).toBeDefined(); + expect(data.cow.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.assists).toEqualTypeOf(); + expect(data.cow.faceOff.deaths).toBeDefined(); + expect(data.cow.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.deaths).toEqualTypeOf(); + expect(data.cow.faceOff.KDR).toBeDefined(); + expect(data.cow.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.KDR).toEqualTypeOf(); + expect(data.cow.faceOff.wins).toBeDefined(); + expect(data.cow.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.wins).toEqualTypeOf(); + expect(data.cow.faceOff.losses).toBeDefined(); + expect(data.cow.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.losses).toEqualTypeOf(); + expect(data.cow.faceOff.WLR).toBeDefined(); + expect(data.cow.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.WLR).toEqualTypeOf(); + expect(data.cow.faceOff.finalKills).toBeDefined(); + expect(data.cow.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.finalKills).toEqualTypeOf(); + expect(data.cow.faceOff.finalAssists).toBeDefined(); + expect(data.cow.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.finalAssists).toEqualTypeOf(); + expect(data.cow.faceOff.finalDeaths).toBeDefined(); + expect(data.cow.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.cow.faceOff.FKDR).toBeDefined(); + expect(data.cow.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.FKDR).toEqualTypeOf(); + expect(data.cow.faceOff.playedGames).toBeDefined(); + expect(data.cow.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.playedGames).toEqualTypeOf(); + expect(data.cow.faceOff.witherDamage).toBeDefined(); + expect(data.cow.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.witherDamage).toEqualTypeOf(); + expect(data.cow.faceOff.defenderKills).toBeDefined(); + expect(data.cow.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.defenderKills).toEqualTypeOf(); + expect(data.cow.faceOff.walked).toBeDefined(); + expect(data.cow.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.walked).toEqualTypeOf(); + expect(data.cow.faceOff.blocksPlaced).toBeDefined(); + expect(data.cow.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.cow.faceOff.blocksBroken).toBeDefined(); + expect(data.cow.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.cow.faceOff.meleeKills).toBeDefined(); + expect(data.cow.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.meleeKills).toEqualTypeOf(); + expect(data.cow.faceOff.damageDealt).toBeDefined(); + expect(data.cow.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.cow.faceOff.damageDealt).toEqualTypeOf(); + expect(data.cow.casualBrawl).toBeDefined(); + expectTypeOf(data.cow.casualBrawl).toEqualTypeOf(); + expect(data.cow.casualBrawl.kills).toBeDefined(); + expect(data.cow.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.kills).toEqualTypeOf(); + expect(data.cow.casualBrawl.assists).toBeDefined(); + expect(data.cow.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.assists).toEqualTypeOf(); + expect(data.cow.casualBrawl.deaths).toBeDefined(); + expect(data.cow.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.deaths).toEqualTypeOf(); + expect(data.cow.casualBrawl.KDR).toBeDefined(); + expect(data.cow.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.KDR).toEqualTypeOf(); + expect(data.cow.casualBrawl.wins).toBeDefined(); + expect(data.cow.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.wins).toEqualTypeOf(); + expect(data.cow.casualBrawl.losses).toBeDefined(); + expect(data.cow.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.losses).toEqualTypeOf(); + expect(data.cow.casualBrawl.WLR).toBeDefined(); + expect(data.cow.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.WLR).toEqualTypeOf(); + expect(data.cow.casualBrawl.finalKills).toBeDefined(); + expect(data.cow.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.cow.casualBrawl.finalAssists).toBeDefined(); + expect(data.cow.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.cow.casualBrawl.finalDeaths).toBeDefined(); + expect(data.cow.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.cow.casualBrawl.FKDR).toBeDefined(); + expect(data.cow.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.cow.casualBrawl.playedGames).toBeDefined(); + expect(data.cow.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.cow.casualBrawl.witherDamage).toBeDefined(); + expect(data.cow.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.cow.casualBrawl.defenderKills).toBeDefined(); + expect(data.cow.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.cow.casualBrawl.walked).toBeDefined(); + expect(data.cow.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.walked).toEqualTypeOf(); + expect(data.cow.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.cow.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.cow.casualBrawl.blocksBroken).toBeDefined(); + expect(data.cow.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.cow.casualBrawl.meleeKills).toBeDefined(); + expect(data.cow.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.cow.casualBrawl.damageDealt).toBeDefined(); + expect(data.cow.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.cow.casualBrawl.damageDealt).toEqualTypeOf(); + + expect(data.hunter).toBeDefined(); + expectTypeOf(data.hunter).toEqualTypeOf(); + expect(data.hunter.kills).toBeDefined(); + expect(data.hunter.kills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.kills).toEqualTypeOf(); + expect(data.hunter.assists).toBeDefined(); + expect(data.hunter.assists).greaterThanOrEqual(0); + expectTypeOf(data.hunter.assists).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.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.finalKills).toBeDefined(); + expect(data.hunter.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.finalKills).toEqualTypeOf(); + expect(data.hunter.finalAssists).toBeDefined(); + expect(data.hunter.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.hunter.finalAssists).toEqualTypeOf(); + expect(data.hunter.finalDeaths).toBeDefined(); + expect(data.hunter.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.hunter.finalDeaths).toEqualTypeOf(); + expect(data.hunter.FKDR).toBeDefined(); + expect(data.hunter.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.FKDR).toEqualTypeOf(); + expect(data.hunter.playedGames).toBeDefined(); + expect(data.hunter.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.hunter.playedGames).toEqualTypeOf(); + expect(data.hunter.witherDamage).toBeDefined(); + expect(data.hunter.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.hunter.witherDamage).toEqualTypeOf(); + expect(data.hunter.defenderKills).toBeDefined(); + expect(data.hunter.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.defenderKills).toEqualTypeOf(); + expect(data.hunter.walked).toBeDefined(); + expect(data.hunter.walked).greaterThanOrEqual(0); + expectTypeOf(data.hunter.walked).toEqualTypeOf(); + expect(data.hunter.blocksPlaced).toBeDefined(); + expect(data.hunter.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.hunter.blocksPlaced).toEqualTypeOf(); + expect(data.hunter.blocksBroken).toBeDefined(); + expect(data.hunter.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.hunter.blocksBroken).toEqualTypeOf(); + expect(data.hunter.meleeKills).toBeDefined(); + expect(data.hunter.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.meleeKills).toEqualTypeOf(); + expect(data.hunter.damageDealt).toBeDefined(); + expect(data.hunter.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.hunter.damageDealt).toEqualTypeOf(); + expect(data.hunter.faceOff).toBeDefined(); + expectTypeOf(data.hunter.faceOff).toEqualTypeOf(); + expect(data.hunter.faceOff.kills).toBeDefined(); + expect(data.hunter.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.kills).toEqualTypeOf(); + expect(data.hunter.faceOff.assists).toBeDefined(); + expect(data.hunter.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.assists).toEqualTypeOf(); + expect(data.hunter.faceOff.deaths).toBeDefined(); + expect(data.hunter.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.deaths).toEqualTypeOf(); + expect(data.hunter.faceOff.KDR).toBeDefined(); + expect(data.hunter.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.KDR).toEqualTypeOf(); + expect(data.hunter.faceOff.wins).toBeDefined(); + expect(data.hunter.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.wins).toEqualTypeOf(); + expect(data.hunter.faceOff.losses).toBeDefined(); + expect(data.hunter.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.losses).toEqualTypeOf(); + expect(data.hunter.faceOff.WLR).toBeDefined(); + expect(data.hunter.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.WLR).toEqualTypeOf(); + expect(data.hunter.faceOff.finalKills).toBeDefined(); + expect(data.hunter.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.finalKills).toEqualTypeOf(); + expect(data.hunter.faceOff.finalAssists).toBeDefined(); + expect(data.hunter.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.finalAssists).toEqualTypeOf(); + expect(data.hunter.faceOff.finalDeaths).toBeDefined(); + expect(data.hunter.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.hunter.faceOff.FKDR).toBeDefined(); + expect(data.hunter.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.FKDR).toEqualTypeOf(); + expect(data.hunter.faceOff.playedGames).toBeDefined(); + expect(data.hunter.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.playedGames).toEqualTypeOf(); + expect(data.hunter.faceOff.witherDamage).toBeDefined(); + expect(data.hunter.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.witherDamage).toEqualTypeOf(); + expect(data.hunter.faceOff.defenderKills).toBeDefined(); + expect(data.hunter.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.defenderKills).toEqualTypeOf(); + expect(data.hunter.faceOff.walked).toBeDefined(); + expect(data.hunter.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.walked).toEqualTypeOf(); + expect(data.hunter.faceOff.blocksPlaced).toBeDefined(); + expect(data.hunter.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.hunter.faceOff.blocksBroken).toBeDefined(); + expect(data.hunter.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.hunter.faceOff.meleeKills).toBeDefined(); + expect(data.hunter.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.meleeKills).toEqualTypeOf(); + expect(data.hunter.faceOff.damageDealt).toBeDefined(); + expect(data.hunter.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.hunter.faceOff.damageDealt).toEqualTypeOf(); + expect(data.hunter.casualBrawl).toBeDefined(); + expectTypeOf(data.hunter.casualBrawl).toEqualTypeOf(); + expect(data.hunter.casualBrawl.kills).toBeDefined(); + expect(data.hunter.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.kills).toEqualTypeOf(); + expect(data.hunter.casualBrawl.assists).toBeDefined(); + expect(data.hunter.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.assists).toEqualTypeOf(); + expect(data.hunter.casualBrawl.deaths).toBeDefined(); + expect(data.hunter.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.deaths).toEqualTypeOf(); + expect(data.hunter.casualBrawl.KDR).toBeDefined(); + expect(data.hunter.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.KDR).toEqualTypeOf(); + expect(data.hunter.casualBrawl.wins).toBeDefined(); + expect(data.hunter.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.wins).toEqualTypeOf(); + expect(data.hunter.casualBrawl.losses).toBeDefined(); + expect(data.hunter.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.losses).toEqualTypeOf(); + expect(data.hunter.casualBrawl.WLR).toBeDefined(); + expect(data.hunter.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.WLR).toEqualTypeOf(); + expect(data.hunter.casualBrawl.finalKills).toBeDefined(); + expect(data.hunter.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.hunter.casualBrawl.finalAssists).toBeDefined(); + expect(data.hunter.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.hunter.casualBrawl.finalDeaths).toBeDefined(); + expect(data.hunter.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.hunter.casualBrawl.FKDR).toBeDefined(); + expect(data.hunter.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.hunter.casualBrawl.playedGames).toBeDefined(); + expect(data.hunter.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.hunter.casualBrawl.witherDamage).toBeDefined(); + expect(data.hunter.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.hunter.casualBrawl.defenderKills).toBeDefined(); + expect(data.hunter.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.hunter.casualBrawl.walked).toBeDefined(); + expect(data.hunter.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.walked).toEqualTypeOf(); + expect(data.hunter.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.hunter.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.hunter.casualBrawl.blocksBroken).toBeDefined(); + expect(data.hunter.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.hunter.casualBrawl.meleeKills).toBeDefined(); + expect(data.hunter.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.hunter.casualBrawl.damageDealt).toBeDefined(); + expect(data.hunter.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.hunter.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.shark).toBeDefined(); + expectTypeOf(data.shark).toEqualTypeOf(); + expect(data.shark.kills).toBeDefined(); + expect(data.shark.kills).greaterThanOrEqual(0); + expectTypeOf(data.shark.kills).toEqualTypeOf(); + expect(data.shark.assists).toBeDefined(); + expect(data.shark.assists).greaterThanOrEqual(0); + expectTypeOf(data.shark.assists).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.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.finalKills).toBeDefined(); + expect(data.shark.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.finalKills).toEqualTypeOf(); + expect(data.shark.finalAssists).toBeDefined(); + expect(data.shark.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.shark.finalAssists).toEqualTypeOf(); + expect(data.shark.finalDeaths).toBeDefined(); + expect(data.shark.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.shark.finalDeaths).toEqualTypeOf(); + expect(data.shark.FKDR).toBeDefined(); + expect(data.shark.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.shark.FKDR).toEqualTypeOf(); + expect(data.shark.playedGames).toBeDefined(); + expect(data.shark.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shark.playedGames).toEqualTypeOf(); + expect(data.shark.witherDamage).toBeDefined(); + expect(data.shark.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.shark.witherDamage).toEqualTypeOf(); + expect(data.shark.defenderKills).toBeDefined(); + expect(data.shark.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.defenderKills).toEqualTypeOf(); + expect(data.shark.walked).toBeDefined(); + expect(data.shark.walked).greaterThanOrEqual(0); + expectTypeOf(data.shark.walked).toEqualTypeOf(); + expect(data.shark.blocksPlaced).toBeDefined(); + expect(data.shark.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.shark.blocksPlaced).toEqualTypeOf(); + expect(data.shark.blocksBroken).toBeDefined(); + expect(data.shark.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.shark.blocksBroken).toEqualTypeOf(); + expect(data.shark.meleeKills).toBeDefined(); + expect(data.shark.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.meleeKills).toEqualTypeOf(); + expect(data.shark.damageDealt).toBeDefined(); + expect(data.shark.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.shark.damageDealt).toEqualTypeOf(); + expect(data.shark.faceOff).toBeDefined(); + expectTypeOf(data.shark.faceOff).toEqualTypeOf(); + expect(data.shark.faceOff.kills).toBeDefined(); + expect(data.shark.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.kills).toEqualTypeOf(); + expect(data.shark.faceOff.assists).toBeDefined(); + expect(data.shark.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.assists).toEqualTypeOf(); + expect(data.shark.faceOff.deaths).toBeDefined(); + expect(data.shark.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.deaths).toEqualTypeOf(); + expect(data.shark.faceOff.KDR).toBeDefined(); + expect(data.shark.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.KDR).toEqualTypeOf(); + expect(data.shark.faceOff.wins).toBeDefined(); + expect(data.shark.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.wins).toEqualTypeOf(); + expect(data.shark.faceOff.losses).toBeDefined(); + expect(data.shark.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.losses).toEqualTypeOf(); + expect(data.shark.faceOff.WLR).toBeDefined(); + expect(data.shark.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.WLR).toEqualTypeOf(); + expect(data.shark.faceOff.finalKills).toBeDefined(); + expect(data.shark.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.finalKills).toEqualTypeOf(); + expect(data.shark.faceOff.finalAssists).toBeDefined(); + expect(data.shark.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.finalAssists).toEqualTypeOf(); + expect(data.shark.faceOff.finalDeaths).toBeDefined(); + expect(data.shark.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.shark.faceOff.FKDR).toBeDefined(); + expect(data.shark.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.FKDR).toEqualTypeOf(); + expect(data.shark.faceOff.playedGames).toBeDefined(); + expect(data.shark.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.playedGames).toEqualTypeOf(); + expect(data.shark.faceOff.witherDamage).toBeDefined(); + expect(data.shark.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.witherDamage).toEqualTypeOf(); + expect(data.shark.faceOff.defenderKills).toBeDefined(); + expect(data.shark.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.defenderKills).toEqualTypeOf(); + expect(data.shark.faceOff.walked).toBeDefined(); + expect(data.shark.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.walked).toEqualTypeOf(); + expect(data.shark.faceOff.blocksPlaced).toBeDefined(); + expect(data.shark.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.shark.faceOff.blocksBroken).toBeDefined(); + expect(data.shark.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.shark.faceOff.meleeKills).toBeDefined(); + expect(data.shark.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.meleeKills).toEqualTypeOf(); + expect(data.shark.faceOff.damageDealt).toBeDefined(); + expect(data.shark.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.shark.faceOff.damageDealt).toEqualTypeOf(); + expect(data.shark.casualBrawl).toBeDefined(); + expectTypeOf(data.shark.casualBrawl).toEqualTypeOf(); + expect(data.shark.casualBrawl.kills).toBeDefined(); + expect(data.shark.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.kills).toEqualTypeOf(); + expect(data.shark.casualBrawl.assists).toBeDefined(); + expect(data.shark.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.assists).toEqualTypeOf(); + expect(data.shark.casualBrawl.deaths).toBeDefined(); + expect(data.shark.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.deaths).toEqualTypeOf(); + expect(data.shark.casualBrawl.KDR).toBeDefined(); + expect(data.shark.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.KDR).toEqualTypeOf(); + expect(data.shark.casualBrawl.wins).toBeDefined(); + expect(data.shark.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.wins).toEqualTypeOf(); + expect(data.shark.casualBrawl.losses).toBeDefined(); + expect(data.shark.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.losses).toEqualTypeOf(); + expect(data.shark.casualBrawl.WLR).toBeDefined(); + expect(data.shark.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.WLR).toEqualTypeOf(); + expect(data.shark.casualBrawl.finalKills).toBeDefined(); + expect(data.shark.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.shark.casualBrawl.finalAssists).toBeDefined(); + expect(data.shark.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.shark.casualBrawl.finalDeaths).toBeDefined(); + expect(data.shark.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.shark.casualBrawl.FKDR).toBeDefined(); + expect(data.shark.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.shark.casualBrawl.playedGames).toBeDefined(); + expect(data.shark.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.shark.casualBrawl.witherDamage).toBeDefined(); + expect(data.shark.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.shark.casualBrawl.defenderKills).toBeDefined(); + expect(data.shark.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.shark.casualBrawl.walked).toBeDefined(); + expect(data.shark.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.walked).toEqualTypeOf(); + expect(data.shark.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.shark.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.shark.casualBrawl.blocksBroken).toBeDefined(); + expect(data.shark.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.shark.casualBrawl.meleeKills).toBeDefined(); + expect(data.shark.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.shark.casualBrawl.damageDealt).toBeDefined(); + expect(data.shark.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.shark.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.arcanist).toBeDefined(); + expectTypeOf(data.arcanist).toEqualTypeOf(); + expect(data.arcanist.kills).toBeDefined(); + expect(data.arcanist.kills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.kills).toEqualTypeOf(); + expect(data.arcanist.assists).toBeDefined(); + expect(data.arcanist.assists).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.assists).toEqualTypeOf(); + expect(data.arcanist.deaths).toBeDefined(); + expect(data.arcanist.deaths).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.deaths).toEqualTypeOf(); + expect(data.arcanist.KDR).toBeDefined(); + expect(data.arcanist.KDR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.KDR).toEqualTypeOf(); + expect(data.arcanist.wins).toBeDefined(); + expect(data.arcanist.wins).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.wins).toEqualTypeOf(); + expect(data.arcanist.losses).toBeDefined(); + expect(data.arcanist.losses).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.losses).toEqualTypeOf(); + expect(data.arcanist.WLR).toBeDefined(); + expect(data.arcanist.WLR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.WLR).toEqualTypeOf(); + expect(data.arcanist.finalKills).toBeDefined(); + expect(data.arcanist.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.finalKills).toEqualTypeOf(); + expect(data.arcanist.finalAssists).toBeDefined(); + expect(data.arcanist.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.finalAssists).toEqualTypeOf(); + expect(data.arcanist.finalDeaths).toBeDefined(); + expect(data.arcanist.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.finalDeaths).toEqualTypeOf(); + expect(data.arcanist.FKDR).toBeDefined(); + expect(data.arcanist.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.FKDR).toEqualTypeOf(); + expect(data.arcanist.playedGames).toBeDefined(); + expect(data.arcanist.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.playedGames).toEqualTypeOf(); + expect(data.arcanist.witherDamage).toBeDefined(); + expect(data.arcanist.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.witherDamage).toEqualTypeOf(); + expect(data.arcanist.defenderKills).toBeDefined(); + expect(data.arcanist.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.defenderKills).toEqualTypeOf(); + expect(data.arcanist.walked).toBeDefined(); + expect(data.arcanist.walked).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.walked).toEqualTypeOf(); + expect(data.arcanist.blocksPlaced).toBeDefined(); + expect(data.arcanist.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.blocksPlaced).toEqualTypeOf(); + expect(data.arcanist.blocksBroken).toBeDefined(); + expect(data.arcanist.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.blocksBroken).toEqualTypeOf(); + expect(data.arcanist.meleeKills).toBeDefined(); + expect(data.arcanist.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.meleeKills).toEqualTypeOf(); + expect(data.arcanist.damageDealt).toBeDefined(); + expect(data.arcanist.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.damageDealt).toEqualTypeOf(); + expect(data.arcanist.faceOff).toBeDefined(); + expectTypeOf(data.arcanist.faceOff).toEqualTypeOf(); + expect(data.arcanist.faceOff.kills).toBeDefined(); + expect(data.arcanist.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.kills).toEqualTypeOf(); + expect(data.arcanist.faceOff.assists).toBeDefined(); + expect(data.arcanist.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.assists).toEqualTypeOf(); + expect(data.arcanist.faceOff.deaths).toBeDefined(); + expect(data.arcanist.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.deaths).toEqualTypeOf(); + expect(data.arcanist.faceOff.KDR).toBeDefined(); + expect(data.arcanist.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.KDR).toEqualTypeOf(); + expect(data.arcanist.faceOff.wins).toBeDefined(); + expect(data.arcanist.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.wins).toEqualTypeOf(); + expect(data.arcanist.faceOff.losses).toBeDefined(); + expect(data.arcanist.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.losses).toEqualTypeOf(); + expect(data.arcanist.faceOff.WLR).toBeDefined(); + expect(data.arcanist.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.WLR).toEqualTypeOf(); + expect(data.arcanist.faceOff.finalKills).toBeDefined(); + expect(data.arcanist.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.finalKills).toEqualTypeOf(); + expect(data.arcanist.faceOff.finalAssists).toBeDefined(); + expect(data.arcanist.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.finalAssists).toEqualTypeOf(); + expect(data.arcanist.faceOff.finalDeaths).toBeDefined(); + expect(data.arcanist.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.arcanist.faceOff.FKDR).toBeDefined(); + expect(data.arcanist.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.FKDR).toEqualTypeOf(); + expect(data.arcanist.faceOff.playedGames).toBeDefined(); + expect(data.arcanist.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.playedGames).toEqualTypeOf(); + expect(data.arcanist.faceOff.witherDamage).toBeDefined(); + expect(data.arcanist.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.witherDamage).toEqualTypeOf(); + expect(data.arcanist.faceOff.defenderKills).toBeDefined(); + expect(data.arcanist.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.defenderKills).toEqualTypeOf(); + expect(data.arcanist.faceOff.walked).toBeDefined(); + expect(data.arcanist.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.walked).toEqualTypeOf(); + expect(data.arcanist.faceOff.blocksPlaced).toBeDefined(); + expect(data.arcanist.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.arcanist.faceOff.blocksBroken).toBeDefined(); + expect(data.arcanist.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.arcanist.faceOff.meleeKills).toBeDefined(); + expect(data.arcanist.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.meleeKills).toEqualTypeOf(); + expect(data.arcanist.faceOff.damageDealt).toBeDefined(); + expect(data.arcanist.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.faceOff.damageDealt).toEqualTypeOf(); + expect(data.arcanist.casualBrawl).toBeDefined(); + expectTypeOf(data.arcanist.casualBrawl).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.kills).toBeDefined(); + expect(data.arcanist.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.kills).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.assists).toBeDefined(); + expect(data.arcanist.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.assists).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.deaths).toBeDefined(); + expect(data.arcanist.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.deaths).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.KDR).toBeDefined(); + expect(data.arcanist.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.KDR).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.wins).toBeDefined(); + expect(data.arcanist.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.wins).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.losses).toBeDefined(); + expect(data.arcanist.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.losses).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.WLR).toBeDefined(); + expect(data.arcanist.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.WLR).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.finalKills).toBeDefined(); + expect(data.arcanist.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.finalAssists).toBeDefined(); + expect(data.arcanist.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.finalDeaths).toBeDefined(); + expect(data.arcanist.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.FKDR).toBeDefined(); + expect(data.arcanist.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.playedGames).toBeDefined(); + expect(data.arcanist.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.witherDamage).toBeDefined(); + expect(data.arcanist.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.defenderKills).toBeDefined(); + expect(data.arcanist.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.walked).toBeDefined(); + expect(data.arcanist.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.walked).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.arcanist.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.blocksBroken).toBeDefined(); + expect(data.arcanist.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.meleeKills).toBeDefined(); + expect(data.arcanist.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.arcanist.casualBrawl.damageDealt).toBeDefined(); + expect(data.arcanist.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.arcanist.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.deadlord).toBeDefined(); + expectTypeOf(data.deadlord).toEqualTypeOf(); + expect(data.deadlord.kills).toBeDefined(); + expect(data.deadlord.kills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.kills).toEqualTypeOf(); + expect(data.deadlord.assists).toBeDefined(); + expect(data.deadlord.assists).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.assists).toEqualTypeOf(); + expect(data.deadlord.deaths).toBeDefined(); + expect(data.deadlord.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.deaths).toEqualTypeOf(); + expect(data.deadlord.KDR).toBeDefined(); + expect(data.deadlord.KDR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.KDR).toEqualTypeOf(); + expect(data.deadlord.wins).toBeDefined(); + expect(data.deadlord.wins).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.wins).toEqualTypeOf(); + expect(data.deadlord.losses).toBeDefined(); + expect(data.deadlord.losses).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.losses).toEqualTypeOf(); + expect(data.deadlord.WLR).toBeDefined(); + expect(data.deadlord.WLR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.WLR).toEqualTypeOf(); + expect(data.deadlord.finalKills).toBeDefined(); + expect(data.deadlord.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.finalKills).toEqualTypeOf(); + expect(data.deadlord.finalAssists).toBeDefined(); + expect(data.deadlord.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.finalAssists).toEqualTypeOf(); + expect(data.deadlord.finalDeaths).toBeDefined(); + expect(data.deadlord.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.finalDeaths).toEqualTypeOf(); + expect(data.deadlord.FKDR).toBeDefined(); + expect(data.deadlord.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.FKDR).toEqualTypeOf(); + expect(data.deadlord.playedGames).toBeDefined(); + expect(data.deadlord.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.playedGames).toEqualTypeOf(); + expect(data.deadlord.witherDamage).toBeDefined(); + expect(data.deadlord.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.witherDamage).toEqualTypeOf(); + expect(data.deadlord.defenderKills).toBeDefined(); + expect(data.deadlord.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.defenderKills).toEqualTypeOf(); + expect(data.deadlord.walked).toBeDefined(); + expect(data.deadlord.walked).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.walked).toEqualTypeOf(); + expect(data.deadlord.blocksPlaced).toBeDefined(); + expect(data.deadlord.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.blocksPlaced).toEqualTypeOf(); + expect(data.deadlord.blocksBroken).toBeDefined(); + expect(data.deadlord.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.blocksBroken).toEqualTypeOf(); + expect(data.deadlord.meleeKills).toBeDefined(); + expect(data.deadlord.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.meleeKills).toEqualTypeOf(); + expect(data.deadlord.damageDealt).toBeDefined(); + expect(data.deadlord.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.damageDealt).toEqualTypeOf(); + expect(data.deadlord.faceOff).toBeDefined(); + expectTypeOf(data.deadlord.faceOff).toEqualTypeOf(); + expect(data.deadlord.faceOff.kills).toBeDefined(); + expect(data.deadlord.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.kills).toEqualTypeOf(); + expect(data.deadlord.faceOff.assists).toBeDefined(); + expect(data.deadlord.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.assists).toEqualTypeOf(); + expect(data.deadlord.faceOff.deaths).toBeDefined(); + expect(data.deadlord.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.deaths).toEqualTypeOf(); + expect(data.deadlord.faceOff.KDR).toBeDefined(); + expect(data.deadlord.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.KDR).toEqualTypeOf(); + expect(data.deadlord.faceOff.wins).toBeDefined(); + expect(data.deadlord.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.wins).toEqualTypeOf(); + expect(data.deadlord.faceOff.losses).toBeDefined(); + expect(data.deadlord.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.losses).toEqualTypeOf(); + expect(data.deadlord.faceOff.WLR).toBeDefined(); + expect(data.deadlord.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.WLR).toEqualTypeOf(); + expect(data.deadlord.faceOff.finalKills).toBeDefined(); + expect(data.deadlord.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.finalKills).toEqualTypeOf(); + expect(data.deadlord.faceOff.finalAssists).toBeDefined(); + expect(data.deadlord.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.finalAssists).toEqualTypeOf(); + expect(data.deadlord.faceOff.finalDeaths).toBeDefined(); + expect(data.deadlord.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.deadlord.faceOff.FKDR).toBeDefined(); + expect(data.deadlord.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.FKDR).toEqualTypeOf(); + expect(data.deadlord.faceOff.playedGames).toBeDefined(); + expect(data.deadlord.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.playedGames).toEqualTypeOf(); + expect(data.deadlord.faceOff.witherDamage).toBeDefined(); + expect(data.deadlord.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.witherDamage).toEqualTypeOf(); + expect(data.deadlord.faceOff.defenderKills).toBeDefined(); + expect(data.deadlord.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.defenderKills).toEqualTypeOf(); + expect(data.deadlord.faceOff.walked).toBeDefined(); + expect(data.deadlord.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.walked).toEqualTypeOf(); + expect(data.deadlord.faceOff.blocksPlaced).toBeDefined(); + expect(data.deadlord.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.deadlord.faceOff.blocksBroken).toBeDefined(); + expect(data.deadlord.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.deadlord.faceOff.meleeKills).toBeDefined(); + expect(data.deadlord.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.meleeKills).toEqualTypeOf(); + expect(data.deadlord.faceOff.damageDealt).toBeDefined(); + expect(data.deadlord.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.faceOff.damageDealt).toEqualTypeOf(); + expect(data.deadlord.casualBrawl).toBeDefined(); + expectTypeOf(data.deadlord.casualBrawl).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.kills).toBeDefined(); + expect(data.deadlord.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.kills).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.assists).toBeDefined(); + expect(data.deadlord.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.assists).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.deaths).toBeDefined(); + expect(data.deadlord.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.deaths).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.KDR).toBeDefined(); + expect(data.deadlord.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.KDR).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.wins).toBeDefined(); + expect(data.deadlord.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.wins).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.losses).toBeDefined(); + expect(data.deadlord.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.losses).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.WLR).toBeDefined(); + expect(data.deadlord.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.WLR).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.finalKills).toBeDefined(); + expect(data.deadlord.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.finalAssists).toBeDefined(); + expect(data.deadlord.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.finalDeaths).toBeDefined(); + expect(data.deadlord.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.FKDR).toBeDefined(); + expect(data.deadlord.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.playedGames).toBeDefined(); + expect(data.deadlord.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.witherDamage).toBeDefined(); + expect(data.deadlord.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.defenderKills).toBeDefined(); + expect(data.deadlord.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.walked).toBeDefined(); + expect(data.deadlord.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.walked).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.deadlord.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.blocksBroken).toBeDefined(); + expect(data.deadlord.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.meleeKills).toBeDefined(); + expect(data.deadlord.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.deadlord.casualBrawl.damageDealt).toBeDefined(); + expect(data.deadlord.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.deadlord.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.golem).toBeDefined(); + expectTypeOf(data.golem).toEqualTypeOf(); + expect(data.golem.kills).toBeDefined(); + expect(data.golem.kills).greaterThanOrEqual(0); + expectTypeOf(data.golem.kills).toEqualTypeOf(); + expect(data.golem.assists).toBeDefined(); + expect(data.golem.assists).greaterThanOrEqual(0); + expectTypeOf(data.golem.assists).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.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.finalKills).toBeDefined(); + expect(data.golem.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.finalKills).toEqualTypeOf(); + expect(data.golem.finalAssists).toBeDefined(); + expect(data.golem.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.golem.finalAssists).toEqualTypeOf(); + expect(data.golem.finalDeaths).toBeDefined(); + expect(data.golem.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.golem.finalDeaths).toEqualTypeOf(); + expect(data.golem.FKDR).toBeDefined(); + expect(data.golem.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.golem.FKDR).toEqualTypeOf(); + expect(data.golem.playedGames).toBeDefined(); + expect(data.golem.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.golem.playedGames).toEqualTypeOf(); + expect(data.golem.witherDamage).toBeDefined(); + expect(data.golem.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.golem.witherDamage).toEqualTypeOf(); + expect(data.golem.defenderKills).toBeDefined(); + expect(data.golem.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.defenderKills).toEqualTypeOf(); + expect(data.golem.walked).toBeDefined(); + expect(data.golem.walked).greaterThanOrEqual(0); + expectTypeOf(data.golem.walked).toEqualTypeOf(); + expect(data.golem.blocksPlaced).toBeDefined(); + expect(data.golem.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.golem.blocksPlaced).toEqualTypeOf(); + expect(data.golem.blocksBroken).toBeDefined(); + expect(data.golem.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.golem.blocksBroken).toEqualTypeOf(); + expect(data.golem.meleeKills).toBeDefined(); + expect(data.golem.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.meleeKills).toEqualTypeOf(); + expect(data.golem.damageDealt).toBeDefined(); + expect(data.golem.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.golem.damageDealt).toEqualTypeOf(); + expect(data.golem.faceOff).toBeDefined(); + expectTypeOf(data.golem.faceOff).toEqualTypeOf(); + expect(data.golem.faceOff.kills).toBeDefined(); + expect(data.golem.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.kills).toEqualTypeOf(); + expect(data.golem.faceOff.assists).toBeDefined(); + expect(data.golem.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.assists).toEqualTypeOf(); + expect(data.golem.faceOff.deaths).toBeDefined(); + expect(data.golem.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.deaths).toEqualTypeOf(); + expect(data.golem.faceOff.KDR).toBeDefined(); + expect(data.golem.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.KDR).toEqualTypeOf(); + expect(data.golem.faceOff.wins).toBeDefined(); + expect(data.golem.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.wins).toEqualTypeOf(); + expect(data.golem.faceOff.losses).toBeDefined(); + expect(data.golem.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.losses).toEqualTypeOf(); + expect(data.golem.faceOff.WLR).toBeDefined(); + expect(data.golem.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.WLR).toEqualTypeOf(); + expect(data.golem.faceOff.finalKills).toBeDefined(); + expect(data.golem.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.finalKills).toEqualTypeOf(); + expect(data.golem.faceOff.finalAssists).toBeDefined(); + expect(data.golem.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.finalAssists).toEqualTypeOf(); + expect(data.golem.faceOff.finalDeaths).toBeDefined(); + expect(data.golem.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.golem.faceOff.FKDR).toBeDefined(); + expect(data.golem.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.FKDR).toEqualTypeOf(); + expect(data.golem.faceOff.playedGames).toBeDefined(); + expect(data.golem.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.playedGames).toEqualTypeOf(); + expect(data.golem.faceOff.witherDamage).toBeDefined(); + expect(data.golem.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.witherDamage).toEqualTypeOf(); + expect(data.golem.faceOff.defenderKills).toBeDefined(); + expect(data.golem.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.defenderKills).toEqualTypeOf(); + expect(data.golem.faceOff.walked).toBeDefined(); + expect(data.golem.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.walked).toEqualTypeOf(); + expect(data.golem.faceOff.blocksPlaced).toBeDefined(); + expect(data.golem.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.golem.faceOff.blocksBroken).toBeDefined(); + expect(data.golem.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.golem.faceOff.meleeKills).toBeDefined(); + expect(data.golem.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.meleeKills).toEqualTypeOf(); + expect(data.golem.faceOff.damageDealt).toBeDefined(); + expect(data.golem.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.golem.faceOff.damageDealt).toEqualTypeOf(); + expect(data.golem.casualBrawl).toBeDefined(); + expectTypeOf(data.golem.casualBrawl).toEqualTypeOf(); + expect(data.golem.casualBrawl.kills).toBeDefined(); + expect(data.golem.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.kills).toEqualTypeOf(); + expect(data.golem.casualBrawl.assists).toBeDefined(); + expect(data.golem.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.assists).toEqualTypeOf(); + expect(data.golem.casualBrawl.deaths).toBeDefined(); + expect(data.golem.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.deaths).toEqualTypeOf(); + expect(data.golem.casualBrawl.KDR).toBeDefined(); + expect(data.golem.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.KDR).toEqualTypeOf(); + expect(data.golem.casualBrawl.wins).toBeDefined(); + expect(data.golem.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.wins).toEqualTypeOf(); + expect(data.golem.casualBrawl.losses).toBeDefined(); + expect(data.golem.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.losses).toEqualTypeOf(); + expect(data.golem.casualBrawl.WLR).toBeDefined(); + expect(data.golem.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.WLR).toEqualTypeOf(); + expect(data.golem.casualBrawl.finalKills).toBeDefined(); + expect(data.golem.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.golem.casualBrawl.finalAssists).toBeDefined(); + expect(data.golem.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.golem.casualBrawl.finalDeaths).toBeDefined(); + expect(data.golem.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.golem.casualBrawl.FKDR).toBeDefined(); + expect(data.golem.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.golem.casualBrawl.playedGames).toBeDefined(); + expect(data.golem.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.golem.casualBrawl.witherDamage).toBeDefined(); + expect(data.golem.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.golem.casualBrawl.defenderKills).toBeDefined(); + expect(data.golem.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.golem.casualBrawl.walked).toBeDefined(); + expect(data.golem.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.walked).toEqualTypeOf(); + expect(data.golem.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.golem.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.golem.casualBrawl.blocksBroken).toBeDefined(); + expect(data.golem.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.golem.casualBrawl.meleeKills).toBeDefined(); + expect(data.golem.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.golem.casualBrawl.damageDealt).toBeDefined(); + expect(data.golem.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.golem.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.herobrine).toBeDefined(); + expectTypeOf(data.herobrine).toEqualTypeOf(); + expect(data.herobrine.kills).toBeDefined(); + expect(data.herobrine.kills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.kills).toEqualTypeOf(); + expect(data.herobrine.assists).toBeDefined(); + expect(data.herobrine.assists).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.assists).toEqualTypeOf(); + expect(data.herobrine.deaths).toBeDefined(); + expect(data.herobrine.deaths).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.deaths).toEqualTypeOf(); + expect(data.herobrine.KDR).toBeDefined(); + expect(data.herobrine.KDR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.KDR).toEqualTypeOf(); + expect(data.herobrine.wins).toBeDefined(); + expect(data.herobrine.wins).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.wins).toEqualTypeOf(); + expect(data.herobrine.losses).toBeDefined(); + expect(data.herobrine.losses).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.losses).toEqualTypeOf(); + expect(data.herobrine.WLR).toBeDefined(); + expect(data.herobrine.WLR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.WLR).toEqualTypeOf(); + expect(data.herobrine.finalKills).toBeDefined(); + expect(data.herobrine.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.finalKills).toEqualTypeOf(); + expect(data.herobrine.finalAssists).toBeDefined(); + expect(data.herobrine.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.finalAssists).toEqualTypeOf(); + expect(data.herobrine.finalDeaths).toBeDefined(); + expect(data.herobrine.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.finalDeaths).toEqualTypeOf(); + expect(data.herobrine.FKDR).toBeDefined(); + expect(data.herobrine.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.FKDR).toEqualTypeOf(); + expect(data.herobrine.playedGames).toBeDefined(); + expect(data.herobrine.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.playedGames).toEqualTypeOf(); + expect(data.herobrine.witherDamage).toBeDefined(); + expect(data.herobrine.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.witherDamage).toEqualTypeOf(); + expect(data.herobrine.defenderKills).toBeDefined(); + expect(data.herobrine.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.defenderKills).toEqualTypeOf(); + expect(data.herobrine.walked).toBeDefined(); + expect(data.herobrine.walked).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.walked).toEqualTypeOf(); + expect(data.herobrine.blocksPlaced).toBeDefined(); + expect(data.herobrine.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.blocksPlaced).toEqualTypeOf(); + expect(data.herobrine.blocksBroken).toBeDefined(); + expect(data.herobrine.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.blocksBroken).toEqualTypeOf(); + expect(data.herobrine.meleeKills).toBeDefined(); + expect(data.herobrine.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.meleeKills).toEqualTypeOf(); + expect(data.herobrine.damageDealt).toBeDefined(); + expect(data.herobrine.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.damageDealt).toEqualTypeOf(); + expect(data.herobrine.faceOff).toBeDefined(); + expectTypeOf(data.herobrine.faceOff).toEqualTypeOf(); + expect(data.herobrine.faceOff.kills).toBeDefined(); + expect(data.herobrine.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.kills).toEqualTypeOf(); + expect(data.herobrine.faceOff.assists).toBeDefined(); + expect(data.herobrine.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.assists).toEqualTypeOf(); + expect(data.herobrine.faceOff.deaths).toBeDefined(); + expect(data.herobrine.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.deaths).toEqualTypeOf(); + expect(data.herobrine.faceOff.KDR).toBeDefined(); + expect(data.herobrine.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.KDR).toEqualTypeOf(); + expect(data.herobrine.faceOff.wins).toBeDefined(); + expect(data.herobrine.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.wins).toEqualTypeOf(); + expect(data.herobrine.faceOff.losses).toBeDefined(); + expect(data.herobrine.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.losses).toEqualTypeOf(); + expect(data.herobrine.faceOff.WLR).toBeDefined(); + expect(data.herobrine.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.WLR).toEqualTypeOf(); + expect(data.herobrine.faceOff.finalKills).toBeDefined(); + expect(data.herobrine.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.finalKills).toEqualTypeOf(); + expect(data.herobrine.faceOff.finalAssists).toBeDefined(); + expect(data.herobrine.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.finalAssists).toEqualTypeOf(); + expect(data.herobrine.faceOff.finalDeaths).toBeDefined(); + expect(data.herobrine.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.herobrine.faceOff.FKDR).toBeDefined(); + expect(data.herobrine.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.FKDR).toEqualTypeOf(); + expect(data.herobrine.faceOff.playedGames).toBeDefined(); + expect(data.herobrine.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.playedGames).toEqualTypeOf(); + expect(data.herobrine.faceOff.witherDamage).toBeDefined(); + expect(data.herobrine.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.witherDamage).toEqualTypeOf(); + expect(data.herobrine.faceOff.defenderKills).toBeDefined(); + expect(data.herobrine.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.defenderKills).toEqualTypeOf(); + expect(data.herobrine.faceOff.walked).toBeDefined(); + expect(data.herobrine.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.walked).toEqualTypeOf(); + expect(data.herobrine.faceOff.blocksPlaced).toBeDefined(); + expect(data.herobrine.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.herobrine.faceOff.blocksBroken).toBeDefined(); + expect(data.herobrine.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.herobrine.faceOff.meleeKills).toBeDefined(); + expect(data.herobrine.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.meleeKills).toEqualTypeOf(); + expect(data.herobrine.faceOff.damageDealt).toBeDefined(); + expect(data.herobrine.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.faceOff.damageDealt).toEqualTypeOf(); + expect(data.herobrine.casualBrawl).toBeDefined(); + expectTypeOf(data.herobrine.casualBrawl).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.kills).toBeDefined(); + expect(data.herobrine.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.kills).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.assists).toBeDefined(); + expect(data.herobrine.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.assists).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.deaths).toBeDefined(); + expect(data.herobrine.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.deaths).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.KDR).toBeDefined(); + expect(data.herobrine.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.KDR).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.wins).toBeDefined(); + expect(data.herobrine.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.wins).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.losses).toBeDefined(); + expect(data.herobrine.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.losses).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.WLR).toBeDefined(); + expect(data.herobrine.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.WLR).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.finalKills).toBeDefined(); + expect(data.herobrine.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.finalAssists).toBeDefined(); + expect(data.herobrine.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.finalDeaths).toBeDefined(); + expect(data.herobrine.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.FKDR).toBeDefined(); + expect(data.herobrine.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.playedGames).toBeDefined(); + expect(data.herobrine.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.witherDamage).toBeDefined(); + expect(data.herobrine.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.defenderKills).toBeDefined(); + expect(data.herobrine.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.walked).toBeDefined(); + expect(data.herobrine.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.walked).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.herobrine.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.blocksBroken).toBeDefined(); + expect(data.herobrine.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.meleeKills).toBeDefined(); + expect(data.herobrine.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.herobrine.casualBrawl.damageDealt).toBeDefined(); + expect(data.herobrine.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.herobrine.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.pigman).toBeDefined(); + expectTypeOf(data.pigman).toEqualTypeOf(); + expect(data.pigman.kills).toBeDefined(); + expect(data.pigman.kills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.kills).toEqualTypeOf(); + expect(data.pigman.assists).toBeDefined(); + expect(data.pigman.assists).greaterThanOrEqual(0); + expectTypeOf(data.pigman.assists).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.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.finalKills).toBeDefined(); + expect(data.pigman.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.finalKills).toEqualTypeOf(); + expect(data.pigman.finalAssists).toBeDefined(); + expect(data.pigman.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.pigman.finalAssists).toEqualTypeOf(); + expect(data.pigman.finalDeaths).toBeDefined(); + expect(data.pigman.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.pigman.finalDeaths).toEqualTypeOf(); + expect(data.pigman.FKDR).toBeDefined(); + expect(data.pigman.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.FKDR).toEqualTypeOf(); + expect(data.pigman.playedGames).toBeDefined(); + expect(data.pigman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pigman.playedGames).toEqualTypeOf(); + expect(data.pigman.witherDamage).toBeDefined(); + expect(data.pigman.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.pigman.witherDamage).toEqualTypeOf(); + expect(data.pigman.defenderKills).toBeDefined(); + expect(data.pigman.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.defenderKills).toEqualTypeOf(); + expect(data.pigman.walked).toBeDefined(); + expect(data.pigman.walked).greaterThanOrEqual(0); + expectTypeOf(data.pigman.walked).toEqualTypeOf(); + expect(data.pigman.blocksPlaced).toBeDefined(); + expect(data.pigman.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.pigman.blocksPlaced).toEqualTypeOf(); + expect(data.pigman.blocksBroken).toBeDefined(); + expect(data.pigman.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.pigman.blocksBroken).toEqualTypeOf(); + expect(data.pigman.meleeKills).toBeDefined(); + expect(data.pigman.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.meleeKills).toEqualTypeOf(); + expect(data.pigman.damageDealt).toBeDefined(); + expect(data.pigman.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.pigman.damageDealt).toEqualTypeOf(); + expect(data.pigman.faceOff).toBeDefined(); + expectTypeOf(data.pigman.faceOff).toEqualTypeOf(); + expect(data.pigman.faceOff.kills).toBeDefined(); + expect(data.pigman.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.kills).toEqualTypeOf(); + expect(data.pigman.faceOff.assists).toBeDefined(); + expect(data.pigman.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.assists).toEqualTypeOf(); + expect(data.pigman.faceOff.deaths).toBeDefined(); + expect(data.pigman.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.deaths).toEqualTypeOf(); + expect(data.pigman.faceOff.KDR).toBeDefined(); + expect(data.pigman.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.KDR).toEqualTypeOf(); + expect(data.pigman.faceOff.wins).toBeDefined(); + expect(data.pigman.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.wins).toEqualTypeOf(); + expect(data.pigman.faceOff.losses).toBeDefined(); + expect(data.pigman.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.losses).toEqualTypeOf(); + expect(data.pigman.faceOff.WLR).toBeDefined(); + expect(data.pigman.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.WLR).toEqualTypeOf(); + expect(data.pigman.faceOff.finalKills).toBeDefined(); + expect(data.pigman.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.finalKills).toEqualTypeOf(); + expect(data.pigman.faceOff.finalAssists).toBeDefined(); + expect(data.pigman.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.finalAssists).toEqualTypeOf(); + expect(data.pigman.faceOff.finalDeaths).toBeDefined(); + expect(data.pigman.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.pigman.faceOff.FKDR).toBeDefined(); + expect(data.pigman.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.FKDR).toEqualTypeOf(); + expect(data.pigman.faceOff.playedGames).toBeDefined(); + expect(data.pigman.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.playedGames).toEqualTypeOf(); + expect(data.pigman.faceOff.witherDamage).toBeDefined(); + expect(data.pigman.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.witherDamage).toEqualTypeOf(); + expect(data.pigman.faceOff.defenderKills).toBeDefined(); + expect(data.pigman.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.defenderKills).toEqualTypeOf(); + expect(data.pigman.faceOff.walked).toBeDefined(); + expect(data.pigman.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.walked).toEqualTypeOf(); + expect(data.pigman.faceOff.blocksPlaced).toBeDefined(); + expect(data.pigman.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.pigman.faceOff.blocksBroken).toBeDefined(); + expect(data.pigman.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.pigman.faceOff.meleeKills).toBeDefined(); + expect(data.pigman.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.meleeKills).toEqualTypeOf(); + expect(data.pigman.faceOff.damageDealt).toBeDefined(); + expect(data.pigman.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.pigman.faceOff.damageDealt).toEqualTypeOf(); + expect(data.pigman.casualBrawl).toBeDefined(); + expectTypeOf(data.pigman.casualBrawl).toEqualTypeOf(); + expect(data.pigman.casualBrawl.kills).toBeDefined(); + expect(data.pigman.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.kills).toEqualTypeOf(); + expect(data.pigman.casualBrawl.assists).toBeDefined(); + expect(data.pigman.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.assists).toEqualTypeOf(); + expect(data.pigman.casualBrawl.deaths).toBeDefined(); + expect(data.pigman.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.deaths).toEqualTypeOf(); + expect(data.pigman.casualBrawl.KDR).toBeDefined(); + expect(data.pigman.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.KDR).toEqualTypeOf(); + expect(data.pigman.casualBrawl.wins).toBeDefined(); + expect(data.pigman.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.wins).toEqualTypeOf(); + expect(data.pigman.casualBrawl.losses).toBeDefined(); + expect(data.pigman.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.losses).toEqualTypeOf(); + expect(data.pigman.casualBrawl.WLR).toBeDefined(); + expect(data.pigman.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.WLR).toEqualTypeOf(); + expect(data.pigman.casualBrawl.finalKills).toBeDefined(); + expect(data.pigman.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.pigman.casualBrawl.finalAssists).toBeDefined(); + expect(data.pigman.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.pigman.casualBrawl.finalDeaths).toBeDefined(); + expect(data.pigman.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.pigman.casualBrawl.FKDR).toBeDefined(); + expect(data.pigman.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.pigman.casualBrawl.playedGames).toBeDefined(); + expect(data.pigman.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.pigman.casualBrawl.witherDamage).toBeDefined(); + expect(data.pigman.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.pigman.casualBrawl.defenderKills).toBeDefined(); + expect(data.pigman.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.pigman.casualBrawl.walked).toBeDefined(); + expect(data.pigman.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.walked).toEqualTypeOf(); + expect(data.pigman.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.pigman.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.pigman.casualBrawl.blocksBroken).toBeDefined(); + expect(data.pigman.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.pigman.casualBrawl.meleeKills).toBeDefined(); + expect(data.pigman.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.pigman.casualBrawl.damageDealt).toBeDefined(); + expect(data.pigman.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.pigman.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.zombie).toBeDefined(); + expectTypeOf(data.zombie).toEqualTypeOf(); + expect(data.zombie.kills).toBeDefined(); + expect(data.zombie.kills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.kills).toEqualTypeOf(); + expect(data.zombie.assists).toBeDefined(); + expect(data.zombie.assists).greaterThanOrEqual(0); + expectTypeOf(data.zombie.assists).toEqualTypeOf(); + expect(data.zombie.deaths).toBeDefined(); + expect(data.zombie.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombie.deaths).toEqualTypeOf(); + expect(data.zombie.KDR).toBeDefined(); + expect(data.zombie.KDR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.KDR).toEqualTypeOf(); + expect(data.zombie.wins).toBeDefined(); + expect(data.zombie.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombie.wins).toEqualTypeOf(); + expect(data.zombie.losses).toBeDefined(); + expect(data.zombie.losses).greaterThanOrEqual(0); + expectTypeOf(data.zombie.losses).toEqualTypeOf(); + expect(data.zombie.WLR).toBeDefined(); + expect(data.zombie.WLR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.WLR).toEqualTypeOf(); + expect(data.zombie.finalKills).toBeDefined(); + expect(data.zombie.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.finalKills).toEqualTypeOf(); + expect(data.zombie.finalAssists).toBeDefined(); + expect(data.zombie.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.zombie.finalAssists).toEqualTypeOf(); + expect(data.zombie.finalDeaths).toBeDefined(); + expect(data.zombie.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.zombie.finalDeaths).toEqualTypeOf(); + expect(data.zombie.FKDR).toBeDefined(); + expect(data.zombie.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.FKDR).toEqualTypeOf(); + expect(data.zombie.playedGames).toBeDefined(); + expect(data.zombie.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.zombie.playedGames).toEqualTypeOf(); + expect(data.zombie.witherDamage).toBeDefined(); + expect(data.zombie.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.zombie.witherDamage).toEqualTypeOf(); + expect(data.zombie.defenderKills).toBeDefined(); + expect(data.zombie.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.defenderKills).toEqualTypeOf(); + expect(data.zombie.walked).toBeDefined(); + expect(data.zombie.walked).greaterThanOrEqual(0); + expectTypeOf(data.zombie.walked).toEqualTypeOf(); + expect(data.zombie.blocksPlaced).toBeDefined(); + expect(data.zombie.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.zombie.blocksPlaced).toEqualTypeOf(); + expect(data.zombie.blocksBroken).toBeDefined(); + expect(data.zombie.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.zombie.blocksBroken).toEqualTypeOf(); + expect(data.zombie.meleeKills).toBeDefined(); + expect(data.zombie.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.meleeKills).toEqualTypeOf(); + expect(data.zombie.damageDealt).toBeDefined(); + expect(data.zombie.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.zombie.damageDealt).toEqualTypeOf(); + expect(data.zombie.faceOff).toBeDefined(); + expectTypeOf(data.zombie.faceOff).toEqualTypeOf(); + expect(data.zombie.faceOff.kills).toBeDefined(); + expect(data.zombie.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.kills).toEqualTypeOf(); + expect(data.zombie.faceOff.assists).toBeDefined(); + expect(data.zombie.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.assists).toEqualTypeOf(); + expect(data.zombie.faceOff.deaths).toBeDefined(); + expect(data.zombie.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.deaths).toEqualTypeOf(); + expect(data.zombie.faceOff.KDR).toBeDefined(); + expect(data.zombie.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.KDR).toEqualTypeOf(); + expect(data.zombie.faceOff.wins).toBeDefined(); + expect(data.zombie.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.wins).toEqualTypeOf(); + expect(data.zombie.faceOff.losses).toBeDefined(); + expect(data.zombie.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.losses).toEqualTypeOf(); + expect(data.zombie.faceOff.WLR).toBeDefined(); + expect(data.zombie.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.WLR).toEqualTypeOf(); + expect(data.zombie.faceOff.finalKills).toBeDefined(); + expect(data.zombie.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.finalKills).toEqualTypeOf(); + expect(data.zombie.faceOff.finalAssists).toBeDefined(); + expect(data.zombie.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.finalAssists).toEqualTypeOf(); + expect(data.zombie.faceOff.finalDeaths).toBeDefined(); + expect(data.zombie.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.zombie.faceOff.FKDR).toBeDefined(); + expect(data.zombie.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.FKDR).toEqualTypeOf(); + expect(data.zombie.faceOff.playedGames).toBeDefined(); + expect(data.zombie.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.playedGames).toEqualTypeOf(); + expect(data.zombie.faceOff.witherDamage).toBeDefined(); + expect(data.zombie.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.witherDamage).toEqualTypeOf(); + expect(data.zombie.faceOff.defenderKills).toBeDefined(); + expect(data.zombie.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.defenderKills).toEqualTypeOf(); + expect(data.zombie.faceOff.walked).toBeDefined(); + expect(data.zombie.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.walked).toEqualTypeOf(); + expect(data.zombie.faceOff.blocksPlaced).toBeDefined(); + expect(data.zombie.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.zombie.faceOff.blocksBroken).toBeDefined(); + expect(data.zombie.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.zombie.faceOff.meleeKills).toBeDefined(); + expect(data.zombie.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.meleeKills).toEqualTypeOf(); + expect(data.zombie.faceOff.damageDealt).toBeDefined(); + expect(data.zombie.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.zombie.faceOff.damageDealt).toEqualTypeOf(); + expect(data.zombie.casualBrawl).toBeDefined(); + expectTypeOf(data.zombie.casualBrawl).toEqualTypeOf(); + expect(data.zombie.casualBrawl.kills).toBeDefined(); + expect(data.zombie.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.kills).toEqualTypeOf(); + expect(data.zombie.casualBrawl.assists).toBeDefined(); + expect(data.zombie.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.assists).toEqualTypeOf(); + expect(data.zombie.casualBrawl.deaths).toBeDefined(); + expect(data.zombie.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.deaths).toEqualTypeOf(); + expect(data.zombie.casualBrawl.KDR).toBeDefined(); + expect(data.zombie.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.KDR).toEqualTypeOf(); + expect(data.zombie.casualBrawl.wins).toBeDefined(); + expect(data.zombie.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.wins).toEqualTypeOf(); + expect(data.zombie.casualBrawl.losses).toBeDefined(); + expect(data.zombie.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.losses).toEqualTypeOf(); + expect(data.zombie.casualBrawl.WLR).toBeDefined(); + expect(data.zombie.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.WLR).toEqualTypeOf(); + expect(data.zombie.casualBrawl.finalKills).toBeDefined(); + expect(data.zombie.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.zombie.casualBrawl.finalAssists).toBeDefined(); + expect(data.zombie.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.zombie.casualBrawl.finalDeaths).toBeDefined(); + expect(data.zombie.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.zombie.casualBrawl.FKDR).toBeDefined(); + expect(data.zombie.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.zombie.casualBrawl.playedGames).toBeDefined(); + expect(data.zombie.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.zombie.casualBrawl.witherDamage).toBeDefined(); + expect(data.zombie.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.zombie.casualBrawl.defenderKills).toBeDefined(); + expect(data.zombie.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.zombie.casualBrawl.walked).toBeDefined(); + expect(data.zombie.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.walked).toEqualTypeOf(); + expect(data.zombie.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.zombie.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.zombie.casualBrawl.blocksBroken).toBeDefined(); + expect(data.zombie.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.zombie.casualBrawl.meleeKills).toBeDefined(); + expect(data.zombie.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.zombie.casualBrawl.damageDealt).toBeDefined(); + expect(data.zombie.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.zombie.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.blaze).toBeDefined(); + expectTypeOf(data.blaze).toEqualTypeOf(); + expect(data.blaze.kills).toBeDefined(); + expect(data.blaze.kills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.kills).toEqualTypeOf(); + expect(data.blaze.assists).toBeDefined(); + expect(data.blaze.assists).greaterThanOrEqual(0); + expectTypeOf(data.blaze.assists).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.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.finalKills).toBeDefined(); + expect(data.blaze.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.finalKills).toEqualTypeOf(); + expect(data.blaze.finalAssists).toBeDefined(); + expect(data.blaze.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.blaze.finalAssists).toEqualTypeOf(); + expect(data.blaze.finalDeaths).toBeDefined(); + expect(data.blaze.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.blaze.finalDeaths).toEqualTypeOf(); + expect(data.blaze.FKDR).toBeDefined(); + expect(data.blaze.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.FKDR).toEqualTypeOf(); + expect(data.blaze.playedGames).toBeDefined(); + expect(data.blaze.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.blaze.playedGames).toEqualTypeOf(); + expect(data.blaze.witherDamage).toBeDefined(); + expect(data.blaze.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.blaze.witherDamage).toEqualTypeOf(); + expect(data.blaze.defenderKills).toBeDefined(); + expect(data.blaze.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.defenderKills).toEqualTypeOf(); + expect(data.blaze.walked).toBeDefined(); + expect(data.blaze.walked).greaterThanOrEqual(0); + expectTypeOf(data.blaze.walked).toEqualTypeOf(); + expect(data.blaze.blocksPlaced).toBeDefined(); + expect(data.blaze.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blaze.blocksPlaced).toEqualTypeOf(); + expect(data.blaze.blocksBroken).toBeDefined(); + expect(data.blaze.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.blaze.blocksBroken).toEqualTypeOf(); + expect(data.blaze.meleeKills).toBeDefined(); + expect(data.blaze.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.meleeKills).toEqualTypeOf(); + expect(data.blaze.damageDealt).toBeDefined(); + expect(data.blaze.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.blaze.damageDealt).toEqualTypeOf(); + expect(data.blaze.faceOff).toBeDefined(); + expectTypeOf(data.blaze.faceOff).toEqualTypeOf(); + expect(data.blaze.faceOff.kills).toBeDefined(); + expect(data.blaze.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.kills).toEqualTypeOf(); + expect(data.blaze.faceOff.assists).toBeDefined(); + expect(data.blaze.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.assists).toEqualTypeOf(); + expect(data.blaze.faceOff.deaths).toBeDefined(); + expect(data.blaze.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.deaths).toEqualTypeOf(); + expect(data.blaze.faceOff.KDR).toBeDefined(); + expect(data.blaze.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.KDR).toEqualTypeOf(); + expect(data.blaze.faceOff.wins).toBeDefined(); + expect(data.blaze.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.wins).toEqualTypeOf(); + expect(data.blaze.faceOff.losses).toBeDefined(); + expect(data.blaze.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.losses).toEqualTypeOf(); + expect(data.blaze.faceOff.WLR).toBeDefined(); + expect(data.blaze.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.WLR).toEqualTypeOf(); + expect(data.blaze.faceOff.finalKills).toBeDefined(); + expect(data.blaze.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.finalKills).toEqualTypeOf(); + expect(data.blaze.faceOff.finalAssists).toBeDefined(); + expect(data.blaze.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.finalAssists).toEqualTypeOf(); + expect(data.blaze.faceOff.finalDeaths).toBeDefined(); + expect(data.blaze.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.blaze.faceOff.FKDR).toBeDefined(); + expect(data.blaze.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.FKDR).toEqualTypeOf(); + expect(data.blaze.faceOff.playedGames).toBeDefined(); + expect(data.blaze.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.playedGames).toEqualTypeOf(); + expect(data.blaze.faceOff.witherDamage).toBeDefined(); + expect(data.blaze.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.witherDamage).toEqualTypeOf(); + expect(data.blaze.faceOff.defenderKills).toBeDefined(); + expect(data.blaze.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.defenderKills).toEqualTypeOf(); + expect(data.blaze.faceOff.walked).toBeDefined(); + expect(data.blaze.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.walked).toEqualTypeOf(); + expect(data.blaze.faceOff.blocksPlaced).toBeDefined(); + expect(data.blaze.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.blaze.faceOff.blocksBroken).toBeDefined(); + expect(data.blaze.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.blaze.faceOff.meleeKills).toBeDefined(); + expect(data.blaze.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.meleeKills).toEqualTypeOf(); + expect(data.blaze.faceOff.damageDealt).toBeDefined(); + expect(data.blaze.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.blaze.faceOff.damageDealt).toEqualTypeOf(); + expect(data.blaze.casualBrawl).toBeDefined(); + expectTypeOf(data.blaze.casualBrawl).toEqualTypeOf(); + expect(data.blaze.casualBrawl.kills).toBeDefined(); + expect(data.blaze.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.kills).toEqualTypeOf(); + expect(data.blaze.casualBrawl.assists).toBeDefined(); + expect(data.blaze.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.assists).toEqualTypeOf(); + expect(data.blaze.casualBrawl.deaths).toBeDefined(); + expect(data.blaze.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.deaths).toEqualTypeOf(); + expect(data.blaze.casualBrawl.KDR).toBeDefined(); + expect(data.blaze.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.KDR).toEqualTypeOf(); + expect(data.blaze.casualBrawl.wins).toBeDefined(); + expect(data.blaze.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.wins).toEqualTypeOf(); + expect(data.blaze.casualBrawl.losses).toBeDefined(); + expect(data.blaze.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.losses).toEqualTypeOf(); + expect(data.blaze.casualBrawl.WLR).toBeDefined(); + expect(data.blaze.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.WLR).toEqualTypeOf(); + expect(data.blaze.casualBrawl.finalKills).toBeDefined(); + expect(data.blaze.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.blaze.casualBrawl.finalAssists).toBeDefined(); + expect(data.blaze.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.blaze.casualBrawl.finalDeaths).toBeDefined(); + expect(data.blaze.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.blaze.casualBrawl.FKDR).toBeDefined(); + expect(data.blaze.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.blaze.casualBrawl.playedGames).toBeDefined(); + expect(data.blaze.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.blaze.casualBrawl.witherDamage).toBeDefined(); + expect(data.blaze.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.blaze.casualBrawl.defenderKills).toBeDefined(); + expect(data.blaze.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.blaze.casualBrawl.walked).toBeDefined(); + expect(data.blaze.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.walked).toEqualTypeOf(); + expect(data.blaze.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.blaze.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.blaze.casualBrawl.blocksBroken).toBeDefined(); + expect(data.blaze.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.blaze.casualBrawl.meleeKills).toBeDefined(); + expect(data.blaze.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.blaze.casualBrawl.damageDealt).toBeDefined(); + expect(data.blaze.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.blaze.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.enderman).toBeDefined(); + expectTypeOf(data.enderman).toEqualTypeOf(); + expect(data.enderman.kills).toBeDefined(); + expect(data.enderman.kills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.kills).toEqualTypeOf(); + expect(data.enderman.assists).toBeDefined(); + expect(data.enderman.assists).greaterThanOrEqual(0); + expectTypeOf(data.enderman.assists).toEqualTypeOf(); + expect(data.enderman.deaths).toBeDefined(); + expect(data.enderman.deaths).greaterThanOrEqual(0); + expectTypeOf(data.enderman.deaths).toEqualTypeOf(); + expect(data.enderman.KDR).toBeDefined(); + expect(data.enderman.KDR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.KDR).toEqualTypeOf(); + expect(data.enderman.wins).toBeDefined(); + expect(data.enderman.wins).greaterThanOrEqual(0); + expectTypeOf(data.enderman.wins).toEqualTypeOf(); + expect(data.enderman.losses).toBeDefined(); + expect(data.enderman.losses).greaterThanOrEqual(0); + expectTypeOf(data.enderman.losses).toEqualTypeOf(); + expect(data.enderman.WLR).toBeDefined(); + expect(data.enderman.WLR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.WLR).toEqualTypeOf(); + expect(data.enderman.finalKills).toBeDefined(); + expect(data.enderman.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.finalKills).toEqualTypeOf(); + expect(data.enderman.finalAssists).toBeDefined(); + expect(data.enderman.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.enderman.finalAssists).toEqualTypeOf(); + expect(data.enderman.finalDeaths).toBeDefined(); + expect(data.enderman.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.enderman.finalDeaths).toEqualTypeOf(); + expect(data.enderman.FKDR).toBeDefined(); + expect(data.enderman.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.FKDR).toEqualTypeOf(); + expect(data.enderman.playedGames).toBeDefined(); + expect(data.enderman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.enderman.playedGames).toEqualTypeOf(); + expect(data.enderman.witherDamage).toBeDefined(); + expect(data.enderman.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.enderman.witherDamage).toEqualTypeOf(); + expect(data.enderman.defenderKills).toBeDefined(); + expect(data.enderman.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.defenderKills).toEqualTypeOf(); + expect(data.enderman.walked).toBeDefined(); + expect(data.enderman.walked).greaterThanOrEqual(0); + expectTypeOf(data.enderman.walked).toEqualTypeOf(); + expect(data.enderman.blocksPlaced).toBeDefined(); + expect(data.enderman.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.enderman.blocksPlaced).toEqualTypeOf(); + expect(data.enderman.blocksBroken).toBeDefined(); + expect(data.enderman.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.enderman.blocksBroken).toEqualTypeOf(); + expect(data.enderman.meleeKills).toBeDefined(); + expect(data.enderman.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.meleeKills).toEqualTypeOf(); + expect(data.enderman.damageDealt).toBeDefined(); + expect(data.enderman.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.enderman.damageDealt).toEqualTypeOf(); + expect(data.enderman.faceOff).toBeDefined(); + expectTypeOf(data.enderman.faceOff).toEqualTypeOf(); + expect(data.enderman.faceOff.kills).toBeDefined(); + expect(data.enderman.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.kills).toEqualTypeOf(); + expect(data.enderman.faceOff.assists).toBeDefined(); + expect(data.enderman.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.assists).toEqualTypeOf(); + expect(data.enderman.faceOff.deaths).toBeDefined(); + expect(data.enderman.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.deaths).toEqualTypeOf(); + expect(data.enderman.faceOff.KDR).toBeDefined(); + expect(data.enderman.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.KDR).toEqualTypeOf(); + expect(data.enderman.faceOff.wins).toBeDefined(); + expect(data.enderman.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.wins).toEqualTypeOf(); + expect(data.enderman.faceOff.losses).toBeDefined(); + expect(data.enderman.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.losses).toEqualTypeOf(); + expect(data.enderman.faceOff.WLR).toBeDefined(); + expect(data.enderman.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.WLR).toEqualTypeOf(); + expect(data.enderman.faceOff.finalKills).toBeDefined(); + expect(data.enderman.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.finalKills).toEqualTypeOf(); + expect(data.enderman.faceOff.finalAssists).toBeDefined(); + expect(data.enderman.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.finalAssists).toEqualTypeOf(); + expect(data.enderman.faceOff.finalDeaths).toBeDefined(); + expect(data.enderman.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.enderman.faceOff.FKDR).toBeDefined(); + expect(data.enderman.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.FKDR).toEqualTypeOf(); + expect(data.enderman.faceOff.playedGames).toBeDefined(); + expect(data.enderman.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.playedGames).toEqualTypeOf(); + expect(data.enderman.faceOff.witherDamage).toBeDefined(); + expect(data.enderman.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.witherDamage).toEqualTypeOf(); + expect(data.enderman.faceOff.defenderKills).toBeDefined(); + expect(data.enderman.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.defenderKills).toEqualTypeOf(); + expect(data.enderman.faceOff.walked).toBeDefined(); + expect(data.enderman.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.walked).toEqualTypeOf(); + expect(data.enderman.faceOff.blocksPlaced).toBeDefined(); + expect(data.enderman.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.enderman.faceOff.blocksBroken).toBeDefined(); + expect(data.enderman.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.enderman.faceOff.meleeKills).toBeDefined(); + expect(data.enderman.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.meleeKills).toEqualTypeOf(); + expect(data.enderman.faceOff.damageDealt).toBeDefined(); + expect(data.enderman.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.enderman.faceOff.damageDealt).toEqualTypeOf(); + expect(data.enderman.casualBrawl).toBeDefined(); + expectTypeOf(data.enderman.casualBrawl).toEqualTypeOf(); + expect(data.enderman.casualBrawl.kills).toBeDefined(); + expect(data.enderman.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.kills).toEqualTypeOf(); + expect(data.enderman.casualBrawl.assists).toBeDefined(); + expect(data.enderman.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.assists).toEqualTypeOf(); + expect(data.enderman.casualBrawl.deaths).toBeDefined(); + expect(data.enderman.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.deaths).toEqualTypeOf(); + expect(data.enderman.casualBrawl.KDR).toBeDefined(); + expect(data.enderman.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.KDR).toEqualTypeOf(); + expect(data.enderman.casualBrawl.wins).toBeDefined(); + expect(data.enderman.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.wins).toEqualTypeOf(); + expect(data.enderman.casualBrawl.losses).toBeDefined(); + expect(data.enderman.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.losses).toEqualTypeOf(); + expect(data.enderman.casualBrawl.WLR).toBeDefined(); + expect(data.enderman.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.WLR).toEqualTypeOf(); + expect(data.enderman.casualBrawl.finalKills).toBeDefined(); + expect(data.enderman.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.enderman.casualBrawl.finalAssists).toBeDefined(); + expect(data.enderman.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.enderman.casualBrawl.finalDeaths).toBeDefined(); + expect(data.enderman.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.enderman.casualBrawl.FKDR).toBeDefined(); + expect(data.enderman.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.enderman.casualBrawl.playedGames).toBeDefined(); + expect(data.enderman.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.enderman.casualBrawl.witherDamage).toBeDefined(); + expect(data.enderman.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.enderman.casualBrawl.defenderKills).toBeDefined(); + expect(data.enderman.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.enderman.casualBrawl.walked).toBeDefined(); + expect(data.enderman.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.walked).toEqualTypeOf(); + expect(data.enderman.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.enderman.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.enderman.casualBrawl.blocksBroken).toBeDefined(); + expect(data.enderman.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.enderman.casualBrawl.meleeKills).toBeDefined(); + expect(data.enderman.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.enderman.casualBrawl.damageDealt).toBeDefined(); + expect(data.enderman.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.enderman.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.shaman).toBeDefined(); + expectTypeOf(data.shaman).toEqualTypeOf(); + expect(data.shaman.kills).toBeDefined(); + expect(data.shaman.kills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.kills).toEqualTypeOf(); + expect(data.shaman.assists).toBeDefined(); + expect(data.shaman.assists).greaterThanOrEqual(0); + expectTypeOf(data.shaman.assists).toEqualTypeOf(); + expect(data.shaman.deaths).toBeDefined(); + expect(data.shaman.deaths).greaterThanOrEqual(0); + expectTypeOf(data.shaman.deaths).toEqualTypeOf(); + expect(data.shaman.KDR).toBeDefined(); + expect(data.shaman.KDR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.KDR).toEqualTypeOf(); + expect(data.shaman.wins).toBeDefined(); + expect(data.shaman.wins).greaterThanOrEqual(0); + expectTypeOf(data.shaman.wins).toEqualTypeOf(); + expect(data.shaman.losses).toBeDefined(); + expect(data.shaman.losses).greaterThanOrEqual(0); + expectTypeOf(data.shaman.losses).toEqualTypeOf(); + expect(data.shaman.WLR).toBeDefined(); + expect(data.shaman.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.WLR).toEqualTypeOf(); + expect(data.shaman.finalKills).toBeDefined(); + expect(data.shaman.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.finalKills).toEqualTypeOf(); + expect(data.shaman.finalAssists).toBeDefined(); + expect(data.shaman.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.shaman.finalAssists).toEqualTypeOf(); + expect(data.shaman.finalDeaths).toBeDefined(); + expect(data.shaman.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.shaman.finalDeaths).toEqualTypeOf(); + expect(data.shaman.FKDR).toBeDefined(); + expect(data.shaman.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.FKDR).toEqualTypeOf(); + expect(data.shaman.playedGames).toBeDefined(); + expect(data.shaman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shaman.playedGames).toEqualTypeOf(); + expect(data.shaman.witherDamage).toBeDefined(); + expect(data.shaman.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.shaman.witherDamage).toEqualTypeOf(); + expect(data.shaman.defenderKills).toBeDefined(); + expect(data.shaman.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.defenderKills).toEqualTypeOf(); + expect(data.shaman.walked).toBeDefined(); + expect(data.shaman.walked).greaterThanOrEqual(0); + expectTypeOf(data.shaman.walked).toEqualTypeOf(); + expect(data.shaman.blocksPlaced).toBeDefined(); + expect(data.shaman.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.shaman.blocksPlaced).toEqualTypeOf(); + expect(data.shaman.blocksBroken).toBeDefined(); + expect(data.shaman.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.shaman.blocksBroken).toEqualTypeOf(); + expect(data.shaman.meleeKills).toBeDefined(); + expect(data.shaman.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.meleeKills).toEqualTypeOf(); + expect(data.shaman.damageDealt).toBeDefined(); + expect(data.shaman.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.shaman.damageDealt).toEqualTypeOf(); + expect(data.shaman.faceOff).toBeDefined(); + expectTypeOf(data.shaman.faceOff).toEqualTypeOf(); + expect(data.shaman.faceOff.kills).toBeDefined(); + expect(data.shaman.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.kills).toEqualTypeOf(); + expect(data.shaman.faceOff.assists).toBeDefined(); + expect(data.shaman.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.assists).toEqualTypeOf(); + expect(data.shaman.faceOff.deaths).toBeDefined(); + expect(data.shaman.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.deaths).toEqualTypeOf(); + expect(data.shaman.faceOff.KDR).toBeDefined(); + expect(data.shaman.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.KDR).toEqualTypeOf(); + expect(data.shaman.faceOff.wins).toBeDefined(); + expect(data.shaman.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.wins).toEqualTypeOf(); + expect(data.shaman.faceOff.losses).toBeDefined(); + expect(data.shaman.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.losses).toEqualTypeOf(); + expect(data.shaman.faceOff.WLR).toBeDefined(); + expect(data.shaman.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.WLR).toEqualTypeOf(); + expect(data.shaman.faceOff.finalKills).toBeDefined(); + expect(data.shaman.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.finalKills).toEqualTypeOf(); + expect(data.shaman.faceOff.finalAssists).toBeDefined(); + expect(data.shaman.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.finalAssists).toEqualTypeOf(); + expect(data.shaman.faceOff.finalDeaths).toBeDefined(); + expect(data.shaman.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.shaman.faceOff.FKDR).toBeDefined(); + expect(data.shaman.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.FKDR).toEqualTypeOf(); + expect(data.shaman.faceOff.playedGames).toBeDefined(); + expect(data.shaman.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.playedGames).toEqualTypeOf(); + expect(data.shaman.faceOff.witherDamage).toBeDefined(); + expect(data.shaman.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.witherDamage).toEqualTypeOf(); + expect(data.shaman.faceOff.defenderKills).toBeDefined(); + expect(data.shaman.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.defenderKills).toEqualTypeOf(); + expect(data.shaman.faceOff.walked).toBeDefined(); + expect(data.shaman.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.walked).toEqualTypeOf(); + expect(data.shaman.faceOff.blocksPlaced).toBeDefined(); + expect(data.shaman.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.shaman.faceOff.blocksBroken).toBeDefined(); + expect(data.shaman.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.shaman.faceOff.meleeKills).toBeDefined(); + expect(data.shaman.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.meleeKills).toEqualTypeOf(); + expect(data.shaman.faceOff.damageDealt).toBeDefined(); + expect(data.shaman.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.shaman.faceOff.damageDealt).toEqualTypeOf(); + expect(data.shaman.casualBrawl).toBeDefined(); + expectTypeOf(data.shaman.casualBrawl).toEqualTypeOf(); + expect(data.shaman.casualBrawl.kills).toBeDefined(); + expect(data.shaman.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.kills).toEqualTypeOf(); + expect(data.shaman.casualBrawl.assists).toBeDefined(); + expect(data.shaman.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.assists).toEqualTypeOf(); + expect(data.shaman.casualBrawl.deaths).toBeDefined(); + expect(data.shaman.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.deaths).toEqualTypeOf(); + expect(data.shaman.casualBrawl.KDR).toBeDefined(); + expect(data.shaman.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.KDR).toEqualTypeOf(); + expect(data.shaman.casualBrawl.wins).toBeDefined(); + expect(data.shaman.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.wins).toEqualTypeOf(); + expect(data.shaman.casualBrawl.losses).toBeDefined(); + expect(data.shaman.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.losses).toEqualTypeOf(); + expect(data.shaman.casualBrawl.WLR).toBeDefined(); + expect(data.shaman.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.WLR).toEqualTypeOf(); + expect(data.shaman.casualBrawl.finalKills).toBeDefined(); + expect(data.shaman.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.shaman.casualBrawl.finalAssists).toBeDefined(); + expect(data.shaman.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.shaman.casualBrawl.finalDeaths).toBeDefined(); + expect(data.shaman.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.shaman.casualBrawl.FKDR).toBeDefined(); + expect(data.shaman.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.shaman.casualBrawl.playedGames).toBeDefined(); + expect(data.shaman.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.shaman.casualBrawl.witherDamage).toBeDefined(); + expect(data.shaman.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.shaman.casualBrawl.defenderKills).toBeDefined(); + expect(data.shaman.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.shaman.casualBrawl.walked).toBeDefined(); + expect(data.shaman.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.walked).toEqualTypeOf(); + expect(data.shaman.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.shaman.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.shaman.casualBrawl.blocksBroken).toBeDefined(); + expect(data.shaman.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.shaman.casualBrawl.meleeKills).toBeDefined(); + expect(data.shaman.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.shaman.casualBrawl.damageDealt).toBeDefined(); + expect(data.shaman.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.shaman.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.squid).toBeDefined(); + expectTypeOf(data.squid).toEqualTypeOf(); + expect(data.squid.kills).toBeDefined(); + expect(data.squid.kills).greaterThanOrEqual(0); + expectTypeOf(data.squid.kills).toEqualTypeOf(); + expect(data.squid.assists).toBeDefined(); + expect(data.squid.assists).greaterThanOrEqual(0); + expectTypeOf(data.squid.assists).toEqualTypeOf(); + expect(data.squid.deaths).toBeDefined(); + expect(data.squid.deaths).greaterThanOrEqual(0); + expectTypeOf(data.squid.deaths).toEqualTypeOf(); + expect(data.squid.KDR).toBeDefined(); + expect(data.squid.KDR).greaterThanOrEqual(0); + expectTypeOf(data.squid.KDR).toEqualTypeOf(); + expect(data.squid.wins).toBeDefined(); + expect(data.squid.wins).greaterThanOrEqual(0); + expectTypeOf(data.squid.wins).toEqualTypeOf(); + expect(data.squid.losses).toBeDefined(); + expect(data.squid.losses).greaterThanOrEqual(0); + expectTypeOf(data.squid.losses).toEqualTypeOf(); + expect(data.squid.WLR).toBeDefined(); + expect(data.squid.WLR).greaterThanOrEqual(0); + expectTypeOf(data.squid.WLR).toEqualTypeOf(); + expect(data.squid.finalKills).toBeDefined(); + expect(data.squid.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.finalKills).toEqualTypeOf(); + expect(data.squid.finalAssists).toBeDefined(); + expect(data.squid.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.squid.finalAssists).toEqualTypeOf(); + expect(data.squid.finalDeaths).toBeDefined(); + expect(data.squid.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.squid.finalDeaths).toEqualTypeOf(); + expect(data.squid.FKDR).toBeDefined(); + expect(data.squid.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.squid.FKDR).toEqualTypeOf(); + expect(data.squid.playedGames).toBeDefined(); + expect(data.squid.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.squid.playedGames).toEqualTypeOf(); + expect(data.squid.witherDamage).toBeDefined(); + expect(data.squid.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.squid.witherDamage).toEqualTypeOf(); + expect(data.squid.defenderKills).toBeDefined(); + expect(data.squid.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.defenderKills).toEqualTypeOf(); + expect(data.squid.walked).toBeDefined(); + expect(data.squid.walked).greaterThanOrEqual(0); + expectTypeOf(data.squid.walked).toEqualTypeOf(); + expect(data.squid.blocksPlaced).toBeDefined(); + expect(data.squid.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.squid.blocksPlaced).toEqualTypeOf(); + expect(data.squid.blocksBroken).toBeDefined(); + expect(data.squid.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.squid.blocksBroken).toEqualTypeOf(); + expect(data.squid.meleeKills).toBeDefined(); + expect(data.squid.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.meleeKills).toEqualTypeOf(); + expect(data.squid.damageDealt).toBeDefined(); + expect(data.squid.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.squid.damageDealt).toEqualTypeOf(); + expect(data.squid.faceOff).toBeDefined(); + expectTypeOf(data.squid.faceOff).toEqualTypeOf(); + expect(data.squid.faceOff.kills).toBeDefined(); + expect(data.squid.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.kills).toEqualTypeOf(); + expect(data.squid.faceOff.assists).toBeDefined(); + expect(data.squid.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.assists).toEqualTypeOf(); + expect(data.squid.faceOff.deaths).toBeDefined(); + expect(data.squid.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.deaths).toEqualTypeOf(); + expect(data.squid.faceOff.KDR).toBeDefined(); + expect(data.squid.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.KDR).toEqualTypeOf(); + expect(data.squid.faceOff.wins).toBeDefined(); + expect(data.squid.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.wins).toEqualTypeOf(); + expect(data.squid.faceOff.losses).toBeDefined(); + expect(data.squid.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.losses).toEqualTypeOf(); + expect(data.squid.faceOff.WLR).toBeDefined(); + expect(data.squid.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.WLR).toEqualTypeOf(); + expect(data.squid.faceOff.finalKills).toBeDefined(); + expect(data.squid.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.finalKills).toEqualTypeOf(); + expect(data.squid.faceOff.finalAssists).toBeDefined(); + expect(data.squid.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.finalAssists).toEqualTypeOf(); + expect(data.squid.faceOff.finalDeaths).toBeDefined(); + expect(data.squid.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.squid.faceOff.FKDR).toBeDefined(); + expect(data.squid.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.FKDR).toEqualTypeOf(); + expect(data.squid.faceOff.playedGames).toBeDefined(); + expect(data.squid.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.playedGames).toEqualTypeOf(); + expect(data.squid.faceOff.witherDamage).toBeDefined(); + expect(data.squid.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.witherDamage).toEqualTypeOf(); + expect(data.squid.faceOff.defenderKills).toBeDefined(); + expect(data.squid.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.defenderKills).toEqualTypeOf(); + expect(data.squid.faceOff.walked).toBeDefined(); + expect(data.squid.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.walked).toEqualTypeOf(); + expect(data.squid.faceOff.blocksPlaced).toBeDefined(); + expect(data.squid.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.squid.faceOff.blocksBroken).toBeDefined(); + expect(data.squid.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.squid.faceOff.meleeKills).toBeDefined(); + expect(data.squid.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.meleeKills).toEqualTypeOf(); + expect(data.squid.faceOff.damageDealt).toBeDefined(); + expect(data.squid.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.squid.faceOff.damageDealt).toEqualTypeOf(); + expect(data.squid.casualBrawl).toBeDefined(); + expectTypeOf(data.squid.casualBrawl).toEqualTypeOf(); + expect(data.squid.casualBrawl.kills).toBeDefined(); + expect(data.squid.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.kills).toEqualTypeOf(); + expect(data.squid.casualBrawl.assists).toBeDefined(); + expect(data.squid.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.assists).toEqualTypeOf(); + expect(data.squid.casualBrawl.deaths).toBeDefined(); + expect(data.squid.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.deaths).toEqualTypeOf(); + expect(data.squid.casualBrawl.KDR).toBeDefined(); + expect(data.squid.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.KDR).toEqualTypeOf(); + expect(data.squid.casualBrawl.wins).toBeDefined(); + expect(data.squid.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.wins).toEqualTypeOf(); + expect(data.squid.casualBrawl.losses).toBeDefined(); + expect(data.squid.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.losses).toEqualTypeOf(); + expect(data.squid.casualBrawl.WLR).toBeDefined(); + expect(data.squid.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.WLR).toEqualTypeOf(); + expect(data.squid.casualBrawl.finalKills).toBeDefined(); + expect(data.squid.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.squid.casualBrawl.finalAssists).toBeDefined(); + expect(data.squid.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.squid.casualBrawl.finalDeaths).toBeDefined(); + expect(data.squid.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.squid.casualBrawl.FKDR).toBeDefined(); + expect(data.squid.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.squid.casualBrawl.playedGames).toBeDefined(); + expect(data.squid.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.squid.casualBrawl.witherDamage).toBeDefined(); + expect(data.squid.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.squid.casualBrawl.defenderKills).toBeDefined(); + expect(data.squid.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.squid.casualBrawl.walked).toBeDefined(); + expect(data.squid.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.walked).toEqualTypeOf(); + expect(data.squid.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.squid.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.squid.casualBrawl.blocksBroken).toBeDefined(); + expect(data.squid.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.squid.casualBrawl.meleeKills).toBeDefined(); + expect(data.squid.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.squid.casualBrawl.damageDealt).toBeDefined(); + expect(data.squid.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.squid.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.creeper).toBeDefined(); + expectTypeOf(data.creeper).toEqualTypeOf(); + expect(data.creeper.kills).toBeDefined(); + expect(data.creeper.kills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.kills).toEqualTypeOf(); + expect(data.creeper.assists).toBeDefined(); + expect(data.creeper.assists).greaterThanOrEqual(0); + expectTypeOf(data.creeper.assists).toEqualTypeOf(); + expect(data.creeper.deaths).toBeDefined(); + expect(data.creeper.deaths).greaterThanOrEqual(0); + expectTypeOf(data.creeper.deaths).toEqualTypeOf(); + expect(data.creeper.KDR).toBeDefined(); + expect(data.creeper.KDR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.KDR).toEqualTypeOf(); + expect(data.creeper.wins).toBeDefined(); + expect(data.creeper.wins).greaterThanOrEqual(0); + expectTypeOf(data.creeper.wins).toEqualTypeOf(); + expect(data.creeper.losses).toBeDefined(); + expect(data.creeper.losses).greaterThanOrEqual(0); + expectTypeOf(data.creeper.losses).toEqualTypeOf(); + expect(data.creeper.WLR).toBeDefined(); + expect(data.creeper.WLR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.WLR).toEqualTypeOf(); + expect(data.creeper.finalKills).toBeDefined(); + expect(data.creeper.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.finalKills).toEqualTypeOf(); + expect(data.creeper.finalAssists).toBeDefined(); + expect(data.creeper.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.creeper.finalAssists).toEqualTypeOf(); + expect(data.creeper.finalDeaths).toBeDefined(); + expect(data.creeper.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.creeper.finalDeaths).toEqualTypeOf(); + expect(data.creeper.FKDR).toBeDefined(); + expect(data.creeper.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.FKDR).toEqualTypeOf(); + expect(data.creeper.playedGames).toBeDefined(); + expect(data.creeper.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.creeper.playedGames).toEqualTypeOf(); + expect(data.creeper.witherDamage).toBeDefined(); + expect(data.creeper.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.creeper.witherDamage).toEqualTypeOf(); + expect(data.creeper.defenderKills).toBeDefined(); + expect(data.creeper.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.defenderKills).toEqualTypeOf(); + expect(data.creeper.walked).toBeDefined(); + expect(data.creeper.walked).greaterThanOrEqual(0); + expectTypeOf(data.creeper.walked).toEqualTypeOf(); + expect(data.creeper.blocksPlaced).toBeDefined(); + expect(data.creeper.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.creeper.blocksPlaced).toEqualTypeOf(); + expect(data.creeper.blocksBroken).toBeDefined(); + expect(data.creeper.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.creeper.blocksBroken).toEqualTypeOf(); + expect(data.creeper.meleeKills).toBeDefined(); + expect(data.creeper.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.meleeKills).toEqualTypeOf(); + expect(data.creeper.damageDealt).toBeDefined(); + expect(data.creeper.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.creeper.damageDealt).toEqualTypeOf(); + expect(data.creeper.faceOff).toBeDefined(); + expectTypeOf(data.creeper.faceOff).toEqualTypeOf(); + expect(data.creeper.faceOff.kills).toBeDefined(); + expect(data.creeper.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.kills).toEqualTypeOf(); + expect(data.creeper.faceOff.assists).toBeDefined(); + expect(data.creeper.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.assists).toEqualTypeOf(); + expect(data.creeper.faceOff.deaths).toBeDefined(); + expect(data.creeper.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.deaths).toEqualTypeOf(); + expect(data.creeper.faceOff.KDR).toBeDefined(); + expect(data.creeper.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.KDR).toEqualTypeOf(); + expect(data.creeper.faceOff.wins).toBeDefined(); + expect(data.creeper.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.wins).toEqualTypeOf(); + expect(data.creeper.faceOff.losses).toBeDefined(); + expect(data.creeper.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.losses).toEqualTypeOf(); + expect(data.creeper.faceOff.WLR).toBeDefined(); + expect(data.creeper.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.WLR).toEqualTypeOf(); + expect(data.creeper.faceOff.finalKills).toBeDefined(); + expect(data.creeper.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.finalKills).toEqualTypeOf(); + expect(data.creeper.faceOff.finalAssists).toBeDefined(); + expect(data.creeper.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.finalAssists).toEqualTypeOf(); + expect(data.creeper.faceOff.finalDeaths).toBeDefined(); + expect(data.creeper.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.creeper.faceOff.FKDR).toBeDefined(); + expect(data.creeper.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.FKDR).toEqualTypeOf(); + expect(data.creeper.faceOff.playedGames).toBeDefined(); + expect(data.creeper.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.playedGames).toEqualTypeOf(); + expect(data.creeper.faceOff.witherDamage).toBeDefined(); + expect(data.creeper.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.witherDamage).toEqualTypeOf(); + expect(data.creeper.faceOff.defenderKills).toBeDefined(); + expect(data.creeper.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.defenderKills).toEqualTypeOf(); + expect(data.creeper.faceOff.walked).toBeDefined(); + expect(data.creeper.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.walked).toEqualTypeOf(); + expect(data.creeper.faceOff.blocksPlaced).toBeDefined(); + expect(data.creeper.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.creeper.faceOff.blocksBroken).toBeDefined(); + expect(data.creeper.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.creeper.faceOff.meleeKills).toBeDefined(); + expect(data.creeper.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.meleeKills).toEqualTypeOf(); + expect(data.creeper.faceOff.damageDealt).toBeDefined(); + expect(data.creeper.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.creeper.faceOff.damageDealt).toEqualTypeOf(); + expect(data.creeper.casualBrawl).toBeDefined(); + expectTypeOf(data.creeper.casualBrawl).toEqualTypeOf(); + expect(data.creeper.casualBrawl.kills).toBeDefined(); + expect(data.creeper.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.kills).toEqualTypeOf(); + expect(data.creeper.casualBrawl.assists).toBeDefined(); + expect(data.creeper.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.assists).toEqualTypeOf(); + expect(data.creeper.casualBrawl.deaths).toBeDefined(); + expect(data.creeper.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.deaths).toEqualTypeOf(); + expect(data.creeper.casualBrawl.KDR).toBeDefined(); + expect(data.creeper.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.KDR).toEqualTypeOf(); + expect(data.creeper.casualBrawl.wins).toBeDefined(); + expect(data.creeper.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.wins).toEqualTypeOf(); + expect(data.creeper.casualBrawl.losses).toBeDefined(); + expect(data.creeper.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.losses).toEqualTypeOf(); + expect(data.creeper.casualBrawl.WLR).toBeDefined(); + expect(data.creeper.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.WLR).toEqualTypeOf(); + expect(data.creeper.casualBrawl.finalKills).toBeDefined(); + expect(data.creeper.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.creeper.casualBrawl.finalAssists).toBeDefined(); + expect(data.creeper.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.creeper.casualBrawl.finalDeaths).toBeDefined(); + expect(data.creeper.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.creeper.casualBrawl.FKDR).toBeDefined(); + expect(data.creeper.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.creeper.casualBrawl.playedGames).toBeDefined(); + expect(data.creeper.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.creeper.casualBrawl.witherDamage).toBeDefined(); + expect(data.creeper.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.creeper.casualBrawl.defenderKills).toBeDefined(); + expect(data.creeper.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.creeper.casualBrawl.walked).toBeDefined(); + expect(data.creeper.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.walked).toEqualTypeOf(); + expect(data.creeper.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.creeper.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.creeper.casualBrawl.blocksBroken).toBeDefined(); + expect(data.creeper.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.creeper.casualBrawl.meleeKills).toBeDefined(); + expect(data.creeper.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.creeper.casualBrawl.damageDealt).toBeDefined(); + expect(data.creeper.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.creeper.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.pirate).toBeDefined(); + expectTypeOf(data.pirate).toEqualTypeOf(); + expect(data.pirate.kills).toBeDefined(); + expect(data.pirate.kills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.kills).toEqualTypeOf(); + expect(data.pirate.assists).toBeDefined(); + expect(data.pirate.assists).greaterThanOrEqual(0); + expectTypeOf(data.pirate.assists).toEqualTypeOf(); + expect(data.pirate.deaths).toBeDefined(); + expect(data.pirate.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pirate.deaths).toEqualTypeOf(); + expect(data.pirate.KDR).toBeDefined(); + expect(data.pirate.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.KDR).toEqualTypeOf(); + expect(data.pirate.wins).toBeDefined(); + expect(data.pirate.wins).greaterThanOrEqual(0); + expectTypeOf(data.pirate.wins).toEqualTypeOf(); + expect(data.pirate.losses).toBeDefined(); + expect(data.pirate.losses).greaterThanOrEqual(0); + expectTypeOf(data.pirate.losses).toEqualTypeOf(); + expect(data.pirate.WLR).toBeDefined(); + expect(data.pirate.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.WLR).toEqualTypeOf(); + expect(data.pirate.finalKills).toBeDefined(); + expect(data.pirate.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.finalKills).toEqualTypeOf(); + expect(data.pirate.finalAssists).toBeDefined(); + expect(data.pirate.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.pirate.finalAssists).toEqualTypeOf(); + expect(data.pirate.finalDeaths).toBeDefined(); + expect(data.pirate.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.pirate.finalDeaths).toEqualTypeOf(); + expect(data.pirate.FKDR).toBeDefined(); + expect(data.pirate.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.FKDR).toEqualTypeOf(); + expect(data.pirate.playedGames).toBeDefined(); + expect(data.pirate.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pirate.playedGames).toEqualTypeOf(); + expect(data.pirate.witherDamage).toBeDefined(); + expect(data.pirate.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.pirate.witherDamage).toEqualTypeOf(); + expect(data.pirate.defenderKills).toBeDefined(); + expect(data.pirate.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.defenderKills).toEqualTypeOf(); + expect(data.pirate.walked).toBeDefined(); + expect(data.pirate.walked).greaterThanOrEqual(0); + expectTypeOf(data.pirate.walked).toEqualTypeOf(); + expect(data.pirate.blocksPlaced).toBeDefined(); + expect(data.pirate.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.pirate.blocksPlaced).toEqualTypeOf(); + expect(data.pirate.blocksBroken).toBeDefined(); + expect(data.pirate.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.pirate.blocksBroken).toEqualTypeOf(); + expect(data.pirate.meleeKills).toBeDefined(); + expect(data.pirate.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.meleeKills).toEqualTypeOf(); + expect(data.pirate.damageDealt).toBeDefined(); + expect(data.pirate.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.pirate.damageDealt).toEqualTypeOf(); + expect(data.pirate.faceOff).toBeDefined(); + expectTypeOf(data.pirate.faceOff).toEqualTypeOf(); + expect(data.pirate.faceOff.kills).toBeDefined(); + expect(data.pirate.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.kills).toEqualTypeOf(); + expect(data.pirate.faceOff.assists).toBeDefined(); + expect(data.pirate.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.assists).toEqualTypeOf(); + expect(data.pirate.faceOff.deaths).toBeDefined(); + expect(data.pirate.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.deaths).toEqualTypeOf(); + expect(data.pirate.faceOff.KDR).toBeDefined(); + expect(data.pirate.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.KDR).toEqualTypeOf(); + expect(data.pirate.faceOff.wins).toBeDefined(); + expect(data.pirate.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.wins).toEqualTypeOf(); + expect(data.pirate.faceOff.losses).toBeDefined(); + expect(data.pirate.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.losses).toEqualTypeOf(); + expect(data.pirate.faceOff.WLR).toBeDefined(); + expect(data.pirate.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.WLR).toEqualTypeOf(); + expect(data.pirate.faceOff.finalKills).toBeDefined(); + expect(data.pirate.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.finalKills).toEqualTypeOf(); + expect(data.pirate.faceOff.finalAssists).toBeDefined(); + expect(data.pirate.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.finalAssists).toEqualTypeOf(); + expect(data.pirate.faceOff.finalDeaths).toBeDefined(); + expect(data.pirate.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.pirate.faceOff.FKDR).toBeDefined(); + expect(data.pirate.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.FKDR).toEqualTypeOf(); + expect(data.pirate.faceOff.playedGames).toBeDefined(); + expect(data.pirate.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.playedGames).toEqualTypeOf(); + expect(data.pirate.faceOff.witherDamage).toBeDefined(); + expect(data.pirate.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.witherDamage).toEqualTypeOf(); + expect(data.pirate.faceOff.defenderKills).toBeDefined(); + expect(data.pirate.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.defenderKills).toEqualTypeOf(); + expect(data.pirate.faceOff.walked).toBeDefined(); + expect(data.pirate.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.walked).toEqualTypeOf(); + expect(data.pirate.faceOff.blocksPlaced).toBeDefined(); + expect(data.pirate.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.pirate.faceOff.blocksBroken).toBeDefined(); + expect(data.pirate.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.pirate.faceOff.meleeKills).toBeDefined(); + expect(data.pirate.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.meleeKills).toEqualTypeOf(); + expect(data.pirate.faceOff.damageDealt).toBeDefined(); + expect(data.pirate.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.pirate.faceOff.damageDealt).toEqualTypeOf(); + expect(data.pirate.casualBrawl).toBeDefined(); + expectTypeOf(data.pirate.casualBrawl).toEqualTypeOf(); + expect(data.pirate.casualBrawl.kills).toBeDefined(); + expect(data.pirate.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.kills).toEqualTypeOf(); + expect(data.pirate.casualBrawl.assists).toBeDefined(); + expect(data.pirate.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.assists).toEqualTypeOf(); + expect(data.pirate.casualBrawl.deaths).toBeDefined(); + expect(data.pirate.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.deaths).toEqualTypeOf(); + expect(data.pirate.casualBrawl.KDR).toBeDefined(); + expect(data.pirate.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.KDR).toEqualTypeOf(); + expect(data.pirate.casualBrawl.wins).toBeDefined(); + expect(data.pirate.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.wins).toEqualTypeOf(); + expect(data.pirate.casualBrawl.losses).toBeDefined(); + expect(data.pirate.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.losses).toEqualTypeOf(); + expect(data.pirate.casualBrawl.WLR).toBeDefined(); + expect(data.pirate.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.WLR).toEqualTypeOf(); + expect(data.pirate.casualBrawl.finalKills).toBeDefined(); + expect(data.pirate.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.pirate.casualBrawl.finalAssists).toBeDefined(); + expect(data.pirate.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.pirate.casualBrawl.finalDeaths).toBeDefined(); + expect(data.pirate.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.pirate.casualBrawl.FKDR).toBeDefined(); + expect(data.pirate.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.pirate.casualBrawl.playedGames).toBeDefined(); + expect(data.pirate.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.pirate.casualBrawl.witherDamage).toBeDefined(); + expect(data.pirate.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.pirate.casualBrawl.defenderKills).toBeDefined(); + expect(data.pirate.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.pirate.casualBrawl.walked).toBeDefined(); + expect(data.pirate.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.walked).toEqualTypeOf(); + expect(data.pirate.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.pirate.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.pirate.casualBrawl.blocksBroken).toBeDefined(); + expect(data.pirate.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.pirate.casualBrawl.meleeKills).toBeDefined(); + expect(data.pirate.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.pirate.casualBrawl.damageDealt).toBeDefined(); + expect(data.pirate.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.pirate.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.sheep).toBeDefined(); + expectTypeOf(data.sheep).toEqualTypeOf(); + expect(data.sheep.kills).toBeDefined(); + expect(data.sheep.kills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.kills).toEqualTypeOf(); + expect(data.sheep.assists).toBeDefined(); + expect(data.sheep.assists).greaterThanOrEqual(0); + expectTypeOf(data.sheep.assists).toEqualTypeOf(); + expect(data.sheep.deaths).toBeDefined(); + expect(data.sheep.deaths).greaterThanOrEqual(0); + expectTypeOf(data.sheep.deaths).toEqualTypeOf(); + expect(data.sheep.KDR).toBeDefined(); + expect(data.sheep.KDR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.KDR).toEqualTypeOf(); + expect(data.sheep.wins).toBeDefined(); + expect(data.sheep.wins).greaterThanOrEqual(0); + expectTypeOf(data.sheep.wins).toEqualTypeOf(); + expect(data.sheep.losses).toBeDefined(); + expect(data.sheep.losses).greaterThanOrEqual(0); + expectTypeOf(data.sheep.losses).toEqualTypeOf(); + expect(data.sheep.WLR).toBeDefined(); + expect(data.sheep.WLR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.WLR).toEqualTypeOf(); + expect(data.sheep.finalKills).toBeDefined(); + expect(data.sheep.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.finalKills).toEqualTypeOf(); + expect(data.sheep.finalAssists).toBeDefined(); + expect(data.sheep.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.sheep.finalAssists).toEqualTypeOf(); + expect(data.sheep.finalDeaths).toBeDefined(); + expect(data.sheep.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.sheep.finalDeaths).toEqualTypeOf(); + expect(data.sheep.FKDR).toBeDefined(); + expect(data.sheep.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.FKDR).toEqualTypeOf(); + expect(data.sheep.playedGames).toBeDefined(); + expect(data.sheep.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.sheep.playedGames).toEqualTypeOf(); + expect(data.sheep.witherDamage).toBeDefined(); + expect(data.sheep.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.sheep.witherDamage).toEqualTypeOf(); + expect(data.sheep.defenderKills).toBeDefined(); + expect(data.sheep.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.defenderKills).toEqualTypeOf(); + expect(data.sheep.walked).toBeDefined(); + expect(data.sheep.walked).greaterThanOrEqual(0); + expectTypeOf(data.sheep.walked).toEqualTypeOf(); + expect(data.sheep.blocksPlaced).toBeDefined(); + expect(data.sheep.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.sheep.blocksPlaced).toEqualTypeOf(); + expect(data.sheep.blocksBroken).toBeDefined(); + expect(data.sheep.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.sheep.blocksBroken).toEqualTypeOf(); + expect(data.sheep.meleeKills).toBeDefined(); + expect(data.sheep.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.meleeKills).toEqualTypeOf(); + expect(data.sheep.damageDealt).toBeDefined(); + expect(data.sheep.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.sheep.damageDealt).toEqualTypeOf(); + expect(data.sheep.faceOff).toBeDefined(); + expectTypeOf(data.sheep.faceOff).toEqualTypeOf(); + expect(data.sheep.faceOff.kills).toBeDefined(); + expect(data.sheep.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.kills).toEqualTypeOf(); + expect(data.sheep.faceOff.assists).toBeDefined(); + expect(data.sheep.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.assists).toEqualTypeOf(); + expect(data.sheep.faceOff.deaths).toBeDefined(); + expect(data.sheep.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.deaths).toEqualTypeOf(); + expect(data.sheep.faceOff.KDR).toBeDefined(); + expect(data.sheep.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.KDR).toEqualTypeOf(); + expect(data.sheep.faceOff.wins).toBeDefined(); + expect(data.sheep.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.wins).toEqualTypeOf(); + expect(data.sheep.faceOff.losses).toBeDefined(); + expect(data.sheep.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.losses).toEqualTypeOf(); + expect(data.sheep.faceOff.WLR).toBeDefined(); + expect(data.sheep.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.WLR).toEqualTypeOf(); + expect(data.sheep.faceOff.finalKills).toBeDefined(); + expect(data.sheep.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.finalKills).toEqualTypeOf(); + expect(data.sheep.faceOff.finalAssists).toBeDefined(); + expect(data.sheep.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.finalAssists).toEqualTypeOf(); + expect(data.sheep.faceOff.finalDeaths).toBeDefined(); + expect(data.sheep.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.sheep.faceOff.FKDR).toBeDefined(); + expect(data.sheep.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.FKDR).toEqualTypeOf(); + expect(data.sheep.faceOff.playedGames).toBeDefined(); + expect(data.sheep.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.playedGames).toEqualTypeOf(); + expect(data.sheep.faceOff.witherDamage).toBeDefined(); + expect(data.sheep.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.witherDamage).toEqualTypeOf(); + expect(data.sheep.faceOff.defenderKills).toBeDefined(); + expect(data.sheep.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.defenderKills).toEqualTypeOf(); + expect(data.sheep.faceOff.walked).toBeDefined(); + expect(data.sheep.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.walked).toEqualTypeOf(); + expect(data.sheep.faceOff.blocksPlaced).toBeDefined(); + expect(data.sheep.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.sheep.faceOff.blocksBroken).toBeDefined(); + expect(data.sheep.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.sheep.faceOff.meleeKills).toBeDefined(); + expect(data.sheep.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.meleeKills).toEqualTypeOf(); + expect(data.sheep.faceOff.damageDealt).toBeDefined(); + expect(data.sheep.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.sheep.faceOff.damageDealt).toEqualTypeOf(); + expect(data.sheep.casualBrawl).toBeDefined(); + expectTypeOf(data.sheep.casualBrawl).toEqualTypeOf(); + expect(data.sheep.casualBrawl.kills).toBeDefined(); + expect(data.sheep.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.kills).toEqualTypeOf(); + expect(data.sheep.casualBrawl.assists).toBeDefined(); + expect(data.sheep.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.assists).toEqualTypeOf(); + expect(data.sheep.casualBrawl.deaths).toBeDefined(); + expect(data.sheep.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.deaths).toEqualTypeOf(); + expect(data.sheep.casualBrawl.KDR).toBeDefined(); + expect(data.sheep.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.KDR).toEqualTypeOf(); + expect(data.sheep.casualBrawl.wins).toBeDefined(); + expect(data.sheep.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.wins).toEqualTypeOf(); + expect(data.sheep.casualBrawl.losses).toBeDefined(); + expect(data.sheep.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.losses).toEqualTypeOf(); + expect(data.sheep.casualBrawl.WLR).toBeDefined(); + expect(data.sheep.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.WLR).toEqualTypeOf(); + expect(data.sheep.casualBrawl.finalKills).toBeDefined(); + expect(data.sheep.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.sheep.casualBrawl.finalAssists).toBeDefined(); + expect(data.sheep.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.sheep.casualBrawl.finalDeaths).toBeDefined(); + expect(data.sheep.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.sheep.casualBrawl.FKDR).toBeDefined(); + expect(data.sheep.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.sheep.casualBrawl.playedGames).toBeDefined(); + expect(data.sheep.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.sheep.casualBrawl.witherDamage).toBeDefined(); + expect(data.sheep.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.sheep.casualBrawl.defenderKills).toBeDefined(); + expect(data.sheep.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.sheep.casualBrawl.walked).toBeDefined(); + expect(data.sheep.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.walked).toEqualTypeOf(); + expect(data.sheep.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.sheep.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.sheep.casualBrawl.blocksBroken).toBeDefined(); + expect(data.sheep.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.sheep.casualBrawl.meleeKills).toBeDefined(); + expect(data.sheep.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.sheep.casualBrawl.damageDealt).toBeDefined(); + expect(data.sheep.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.sheep.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.skeleton).toBeDefined(); + expectTypeOf(data.skeleton).toEqualTypeOf(); + expect(data.skeleton.kills).toBeDefined(); + expect(data.skeleton.kills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.kills).toEqualTypeOf(); + expect(data.skeleton.assists).toBeDefined(); + expect(data.skeleton.assists).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.assists).toEqualTypeOf(); + expect(data.skeleton.deaths).toBeDefined(); + expect(data.skeleton.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.deaths).toEqualTypeOf(); + expect(data.skeleton.KDR).toBeDefined(); + expect(data.skeleton.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.KDR).toEqualTypeOf(); + expect(data.skeleton.wins).toBeDefined(); + expect(data.skeleton.wins).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.wins).toEqualTypeOf(); + expect(data.skeleton.losses).toBeDefined(); + expect(data.skeleton.losses).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.losses).toEqualTypeOf(); + expect(data.skeleton.WLR).toBeDefined(); + expect(data.skeleton.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.WLR).toEqualTypeOf(); + expect(data.skeleton.finalKills).toBeDefined(); + expect(data.skeleton.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.finalKills).toEqualTypeOf(); + expect(data.skeleton.finalAssists).toBeDefined(); + expect(data.skeleton.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.finalAssists).toEqualTypeOf(); + expect(data.skeleton.finalDeaths).toBeDefined(); + expect(data.skeleton.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.finalDeaths).toEqualTypeOf(); + expect(data.skeleton.FKDR).toBeDefined(); + expect(data.skeleton.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.FKDR).toEqualTypeOf(); + expect(data.skeleton.playedGames).toBeDefined(); + expect(data.skeleton.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.playedGames).toEqualTypeOf(); + expect(data.skeleton.witherDamage).toBeDefined(); + expect(data.skeleton.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.witherDamage).toEqualTypeOf(); + expect(data.skeleton.defenderKills).toBeDefined(); + expect(data.skeleton.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.defenderKills).toEqualTypeOf(); + expect(data.skeleton.walked).toBeDefined(); + expect(data.skeleton.walked).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.walked).toEqualTypeOf(); + expect(data.skeleton.blocksPlaced).toBeDefined(); + expect(data.skeleton.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.blocksPlaced).toEqualTypeOf(); + expect(data.skeleton.blocksBroken).toBeDefined(); + expect(data.skeleton.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.blocksBroken).toEqualTypeOf(); + expect(data.skeleton.meleeKills).toBeDefined(); + expect(data.skeleton.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.meleeKills).toEqualTypeOf(); + expect(data.skeleton.damageDealt).toBeDefined(); + expect(data.skeleton.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.damageDealt).toEqualTypeOf(); + expect(data.skeleton.faceOff).toBeDefined(); + expectTypeOf(data.skeleton.faceOff).toEqualTypeOf(); + expect(data.skeleton.faceOff.kills).toBeDefined(); + expect(data.skeleton.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.kills).toEqualTypeOf(); + expect(data.skeleton.faceOff.assists).toBeDefined(); + expect(data.skeleton.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.assists).toEqualTypeOf(); + expect(data.skeleton.faceOff.deaths).toBeDefined(); + expect(data.skeleton.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.deaths).toEqualTypeOf(); + expect(data.skeleton.faceOff.KDR).toBeDefined(); + expect(data.skeleton.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.KDR).toEqualTypeOf(); + expect(data.skeleton.faceOff.wins).toBeDefined(); + expect(data.skeleton.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.wins).toEqualTypeOf(); + expect(data.skeleton.faceOff.losses).toBeDefined(); + expect(data.skeleton.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.losses).toEqualTypeOf(); + expect(data.skeleton.faceOff.WLR).toBeDefined(); + expect(data.skeleton.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.WLR).toEqualTypeOf(); + expect(data.skeleton.faceOff.finalKills).toBeDefined(); + expect(data.skeleton.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.finalKills).toEqualTypeOf(); + expect(data.skeleton.faceOff.finalAssists).toBeDefined(); + expect(data.skeleton.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.finalAssists).toEqualTypeOf(); + expect(data.skeleton.faceOff.finalDeaths).toBeDefined(); + expect(data.skeleton.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.skeleton.faceOff.FKDR).toBeDefined(); + expect(data.skeleton.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.FKDR).toEqualTypeOf(); + expect(data.skeleton.faceOff.playedGames).toBeDefined(); + expect(data.skeleton.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.playedGames).toEqualTypeOf(); + expect(data.skeleton.faceOff.witherDamage).toBeDefined(); + expect(data.skeleton.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.witherDamage).toEqualTypeOf(); + expect(data.skeleton.faceOff.defenderKills).toBeDefined(); + expect(data.skeleton.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.defenderKills).toEqualTypeOf(); + expect(data.skeleton.faceOff.walked).toBeDefined(); + expect(data.skeleton.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.walked).toEqualTypeOf(); + expect(data.skeleton.faceOff.blocksPlaced).toBeDefined(); + expect(data.skeleton.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.skeleton.faceOff.blocksBroken).toBeDefined(); + expect(data.skeleton.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.skeleton.faceOff.meleeKills).toBeDefined(); + expect(data.skeleton.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.meleeKills).toEqualTypeOf(); + expect(data.skeleton.faceOff.damageDealt).toBeDefined(); + expect(data.skeleton.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.faceOff.damageDealt).toEqualTypeOf(); + expect(data.skeleton.casualBrawl).toBeDefined(); + expectTypeOf(data.skeleton.casualBrawl).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.kills).toBeDefined(); + expect(data.skeleton.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.kills).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.assists).toBeDefined(); + expect(data.skeleton.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.assists).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.deaths).toBeDefined(); + expect(data.skeleton.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.deaths).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.KDR).toBeDefined(); + expect(data.skeleton.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.KDR).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.wins).toBeDefined(); + expect(data.skeleton.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.wins).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.losses).toBeDefined(); + expect(data.skeleton.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.losses).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.WLR).toBeDefined(); + expect(data.skeleton.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.WLR).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.finalKills).toBeDefined(); + expect(data.skeleton.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.finalAssists).toBeDefined(); + expect(data.skeleton.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.finalDeaths).toBeDefined(); + expect(data.skeleton.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.FKDR).toBeDefined(); + expect(data.skeleton.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.playedGames).toBeDefined(); + expect(data.skeleton.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.witherDamage).toBeDefined(); + expect(data.skeleton.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.defenderKills).toBeDefined(); + expect(data.skeleton.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.walked).toBeDefined(); + expect(data.skeleton.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.walked).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.skeleton.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.blocksBroken).toBeDefined(); + expect(data.skeleton.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.meleeKills).toBeDefined(); + expect(data.skeleton.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.skeleton.casualBrawl.damageDealt).toBeDefined(); + expect(data.skeleton.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.skeleton.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.spider).toBeDefined(); + expectTypeOf(data.spider).toEqualTypeOf(); + expect(data.spider.kills).toBeDefined(); + expect(data.spider.kills).greaterThanOrEqual(0); + expectTypeOf(data.spider.kills).toEqualTypeOf(); + expect(data.spider.assists).toBeDefined(); + expect(data.spider.assists).greaterThanOrEqual(0); + expectTypeOf(data.spider.assists).toEqualTypeOf(); + expect(data.spider.deaths).toBeDefined(); + expect(data.spider.deaths).greaterThanOrEqual(0); + expectTypeOf(data.spider.deaths).toEqualTypeOf(); + expect(data.spider.KDR).toBeDefined(); + expect(data.spider.KDR).greaterThanOrEqual(0); + expectTypeOf(data.spider.KDR).toEqualTypeOf(); + expect(data.spider.wins).toBeDefined(); + expect(data.spider.wins).greaterThanOrEqual(0); + expectTypeOf(data.spider.wins).toEqualTypeOf(); + expect(data.spider.losses).toBeDefined(); + expect(data.spider.losses).greaterThanOrEqual(0); + expectTypeOf(data.spider.losses).toEqualTypeOf(); + expect(data.spider.WLR).toBeDefined(); + expect(data.spider.WLR).greaterThanOrEqual(0); + expectTypeOf(data.spider.WLR).toEqualTypeOf(); + expect(data.spider.finalKills).toBeDefined(); + expect(data.spider.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.finalKills).toEqualTypeOf(); + expect(data.spider.finalAssists).toBeDefined(); + expect(data.spider.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.spider.finalAssists).toEqualTypeOf(); + expect(data.spider.finalDeaths).toBeDefined(); + expect(data.spider.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.spider.finalDeaths).toEqualTypeOf(); + expect(data.spider.FKDR).toBeDefined(); + expect(data.spider.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.spider.FKDR).toEqualTypeOf(); + expect(data.spider.playedGames).toBeDefined(); + expect(data.spider.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.spider.playedGames).toEqualTypeOf(); + expect(data.spider.witherDamage).toBeDefined(); + expect(data.spider.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.spider.witherDamage).toEqualTypeOf(); + expect(data.spider.defenderKills).toBeDefined(); + expect(data.spider.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.defenderKills).toEqualTypeOf(); + expect(data.spider.walked).toBeDefined(); + expect(data.spider.walked).greaterThanOrEqual(0); + expectTypeOf(data.spider.walked).toEqualTypeOf(); + expect(data.spider.blocksPlaced).toBeDefined(); + expect(data.spider.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.spider.blocksPlaced).toEqualTypeOf(); + expect(data.spider.blocksBroken).toBeDefined(); + expect(data.spider.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.spider.blocksBroken).toEqualTypeOf(); + expect(data.spider.meleeKills).toBeDefined(); + expect(data.spider.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.meleeKills).toEqualTypeOf(); + expect(data.spider.damageDealt).toBeDefined(); + expect(data.spider.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.spider.damageDealt).toEqualTypeOf(); + expect(data.spider.faceOff).toBeDefined(); + expectTypeOf(data.spider.faceOff).toEqualTypeOf(); + expect(data.spider.faceOff.kills).toBeDefined(); + expect(data.spider.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.kills).toEqualTypeOf(); + expect(data.spider.faceOff.assists).toBeDefined(); + expect(data.spider.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.assists).toEqualTypeOf(); + expect(data.spider.faceOff.deaths).toBeDefined(); + expect(data.spider.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.deaths).toEqualTypeOf(); + expect(data.spider.faceOff.KDR).toBeDefined(); + expect(data.spider.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.KDR).toEqualTypeOf(); + expect(data.spider.faceOff.wins).toBeDefined(); + expect(data.spider.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.wins).toEqualTypeOf(); + expect(data.spider.faceOff.losses).toBeDefined(); + expect(data.spider.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.losses).toEqualTypeOf(); + expect(data.spider.faceOff.WLR).toBeDefined(); + expect(data.spider.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.WLR).toEqualTypeOf(); + expect(data.spider.faceOff.finalKills).toBeDefined(); + expect(data.spider.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.finalKills).toEqualTypeOf(); + expect(data.spider.faceOff.finalAssists).toBeDefined(); + expect(data.spider.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.finalAssists).toEqualTypeOf(); + expect(data.spider.faceOff.finalDeaths).toBeDefined(); + expect(data.spider.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.spider.faceOff.FKDR).toBeDefined(); + expect(data.spider.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.FKDR).toEqualTypeOf(); + expect(data.spider.faceOff.playedGames).toBeDefined(); + expect(data.spider.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.playedGames).toEqualTypeOf(); + expect(data.spider.faceOff.witherDamage).toBeDefined(); + expect(data.spider.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.witherDamage).toEqualTypeOf(); + expect(data.spider.faceOff.defenderKills).toBeDefined(); + expect(data.spider.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.defenderKills).toEqualTypeOf(); + expect(data.spider.faceOff.walked).toBeDefined(); + expect(data.spider.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.walked).toEqualTypeOf(); + expect(data.spider.faceOff.blocksPlaced).toBeDefined(); + expect(data.spider.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.spider.faceOff.blocksBroken).toBeDefined(); + expect(data.spider.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.spider.faceOff.meleeKills).toBeDefined(); + expect(data.spider.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.meleeKills).toEqualTypeOf(); + expect(data.spider.faceOff.damageDealt).toBeDefined(); + expect(data.spider.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.spider.faceOff.damageDealt).toEqualTypeOf(); + expect(data.spider.casualBrawl).toBeDefined(); + expectTypeOf(data.spider.casualBrawl).toEqualTypeOf(); + expect(data.spider.casualBrawl.kills).toBeDefined(); + expect(data.spider.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.kills).toEqualTypeOf(); + expect(data.spider.casualBrawl.assists).toBeDefined(); + expect(data.spider.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.assists).toEqualTypeOf(); + expect(data.spider.casualBrawl.deaths).toBeDefined(); + expect(data.spider.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.deaths).toEqualTypeOf(); + expect(data.spider.casualBrawl.KDR).toBeDefined(); + expect(data.spider.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.KDR).toEqualTypeOf(); + expect(data.spider.casualBrawl.wins).toBeDefined(); + expect(data.spider.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.wins).toEqualTypeOf(); + expect(data.spider.casualBrawl.losses).toBeDefined(); + expect(data.spider.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.losses).toEqualTypeOf(); + expect(data.spider.casualBrawl.WLR).toBeDefined(); + expect(data.spider.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.WLR).toEqualTypeOf(); + expect(data.spider.casualBrawl.finalKills).toBeDefined(); + expect(data.spider.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.spider.casualBrawl.finalAssists).toBeDefined(); + expect(data.spider.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.spider.casualBrawl.finalDeaths).toBeDefined(); + expect(data.spider.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.spider.casualBrawl.FKDR).toBeDefined(); + expect(data.spider.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.spider.casualBrawl.playedGames).toBeDefined(); + expect(data.spider.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.spider.casualBrawl.witherDamage).toBeDefined(); + expect(data.spider.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.spider.casualBrawl.defenderKills).toBeDefined(); + expect(data.spider.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.spider.casualBrawl.walked).toBeDefined(); + expect(data.spider.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.walked).toEqualTypeOf(); + expect(data.spider.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.spider.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.spider.casualBrawl.blocksBroken).toBeDefined(); + expect(data.spider.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.spider.casualBrawl.meleeKills).toBeDefined(); + expect(data.spider.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.spider.casualBrawl.damageDealt).toBeDefined(); + expect(data.spider.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.spider.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.werewolf).toBeDefined(); + expectTypeOf(data.werewolf).toEqualTypeOf(); + expect(data.werewolf.kills).toBeDefined(); + expect(data.werewolf.kills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.kills).toEqualTypeOf(); + expect(data.werewolf.assists).toBeDefined(); + expect(data.werewolf.assists).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.assists).toEqualTypeOf(); + expect(data.werewolf.deaths).toBeDefined(); + expect(data.werewolf.deaths).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.deaths).toEqualTypeOf(); + expect(data.werewolf.KDR).toBeDefined(); + expect(data.werewolf.KDR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.KDR).toEqualTypeOf(); + expect(data.werewolf.wins).toBeDefined(); + expect(data.werewolf.wins).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.wins).toEqualTypeOf(); + expect(data.werewolf.losses).toBeDefined(); + expect(data.werewolf.losses).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.losses).toEqualTypeOf(); + expect(data.werewolf.WLR).toBeDefined(); + expect(data.werewolf.WLR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.WLR).toEqualTypeOf(); + expect(data.werewolf.finalKills).toBeDefined(); + expect(data.werewolf.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.finalKills).toEqualTypeOf(); + expect(data.werewolf.finalAssists).toBeDefined(); + expect(data.werewolf.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.finalAssists).toEqualTypeOf(); + expect(data.werewolf.finalDeaths).toBeDefined(); + expect(data.werewolf.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.finalDeaths).toEqualTypeOf(); + expect(data.werewolf.FKDR).toBeDefined(); + expect(data.werewolf.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.FKDR).toEqualTypeOf(); + expect(data.werewolf.playedGames).toBeDefined(); + expect(data.werewolf.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.playedGames).toEqualTypeOf(); + expect(data.werewolf.witherDamage).toBeDefined(); + expect(data.werewolf.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.witherDamage).toEqualTypeOf(); + expect(data.werewolf.defenderKills).toBeDefined(); + expect(data.werewolf.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.defenderKills).toEqualTypeOf(); + expect(data.werewolf.walked).toBeDefined(); + expect(data.werewolf.walked).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.walked).toEqualTypeOf(); + expect(data.werewolf.blocksPlaced).toBeDefined(); + expect(data.werewolf.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.blocksPlaced).toEqualTypeOf(); + expect(data.werewolf.blocksBroken).toBeDefined(); + expect(data.werewolf.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.blocksBroken).toEqualTypeOf(); + expect(data.werewolf.meleeKills).toBeDefined(); + expect(data.werewolf.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.meleeKills).toEqualTypeOf(); + expect(data.werewolf.damageDealt).toBeDefined(); + expect(data.werewolf.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.damageDealt).toEqualTypeOf(); + expect(data.werewolf.faceOff).toBeDefined(); + expectTypeOf(data.werewolf.faceOff).toEqualTypeOf(); + expect(data.werewolf.faceOff.kills).toBeDefined(); + expect(data.werewolf.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.kills).toEqualTypeOf(); + expect(data.werewolf.faceOff.assists).toBeDefined(); + expect(data.werewolf.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.assists).toEqualTypeOf(); + expect(data.werewolf.faceOff.deaths).toBeDefined(); + expect(data.werewolf.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.deaths).toEqualTypeOf(); + expect(data.werewolf.faceOff.KDR).toBeDefined(); + expect(data.werewolf.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.KDR).toEqualTypeOf(); + expect(data.werewolf.faceOff.wins).toBeDefined(); + expect(data.werewolf.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.wins).toEqualTypeOf(); + expect(data.werewolf.faceOff.losses).toBeDefined(); + expect(data.werewolf.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.losses).toEqualTypeOf(); + expect(data.werewolf.faceOff.WLR).toBeDefined(); + expect(data.werewolf.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.WLR).toEqualTypeOf(); + expect(data.werewolf.faceOff.finalKills).toBeDefined(); + expect(data.werewolf.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.finalKills).toEqualTypeOf(); + expect(data.werewolf.faceOff.finalAssists).toBeDefined(); + expect(data.werewolf.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.finalAssists).toEqualTypeOf(); + expect(data.werewolf.faceOff.finalDeaths).toBeDefined(); + expect(data.werewolf.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.werewolf.faceOff.FKDR).toBeDefined(); + expect(data.werewolf.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.FKDR).toEqualTypeOf(); + expect(data.werewolf.faceOff.playedGames).toBeDefined(); + expect(data.werewolf.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.playedGames).toEqualTypeOf(); + expect(data.werewolf.faceOff.witherDamage).toBeDefined(); + expect(data.werewolf.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.witherDamage).toEqualTypeOf(); + expect(data.werewolf.faceOff.defenderKills).toBeDefined(); + expect(data.werewolf.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.defenderKills).toEqualTypeOf(); + expect(data.werewolf.faceOff.walked).toBeDefined(); + expect(data.werewolf.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.walked).toEqualTypeOf(); + expect(data.werewolf.faceOff.blocksPlaced).toBeDefined(); + expect(data.werewolf.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.werewolf.faceOff.blocksBroken).toBeDefined(); + expect(data.werewolf.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.werewolf.faceOff.meleeKills).toBeDefined(); + expect(data.werewolf.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.meleeKills).toEqualTypeOf(); + expect(data.werewolf.faceOff.damageDealt).toBeDefined(); + expect(data.werewolf.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.faceOff.damageDealt).toEqualTypeOf(); + expect(data.werewolf.casualBrawl).toBeDefined(); + expectTypeOf(data.werewolf.casualBrawl).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.kills).toBeDefined(); + expect(data.werewolf.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.kills).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.assists).toBeDefined(); + expect(data.werewolf.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.assists).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.deaths).toBeDefined(); + expect(data.werewolf.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.deaths).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.KDR).toBeDefined(); + expect(data.werewolf.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.KDR).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.wins).toBeDefined(); + expect(data.werewolf.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.wins).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.losses).toBeDefined(); + expect(data.werewolf.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.losses).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.WLR).toBeDefined(); + expect(data.werewolf.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.WLR).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.finalKills).toBeDefined(); + expect(data.werewolf.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.finalAssists).toBeDefined(); + expect(data.werewolf.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.finalDeaths).toBeDefined(); + expect(data.werewolf.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.FKDR).toBeDefined(); + expect(data.werewolf.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.playedGames).toBeDefined(); + expect(data.werewolf.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.witherDamage).toBeDefined(); + expect(data.werewolf.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.defenderKills).toBeDefined(); + expect(data.werewolf.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.walked).toBeDefined(); + expect(data.werewolf.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.walked).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.werewolf.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.blocksBroken).toBeDefined(); + expect(data.werewolf.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.meleeKills).toBeDefined(); + expect(data.werewolf.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.werewolf.casualBrawl.damageDealt).toBeDefined(); + expect(data.werewolf.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.werewolf.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.angel).toBeDefined(); + expectTypeOf(data.angel).toEqualTypeOf(); + expect(data.angel.kills).toBeDefined(); + expect(data.angel.kills).greaterThanOrEqual(0); + expectTypeOf(data.angel.kills).toEqualTypeOf(); + expect(data.angel.assists).toBeDefined(); + expect(data.angel.assists).greaterThanOrEqual(0); + expectTypeOf(data.angel.assists).toEqualTypeOf(); + expect(data.angel.deaths).toBeDefined(); + expect(data.angel.deaths).greaterThanOrEqual(0); + expectTypeOf(data.angel.deaths).toEqualTypeOf(); + expect(data.angel.KDR).toBeDefined(); + expect(data.angel.KDR).greaterThanOrEqual(0); + expectTypeOf(data.angel.KDR).toEqualTypeOf(); + expect(data.angel.wins).toBeDefined(); + expect(data.angel.wins).greaterThanOrEqual(0); + expectTypeOf(data.angel.wins).toEqualTypeOf(); + expect(data.angel.losses).toBeDefined(); + expect(data.angel.losses).greaterThanOrEqual(0); + expectTypeOf(data.angel.losses).toEqualTypeOf(); + expect(data.angel.WLR).toBeDefined(); + expect(data.angel.WLR).greaterThanOrEqual(0); + expectTypeOf(data.angel.WLR).toEqualTypeOf(); + expect(data.angel.finalKills).toBeDefined(); + expect(data.angel.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.finalKills).toEqualTypeOf(); + expect(data.angel.finalAssists).toBeDefined(); + expect(data.angel.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.angel.finalAssists).toEqualTypeOf(); + expect(data.angel.finalDeaths).toBeDefined(); + expect(data.angel.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.angel.finalDeaths).toEqualTypeOf(); + expect(data.angel.FKDR).toBeDefined(); + expect(data.angel.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.angel.FKDR).toEqualTypeOf(); + expect(data.angel.playedGames).toBeDefined(); + expect(data.angel.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.angel.playedGames).toEqualTypeOf(); + expect(data.angel.witherDamage).toBeDefined(); + expect(data.angel.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.angel.witherDamage).toEqualTypeOf(); + expect(data.angel.defenderKills).toBeDefined(); + expect(data.angel.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.defenderKills).toEqualTypeOf(); + expect(data.angel.walked).toBeDefined(); + expect(data.angel.walked).greaterThanOrEqual(0); + expectTypeOf(data.angel.walked).toEqualTypeOf(); + expect(data.angel.blocksPlaced).toBeDefined(); + expect(data.angel.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.angel.blocksPlaced).toEqualTypeOf(); + expect(data.angel.blocksBroken).toBeDefined(); + expect(data.angel.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.angel.blocksBroken).toEqualTypeOf(); + expect(data.angel.meleeKills).toBeDefined(); + expect(data.angel.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.meleeKills).toEqualTypeOf(); + expect(data.angel.damageDealt).toBeDefined(); + expect(data.angel.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.angel.damageDealt).toEqualTypeOf(); + expect(data.angel.faceOff).toBeDefined(); + expectTypeOf(data.angel.faceOff).toEqualTypeOf(); + expect(data.angel.faceOff.kills).toBeDefined(); + expect(data.angel.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.kills).toEqualTypeOf(); + expect(data.angel.faceOff.assists).toBeDefined(); + expect(data.angel.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.assists).toEqualTypeOf(); + expect(data.angel.faceOff.deaths).toBeDefined(); + expect(data.angel.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.deaths).toEqualTypeOf(); + expect(data.angel.faceOff.KDR).toBeDefined(); + expect(data.angel.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.KDR).toEqualTypeOf(); + expect(data.angel.faceOff.wins).toBeDefined(); + expect(data.angel.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.wins).toEqualTypeOf(); + expect(data.angel.faceOff.losses).toBeDefined(); + expect(data.angel.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.losses).toEqualTypeOf(); + expect(data.angel.faceOff.WLR).toBeDefined(); + expect(data.angel.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.WLR).toEqualTypeOf(); + expect(data.angel.faceOff.finalKills).toBeDefined(); + expect(data.angel.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.finalKills).toEqualTypeOf(); + expect(data.angel.faceOff.finalAssists).toBeDefined(); + expect(data.angel.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.finalAssists).toEqualTypeOf(); + expect(data.angel.faceOff.finalDeaths).toBeDefined(); + expect(data.angel.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.angel.faceOff.FKDR).toBeDefined(); + expect(data.angel.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.FKDR).toEqualTypeOf(); + expect(data.angel.faceOff.playedGames).toBeDefined(); + expect(data.angel.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.playedGames).toEqualTypeOf(); + expect(data.angel.faceOff.witherDamage).toBeDefined(); + expect(data.angel.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.witherDamage).toEqualTypeOf(); + expect(data.angel.faceOff.defenderKills).toBeDefined(); + expect(data.angel.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.defenderKills).toEqualTypeOf(); + expect(data.angel.faceOff.walked).toBeDefined(); + expect(data.angel.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.walked).toEqualTypeOf(); + expect(data.angel.faceOff.blocksPlaced).toBeDefined(); + expect(data.angel.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.angel.faceOff.blocksBroken).toBeDefined(); + expect(data.angel.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.angel.faceOff.meleeKills).toBeDefined(); + expect(data.angel.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.meleeKills).toEqualTypeOf(); + expect(data.angel.faceOff.damageDealt).toBeDefined(); + expect(data.angel.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.angel.faceOff.damageDealt).toEqualTypeOf(); + expect(data.angel.casualBrawl).toBeDefined(); + expectTypeOf(data.angel.casualBrawl).toEqualTypeOf(); + expect(data.angel.casualBrawl.kills).toBeDefined(); + expect(data.angel.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.kills).toEqualTypeOf(); + expect(data.angel.casualBrawl.assists).toBeDefined(); + expect(data.angel.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.assists).toEqualTypeOf(); + expect(data.angel.casualBrawl.deaths).toBeDefined(); + expect(data.angel.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.deaths).toEqualTypeOf(); + expect(data.angel.casualBrawl.KDR).toBeDefined(); + expect(data.angel.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.KDR).toEqualTypeOf(); + expect(data.angel.casualBrawl.wins).toBeDefined(); + expect(data.angel.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.wins).toEqualTypeOf(); + expect(data.angel.casualBrawl.losses).toBeDefined(); + expect(data.angel.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.losses).toEqualTypeOf(); + expect(data.angel.casualBrawl.WLR).toBeDefined(); + expect(data.angel.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.WLR).toEqualTypeOf(); + expect(data.angel.casualBrawl.finalKills).toBeDefined(); + expect(data.angel.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.angel.casualBrawl.finalAssists).toBeDefined(); + expect(data.angel.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.angel.casualBrawl.finalDeaths).toBeDefined(); + expect(data.angel.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.angel.casualBrawl.FKDR).toBeDefined(); + expect(data.angel.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.angel.casualBrawl.playedGames).toBeDefined(); + expect(data.angel.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.angel.casualBrawl.witherDamage).toBeDefined(); + expect(data.angel.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.angel.casualBrawl.defenderKills).toBeDefined(); + expect(data.angel.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.angel.casualBrawl.walked).toBeDefined(); + expect(data.angel.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.walked).toEqualTypeOf(); + expect(data.angel.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.angel.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.angel.casualBrawl.blocksBroken).toBeDefined(); + expect(data.angel.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.angel.casualBrawl.meleeKills).toBeDefined(); + expect(data.angel.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.angel.casualBrawl.damageDealt).toBeDefined(); + expect(data.angel.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.angel.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.assassin).toBeDefined(); + expectTypeOf(data.assassin).toEqualTypeOf(); + expect(data.assassin.kills).toBeDefined(); + expect(data.assassin.kills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.kills).toEqualTypeOf(); + expect(data.assassin.assists).toBeDefined(); + expect(data.assassin.assists).greaterThanOrEqual(0); + expectTypeOf(data.assassin.assists).toEqualTypeOf(); + expect(data.assassin.deaths).toBeDefined(); + expect(data.assassin.deaths).greaterThanOrEqual(0); + expectTypeOf(data.assassin.deaths).toEqualTypeOf(); + expect(data.assassin.KDR).toBeDefined(); + expect(data.assassin.KDR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.KDR).toEqualTypeOf(); + expect(data.assassin.wins).toBeDefined(); + expect(data.assassin.wins).greaterThanOrEqual(0); + expectTypeOf(data.assassin.wins).toEqualTypeOf(); + expect(data.assassin.losses).toBeDefined(); + expect(data.assassin.losses).greaterThanOrEqual(0); + expectTypeOf(data.assassin.losses).toEqualTypeOf(); + expect(data.assassin.WLR).toBeDefined(); + expect(data.assassin.WLR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.WLR).toEqualTypeOf(); + expect(data.assassin.finalKills).toBeDefined(); + expect(data.assassin.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.finalKills).toEqualTypeOf(); + expect(data.assassin.finalAssists).toBeDefined(); + expect(data.assassin.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.assassin.finalAssists).toEqualTypeOf(); + expect(data.assassin.finalDeaths).toBeDefined(); + expect(data.assassin.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.assassin.finalDeaths).toEqualTypeOf(); + expect(data.assassin.FKDR).toBeDefined(); + expect(data.assassin.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.FKDR).toEqualTypeOf(); + expect(data.assassin.playedGames).toBeDefined(); + expect(data.assassin.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.assassin.playedGames).toEqualTypeOf(); + expect(data.assassin.witherDamage).toBeDefined(); + expect(data.assassin.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.assassin.witherDamage).toEqualTypeOf(); + expect(data.assassin.defenderKills).toBeDefined(); + expect(data.assassin.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.defenderKills).toEqualTypeOf(); + expect(data.assassin.walked).toBeDefined(); + expect(data.assassin.walked).greaterThanOrEqual(0); + expectTypeOf(data.assassin.walked).toEqualTypeOf(); + expect(data.assassin.blocksPlaced).toBeDefined(); + expect(data.assassin.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.assassin.blocksPlaced).toEqualTypeOf(); + expect(data.assassin.blocksBroken).toBeDefined(); + expect(data.assassin.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.assassin.blocksBroken).toEqualTypeOf(); + expect(data.assassin.meleeKills).toBeDefined(); + expect(data.assassin.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.meleeKills).toEqualTypeOf(); + expect(data.assassin.damageDealt).toBeDefined(); + expect(data.assassin.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.assassin.damageDealt).toEqualTypeOf(); + expect(data.assassin.faceOff).toBeDefined(); + expectTypeOf(data.assassin.faceOff).toEqualTypeOf(); + expect(data.assassin.faceOff.kills).toBeDefined(); + expect(data.assassin.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.kills).toEqualTypeOf(); + expect(data.assassin.faceOff.assists).toBeDefined(); + expect(data.assassin.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.assists).toEqualTypeOf(); + expect(data.assassin.faceOff.deaths).toBeDefined(); + expect(data.assassin.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.deaths).toEqualTypeOf(); + expect(data.assassin.faceOff.KDR).toBeDefined(); + expect(data.assassin.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.KDR).toEqualTypeOf(); + expect(data.assassin.faceOff.wins).toBeDefined(); + expect(data.assassin.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.wins).toEqualTypeOf(); + expect(data.assassin.faceOff.losses).toBeDefined(); + expect(data.assassin.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.losses).toEqualTypeOf(); + expect(data.assassin.faceOff.WLR).toBeDefined(); + expect(data.assassin.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.WLR).toEqualTypeOf(); + expect(data.assassin.faceOff.finalKills).toBeDefined(); + expect(data.assassin.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.finalKills).toEqualTypeOf(); + expect(data.assassin.faceOff.finalAssists).toBeDefined(); + expect(data.assassin.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.finalAssists).toEqualTypeOf(); + expect(data.assassin.faceOff.finalDeaths).toBeDefined(); + expect(data.assassin.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.assassin.faceOff.FKDR).toBeDefined(); + expect(data.assassin.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.FKDR).toEqualTypeOf(); + expect(data.assassin.faceOff.playedGames).toBeDefined(); + expect(data.assassin.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.playedGames).toEqualTypeOf(); + expect(data.assassin.faceOff.witherDamage).toBeDefined(); + expect(data.assassin.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.witherDamage).toEqualTypeOf(); + expect(data.assassin.faceOff.defenderKills).toBeDefined(); + expect(data.assassin.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.defenderKills).toEqualTypeOf(); + expect(data.assassin.faceOff.walked).toBeDefined(); + expect(data.assassin.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.walked).toEqualTypeOf(); + expect(data.assassin.faceOff.blocksPlaced).toBeDefined(); + expect(data.assassin.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.assassin.faceOff.blocksBroken).toBeDefined(); + expect(data.assassin.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.assassin.faceOff.meleeKills).toBeDefined(); + expect(data.assassin.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.meleeKills).toEqualTypeOf(); + expect(data.assassin.faceOff.damageDealt).toBeDefined(); + expect(data.assassin.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.assassin.faceOff.damageDealt).toEqualTypeOf(); + expect(data.assassin.casualBrawl).toBeDefined(); + expectTypeOf(data.assassin.casualBrawl).toEqualTypeOf(); + expect(data.assassin.casualBrawl.kills).toBeDefined(); + expect(data.assassin.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.kills).toEqualTypeOf(); + expect(data.assassin.casualBrawl.assists).toBeDefined(); + expect(data.assassin.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.assists).toEqualTypeOf(); + expect(data.assassin.casualBrawl.deaths).toBeDefined(); + expect(data.assassin.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.deaths).toEqualTypeOf(); + expect(data.assassin.casualBrawl.KDR).toBeDefined(); + expect(data.assassin.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.KDR).toEqualTypeOf(); + expect(data.assassin.casualBrawl.wins).toBeDefined(); + expect(data.assassin.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.wins).toEqualTypeOf(); + expect(data.assassin.casualBrawl.losses).toBeDefined(); + expect(data.assassin.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.losses).toEqualTypeOf(); + expect(data.assassin.casualBrawl.WLR).toBeDefined(); + expect(data.assassin.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.WLR).toEqualTypeOf(); + expect(data.assassin.casualBrawl.finalKills).toBeDefined(); + expect(data.assassin.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.assassin.casualBrawl.finalAssists).toBeDefined(); + expect(data.assassin.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.assassin.casualBrawl.finalDeaths).toBeDefined(); + expect(data.assassin.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.assassin.casualBrawl.FKDR).toBeDefined(); + expect(data.assassin.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.assassin.casualBrawl.playedGames).toBeDefined(); + expect(data.assassin.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.assassin.casualBrawl.witherDamage).toBeDefined(); + expect(data.assassin.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.assassin.casualBrawl.defenderKills).toBeDefined(); + expect(data.assassin.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.assassin.casualBrawl.walked).toBeDefined(); + expect(data.assassin.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.walked).toEqualTypeOf(); + expect(data.assassin.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.assassin.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.assassin.casualBrawl.blocksBroken).toBeDefined(); + expect(data.assassin.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.assassin.casualBrawl.meleeKills).toBeDefined(); + expect(data.assassin.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.assassin.casualBrawl.damageDealt).toBeDefined(); + expect(data.assassin.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.assassin.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.automaton).toBeDefined(); + expectTypeOf(data.automaton).toEqualTypeOf(); + expect(data.automaton.kills).toBeDefined(); + expect(data.automaton.kills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.kills).toEqualTypeOf(); + expect(data.automaton.assists).toBeDefined(); + expect(data.automaton.assists).greaterThanOrEqual(0); + expectTypeOf(data.automaton.assists).toEqualTypeOf(); + expect(data.automaton.deaths).toBeDefined(); + expect(data.automaton.deaths).greaterThanOrEqual(0); + expectTypeOf(data.automaton.deaths).toEqualTypeOf(); + expect(data.automaton.KDR).toBeDefined(); + expect(data.automaton.KDR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.KDR).toEqualTypeOf(); + expect(data.automaton.wins).toBeDefined(); + expect(data.automaton.wins).greaterThanOrEqual(0); + expectTypeOf(data.automaton.wins).toEqualTypeOf(); + expect(data.automaton.losses).toBeDefined(); + expect(data.automaton.losses).greaterThanOrEqual(0); + expectTypeOf(data.automaton.losses).toEqualTypeOf(); + expect(data.automaton.WLR).toBeDefined(); + expect(data.automaton.WLR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.WLR).toEqualTypeOf(); + expect(data.automaton.finalKills).toBeDefined(); + expect(data.automaton.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.finalKills).toEqualTypeOf(); + expect(data.automaton.finalAssists).toBeDefined(); + expect(data.automaton.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.automaton.finalAssists).toEqualTypeOf(); + expect(data.automaton.finalDeaths).toBeDefined(); + expect(data.automaton.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.automaton.finalDeaths).toEqualTypeOf(); + expect(data.automaton.FKDR).toBeDefined(); + expect(data.automaton.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.FKDR).toEqualTypeOf(); + expect(data.automaton.playedGames).toBeDefined(); + expect(data.automaton.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.automaton.playedGames).toEqualTypeOf(); + expect(data.automaton.witherDamage).toBeDefined(); + expect(data.automaton.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.automaton.witherDamage).toEqualTypeOf(); + expect(data.automaton.defenderKills).toBeDefined(); + expect(data.automaton.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.defenderKills).toEqualTypeOf(); + expect(data.automaton.walked).toBeDefined(); + expect(data.automaton.walked).greaterThanOrEqual(0); + expectTypeOf(data.automaton.walked).toEqualTypeOf(); + expect(data.automaton.blocksPlaced).toBeDefined(); + expect(data.automaton.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.automaton.blocksPlaced).toEqualTypeOf(); + expect(data.automaton.blocksBroken).toBeDefined(); + expect(data.automaton.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.automaton.blocksBroken).toEqualTypeOf(); + expect(data.automaton.meleeKills).toBeDefined(); + expect(data.automaton.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.meleeKills).toEqualTypeOf(); + expect(data.automaton.damageDealt).toBeDefined(); + expect(data.automaton.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.automaton.damageDealt).toEqualTypeOf(); + expect(data.automaton.faceOff).toBeDefined(); + expectTypeOf(data.automaton.faceOff).toEqualTypeOf(); + expect(data.automaton.faceOff.kills).toBeDefined(); + expect(data.automaton.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.kills).toEqualTypeOf(); + expect(data.automaton.faceOff.assists).toBeDefined(); + expect(data.automaton.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.assists).toEqualTypeOf(); + expect(data.automaton.faceOff.deaths).toBeDefined(); + expect(data.automaton.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.deaths).toEqualTypeOf(); + expect(data.automaton.faceOff.KDR).toBeDefined(); + expect(data.automaton.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.KDR).toEqualTypeOf(); + expect(data.automaton.faceOff.wins).toBeDefined(); + expect(data.automaton.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.wins).toEqualTypeOf(); + expect(data.automaton.faceOff.losses).toBeDefined(); + expect(data.automaton.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.losses).toEqualTypeOf(); + expect(data.automaton.faceOff.WLR).toBeDefined(); + expect(data.automaton.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.WLR).toEqualTypeOf(); + expect(data.automaton.faceOff.finalKills).toBeDefined(); + expect(data.automaton.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.finalKills).toEqualTypeOf(); + expect(data.automaton.faceOff.finalAssists).toBeDefined(); + expect(data.automaton.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.finalAssists).toEqualTypeOf(); + expect(data.automaton.faceOff.finalDeaths).toBeDefined(); + expect(data.automaton.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.automaton.faceOff.FKDR).toBeDefined(); + expect(data.automaton.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.FKDR).toEqualTypeOf(); + expect(data.automaton.faceOff.playedGames).toBeDefined(); + expect(data.automaton.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.playedGames).toEqualTypeOf(); + expect(data.automaton.faceOff.witherDamage).toBeDefined(); + expect(data.automaton.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.witherDamage).toEqualTypeOf(); + expect(data.automaton.faceOff.defenderKills).toBeDefined(); + expect(data.automaton.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.defenderKills).toEqualTypeOf(); + expect(data.automaton.faceOff.walked).toBeDefined(); + expect(data.automaton.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.walked).toEqualTypeOf(); + expect(data.automaton.faceOff.blocksPlaced).toBeDefined(); + expect(data.automaton.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.automaton.faceOff.blocksBroken).toBeDefined(); + expect(data.automaton.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.automaton.faceOff.meleeKills).toBeDefined(); + expect(data.automaton.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.meleeKills).toEqualTypeOf(); + expect(data.automaton.faceOff.damageDealt).toBeDefined(); + expect(data.automaton.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.automaton.faceOff.damageDealt).toEqualTypeOf(); + expect(data.automaton.casualBrawl).toBeDefined(); + expectTypeOf(data.automaton.casualBrawl).toEqualTypeOf(); + expect(data.automaton.casualBrawl.kills).toBeDefined(); + expect(data.automaton.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.kills).toEqualTypeOf(); + expect(data.automaton.casualBrawl.assists).toBeDefined(); + expect(data.automaton.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.assists).toEqualTypeOf(); + expect(data.automaton.casualBrawl.deaths).toBeDefined(); + expect(data.automaton.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.deaths).toEqualTypeOf(); + expect(data.automaton.casualBrawl.KDR).toBeDefined(); + expect(data.automaton.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.KDR).toEqualTypeOf(); + expect(data.automaton.casualBrawl.wins).toBeDefined(); + expect(data.automaton.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.wins).toEqualTypeOf(); + expect(data.automaton.casualBrawl.losses).toBeDefined(); + expect(data.automaton.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.losses).toEqualTypeOf(); + expect(data.automaton.casualBrawl.WLR).toBeDefined(); + expect(data.automaton.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.WLR).toEqualTypeOf(); + expect(data.automaton.casualBrawl.finalKills).toBeDefined(); + expect(data.automaton.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.automaton.casualBrawl.finalAssists).toBeDefined(); + expect(data.automaton.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.automaton.casualBrawl.finalDeaths).toBeDefined(); + expect(data.automaton.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.automaton.casualBrawl.FKDR).toBeDefined(); + expect(data.automaton.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.automaton.casualBrawl.playedGames).toBeDefined(); + expect(data.automaton.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.automaton.casualBrawl.witherDamage).toBeDefined(); + expect(data.automaton.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.automaton.casualBrawl.defenderKills).toBeDefined(); + expect(data.automaton.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.automaton.casualBrawl.walked).toBeDefined(); + expect(data.automaton.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.walked).toEqualTypeOf(); + expect(data.automaton.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.automaton.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.automaton.casualBrawl.blocksBroken).toBeDefined(); + expect(data.automaton.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.automaton.casualBrawl.meleeKills).toBeDefined(); + expect(data.automaton.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.automaton.casualBrawl.damageDealt).toBeDefined(); + expect(data.automaton.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.automaton.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.moleman).toBeDefined(); + expectTypeOf(data.moleman).toEqualTypeOf(); + expect(data.moleman.kills).toBeDefined(); + expect(data.moleman.kills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.kills).toEqualTypeOf(); + expect(data.moleman.assists).toBeDefined(); + expect(data.moleman.assists).greaterThanOrEqual(0); + expectTypeOf(data.moleman.assists).toEqualTypeOf(); + expect(data.moleman.deaths).toBeDefined(); + expect(data.moleman.deaths).greaterThanOrEqual(0); + expectTypeOf(data.moleman.deaths).toEqualTypeOf(); + expect(data.moleman.KDR).toBeDefined(); + expect(data.moleman.KDR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.KDR).toEqualTypeOf(); + expect(data.moleman.wins).toBeDefined(); + expect(data.moleman.wins).greaterThanOrEqual(0); + expectTypeOf(data.moleman.wins).toEqualTypeOf(); + expect(data.moleman.losses).toBeDefined(); + expect(data.moleman.losses).greaterThanOrEqual(0); + expectTypeOf(data.moleman.losses).toEqualTypeOf(); + expect(data.moleman.WLR).toBeDefined(); + expect(data.moleman.WLR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.WLR).toEqualTypeOf(); + expect(data.moleman.finalKills).toBeDefined(); + expect(data.moleman.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.finalKills).toEqualTypeOf(); + expect(data.moleman.finalAssists).toBeDefined(); + expect(data.moleman.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.moleman.finalAssists).toEqualTypeOf(); + expect(data.moleman.finalDeaths).toBeDefined(); + expect(data.moleman.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.moleman.finalDeaths).toEqualTypeOf(); + expect(data.moleman.FKDR).toBeDefined(); + expect(data.moleman.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.FKDR).toEqualTypeOf(); + expect(data.moleman.playedGames).toBeDefined(); + expect(data.moleman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.moleman.playedGames).toEqualTypeOf(); + expect(data.moleman.witherDamage).toBeDefined(); + expect(data.moleman.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.moleman.witherDamage).toEqualTypeOf(); + expect(data.moleman.defenderKills).toBeDefined(); + expect(data.moleman.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.defenderKills).toEqualTypeOf(); + expect(data.moleman.walked).toBeDefined(); + expect(data.moleman.walked).greaterThanOrEqual(0); + expectTypeOf(data.moleman.walked).toEqualTypeOf(); + expect(data.moleman.blocksPlaced).toBeDefined(); + expect(data.moleman.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.moleman.blocksPlaced).toEqualTypeOf(); + expect(data.moleman.blocksBroken).toBeDefined(); + expect(data.moleman.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.moleman.blocksBroken).toEqualTypeOf(); + expect(data.moleman.meleeKills).toBeDefined(); + expect(data.moleman.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.meleeKills).toEqualTypeOf(); + expect(data.moleman.damageDealt).toBeDefined(); + expect(data.moleman.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.moleman.damageDealt).toEqualTypeOf(); + expect(data.moleman.faceOff).toBeDefined(); + expectTypeOf(data.moleman.faceOff).toEqualTypeOf(); + expect(data.moleman.faceOff.kills).toBeDefined(); + expect(data.moleman.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.kills).toEqualTypeOf(); + expect(data.moleman.faceOff.assists).toBeDefined(); + expect(data.moleman.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.assists).toEqualTypeOf(); + expect(data.moleman.faceOff.deaths).toBeDefined(); + expect(data.moleman.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.deaths).toEqualTypeOf(); + expect(data.moleman.faceOff.KDR).toBeDefined(); + expect(data.moleman.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.KDR).toEqualTypeOf(); + expect(data.moleman.faceOff.wins).toBeDefined(); + expect(data.moleman.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.wins).toEqualTypeOf(); + expect(data.moleman.faceOff.losses).toBeDefined(); + expect(data.moleman.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.losses).toEqualTypeOf(); + expect(data.moleman.faceOff.WLR).toBeDefined(); + expect(data.moleman.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.WLR).toEqualTypeOf(); + expect(data.moleman.faceOff.finalKills).toBeDefined(); + expect(data.moleman.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.finalKills).toEqualTypeOf(); + expect(data.moleman.faceOff.finalAssists).toBeDefined(); + expect(data.moleman.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.finalAssists).toEqualTypeOf(); + expect(data.moleman.faceOff.finalDeaths).toBeDefined(); + expect(data.moleman.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.moleman.faceOff.FKDR).toBeDefined(); + expect(data.moleman.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.FKDR).toEqualTypeOf(); + expect(data.moleman.faceOff.playedGames).toBeDefined(); + expect(data.moleman.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.playedGames).toEqualTypeOf(); + expect(data.moleman.faceOff.witherDamage).toBeDefined(); + expect(data.moleman.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.witherDamage).toEqualTypeOf(); + expect(data.moleman.faceOff.defenderKills).toBeDefined(); + expect(data.moleman.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.defenderKills).toEqualTypeOf(); + expect(data.moleman.faceOff.walked).toBeDefined(); + expect(data.moleman.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.walked).toEqualTypeOf(); + expect(data.moleman.faceOff.blocksPlaced).toBeDefined(); + expect(data.moleman.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.moleman.faceOff.blocksBroken).toBeDefined(); + expect(data.moleman.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.moleman.faceOff.meleeKills).toBeDefined(); + expect(data.moleman.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.meleeKills).toEqualTypeOf(); + expect(data.moleman.faceOff.damageDealt).toBeDefined(); + expect(data.moleman.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.moleman.faceOff.damageDealt).toEqualTypeOf(); + expect(data.moleman.casualBrawl).toBeDefined(); + expectTypeOf(data.moleman.casualBrawl).toEqualTypeOf(); + expect(data.moleman.casualBrawl.kills).toBeDefined(); + expect(data.moleman.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.kills).toEqualTypeOf(); + expect(data.moleman.casualBrawl.assists).toBeDefined(); + expect(data.moleman.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.assists).toEqualTypeOf(); + expect(data.moleman.casualBrawl.deaths).toBeDefined(); + expect(data.moleman.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.deaths).toEqualTypeOf(); + expect(data.moleman.casualBrawl.KDR).toBeDefined(); + expect(data.moleman.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.KDR).toEqualTypeOf(); + expect(data.moleman.casualBrawl.wins).toBeDefined(); + expect(data.moleman.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.wins).toEqualTypeOf(); + expect(data.moleman.casualBrawl.losses).toBeDefined(); + expect(data.moleman.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.losses).toEqualTypeOf(); + expect(data.moleman.casualBrawl.WLR).toBeDefined(); + expect(data.moleman.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.WLR).toEqualTypeOf(); + expect(data.moleman.casualBrawl.finalKills).toBeDefined(); + expect(data.moleman.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.moleman.casualBrawl.finalAssists).toBeDefined(); + expect(data.moleman.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.moleman.casualBrawl.finalDeaths).toBeDefined(); + expect(data.moleman.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.moleman.casualBrawl.FKDR).toBeDefined(); + expect(data.moleman.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.moleman.casualBrawl.playedGames).toBeDefined(); + expect(data.moleman.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.moleman.casualBrawl.witherDamage).toBeDefined(); + expect(data.moleman.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.moleman.casualBrawl.defenderKills).toBeDefined(); + expect(data.moleman.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.moleman.casualBrawl.walked).toBeDefined(); + expect(data.moleman.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.walked).toEqualTypeOf(); + expect(data.moleman.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.moleman.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.moleman.casualBrawl.blocksBroken).toBeDefined(); + expect(data.moleman.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.moleman.casualBrawl.meleeKills).toBeDefined(); + expect(data.moleman.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.moleman.casualBrawl.damageDealt).toBeDefined(); + expect(data.moleman.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.moleman.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.phoenix).toBeDefined(); + expectTypeOf(data.phoenix).toEqualTypeOf(); + expect(data.phoenix.kills).toBeDefined(); + expect(data.phoenix.kills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.kills).toEqualTypeOf(); + expect(data.phoenix.assists).toBeDefined(); + expect(data.phoenix.assists).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.assists).toEqualTypeOf(); + expect(data.phoenix.deaths).toBeDefined(); + expect(data.phoenix.deaths).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.deaths).toEqualTypeOf(); + expect(data.phoenix.KDR).toBeDefined(); + expect(data.phoenix.KDR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.KDR).toEqualTypeOf(); + expect(data.phoenix.wins).toBeDefined(); + expect(data.phoenix.wins).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.wins).toEqualTypeOf(); + expect(data.phoenix.losses).toBeDefined(); + expect(data.phoenix.losses).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.losses).toEqualTypeOf(); + expect(data.phoenix.WLR).toBeDefined(); + expect(data.phoenix.WLR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.WLR).toEqualTypeOf(); + expect(data.phoenix.finalKills).toBeDefined(); + expect(data.phoenix.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.finalKills).toEqualTypeOf(); + expect(data.phoenix.finalAssists).toBeDefined(); + expect(data.phoenix.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.finalAssists).toEqualTypeOf(); + expect(data.phoenix.finalDeaths).toBeDefined(); + expect(data.phoenix.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.finalDeaths).toEqualTypeOf(); + expect(data.phoenix.FKDR).toBeDefined(); + expect(data.phoenix.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.FKDR).toEqualTypeOf(); + expect(data.phoenix.playedGames).toBeDefined(); + expect(data.phoenix.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.playedGames).toEqualTypeOf(); + expect(data.phoenix.witherDamage).toBeDefined(); + expect(data.phoenix.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.witherDamage).toEqualTypeOf(); + expect(data.phoenix.defenderKills).toBeDefined(); + expect(data.phoenix.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.defenderKills).toEqualTypeOf(); + expect(data.phoenix.walked).toBeDefined(); + expect(data.phoenix.walked).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.walked).toEqualTypeOf(); + expect(data.phoenix.blocksPlaced).toBeDefined(); + expect(data.phoenix.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.blocksPlaced).toEqualTypeOf(); + expect(data.phoenix.blocksBroken).toBeDefined(); + expect(data.phoenix.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.blocksBroken).toEqualTypeOf(); + expect(data.phoenix.meleeKills).toBeDefined(); + expect(data.phoenix.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.meleeKills).toEqualTypeOf(); + expect(data.phoenix.damageDealt).toBeDefined(); + expect(data.phoenix.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.damageDealt).toEqualTypeOf(); + expect(data.phoenix.faceOff).toBeDefined(); + expectTypeOf(data.phoenix.faceOff).toEqualTypeOf(); + expect(data.phoenix.faceOff.kills).toBeDefined(); + expect(data.phoenix.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.kills).toEqualTypeOf(); + expect(data.phoenix.faceOff.assists).toBeDefined(); + expect(data.phoenix.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.assists).toEqualTypeOf(); + expect(data.phoenix.faceOff.deaths).toBeDefined(); + expect(data.phoenix.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.deaths).toEqualTypeOf(); + expect(data.phoenix.faceOff.KDR).toBeDefined(); + expect(data.phoenix.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.KDR).toEqualTypeOf(); + expect(data.phoenix.faceOff.wins).toBeDefined(); + expect(data.phoenix.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.wins).toEqualTypeOf(); + expect(data.phoenix.faceOff.losses).toBeDefined(); + expect(data.phoenix.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.losses).toEqualTypeOf(); + expect(data.phoenix.faceOff.WLR).toBeDefined(); + expect(data.phoenix.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.WLR).toEqualTypeOf(); + expect(data.phoenix.faceOff.finalKills).toBeDefined(); + expect(data.phoenix.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.finalKills).toEqualTypeOf(); + expect(data.phoenix.faceOff.finalAssists).toBeDefined(); + expect(data.phoenix.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.finalAssists).toEqualTypeOf(); + expect(data.phoenix.faceOff.finalDeaths).toBeDefined(); + expect(data.phoenix.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.phoenix.faceOff.FKDR).toBeDefined(); + expect(data.phoenix.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.FKDR).toEqualTypeOf(); + expect(data.phoenix.faceOff.playedGames).toBeDefined(); + expect(data.phoenix.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.playedGames).toEqualTypeOf(); + expect(data.phoenix.faceOff.witherDamage).toBeDefined(); + expect(data.phoenix.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.witherDamage).toEqualTypeOf(); + expect(data.phoenix.faceOff.defenderKills).toBeDefined(); + expect(data.phoenix.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.defenderKills).toEqualTypeOf(); + expect(data.phoenix.faceOff.walked).toBeDefined(); + expect(data.phoenix.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.walked).toEqualTypeOf(); + expect(data.phoenix.faceOff.blocksPlaced).toBeDefined(); + expect(data.phoenix.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.phoenix.faceOff.blocksBroken).toBeDefined(); + expect(data.phoenix.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.phoenix.faceOff.meleeKills).toBeDefined(); + expect(data.phoenix.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.meleeKills).toEqualTypeOf(); + expect(data.phoenix.faceOff.damageDealt).toBeDefined(); + expect(data.phoenix.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.faceOff.damageDealt).toEqualTypeOf(); + expect(data.phoenix.casualBrawl).toBeDefined(); + expectTypeOf(data.phoenix.casualBrawl).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.kills).toBeDefined(); + expect(data.phoenix.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.kills).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.assists).toBeDefined(); + expect(data.phoenix.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.assists).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.deaths).toBeDefined(); + expect(data.phoenix.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.deaths).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.KDR).toBeDefined(); + expect(data.phoenix.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.KDR).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.wins).toBeDefined(); + expect(data.phoenix.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.wins).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.losses).toBeDefined(); + expect(data.phoenix.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.losses).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.WLR).toBeDefined(); + expect(data.phoenix.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.WLR).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.finalKills).toBeDefined(); + expect(data.phoenix.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.finalAssists).toBeDefined(); + expect(data.phoenix.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.finalDeaths).toBeDefined(); + expect(data.phoenix.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.FKDR).toBeDefined(); + expect(data.phoenix.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.playedGames).toBeDefined(); + expect(data.phoenix.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.witherDamage).toBeDefined(); + expect(data.phoenix.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.defenderKills).toBeDefined(); + expect(data.phoenix.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.walked).toBeDefined(); + expect(data.phoenix.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.walked).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.phoenix.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.blocksBroken).toBeDefined(); + expect(data.phoenix.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.meleeKills).toBeDefined(); + expect(data.phoenix.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.phoenix.casualBrawl.damageDealt).toBeDefined(); + expect(data.phoenix.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.phoenix.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.renegade).toBeDefined(); + expectTypeOf(data.renegade).toEqualTypeOf(); + expect(data.renegade.kills).toBeDefined(); + expect(data.renegade.kills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.kills).toEqualTypeOf(); + expect(data.renegade.assists).toBeDefined(); + expect(data.renegade.assists).greaterThanOrEqual(0); + expectTypeOf(data.renegade.assists).toEqualTypeOf(); + expect(data.renegade.deaths).toBeDefined(); + expect(data.renegade.deaths).greaterThanOrEqual(0); + expectTypeOf(data.renegade.deaths).toEqualTypeOf(); + expect(data.renegade.KDR).toBeDefined(); + expect(data.renegade.KDR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.KDR).toEqualTypeOf(); + expect(data.renegade.wins).toBeDefined(); + expect(data.renegade.wins).greaterThanOrEqual(0); + expectTypeOf(data.renegade.wins).toEqualTypeOf(); + expect(data.renegade.losses).toBeDefined(); + expect(data.renegade.losses).greaterThanOrEqual(0); + expectTypeOf(data.renegade.losses).toEqualTypeOf(); + expect(data.renegade.WLR).toBeDefined(); + expect(data.renegade.WLR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.WLR).toEqualTypeOf(); + expect(data.renegade.finalKills).toBeDefined(); + expect(data.renegade.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.finalKills).toEqualTypeOf(); + expect(data.renegade.finalAssists).toBeDefined(); + expect(data.renegade.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.renegade.finalAssists).toEqualTypeOf(); + expect(data.renegade.finalDeaths).toBeDefined(); + expect(data.renegade.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.renegade.finalDeaths).toEqualTypeOf(); + expect(data.renegade.FKDR).toBeDefined(); + expect(data.renegade.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.FKDR).toEqualTypeOf(); + expect(data.renegade.playedGames).toBeDefined(); + expect(data.renegade.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.renegade.playedGames).toEqualTypeOf(); + expect(data.renegade.witherDamage).toBeDefined(); + expect(data.renegade.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.renegade.witherDamage).toEqualTypeOf(); + expect(data.renegade.defenderKills).toBeDefined(); + expect(data.renegade.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.defenderKills).toEqualTypeOf(); + expect(data.renegade.walked).toBeDefined(); + expect(data.renegade.walked).greaterThanOrEqual(0); + expectTypeOf(data.renegade.walked).toEqualTypeOf(); + expect(data.renegade.blocksPlaced).toBeDefined(); + expect(data.renegade.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.renegade.blocksPlaced).toEqualTypeOf(); + expect(data.renegade.blocksBroken).toBeDefined(); + expect(data.renegade.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.renegade.blocksBroken).toEqualTypeOf(); + expect(data.renegade.meleeKills).toBeDefined(); + expect(data.renegade.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.meleeKills).toEqualTypeOf(); + expect(data.renegade.damageDealt).toBeDefined(); + expect(data.renegade.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.renegade.damageDealt).toEqualTypeOf(); + expect(data.renegade.faceOff).toBeDefined(); + expectTypeOf(data.renegade.faceOff).toEqualTypeOf(); + expect(data.renegade.faceOff.kills).toBeDefined(); + expect(data.renegade.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.kills).toEqualTypeOf(); + expect(data.renegade.faceOff.assists).toBeDefined(); + expect(data.renegade.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.assists).toEqualTypeOf(); + expect(data.renegade.faceOff.deaths).toBeDefined(); + expect(data.renegade.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.deaths).toEqualTypeOf(); + expect(data.renegade.faceOff.KDR).toBeDefined(); + expect(data.renegade.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.KDR).toEqualTypeOf(); + expect(data.renegade.faceOff.wins).toBeDefined(); + expect(data.renegade.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.wins).toEqualTypeOf(); + expect(data.renegade.faceOff.losses).toBeDefined(); + expect(data.renegade.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.losses).toEqualTypeOf(); + expect(data.renegade.faceOff.WLR).toBeDefined(); + expect(data.renegade.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.WLR).toEqualTypeOf(); + expect(data.renegade.faceOff.finalKills).toBeDefined(); + expect(data.renegade.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.finalKills).toEqualTypeOf(); + expect(data.renegade.faceOff.finalAssists).toBeDefined(); + expect(data.renegade.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.finalAssists).toEqualTypeOf(); + expect(data.renegade.faceOff.finalDeaths).toBeDefined(); + expect(data.renegade.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.renegade.faceOff.FKDR).toBeDefined(); + expect(data.renegade.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.FKDR).toEqualTypeOf(); + expect(data.renegade.faceOff.playedGames).toBeDefined(); + expect(data.renegade.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.playedGames).toEqualTypeOf(); + expect(data.renegade.faceOff.witherDamage).toBeDefined(); + expect(data.renegade.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.witherDamage).toEqualTypeOf(); + expect(data.renegade.faceOff.defenderKills).toBeDefined(); + expect(data.renegade.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.defenderKills).toEqualTypeOf(); + expect(data.renegade.faceOff.walked).toBeDefined(); + expect(data.renegade.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.walked).toEqualTypeOf(); + expect(data.renegade.faceOff.blocksPlaced).toBeDefined(); + expect(data.renegade.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.renegade.faceOff.blocksBroken).toBeDefined(); + expect(data.renegade.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.renegade.faceOff.meleeKills).toBeDefined(); + expect(data.renegade.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.meleeKills).toEqualTypeOf(); + expect(data.renegade.faceOff.damageDealt).toBeDefined(); + expect(data.renegade.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.renegade.faceOff.damageDealt).toEqualTypeOf(); + expect(data.renegade.casualBrawl).toBeDefined(); + expectTypeOf(data.renegade.casualBrawl).toEqualTypeOf(); + expect(data.renegade.casualBrawl.kills).toBeDefined(); + expect(data.renegade.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.kills).toEqualTypeOf(); + expect(data.renegade.casualBrawl.assists).toBeDefined(); + expect(data.renegade.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.assists).toEqualTypeOf(); + expect(data.renegade.casualBrawl.deaths).toBeDefined(); + expect(data.renegade.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.deaths).toEqualTypeOf(); + expect(data.renegade.casualBrawl.KDR).toBeDefined(); + expect(data.renegade.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.KDR).toEqualTypeOf(); + expect(data.renegade.casualBrawl.wins).toBeDefined(); + expect(data.renegade.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.wins).toEqualTypeOf(); + expect(data.renegade.casualBrawl.losses).toBeDefined(); + expect(data.renegade.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.losses).toEqualTypeOf(); + expect(data.renegade.casualBrawl.WLR).toBeDefined(); + expect(data.renegade.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.WLR).toEqualTypeOf(); + expect(data.renegade.casualBrawl.finalKills).toBeDefined(); + expect(data.renegade.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.renegade.casualBrawl.finalAssists).toBeDefined(); + expect(data.renegade.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.renegade.casualBrawl.finalDeaths).toBeDefined(); + expect(data.renegade.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.renegade.casualBrawl.FKDR).toBeDefined(); + expect(data.renegade.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.renegade.casualBrawl.playedGames).toBeDefined(); + expect(data.renegade.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.renegade.casualBrawl.witherDamage).toBeDefined(); + expect(data.renegade.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.renegade.casualBrawl.defenderKills).toBeDefined(); + expect(data.renegade.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.renegade.casualBrawl.walked).toBeDefined(); + expect(data.renegade.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.walked).toEqualTypeOf(); + expect(data.renegade.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.renegade.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.renegade.casualBrawl.blocksBroken).toBeDefined(); + expect(data.renegade.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.renegade.casualBrawl.meleeKills).toBeDefined(); + expect(data.renegade.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.renegade.casualBrawl.damageDealt).toBeDefined(); + expect(data.renegade.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.renegade.casualBrawl.damageDealt).toEqualTypeOf(); + expect(data.snowman).toBeDefined(); + expectTypeOf(data.snowman).toEqualTypeOf(); + expect(data.snowman.kills).toBeDefined(); + expect(data.snowman.kills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.kills).toEqualTypeOf(); + expect(data.snowman.assists).toBeDefined(); + expect(data.snowman.assists).greaterThanOrEqual(0); + expectTypeOf(data.snowman.assists).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.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.finalKills).toBeDefined(); + expect(data.snowman.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.finalKills).toEqualTypeOf(); + expect(data.snowman.finalAssists).toBeDefined(); + expect(data.snowman.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.snowman.finalAssists).toEqualTypeOf(); + expect(data.snowman.finalDeaths).toBeDefined(); + expect(data.snowman.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.snowman.finalDeaths).toEqualTypeOf(); + expect(data.snowman.FKDR).toBeDefined(); + expect(data.snowman.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.FKDR).toEqualTypeOf(); + expect(data.snowman.playedGames).toBeDefined(); + expect(data.snowman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.snowman.playedGames).toEqualTypeOf(); + expect(data.snowman.witherDamage).toBeDefined(); + expect(data.snowman.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.snowman.witherDamage).toEqualTypeOf(); + expect(data.snowman.defenderKills).toBeDefined(); + expect(data.snowman.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.defenderKills).toEqualTypeOf(); + expect(data.snowman.walked).toBeDefined(); + expect(data.snowman.walked).greaterThanOrEqual(0); + expectTypeOf(data.snowman.walked).toEqualTypeOf(); + expect(data.snowman.blocksPlaced).toBeDefined(); + expect(data.snowman.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.snowman.blocksPlaced).toEqualTypeOf(); + expect(data.snowman.blocksBroken).toBeDefined(); + expect(data.snowman.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.snowman.blocksBroken).toEqualTypeOf(); + expect(data.snowman.meleeKills).toBeDefined(); + expect(data.snowman.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.meleeKills).toEqualTypeOf(); + expect(data.snowman.damageDealt).toBeDefined(); + expect(data.snowman.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.snowman.damageDealt).toEqualTypeOf(); + expect(data.snowman.faceOff).toBeDefined(); + expectTypeOf(data.snowman.faceOff).toEqualTypeOf(); + expect(data.snowman.faceOff.kills).toBeDefined(); + expect(data.snowman.faceOff.kills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.kills).toEqualTypeOf(); + expect(data.snowman.faceOff.assists).toBeDefined(); + expect(data.snowman.faceOff.assists).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.assists).toEqualTypeOf(); + expect(data.snowman.faceOff.deaths).toBeDefined(); + expect(data.snowman.faceOff.deaths).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.deaths).toEqualTypeOf(); + expect(data.snowman.faceOff.KDR).toBeDefined(); + expect(data.snowman.faceOff.KDR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.KDR).toEqualTypeOf(); + expect(data.snowman.faceOff.wins).toBeDefined(); + expect(data.snowman.faceOff.wins).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.wins).toEqualTypeOf(); + expect(data.snowman.faceOff.losses).toBeDefined(); + expect(data.snowman.faceOff.losses).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.losses).toEqualTypeOf(); + expect(data.snowman.faceOff.WLR).toBeDefined(); + expect(data.snowman.faceOff.WLR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.WLR).toEqualTypeOf(); + expect(data.snowman.faceOff.finalKills).toBeDefined(); + expect(data.snowman.faceOff.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.finalKills).toEqualTypeOf(); + expect(data.snowman.faceOff.finalAssists).toBeDefined(); + expect(data.snowman.faceOff.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.finalAssists).toEqualTypeOf(); + expect(data.snowman.faceOff.finalDeaths).toBeDefined(); + expect(data.snowman.faceOff.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.finalDeaths).toEqualTypeOf(); + expect(data.snowman.faceOff.FKDR).toBeDefined(); + expect(data.snowman.faceOff.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.FKDR).toEqualTypeOf(); + expect(data.snowman.faceOff.playedGames).toBeDefined(); + expect(data.snowman.faceOff.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.playedGames).toEqualTypeOf(); + expect(data.snowman.faceOff.witherDamage).toBeDefined(); + expect(data.snowman.faceOff.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.witherDamage).toEqualTypeOf(); + expect(data.snowman.faceOff.defenderKills).toBeDefined(); + expect(data.snowman.faceOff.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.defenderKills).toEqualTypeOf(); + expect(data.snowman.faceOff.walked).toBeDefined(); + expect(data.snowman.faceOff.walked).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.walked).toEqualTypeOf(); + expect(data.snowman.faceOff.blocksPlaced).toBeDefined(); + expect(data.snowman.faceOff.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.blocksPlaced).toEqualTypeOf(); + expect(data.snowman.faceOff.blocksBroken).toBeDefined(); + expect(data.snowman.faceOff.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.blocksBroken).toEqualTypeOf(); + expect(data.snowman.faceOff.meleeKills).toBeDefined(); + expect(data.snowman.faceOff.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.meleeKills).toEqualTypeOf(); + expect(data.snowman.faceOff.damageDealt).toBeDefined(); + expect(data.snowman.faceOff.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.snowman.faceOff.damageDealt).toEqualTypeOf(); + expect(data.snowman.casualBrawl).toBeDefined(); + expectTypeOf(data.snowman.casualBrawl).toEqualTypeOf(); + expect(data.snowman.casualBrawl.kills).toBeDefined(); + expect(data.snowman.casualBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.kills).toEqualTypeOf(); + expect(data.snowman.casualBrawl.assists).toBeDefined(); + expect(data.snowman.casualBrawl.assists).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.assists).toEqualTypeOf(); + expect(data.snowman.casualBrawl.deaths).toBeDefined(); + expect(data.snowman.casualBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.deaths).toEqualTypeOf(); + expect(data.snowman.casualBrawl.KDR).toBeDefined(); + expect(data.snowman.casualBrawl.KDR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.KDR).toEqualTypeOf(); + expect(data.snowman.casualBrawl.wins).toBeDefined(); + expect(data.snowman.casualBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.wins).toEqualTypeOf(); + expect(data.snowman.casualBrawl.losses).toBeDefined(); + expect(data.snowman.casualBrawl.losses).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.losses).toEqualTypeOf(); + expect(data.snowman.casualBrawl.WLR).toBeDefined(); + expect(data.snowman.casualBrawl.WLR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.WLR).toEqualTypeOf(); + expect(data.snowman.casualBrawl.finalKills).toBeDefined(); + expect(data.snowman.casualBrawl.finalKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.finalKills).toEqualTypeOf(); + expect(data.snowman.casualBrawl.finalAssists).toBeDefined(); + expect(data.snowman.casualBrawl.finalAssists).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.finalAssists).toEqualTypeOf(); + expect(data.snowman.casualBrawl.finalDeaths).toBeDefined(); + expect(data.snowman.casualBrawl.finalDeaths).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.finalDeaths).toEqualTypeOf(); + expect(data.snowman.casualBrawl.FKDR).toBeDefined(); + expect(data.snowman.casualBrawl.FKDR).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.FKDR).toEqualTypeOf(); + expect(data.snowman.casualBrawl.playedGames).toBeDefined(); + expect(data.snowman.casualBrawl.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.playedGames).toEqualTypeOf(); + expect(data.snowman.casualBrawl.witherDamage).toBeDefined(); + expect(data.snowman.casualBrawl.witherDamage).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.witherDamage).toEqualTypeOf(); + expect(data.snowman.casualBrawl.defenderKills).toBeDefined(); + expect(data.snowman.casualBrawl.defenderKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.defenderKills).toEqualTypeOf(); + expect(data.snowman.casualBrawl.walked).toBeDefined(); + expect(data.snowman.casualBrawl.walked).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.walked).toEqualTypeOf(); + expect(data.snowman.casualBrawl.blocksPlaced).toBeDefined(); + expect(data.snowman.casualBrawl.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.blocksPlaced).toEqualTypeOf(); + expect(data.snowman.casualBrawl.blocksBroken).toBeDefined(); + expect(data.snowman.casualBrawl.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.blocksBroken).toEqualTypeOf(); + expect(data.snowman.casualBrawl.meleeKills).toBeDefined(); + expect(data.snowman.casualBrawl.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.meleeKills).toEqualTypeOf(); + expect(data.snowman.casualBrawl.damageDealt).toBeDefined(); + expect(data.snowman.casualBrawl.damageDealt).greaterThanOrEqual(0); + expectTypeOf(data.snowman.casualBrawl.damageDealt).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/MegaWalls.ts b/src/structures/MiniGames/MegaWalls.ts index 21853646..e414f311 100644 --- a/src/structures/MiniGames/MegaWalls.ts +++ b/src/structures/MiniGames/MegaWalls.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class MegaWallsModeStats { +export class MegaWallsModeStats { kills: number; assists: number; deaths: number; @@ -22,29 +22,29 @@ class MegaWallsModeStats { damageDealt: number; constructor(data: Record, mode: string, kit?: string) { if (kit) kit = `${kit}_`; - this.kills = data[`${kit}kills_${mode}`] || 0; - this.assists = data[`${kit}assists_${mode}`] || 0; - this.deaths = data[`${kit}deaths_${mode}`] || 0; + this.kills = data?.[`${kit}kills_${mode}`] || 0; + this.assists = data?.[`${kit}assists_${mode}`] || 0; + this.deaths = data?.[`${kit}deaths_${mode}`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`${kit}wins_${mode}`] || 0; - this.losses = data[`${kit}losses_${mode}`] || 0; + this.wins = data?.[`${kit}wins_${mode}`] || 0; + this.losses = data?.[`${kit}losses_${mode}`] || 0; this.WLR = divide(this.wins, this.losses); - this.finalKills = data[`${kit}final_kills_${mode}`] || 0; - this.finalAssists = data[`${kit}final_assists_${mode}`] || 0; - this.finalDeaths = data[`${kit}final_deaths_${mode}`] || 0; + this.finalKills = data?.[`${kit}final_kills_${mode}`] || 0; + this.finalAssists = data?.[`${kit}final_assists_${mode}`] || 0; + this.finalDeaths = data?.[`${kit}final_deaths_${mode}`] || 0; this.FKDR = divide(this.finalKills, this.finalDeaths); - this.playedGames = data[`${kit}games_played_${mode}`] || 0; - this.witherDamage = data[`${kit}wither_damage_${mode}`] || 0; - this.defenderKills = data[`${kit}defender_kills_${mode}`] || 0; - this.walked = data[`${kit}meters_walked_${mode}`] || 0; - this.blocksPlaced = data[`${kit}blocks_placed_${mode}`] || 0; - this.blocksBroken = data[`${kit}blocks_broken_${mode}`] || 0; - this.meleeKills = data[`${kit}kills_melee_${mode}`] || 0; - this.damageDealt = data[`${kit}damage_dealt_${mode}`] || 0; + this.playedGames = data?.[`${kit}games_played_${mode}`] || 0; + this.witherDamage = data?.[`${kit}wither_damage_${mode}`] || 0; + this.defenderKills = data?.[`${kit}defender_kills_${mode}`] || 0; + this.walked = data?.[`${kit}meters_walked_${mode}`] || 0; + this.blocksPlaced = data?.[`${kit}blocks_placed_${mode}`] || 0; + this.blocksBroken = data?.[`${kit}blocks_broken_${mode}`] || 0; + this.meleeKills = data?.[`${kit}kills_melee_${mode}`] || 0; + this.damageDealt = data?.[`${kit}damage_dealt_${mode}`] || 0; } } -class MegaWallsKitStats { +export class MegaWallsKitStats { kills: number; assists: number; deaths: number; @@ -67,32 +67,32 @@ class MegaWallsKitStats { faceOff: MegaWallsModeStats; casualBrawl: MegaWallsModeStats; constructor(data: Record, kit: string) { - this.kills = data[`${kit}_kills`] || 0; - this.assists = data[`${kit}_assists`] || 0; - this.deaths = data[`${kit}_deaths`] || 0; + this.kills = data?.[`${kit}_kills`] || 0; + this.assists = data?.[`${kit}_assists`] || 0; + this.deaths = data?.[`${kit}_deaths`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`${kit}_wins`] || 0; - this.losses = data[`${kit}_losses`] || 0; + this.wins = data?.[`${kit}_wins`] || 0; + this.losses = data?.[`${kit}_losses`] || 0; this.WLR = divide(this.wins, this.losses); - this.finalKills = data[`${kit}_final_kills`] || 0; - this.finalAssists = data[`${kit}_final_assists`] || 0; - this.finalDeaths = data[`${kit}_final_deaths`] || 0; + this.finalKills = data?.[`${kit}_final_kills`] || 0; + this.finalAssists = data?.[`${kit}_final_assists`] || 0; + this.finalDeaths = data?.[`${kit}_final_deaths`] || 0; this.FKDR = divide(this.finalKills, this.finalDeaths); - this.playedGames = data[`${kit}_games_played`] || 0; - this.witherDamage = data[`${kit}_wither_damage`] || 0; - this.defenderKills = data[`${kit}_defender_kills`] || 0; - this.walked = data[`${kit}_meters_walked`] || 0; - this.blocksPlaced = data[`${kit}_blocks_placed`] || 0; - this.blocksBroken = data[`${kit}_blocks_broken`] || 0; - this.meleeKills = data[`${kit}_kills_melee`] || 0; - this.damageDealt = data[`${kit}_damage_dealt`] || 0; + this.playedGames = data?.[`${kit}_games_played`] || 0; + this.witherDamage = data?.[`${kit}_wither_damage`] || 0; + this.defenderKills = data?.[`${kit}_defender_kills`] || 0; + this.walked = data?.[`${kit}_meters_walked`] || 0; + this.blocksPlaced = data?.[`${kit}_blocks_placed`] || 0; + this.blocksBroken = data?.[`${kit}_blocks_broken`] || 0; + this.meleeKills = data?.[`${kit}_kills_melee`] || 0; + this.damageDealt = data?.[`${kit}_damage_dealt`] || 0; this.faceOff = new MegaWallsModeStats(data, 'face_off', kit); this.casualBrawl = new MegaWallsModeStats(data, 'gvg', kit); } } class MegaWalls { - selectedClass: string | null; + selectedClass: string; coins: number; kills: number; assists: number; @@ -142,27 +142,27 @@ class MegaWalls { renegade: MegaWallsKitStats; snowman: MegaWallsKitStats; constructor(data: Record) { - this.selectedClass = data.chosen_class || null; - this.coins = data.coins || 0; - this.kills = data.kills || 0; - this.assists = data.assists || 0; - this.deaths = data.deaths || 0; + this.selectedClass = data?.chosen_class || ''; + this.coins = data?.coins || 0; + this.kills = data?.kills || 0; + this.assists = data?.assists || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; this.WLR = divide(this.wins, this.losses); - this.finalKills = (data.final_kills || 0) + (data.finalkills || 0); - this.finalAssists = (data.final_assists || 0) + (data.finalassists || 0); - this.finalDeaths = (data.final_deaths || 0) + (data.finalDeaths || 0); + this.finalKills = (data?.final_kills || 0) + (data?.finalkills || 0); + this.finalAssists = (data?.final_assists || 0) + (data?.finalassists || 0); + this.finalDeaths = (data?.final_deaths || 0) + (data?.finalDeaths || 0); this.FKDR = divide(this.finalKills, this.finalDeaths); - this.playedGames = data.games_played || 0; - this.witherDamage = (data.wither_damage || 0) + (data.witherDamager || 0); - this.defenderKills = data.defender_kills || 0; - this.walked = data.meters_walked || 0; - this.blocksPlaced = data.blocks_placed || 0; - this.blocksBroken = data.blocks_broken || 0; - this.meleeKills = data.kills_melee || 0; - this.damageDealt = data.damage_dealt || 0; + this.playedGames = data?.games_played || 0; + this.witherDamage = (data?.wither_damage || 0) + (data?.witherDamager || 0); + this.defenderKills = data?.defender_kills || 0; + this.walked = data?.meters_walked || 0; + this.blocksPlaced = data?.blocks_placed || 0; + this.blocksBroken = data?.blocks_broken || 0; + this.meleeKills = data?.kills_melee || 0; + this.damageDealt = data?.damage_dealt || 0; this.faceOff = new MegaWallsModeStats(data, 'face_off'); this.casualBrawl = new MegaWallsModeStats(data, 'gvg'); this.cow = new MegaWallsKitStats(data, 'cow'); diff --git a/src/structures/MiniGames/MurderMystery.test.ts b/src/structures/MiniGames/MurderMystery.test.ts new file mode 100644 index 00000000..0314efed --- /dev/null +++ b/src/structures/MiniGames/MurderMystery.test.ts @@ -0,0 +1,242 @@ +import MurderMystery, { MurderMysteryModeStats } from './MurderMystery'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('MurderMystery', () => { + const data = new MurderMystery({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(MurderMystery); + expectTypeOf(data).toEqualTypeOf(); + expect(data.tokens).toBeDefined(); + expect(data.tokens).greaterThanOrEqual(0); + expectTypeOf(data.tokens).toEqualTypeOf(); + expect(data.goldPickedUp).toBeDefined(); + expect(data.goldPickedUp).greaterThanOrEqual(0); + expectTypeOf(data.goldPickedUp).toEqualTypeOf(); + expect(data.playedGames).toBeDefined(); + expect(data.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.playedGames).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.thrownKnifeKills).toBeDefined(); + expect(data.thrownKnifeKills).greaterThanOrEqual(0); + expectTypeOf(data.thrownKnifeKills).toEqualTypeOf(); + expect(data.knifeKills).toBeDefined(); + expect(data.knifeKills).greaterThanOrEqual(0); + expectTypeOf(data.knifeKills).toEqualTypeOf(); + expect(data.trapKills).toBeDefined(); + expect(data.trapKills).greaterThanOrEqual(0); + expectTypeOf(data.trapKills).toEqualTypeOf(); + expect(data.bowKills).toBeDefined(); + expect(data.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.bowKills).toEqualTypeOf(); + expect(data.killsAsMurderer).toBeDefined(); + expect(data.killsAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.killsAsMurderer).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.winsAsMurderer).toBeDefined(); + expect(data.winsAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.winsAsMurderer).toEqualTypeOf(); + expect(data.winsAsDetective).toBeDefined(); + expect(data.winsAsDetective).greaterThanOrEqual(0); + expectTypeOf(data.winsAsDetective).toEqualTypeOf(); + expect(data.winsAsHero).toBeDefined(); + expect(data.winsAsHero).greaterThanOrEqual(0); + expectTypeOf(data.winsAsHero).toEqualTypeOf(); + expect(data.fastestWinAsMurderer).toBeDefined(); + expect(data.fastestWinAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.fastestWinAsMurderer).toEqualTypeOf(); + expect(data.fastestWinAsDetective).toBeDefined(); + expect(data.fastestWinAsDetective).greaterThanOrEqual(0); + expectTypeOf(data.fastestWinAsDetective).toEqualTypeOf(); + expect(data.totalTimeSurvived).toBeDefined(); + expect(data.totalTimeSurvived).greaterThanOrEqual(0); + expectTypeOf(data.totalTimeSurvived).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.suicides).toBeDefined(); + expect(data.suicides).greaterThanOrEqual(0); + expectTypeOf(data.suicides).toEqualTypeOf(); + expect(data.classic).toBeDefined(); + expectTypeOf(data.classic).toEqualTypeOf(); + expect(data.classic.goldPickedUp).toBeDefined(); + expect(data.classic.goldPickedUp).greaterThanOrEqual(0); + expectTypeOf(data.classic.goldPickedUp).toEqualTypeOf(); + expect(data.classic.kills).toBeDefined(); + expect(data.classic.kills).greaterThanOrEqual(0); + expectTypeOf(data.classic.kills).toEqualTypeOf(); + expect(data.classic.thrownKnifeKills).toBeDefined(); + expect(data.classic.thrownKnifeKills).greaterThanOrEqual(0); + expectTypeOf(data.classic.thrownKnifeKills).toEqualTypeOf(); + expect(data.classic.knifeKills).toBeDefined(); + expect(data.classic.knifeKills).greaterThanOrEqual(0); + expectTypeOf(data.classic.knifeKills).toEqualTypeOf(); + expect(data.classic.bowKills).toBeDefined(); + expect(data.classic.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.classic.bowKills).toEqualTypeOf(); + expect(data.classic.trapKills).toBeDefined(); + expect(data.classic.trapKills).greaterThanOrEqual(0); + expectTypeOf(data.classic.trapKills).toEqualTypeOf(); + expect(data.classic.deaths).toBeDefined(); + expect(data.classic.deaths).greaterThanOrEqual(0); + expectTypeOf(data.classic.deaths).toEqualTypeOf(); + expect(data.classic.suicides).toBeDefined(); + expect(data.classic.suicides).greaterThanOrEqual(0); + expectTypeOf(data.classic.suicides).toEqualTypeOf(); + expect(data.classic.KDR).toBeDefined(); + expect(data.classic.KDR).greaterThanOrEqual(0); + expectTypeOf(data.classic.KDR).toEqualTypeOf(); + expect(data.classic.wins).toBeDefined(); + expect(data.classic.wins).greaterThanOrEqual(0); + expectTypeOf(data.classic.wins).toEqualTypeOf(); + expect(data.classic.winsAsDetective).toBeDefined(); + expect(data.classic.winsAsDetective).greaterThanOrEqual(0); + expectTypeOf(data.classic.winsAsDetective).toEqualTypeOf(); + expect(data.classic.winsAsMurderer).toBeDefined(); + expect(data.classic.winsAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.classic.winsAsMurderer).toEqualTypeOf(); + expect(data.classic.winsAsHero).toBeDefined(); + expect(data.classic.winsAsHero).greaterThanOrEqual(0); + expectTypeOf(data.classic.winsAsHero).toEqualTypeOf(); + expect(data.classic.playedGames).toBeDefined(); + expect(data.classic.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.classic.playedGames).toEqualTypeOf(); + expect(data.assassins).toBeDefined(); + expectTypeOf(data.assassins).toEqualTypeOf(); + expect(data.assassins.goldPickedUp).toBeDefined(); + expect(data.assassins.goldPickedUp).greaterThanOrEqual(0); + expectTypeOf(data.assassins.goldPickedUp).toEqualTypeOf(); + expect(data.assassins.kills).toBeDefined(); + expect(data.assassins.kills).greaterThanOrEqual(0); + expectTypeOf(data.assassins.kills).toEqualTypeOf(); + expect(data.assassins.thrownKnifeKills).toBeDefined(); + expect(data.assassins.thrownKnifeKills).greaterThanOrEqual(0); + expectTypeOf(data.assassins.thrownKnifeKills).toEqualTypeOf(); + expect(data.assassins.knifeKills).toBeDefined(); + expect(data.assassins.knifeKills).greaterThanOrEqual(0); + expectTypeOf(data.assassins.knifeKills).toEqualTypeOf(); + expect(data.assassins.bowKills).toBeDefined(); + expect(data.assassins.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.assassins.bowKills).toEqualTypeOf(); + expect(data.assassins.trapKills).toBeDefined(); + expect(data.assassins.trapKills).greaterThanOrEqual(0); + expectTypeOf(data.assassins.trapKills).toEqualTypeOf(); + expect(data.assassins.deaths).toBeDefined(); + expect(data.assassins.deaths).greaterThanOrEqual(0); + expectTypeOf(data.assassins.deaths).toEqualTypeOf(); + expect(data.assassins.suicides).toBeDefined(); + expect(data.assassins.suicides).greaterThanOrEqual(0); + expectTypeOf(data.assassins.suicides).toEqualTypeOf(); + expect(data.assassins.KDR).toBeDefined(); + expect(data.assassins.KDR).greaterThanOrEqual(0); + expectTypeOf(data.assassins.KDR).toEqualTypeOf(); + expect(data.assassins.wins).toBeDefined(); + expect(data.assassins.wins).greaterThanOrEqual(0); + expectTypeOf(data.assassins.wins).toEqualTypeOf(); + expect(data.assassins.winsAsDetective).toBeDefined(); + expect(data.assassins.winsAsDetective).greaterThanOrEqual(0); + expectTypeOf(data.assassins.winsAsDetective).toEqualTypeOf(); + expect(data.assassins.winsAsMurderer).toBeDefined(); + expect(data.assassins.winsAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.assassins.winsAsMurderer).toEqualTypeOf(); + expect(data.assassins.winsAsHero).toBeDefined(); + expect(data.assassins.winsAsHero).greaterThanOrEqual(0); + expectTypeOf(data.assassins.winsAsHero).toEqualTypeOf(); + expect(data.assassins.playedGames).toBeDefined(); + expect(data.assassins.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.assassins.playedGames).toEqualTypeOf(); + expect(data.doubleUp).toBeDefined(); + expectTypeOf(data.doubleUp).toEqualTypeOf(); + expect(data.doubleUp.goldPickedUp).toBeDefined(); + expect(data.doubleUp.goldPickedUp).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.goldPickedUp).toEqualTypeOf(); + expect(data.doubleUp.kills).toBeDefined(); + expect(data.doubleUp.kills).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.kills).toEqualTypeOf(); + expect(data.doubleUp.thrownKnifeKills).toBeDefined(); + expect(data.doubleUp.thrownKnifeKills).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.thrownKnifeKills).toEqualTypeOf(); + expect(data.doubleUp.knifeKills).toBeDefined(); + expect(data.doubleUp.knifeKills).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.knifeKills).toEqualTypeOf(); + expect(data.doubleUp.bowKills).toBeDefined(); + expect(data.doubleUp.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.bowKills).toEqualTypeOf(); + expect(data.doubleUp.trapKills).toBeDefined(); + expect(data.doubleUp.trapKills).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.trapKills).toEqualTypeOf(); + expect(data.doubleUp.deaths).toBeDefined(); + expect(data.doubleUp.deaths).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.deaths).toEqualTypeOf(); + expect(data.doubleUp.suicides).toBeDefined(); + expect(data.doubleUp.suicides).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.suicides).toEqualTypeOf(); + expect(data.doubleUp.KDR).toBeDefined(); + expect(data.doubleUp.KDR).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.KDR).toEqualTypeOf(); + expect(data.doubleUp.wins).toBeDefined(); + expect(data.doubleUp.wins).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.wins).toEqualTypeOf(); + expect(data.doubleUp.winsAsDetective).toBeDefined(); + expect(data.doubleUp.winsAsDetective).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.winsAsDetective).toEqualTypeOf(); + expect(data.doubleUp.winsAsMurderer).toBeDefined(); + expect(data.doubleUp.winsAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.winsAsMurderer).toEqualTypeOf(); + expect(data.doubleUp.winsAsHero).toBeDefined(); + expect(data.doubleUp.winsAsHero).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.winsAsHero).toEqualTypeOf(); + expect(data.doubleUp.playedGames).toBeDefined(); + expect(data.doubleUp.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.doubleUp.playedGames).toEqualTypeOf(); + expect(data.infection).toBeDefined(); + expectTypeOf(data.infection).toEqualTypeOf(); + expect(data.infection.goldPickedUp).toBeDefined(); + expect(data.infection.goldPickedUp).greaterThanOrEqual(0); + expectTypeOf(data.infection.goldPickedUp).toEqualTypeOf(); + expect(data.infection.kills).toBeDefined(); + expect(data.infection.kills).greaterThanOrEqual(0); + expectTypeOf(data.infection.kills).toEqualTypeOf(); + expect(data.infection.thrownKnifeKills).toBeDefined(); + expect(data.infection.thrownKnifeKills).greaterThanOrEqual(0); + expectTypeOf(data.infection.thrownKnifeKills).toEqualTypeOf(); + expect(data.infection.knifeKills).toBeDefined(); + expect(data.infection.knifeKills).greaterThanOrEqual(0); + expectTypeOf(data.infection.knifeKills).toEqualTypeOf(); + expect(data.infection.bowKills).toBeDefined(); + expect(data.infection.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.infection.bowKills).toEqualTypeOf(); + expect(data.infection.trapKills).toBeDefined(); + expect(data.infection.trapKills).greaterThanOrEqual(0); + expectTypeOf(data.infection.trapKills).toEqualTypeOf(); + expect(data.infection.deaths).toBeDefined(); + expect(data.infection.deaths).greaterThanOrEqual(0); + expectTypeOf(data.infection.deaths).toEqualTypeOf(); + expect(data.infection.suicides).toBeDefined(); + expect(data.infection.suicides).greaterThanOrEqual(0); + expectTypeOf(data.infection.suicides).toEqualTypeOf(); + expect(data.infection.KDR).toBeDefined(); + expect(data.infection.KDR).greaterThanOrEqual(0); + expectTypeOf(data.infection.KDR).toEqualTypeOf(); + expect(data.infection.wins).toBeDefined(); + expect(data.infection.wins).greaterThanOrEqual(0); + expectTypeOf(data.infection.wins).toEqualTypeOf(); + expect(data.infection.winsAsDetective).toBeDefined(); + expect(data.infection.winsAsDetective).greaterThanOrEqual(0); + expectTypeOf(data.infection.winsAsDetective).toEqualTypeOf(); + expect(data.infection.winsAsMurderer).toBeDefined(); + expect(data.infection.winsAsMurderer).greaterThanOrEqual(0); + expectTypeOf(data.infection.winsAsMurderer).toEqualTypeOf(); + expect(data.infection.winsAsHero).toBeDefined(); + expect(data.infection.winsAsHero).greaterThanOrEqual(0); + expectTypeOf(data.infection.winsAsHero).toEqualTypeOf(); + expect(data.infection.playedGames).toBeDefined(); + expect(data.infection.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.infection.playedGames).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/MurderMystery.ts b/src/structures/MiniGames/MurderMystery.ts index b952136c..e8dfee5b 100644 --- a/src/structures/MiniGames/MurderMystery.ts +++ b/src/structures/MiniGames/MurderMystery.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class MurderMysteryModeStats { +export class MurderMysteryModeStats { goldPickedUp: number; kills: number; thrownKnifeKills: number; @@ -16,20 +16,20 @@ class MurderMysteryModeStats { winsAsHero: number; playedGames: number; constructor(data: Record, gamemode: string) { - this.goldPickedUp = data[`coins_pickedup_${gamemode}`] || 0; - this.kills = data[`kills_${gamemode}`] || 0; - this.thrownKnifeKills = data[`thrown_knife_kills_${gamemode}`] || 0; - this.knifeKills = data[`knife_kills_${gamemode}`] || 0; - this.bowKills = data[`bow_kills_${gamemode}`] || 0; - this.trapKills = data[`trap_kills_${gamemode}`] || 0; - this.deaths = data[`deaths_${gamemode}`] || 0; - this.suicides = data[`suicides_${gamemode}`] || 0; + this.goldPickedUp = data?.[`coins_pickedup_${gamemode}`] || 0; + this.kills = data?.[`kills_${gamemode}`] || 0; + this.thrownKnifeKills = data?.[`thrown_knife_kills_${gamemode}`] || 0; + this.knifeKills = data?.[`knife_kills_${gamemode}`] || 0; + this.bowKills = data?.[`bow_kills_${gamemode}`] || 0; + this.trapKills = data?.[`trap_kills_${gamemode}`] || 0; + this.deaths = data?.[`deaths_${gamemode}`] || 0; + this.suicides = data?.[`suicides_${gamemode}`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`wins_${gamemode}`] || 0; - this.winsAsDetective = data[`detective_wins_${gamemode}`] || 0; - this.winsAsMurderer = data[`murderer_wins_${gamemode}`] || 0; - this.winsAsHero = data[`was_hero_${gamemode}`] || 0; - this.playedGames = data[`games_${gamemode}`] || 0; + this.wins = data?.[`wins_${gamemode}`] || 0; + this.winsAsDetective = data?.[`detective_wins_${gamemode}`] || 0; + this.winsAsMurderer = data?.[`murderer_wins_${gamemode}`] || 0; + this.winsAsHero = data?.[`was_hero_${gamemode}`] || 0; + this.playedGames = data?.[`games_${gamemode}`] || 0; } } @@ -58,25 +58,25 @@ class MurderMystery { doubleUp: MurderMysteryModeStats; infection: MurderMysteryModeStats; constructor(data: Record) { - this.tokens = data.coins || 0; - this.goldPickedUp = data.coins_pickedup || 0; - this.playedGames = data.games || 0; - this.kills = data.kills || 0; - this.thrownKnifeKills = data.thrown_knife_kills || 0; - this.knifeKills = data.knife_kills || 0; - this.trapKills = data.trap_kills || 0; - this.bowKills = data.bow_kills || 0; - this.killsAsMurderer = data.kills_as_murderer || 0; - this.deaths = data.deaths || 0; + this.tokens = data?.coins || 0; + this.goldPickedUp = data?.coins_pickedup || 0; + this.playedGames = data?.games || 0; + this.kills = data?.kills || 0; + this.thrownKnifeKills = data?.thrown_knife_kills || 0; + this.knifeKills = data?.knife_kills || 0; + this.trapKills = data?.trap_kills || 0; + this.bowKills = data?.bow_kills || 0; + this.killsAsMurderer = data?.kills_as_murderer || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.winsAsMurderer = data.murderer_wins || 0; - this.winsAsDetective = data.detective_wins || 0; - this.winsAsHero = data.was_hero || 0; - this.fastestWinAsMurderer = data.quickest_murderer_win_time_seconds || 0; - this.fastestWinAsDetective = data.quickest_detective_win_time_seconds || 0; - this.totalTimeSurvived = data.total_time_survived_seconds || 0; - this.wins = data.wins || 0; - this.suicides = data.suicides || 0; + this.winsAsMurderer = data?.murderer_wins || 0; + this.winsAsDetective = data?.detective_wins || 0; + this.winsAsHero = data?.was_hero || 0; + this.fastestWinAsMurderer = data?.quickest_murderer_win_time_seconds || 0; + this.fastestWinAsDetective = data?.quickest_detective_win_time_seconds || 0; + this.totalTimeSurvived = data?.total_time_survived_seconds || 0; + this.wins = data?.wins || 0; + this.suicides = data?.suicides || 0; this.classic = new MurderMysteryModeStats(data, 'MURDER_CLASSIC'); this.assassins = new MurderMysteryModeStats(data, 'MURDER_ASSASSINS'); this.doubleUp = new MurderMysteryModeStats(data, 'MURDER_DOUBLE_UP'); diff --git a/src/structures/MiniGames/Paintball.test.ts b/src/structures/MiniGames/Paintball.test.ts new file mode 100644 index 00000000..270c22eb --- /dev/null +++ b/src/structures/MiniGames/Paintball.test.ts @@ -0,0 +1,52 @@ +import Paintball from './Paintball'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Paintball', () => { + const data = new Paintball({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Paintball); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.shotsFired).toBeDefined(); + expect(data.shotsFired).greaterThanOrEqual(0); + expectTypeOf(data.shotsFired).toEqualTypeOf(); + expect(data.killstreaks).toBeDefined(); + expect(data.killstreaks).greaterThanOrEqual(0); + expectTypeOf(data.killstreaks).toEqualTypeOf(); + expect(data.forceFieldTime).toBeDefined(); + expect(data.forceFieldTime).greaterThanOrEqual(0); + expectTypeOf(data.forceFieldTime).toEqualTypeOf(); + expect(data.hat).toBeDefined(); + expect(data.adrenaline).toBeDefined(); + expect(data.adrenaline).greaterThanOrEqual(0); + expectTypeOf(data.adrenaline).toEqualTypeOf(); + expect(data.endurance).toBeDefined(); + expect(data.endurance).greaterThanOrEqual(0); + expectTypeOf(data.endurance).toEqualTypeOf(); + expect(data.fortune).toBeDefined(); + expect(data.fortune).greaterThanOrEqual(0); + expectTypeOf(data.fortune).toEqualTypeOf(); + expect(data.godfather).toBeDefined(); + expect(data.godfather).greaterThanOrEqual(0); + expectTypeOf(data.godfather).toEqualTypeOf(); + expect(data.superluck).toBeDefined(); + expect(data.superluck).greaterThanOrEqual(0); + expectTypeOf(data.superluck).toEqualTypeOf(); + expect(data.transfusion).toBeDefined(); + expect(data.transfusion).greaterThanOrEqual(0); + expectTypeOf(data.transfusion).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/Paintball.ts b/src/structures/MiniGames/Paintball.ts index 9c97b996..0795518f 100644 --- a/src/structures/MiniGames/Paintball.ts +++ b/src/structures/MiniGames/Paintball.ts @@ -17,21 +17,21 @@ class Paintball { superluck: number; transfusion: number; constructor(data: Record) { - this.coins = data.coins || 0; - this.kills = data.kills || 0; - this.deaths = data.deaths || 0; + this.coins = data?.coins || 0; + this.kills = data?.kills || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.shotsFired = data.shots_fired || 0; - this.killstreaks = data.killstreaks || 0; - this.forceFieldTime = data.forcefieldTime || 0; - this.hat = data.hat || 'None'; - this.adrenaline = data.adrenaline || 0; - this.endurance = data.endurance || 0; - this.fortune = data.fortune || 0; - this.godfather = data.godfather || 0; - this.superluck = data.superluck || 0; - this.transfusion = data.transfusion || 0; + this.wins = data?.wins || 0; + this.shotsFired = data?.shots_fired || 0; + this.killstreaks = data?.killstreaks || 0; + this.forceFieldTime = data?.forcefieldTime || 0; + this.hat = data?.hat || 'None'; + this.adrenaline = data?.adrenaline || 0; + this.endurance = data?.endurance || 0; + this.fortune = data?.fortune || 0; + this.godfather = data?.godfather || 0; + this.superluck = data?.superluck || 0; + this.transfusion = data?.transfusion || 0; } } diff --git a/src/structures/MiniGames/Pit.test.ts b/src/structures/MiniGames/Pit.test.ts new file mode 100644 index 00000000..a6201151 --- /dev/null +++ b/src/structures/MiniGames/Pit.test.ts @@ -0,0 +1,220 @@ +import Client from '../../Client'; +import Pit, { PitArmor } from './Pit'; +import PitInventoryItem from './PitInventoryItem'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Pit', () => { + const data = new Pit({ stats: 'meow' }); + expect(data).toBeInstanceOf(Pit); + expect(data.prestige).toBeDefined(); + expectTypeOf(data.prestige).toEqualTypeOf(); + expect(data.prestige).toBeGreaterThanOrEqual(0); + expect(data.xp).toBeDefined(); + expectTypeOf(data.xp).toEqualTypeOf(); + expect(data.xp).toBeGreaterThanOrEqual(0); + expect(data.level).toBeDefined(); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.level).toBeGreaterThanOrEqual(0); + expect(data.kills).toBeDefined(); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.kills).toBeGreaterThanOrEqual(0); + expect(data.deaths).toBeDefined(); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.deaths).toBeGreaterThanOrEqual(0); + expect(data.KDR).toBeDefined(); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.KDR).toBeGreaterThanOrEqual(0); + expect(data.assists).toBeDefined(); + expectTypeOf(data.assists).toEqualTypeOf(); + expect(data.assists).toBeGreaterThanOrEqual(0); + expect(data.maxKillStreak).toBeDefined(); + expectTypeOf(data.maxKillStreak).toEqualTypeOf(); + expect(data.maxKillStreak).toBeGreaterThanOrEqual(0); + expect(data.playtime).toBeDefined(); + expectTypeOf(data.playtime).toEqualTypeOf(); + expect(data.playtime).toBeGreaterThanOrEqual(0); + expect(data.joins).toBeDefined(); + expectTypeOf(data.joins).toEqualTypeOf(); + expect(data.joins).toBeGreaterThanOrEqual(0); + expect(data.damageReceived).toBeDefined(); + expectTypeOf(data.damageReceived).toEqualTypeOf(); + expect(data.damageReceived).toBeGreaterThanOrEqual(0); + expect(data.damageDealt).toBeDefined(); + expectTypeOf(data.damageDealt).toEqualTypeOf(); + expect(data.damageDealt).toBeGreaterThanOrEqual(0); + expect(data.damageRatio).toBeDefined(); + expectTypeOf(data.damageRatio).toEqualTypeOf(); + expect(data.damageRatio).toBeGreaterThanOrEqual(0); + expect(data.meleeDamageReceived).toBeDefined(); + expectTypeOf(data.meleeDamageReceived).toEqualTypeOf(); + expect(data.meleeDamageReceived).toBeGreaterThanOrEqual(0); + expect(data.meleeDamageDealt).toBeDefined(); + expectTypeOf(data.meleeDamageDealt).toEqualTypeOf(); + expect(data.meleeDamageDealt).toBeGreaterThanOrEqual(0); + expect(data.swordHits).toBeDefined(); + expectTypeOf(data.swordHits).toEqualTypeOf(); + expect(data.swordHits).toBeGreaterThanOrEqual(0); + expect(data.leftClicks).toBeDefined(); + expectTypeOf(data.leftClicks).toEqualTypeOf(); + expect(data.leftClicks).toBeGreaterThanOrEqual(0); + expect(data.meleeAccuracy).toBeDefined(); + expectTypeOf(data.meleeAccuracy).toEqualTypeOf(); + expect(data.meleeAccuracy).toBeGreaterThanOrEqual(0); + expect(data.meleeDamageRatio).toBeDefined(); + expectTypeOf(data.meleeDamageRatio).toEqualTypeOf(); + expect(data.meleeDamageRatio).toBeGreaterThanOrEqual(0); + expect(data.bowDamageReceived).toBeDefined(); + expectTypeOf(data.bowDamageReceived).toEqualTypeOf(); + expect(data.bowDamageReceived).toBeGreaterThanOrEqual(0); + expect(data.bowDamageDealt).toBeDefined(); + expectTypeOf(data.bowDamageDealt).toEqualTypeOf(); + expect(data.bowDamageDealt).toBeGreaterThanOrEqual(0); + expect(data.arrowsHit).toBeDefined(); + expectTypeOf(data.arrowsHit).toEqualTypeOf(); + expect(data.arrowsHit).toBeGreaterThanOrEqual(0); + expect(data.arrowsFired).toBeDefined(); + expectTypeOf(data.arrowsFired).toEqualTypeOf(); + expect(data.arrowsFired).toBeGreaterThanOrEqual(0); + expect(data.bowAccuracy).toBeDefined(); + expectTypeOf(data.bowAccuracy).toEqualTypeOf(); + expect(data.bowAccuracy).toBeGreaterThanOrEqual(0); + expect(data.bowDamageRatio).toBeDefined(); + expectTypeOf(data.bowDamageRatio).toEqualTypeOf(); + expect(data.bowDamageRatio).toBeGreaterThanOrEqual(0); + expect(data.goldenHeadsEaten).toBeDefined(); + expectTypeOf(data.goldenHeadsEaten).toEqualTypeOf(); + expect(data.goldenHeadsEaten).toBeGreaterThanOrEqual(0); +}); + +test('Pit Inventory', async () => { + const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' }); + // eslint-disable-next-line @typescript-eslint/ban-ts-comment + // @ts-expect-error + const data = await client.getPlayer('3457688aa57c4d71ab9d22b04f9160db'); + expect(data.stats.pit.getInventory).toBeDefined(); + expectTypeOf(data.stats.pit.getInventory).toEqualTypeOf<() => Promise>(); + expect(data.stats.pit.getInventory).toBeInstanceOf(Function); + const pitInventory = await data.stats.pit.getInventory(); + expect(pitInventory).toBeDefined(); + pitInventory.forEach((item: PitInventoryItem) => { + expect(item).toBeDefined(); + expect(item).toBeInstanceOf(PitInventoryItem); + expectTypeOf(item).toEqualTypeOf(); + expect(item.itemId).toBeDefined(); + expectTypeOf(item.itemId).toEqualTypeOf(); + expect(item.count).toBeDefined(); + expectTypeOf(item.count).toEqualTypeOf(); + expect(item.name).toBeDefined(); + expectTypeOf(item.name).toEqualTypeOf(); + expect(item.lore).toBeDefined(); + expectTypeOf(item.lore).toEqualTypeOf(); + expect(item.loreArray).toBeDefined(); + expectTypeOf(item.loreArray).toEqualTypeOf(); + expect(item.extraAttributes).toBeDefined(); + expectTypeOf(item.extraAttributes).toEqualTypeOf(); + }); + expect(data.stats.pit.getEnterChest).toBeDefined(); + expectTypeOf(data.stats.pit.getEnterChest).toEqualTypeOf<() => Promise>(); + expect(data.stats.pit.getEnterChest).toBeInstanceOf(Function); + const pitEnterChest = await data.stats.pit.getEnterChest(); + expect(pitEnterChest).toBeDefined(); + pitEnterChest.forEach((item: PitInventoryItem) => { + expect(item).toBeDefined(); + expect(item).toBeInstanceOf(PitInventoryItem); + expectTypeOf(item).toEqualTypeOf(); + expect(item.itemId).toBeDefined(); + expectTypeOf(item.itemId).toEqualTypeOf(); + expect(item.count).toBeDefined(); + expectTypeOf(item.count).toEqualTypeOf(); + expect(item.name).toBeDefined(); + expectTypeOf(item.name).toEqualTypeOf(); + expect(item.lore).toBeDefined(); + expectTypeOf(item.lore).toEqualTypeOf(); + expect(item.loreArray).toBeDefined(); + expectTypeOf(item.loreArray).toEqualTypeOf(); + expect(item.extraAttributes).toBeDefined(); + expectTypeOf(item.extraAttributes).toEqualTypeOf(); + }); + expect(data.stats.pit.getArmor).toBeDefined(); + expectTypeOf(data.stats.pit.getArmor).toEqualTypeOf<() => Promise>(); + expect(data.stats.pit.getArmor).toBeInstanceOf(Function); + const pitArmor = await data.stats.pit.getArmor(); + expect(pitArmor).toBeDefined(); + expectTypeOf(pitArmor).toEqualTypeOf(); + expect(pitArmor.helmet).toBeDefined(); + expectTypeOf(pitArmor.helmet).toEqualTypeOf(); + if (null !== pitArmor.helmet) { + expect(pitArmor.helmet).toBeDefined(); + expect(pitArmor.helmet).toBeInstanceOf(PitInventoryItem); + expectTypeOf(pitArmor.helmet).toEqualTypeOf(); + expect(pitArmor.helmet.itemId).toBeDefined(); + expectTypeOf(pitArmor.helmet.itemId).toEqualTypeOf(); + expect(pitArmor.helmet.count).toBeDefined(); + expectTypeOf(pitArmor.helmet.count).toEqualTypeOf(); + expect(pitArmor.helmet.name).toBeDefined(); + expectTypeOf(pitArmor.helmet.name).toEqualTypeOf(); + expect(pitArmor.helmet.lore).toBeDefined(); + expectTypeOf(pitArmor.helmet.lore).toEqualTypeOf(); + expect(pitArmor.helmet.loreArray).toBeDefined(); + expectTypeOf(pitArmor.helmet.loreArray).toEqualTypeOf(); + expect(pitArmor.helmet.extraAttributes).toBeDefined(); + expectTypeOf(pitArmor.helmet.extraAttributes).toEqualTypeOf(); + } + expect(pitArmor.chestplate).toBeDefined(); + expectTypeOf(pitArmor.chestplate).toEqualTypeOf(); + if (null !== pitArmor.chestplate) { + expect(pitArmor.chestplate).toBeDefined(); + expect(pitArmor.chestplate).toBeInstanceOf(PitInventoryItem); + expectTypeOf(pitArmor.chestplate).toEqualTypeOf(); + expect(pitArmor.chestplate.itemId).toBeDefined(); + expectTypeOf(pitArmor.chestplate.itemId).toEqualTypeOf(); + expect(pitArmor.chestplate.count).toBeDefined(); + expectTypeOf(pitArmor.chestplate.count).toEqualTypeOf(); + expect(pitArmor.chestplate.name).toBeDefined(); + expectTypeOf(pitArmor.chestplate.name).toEqualTypeOf(); + expect(pitArmor.chestplate.lore).toBeDefined(); + expectTypeOf(pitArmor.chestplate.lore).toEqualTypeOf(); + expect(pitArmor.chestplate.loreArray).toBeDefined(); + expectTypeOf(pitArmor.chestplate.loreArray).toEqualTypeOf(); + expect(pitArmor.chestplate.extraAttributes).toBeDefined(); + expectTypeOf(pitArmor.chestplate.extraAttributes).toEqualTypeOf(); + } + expect(pitArmor.leggings).toBeDefined(); + expectTypeOf(pitArmor.leggings).toEqualTypeOf(); + if (null !== pitArmor.leggings) { + expect(pitArmor.leggings).toBeDefined(); + expect(pitArmor.leggings).toBeInstanceOf(PitInventoryItem); + expectTypeOf(pitArmor.leggings).toEqualTypeOf(); + expect(pitArmor.leggings.itemId).toBeDefined(); + expectTypeOf(pitArmor.leggings.itemId).toEqualTypeOf(); + expect(pitArmor.leggings.count).toBeDefined(); + expectTypeOf(pitArmor.leggings.count).toEqualTypeOf(); + expect(pitArmor.leggings.name).toBeDefined(); + expectTypeOf(pitArmor.leggings.name).toEqualTypeOf(); + expect(pitArmor.leggings.lore).toBeDefined(); + expectTypeOf(pitArmor.leggings.lore).toEqualTypeOf(); + expect(pitArmor.leggings.loreArray).toBeDefined(); + expectTypeOf(pitArmor.leggings.loreArray).toEqualTypeOf(); + expect(pitArmor.leggings.extraAttributes).toBeDefined(); + expectTypeOf(pitArmor.leggings.extraAttributes).toEqualTypeOf(); + } + expect(pitArmor.boots).toBeDefined(); + expectTypeOf(pitArmor.boots).toEqualTypeOf(); + if (null !== pitArmor.boots) { + expect(pitArmor.boots).toBeDefined(); + expect(pitArmor.boots).toBeInstanceOf(PitInventoryItem); + expectTypeOf(pitArmor.boots).toEqualTypeOf(); + expect(pitArmor.boots.itemId).toBeDefined(); + expectTypeOf(pitArmor.boots.itemId).toEqualTypeOf(); + expect(pitArmor.boots.count).toBeDefined(); + expectTypeOf(pitArmor.boots.count).toEqualTypeOf(); + expect(pitArmor.boots.name).toBeDefined(); + expectTypeOf(pitArmor.boots.name).toEqualTypeOf(); + expect(pitArmor.boots.lore).toBeDefined(); + expectTypeOf(pitArmor.boots.lore).toEqualTypeOf(); + expect(pitArmor.boots.loreArray).toBeDefined(); + expectTypeOf(pitArmor.boots.loreArray).toEqualTypeOf(); + expect(pitArmor.boots.extraAttributes).toBeDefined(); + expectTypeOf(pitArmor.boots.extraAttributes).toEqualTypeOf(); + } +}); diff --git a/src/structures/MiniGames/Pit.ts b/src/structures/MiniGames/Pit.ts index 452b74a0..83e5efbc 100644 --- a/src/structures/MiniGames/Pit.ts +++ b/src/structures/MiniGames/Pit.ts @@ -41,88 +41,81 @@ class Pit { getEnterChest: () => Promise; getArmor: () => Promise; constructor(data: Record) { - this.prestige = data.profile?.prestiges?.[data.profile?.prestiges?.length - 1].index || 0; - this.xp = data.profile?.xp || 0; + this.prestige = data?.profile?.prestiges?.[data?.profile?.prestiges?.length - 1]?.index || 0; + this.xp = data?.profile?.xp || 0; this.level = this.calcLevel( this.prestige, - 0 < this.prestige ? this.xp - Constants.pit.Prestiges[this.prestige - 1].SumXp : this.xp + 0 < this.prestige ? this.xp - Constants?.pit?.Prestiges[this.prestige - 1]?.SumXp : this.xp ) ?? 0; - this.kills = data.pit_stats_ptl?.kills || 0; - this.deaths = data.pit_stats_ptl?.deaths || 0; + this.kills = data?.pit_stats_ptl?.kills || 0; + this.deaths = data?.pit_stats_ptl?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.assists = data.pit_stats_ptl?.assists || 0; - this.maxKillStreak = data.pit_stats_ptl?.max_streak || 0; - this.playtime = (data.pit_stats_ptl?.playtime_minutes || 0) * 60; - this.joins = data.pit_stats_ptl?.joins || 0; - this.damageReceived = data.pit_stats_ptl?.damage_received || 0; - this.damageDealt = data.pit_stats_ptl?.damage_dealt || 0; + this.assists = data?.pit_stats_ptl?.assists || 0; + this.maxKillStreak = data?.pit_stats_ptl?.max_streak || 0; + this.playtime = (data?.pit_stats_ptl?.playtime_minutes || 0) * 60; + this.joins = data?.pit_stats_ptl?.joins || 0; + this.damageReceived = data?.pit_stats_ptl?.damage_received || 0; + this.damageDealt = data?.pit_stats_ptl?.damage_dealt || 0; this.damageRatio = divide(this.damageDealt, this.damageReceived); - this.meleeDamageReceived = data.pit_stats_ptl?.melee_damage_received || 0; - this.meleeDamageDealt = data.pit_stats_ptl?.melee_damage_dealt || 0; - this.swordHits = data.pit_stats_ptl?.sword_hits || 0; - this.leftClicks = data.pit_stats_ptl?.left_clicks || 0; + this.meleeDamageReceived = data?.pit_stats_ptl?.melee_damage_received || 0; + this.meleeDamageDealt = data?.pit_stats_ptl?.melee_damage_dealt || 0; + this.swordHits = data?.pit_stats_ptl?.sword_hits || 0; + this.leftClicks = data?.pit_stats_ptl?.left_clicks || 0; this.meleeAccuracy = divide(this.swordHits, this.leftClicks); this.meleeDamageRatio = divide(this.meleeDamageDealt, this.meleeDamageReceived); - this.bowDamageReceived = data.pit_stats_ptl?.bow_damage_received || 0; - this.bowDamageDealt = data.pit_stats_ptl?.bow_damage_dealt || 0; - this.arrowsHit = data.pit_stats_ptl?.arrow_hits || 0; - this.arrowsFired = data.pit_stats_ptl?.arrows_fired || 0; + this.bowDamageReceived = data?.pit_stats_ptl?.bow_damage_received || 0; + this.bowDamageDealt = data?.pit_stats_ptl?.bow_damage_dealt || 0; + this.arrowsHit = data?.pit_stats_ptl?.arrow_hits || 0; + this.arrowsFired = data?.pit_stats_ptl?.arrows_fired || 0; this.bowAccuracy = divide(this.arrowsHit, this.arrowsFired); this.bowDamageRatio = divide(this.bowDamageDealt, this.bowDamageReceived); - this.goldenHeadsEaten = data.pit_stats_ptl?.ghead_eaten || 0; + this.goldenHeadsEaten = data?.pit_stats_ptl?.ghead_eaten || 0; this.getInventory = async (): Promise => { - let inventory = data.profile.inv_contents; + let inventory = data?.profile?.inv_contents || undefined; if (!inventory) return []; - try { - inventory = await decode(inventory.data); - const edited = []; - for (let i = 1; i < inventory.length; i++) { - if (!inventory[i].id) { - continue; - } - edited.push(new PitInventoryItem(inventory[i])); + inventory = await decode(inventory?.data); + const edited = []; + for (let i = 1; i < inventory?.length; i++) { + if (!inventory[i]?.id) { + continue; } - return edited; - } catch { - return []; + edited?.push(new PitInventoryItem(inventory[i])); } + return edited; }; this.getEnterChest = async () => { - let chest = data.profile.inv_enderchest; + let chest = data?.profile?.inv_enderchest || undefined; if (!chest) return []; - try { - chest = await decode(chest.data); - const edited = []; - for (let i = 1; i < chest.length; i++) { - if (!chest[i].id) { - continue; - } - edited.push(new PitInventoryItem(chest[i])); + chest = await decode(chest?.data); + const edited = []; + for (let i = 1; i < chest?.length; i++) { + if (!chest[i]?.id) { + continue; } - return edited; - } catch { - return []; + edited?.push(new PitInventoryItem(chest[i])); } + return edited; }; this.getArmor = async () => { - const base64 = data.profile.inv_armor; - const decoded = await decode(base64.data); + const base64 = data?.profile?.inv_armor || undefined; + if (!base64) return { helmet: null, chestplate: null, leggings: null, boots: null }; + const decoded = await decode(base64?.data); const armor = { - helmet: decoded[3].id ? new PitInventoryItem(decoded[3]) : null, - chestplate: decoded[2].id ? new PitInventoryItem(decoded[2]) : null, - leggings: decoded[1].id ? new PitInventoryItem(decoded[1]) : null, - boots: decoded[0].id ? new PitInventoryItem(decoded[0]) : null + helmet: decoded[3]?.id ? new PitInventoryItem(decoded[3]) : null, + chestplate: decoded[2]?.id ? new PitInventoryItem(decoded[2]) : null, + leggings: decoded[1]?.id ? new PitInventoryItem(decoded[1]) : null, + boots: decoded[0]?.id ? new PitInventoryItem(decoded[0]) : null }; return armor; }; } // Credit https://github.com/PitPanda/PitPandaProduction/blob/b1971f56ea1aa8c829b722cbb33247c96591c0cb/structures/Pit.js private calcLevel(prestige: number, xp: number): number { - const multiplier = Constants.pit.Prestiges[prestige].Multiplier; + const multiplier = Constants?.pit?.Prestiges[prestige]?.Multiplier; let level = 0; while (0 < xp && 120 > level) { - const levelXp = Constants.pit.Levels[Math.floor(level / 10)].Xp * multiplier; + const levelXp = Constants?.pit?.Levels[Math.floor(level / 10)]?.Xp * multiplier; if (xp >= levelXp * 10) { xp -= levelXp * 10; level += 10; diff --git a/src/structures/MiniGames/PitInventoryItem.ts b/src/structures/MiniGames/PitInventoryItem.ts index 94875f9e..7b5d3f98 100644 --- a/src/structures/MiniGames/PitInventoryItem.ts +++ b/src/structures/MiniGames/PitInventoryItem.ts @@ -6,10 +6,12 @@ class PitInventoryItem { loreArray: string[]; extraAttributes: object | null; constructor(data: Record) { - this.itemId = data.id || 0; - this.count = data.Count || 0; - this.name = data?.tag?.display?.Name ? data.tag.display.Name.toString().replace(/§([1-9]|[a-f])|§/gm, '') : null; - this.lore = data?.tag?.display?.Lore ? data.tag.display.Lore.join('\n') : null; + this.itemId = data?.id || 0; + this.count = data?.Count || 0; + this.name = data?.tag?.display?.Name + ? data?.tag?.display?.Name?.toString().replace(/§([1-9]|[a-f])|§/gm, '') + : null; + this.lore = data?.tag?.display?.Lore ? data?.tag?.display?.Lore?.join('\n') : null; this.loreArray = data?.tag?.display?.Lore ?? []; this.extraAttributes = data?.tag?.ExtraAttributes ?? null; } diff --git a/src/structures/MiniGames/Quakecraft.test.ts b/src/structures/MiniGames/Quakecraft.test.ts new file mode 100644 index 00000000..dd8e5253 --- /dev/null +++ b/src/structures/MiniGames/Quakecraft.test.ts @@ -0,0 +1,106 @@ +import Quakecraft, { QuakecraftMode } from './Quakecraft'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Quakecraft', () => { + const data = new Quakecraft({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Quakecraft); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.solo).toBeDefined(); + expectTypeOf(data.solo).toEqualTypeOf(); + expect(data.solo.wins).toBeDefined(); + expect(data.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.wins).toEqualTypeOf(); + expect(data.solo.kills).toBeDefined(); + expect(data.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.kills).toEqualTypeOf(); + expect(data.solo.deaths).toBeDefined(); + expect(data.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.deaths).toEqualTypeOf(); + expect(data.solo.KDR).toBeDefined(); + expect(data.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.KDR).toEqualTypeOf(); + expect(data.solo.killstreaks).toBeDefined(); + expect(data.solo.killstreaks).greaterThanOrEqual(0); + expectTypeOf(data.solo.killstreaks).toEqualTypeOf(); + expect(data.solo.distanceTravelled).toBeDefined(); + expect(data.solo.distanceTravelled).greaterThanOrEqual(0); + expectTypeOf(data.solo.distanceTravelled).toEqualTypeOf(); + expect(data.solo.shotsFired).toBeDefined(); + expect(data.solo.shotsFired).greaterThanOrEqual(0); + expectTypeOf(data.solo.shotsFired).toEqualTypeOf(); + expect(data.solo.headshots).toBeDefined(); + expect(data.solo.headshots).greaterThanOrEqual(0); + expectTypeOf(data.solo.headshots).toEqualTypeOf(); + expect(data.teams).toBeDefined(); + expectTypeOf(data.teams).toEqualTypeOf(); + expect(data.teams.wins).toBeDefined(); + expect(data.teams.wins).greaterThanOrEqual(0); + expectTypeOf(data.teams.wins).toEqualTypeOf(); + expect(data.teams.kills).toBeDefined(); + expect(data.teams.kills).greaterThanOrEqual(0); + expectTypeOf(data.teams.kills).toEqualTypeOf(); + expect(data.teams.deaths).toBeDefined(); + expect(data.teams.deaths).greaterThanOrEqual(0); + expectTypeOf(data.teams.deaths).toEqualTypeOf(); + expect(data.teams.KDR).toBeDefined(); + expect(data.teams.KDR).greaterThanOrEqual(0); + expectTypeOf(data.teams.KDR).toEqualTypeOf(); + expect(data.teams.killstreaks).toBeDefined(); + expect(data.teams.killstreaks).greaterThanOrEqual(0); + expectTypeOf(data.teams.killstreaks).toEqualTypeOf(); + expect(data.teams.distanceTravelled).toBeDefined(); + expect(data.teams.distanceTravelled).greaterThanOrEqual(0); + expectTypeOf(data.teams.distanceTravelled).toEqualTypeOf(); + expect(data.teams.shotsFired).toBeDefined(); + expect(data.teams.shotsFired).greaterThanOrEqual(0); + expectTypeOf(data.teams.shotsFired).toEqualTypeOf(); + expect(data.teams.headshots).toBeDefined(); + expect(data.teams.headshots).greaterThanOrEqual(0); + expectTypeOf(data.teams.headshots).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.killstreaks).toBeDefined(); + expect(data.killstreaks).greaterThanOrEqual(0); + expectTypeOf(data.killstreaks).toEqualTypeOf(); + expect(data.distanceTravelled).toBeDefined(); + expect(data.distanceTravelled).greaterThanOrEqual(0); + expectTypeOf(data.distanceTravelled).toEqualTypeOf(); + expect(data.shotsFired).toBeDefined(); + expect(data.shotsFired).greaterThanOrEqual(0); + expectTypeOf(data.shotsFired).toEqualTypeOf(); + expect(data.headshots).toBeDefined(); + expect(data.headshots).greaterThanOrEqual(0); + expectTypeOf(data.headshots).toEqualTypeOf(); + expect(data.instantRespawn).toBeDefined(); + expectTypeOf(data.instantRespawn).toEqualTypeOf(); + expect(data.killPrefixColor).toBeDefined(); + expectTypeOf(data.killPrefixColor).toEqualTypeOf(); + expect(data.showPrefix).toBeDefined(); + expectTypeOf(data.showPrefix).toEqualTypeOf(); + expect(data.killSound).toBeDefined(); + expectTypeOf(data.killSound).toEqualTypeOf(); + expect(data.barrel).toBeDefined(); + expectTypeOf(data.barrel).toEqualTypeOf(); + expect(data.case).toBeDefined(); + expectTypeOf(data.case).toEqualTypeOf(); + expect(data.muzzle).toBeDefined(); + expectTypeOf(data.muzzle).toEqualTypeOf(); + expect(data.sight).toBeDefined(); + expectTypeOf(data.sight).toEqualTypeOf(); + expect(data.trigger).toBeDefined(); + expectTypeOf(data.trigger).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/Quakecraft.ts b/src/structures/MiniGames/Quakecraft.ts index 531141d7..e761b37a 100644 --- a/src/structures/MiniGames/Quakecraft.ts +++ b/src/structures/MiniGames/Quakecraft.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class QuakecraftMode { +export class QuakecraftMode { wins: number; kills: number; deaths: number; @@ -11,14 +11,14 @@ class QuakecraftMode { headshots: number; constructor(data: Record, gamemode?: string) { if (gamemode) gamemode = `_${gamemode}`; - this.wins = data[`wins${gamemode}`] || 0; - this.kills = data[`kills${gamemode}`] || 0; - this.deaths = data[`deaths${gamemode}`] || 0; + this.wins = data?.[`wins${gamemode}`] || 0; + this.kills = data?.[`kills${gamemode}`] || 0; + this.deaths = data?.[`deaths${gamemode}`] || 0; this.KDR = divide(this.kills, this.deaths); - this.killstreaks = data[`killstreaks${gamemode}`] || 0; - this.distanceTravelled = data[`distance_travelled${gamemode}`] || 0; - this.shotsFired = data[`shots_fired${gamemode}`] || 0; - this.headshots = data[`headshots${gamemode}`] || 0; + this.killstreaks = data?.[`killstreaks${gamemode}`] || 0; + this.distanceTravelled = data?.[`distance_travelled${gamemode}`] || 0; + this.shotsFired = data?.[`shots_fired${gamemode}`] || 0; + this.headshots = data?.[`headshots${gamemode}`] || 0; } } @@ -44,26 +44,26 @@ class Quakecraft { sight: string; trigger: string; constructor(data: Record) { - this.coins = data.coins || 0; + this.coins = data?.coins || 0; this.solo = new QuakecraftMode(data); this.teams = new QuakecraftMode(data, 'teams'); - this.wins = this.solo.wins + this.teams.wins; - this.kills = this.solo.kills + this.teams.kills; - this.deaths = this.solo.deaths + this.teams.deaths; + this.wins = this.solo?.wins + this.teams?.wins; + this.kills = this.solo?.kills + this.teams?.kills; + this.deaths = this.solo?.deaths + this.teams?.deaths; this.KDR = divide(this.kills, this.deaths); - this.killstreaks = this.solo.killstreaks + this.teams.killstreaks; - this.distanceTravelled = this.solo.distanceTravelled + this.teams.distanceTravelled; - this.shotsFired = this.solo.shotsFired + this.teams.shotsFired; - this.headshots = this.solo.headshots + this.teams.headshots; - this.instantRespawn = data.instantRespawn || false; - this.killPrefixColor = data.selectedKillPrefix || ''; - this.showPrefix = data.showKillPrefix || false; - this.killSound = data.killsound || ''; - this.barrel = data.barrel || ''; - this.case = data.case || ''; - this.muzzle = data.muzzle || ''; - this.sight = data.sight || ''; - this.trigger = data.trigger || ''; + this.killstreaks = this.solo?.killstreaks + this.teams?.killstreaks; + this.distanceTravelled = this.solo?.distanceTravelled + this.teams?.distanceTravelled; + this.shotsFired = this.solo?.shotsFired + this.teams?.shotsFired; + this.headshots = this.solo?.headshots + this.teams?.headshots; + this.instantRespawn = data?.instantRespawn || false; + this.killPrefixColor = data?.selectedKillPrefix || ''; + this.showPrefix = data?.showKillPrefix || false; + this.killSound = data?.killsound || ''; + this.barrel = data?.barrel || ''; + this.case = data?.case || ''; + this.muzzle = data?.muzzle || ''; + this.sight = data?.sight || ''; + this.trigger = data?.trigger || ''; } } diff --git a/src/structures/MiniGames/SkyWars.ts b/src/structures/MiniGames/SkyWars.ts index fd7989cd..857791aa 100644 --- a/src/structures/MiniGames/SkyWars.ts +++ b/src/structures/MiniGames/SkyWars.ts @@ -23,9 +23,10 @@ function getSkyWarsPrestige(level: number): SkyWarsPrestige { function getSkyWarsLevel(xp: number): number { const totalXp = [0, 2, 7, 15, 25, 50, 100, 200, 350, 600, 1000, 1500]; + if (0 === xp) return 0; if (15000 <= xp) return Math.floor((xp - 15000) / 10000 + 12); const level = totalXp.findIndex((x) => 0 < x * 10 - xp); - return level; + return -1 === level ? 0 : level; } function getSkyWarsLevelProgress(xp: number) { @@ -57,7 +58,7 @@ function getSkyWarsLevelProgress(xp: number) { return { currentLevelXp, xpToNextLevel, percent, xpNextLevel: totalXptoNextLevel }; } -class SkywarsMode { +export class SkywarsMode { kills: number; deaths: number; KDR: number; @@ -65,16 +66,16 @@ class SkywarsMode { losses: number; WLR: number; constructor(data: Record, gamemode: string) { - this.kills = data[`kills_${gamemode}`] || 0; - this.deaths = data[`deaths_${gamemode}`] || 0; - this.KDR = divide(data.kills, data.deaths); - this.wins = data[`wins_${gamemode}`] || 0; - this.losses = data[`losses_${gamemode}`] || 0; - this.WLR = divide(data.wins, data.losses); + this.kills = data?.[`kills_${gamemode}`] || 0; + this.deaths = data?.[`deaths_${gamemode}`] || 0; + this.KDR = divide(data?.kills, data?.deaths); + this.wins = data?.[`wins_${gamemode}`] || 0; + this.losses = data?.[`losses_${gamemode}`] || 0; + this.WLR = divide(data?.wins, data?.losses); } } -class SkywarsModeStats { +export class SkywarsModeStats { activeKit: string; killstreak: number; kills: number; @@ -99,31 +100,35 @@ class SkywarsModeStats { bowAccuracy: number; fastestWin: number; heads: number; + normal: SkywarsMode; + insane: SkywarsMode; constructor(data: Record, gamemode: string) { - this.activeKit = data[`activeKit_${gamemode.toUpperCase()}`] || ''; - this.killstreak = data[`killstreak_${gamemode}`] || 0; - this.kills = data[`kills_${gamemode}`] || 0; - this.voidKills = data[`void_kills_${gamemode}`] || 0; - this.meleeKills = data[`melee_kills_${gamemode}`] || 0; - this.bowKills = data[`bow_kills_${gamemode}`] || 0; - this.mobKills = data[`mob_kills_${gamemode}`] || 0; - this.assists = data[`assists_${gamemode}`] || 0; - this.deaths = data[`deaths_${gamemode}`] || 0; - this.KDR = divide(data.kills, data.deaths); - this.wins = data[`wins_${gamemode}`] || 0; - this.losses = data[`losses_${gamemode}`] || 0; - this.WLR = divide(data.wins, data.losses); - this.gamesPlayed = data[`games_${gamemode}`] || 0; - this.survivedPlayers = data[`survived_players_${gamemode}`] || 0; - this.chestsOpened = data[`chests_opened_${gamemode}`] || 0; - this.timePlayed = data[`time_played_${gamemode}`] || 0; - this.shard = data[`shard_${gamemode}`] || 0; - this.longestBowShot = data[`longest_bow_shot_${gamemode}`] || 0; - this.arrowsShot = data[`arrows_shot_${gamemode}`] || 0; - this.arrowsHit = data[`arrows_hit_${gamemode}`] || 0; + this.activeKit = data?.[`activeKit_${gamemode?.toUpperCase()}`] || ''; + this.killstreak = data?.[`killstreak_${gamemode}`] || 0; + this.kills = data?.[`kills_${gamemode}`] || 0; + this.voidKills = data?.[`void_kills_${gamemode}`] || 0; + this.meleeKills = data?.[`melee_kills_${gamemode}`] || 0; + this.bowKills = data?.[`bow_kills_${gamemode}`] || 0; + this.mobKills = data?.[`mob_kills_${gamemode}`] || 0; + this.assists = data?.[`assists_${gamemode}`] || 0; + this.deaths = data?.[`deaths_${gamemode}`] || 0; + this.KDR = divide(data?.kills, data?.deaths); + this.wins = data?.[`wins_${gamemode}`] || 0; + this.losses = data?.[`losses_${gamemode}`] || 0; + this.WLR = divide(data?.wins, data?.losses); + this.gamesPlayed = data?.[`games_${gamemode}`] || 0; + this.survivedPlayers = data?.[`survived_players_${gamemode}`] || 0; + this.chestsOpened = data?.[`chests_opened_${gamemode}`] || 0; + this.timePlayed = data?.[`time_played_${gamemode}`] || 0; + this.shard = data?.[`shard_${gamemode}`] || 0; + this.longestBowShot = data?.[`longest_bow_shot_${gamemode}`] || 0; + this.arrowsShot = data?.[`arrows_shot_${gamemode}`] || 0; + this.arrowsHit = data?.[`arrows_hit_${gamemode}`] || 0; this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot); - this.fastestWin = data[`fastest_win_${gamemode}`] || 0; - this.heads = data[`heads_${gamemode}`] || 0; + this.fastestWin = data?.[`fastest_win_${gamemode}`] || 0; + this.heads = data?.[`heads_${gamemode}`] || 0; + this.insane = new SkywarsMode(data, `${gamemode}_insane`); + this.normal = new SkywarsMode(data, `${gamemode}_normal`); } } @@ -134,25 +139,25 @@ class SkywarsKit { kitType: string; kitName: string; constructor(kit: Record) { - this.kitData = kit.match(/^kit_([a-z]+)_([a-z]+)_([a-z]+)$/); + this.kitData = kit?.match(/^kit_([a-z]+)_([a-z]+)_([a-z]+)$/); this.isKit = Boolean(this.kitData); - this.gameMode = this.kitData ? this.kitData[2] : ''; - this.kitType = this.kitData ? this.kitData[1] : ''; - this.kitName = removeSnakeCaseString(this.kitData ? this.kitData[3] : ''); + this.gameMode = this.kitData ? this.kitData?.[2] : ''; + this.kitType = this.kitData ? this.kitData?.[1] : ''; + this.kitName = removeSnakeCaseString(this.kitData ? this.kitData?.[3] : ''); } } class SkywarsKits { kits: SkywarsKit[]; constructor(kits: Record) { - this.kits = kits.map((kit: any) => new SkywarsKit(kit)).filter((kit: SkywarsKit) => kit.isKit); + this.kits = kits.map((kit: any) => new SkywarsKit(kit)).filter((kit: SkywarsKit) => kit?.isKit); } get(gameMode: string = '', type: string = ''): SkywarsKit[] { - return this.kits.filter((kit) => kit.gameMode.startsWith(gameMode) && kit.kitType.startsWith(type)); + return this.kits.filter((kit) => kit?.gameMode?.startsWith(gameMode) && kit?.kitType.startsWith(type)); } } -class SkywarsPackages { +export class SkywarsPackages { rawPackages: Record; cages: any; kits: SkywarsKits; @@ -162,16 +167,16 @@ class SkywarsPackages { this.cages = this.parseCages(); this.kits = new SkywarsKits(data); this.achievements = this.rawPackages - .map((pkg: string) => pkg.match(/^([A-Za-z]+)_?achievement([0-9]?)$/)) - .filter((x: any) => x) - .map((x: any[]) => x.slice(1).join('')); + ?.map((pkg: string) => pkg?.match(/^([A-Za-z]+)_?achievement([0-9]?)$/)) + ?.filter((x: any) => x) + ?.map((x: any[]) => x?.slice(1)?.join('')); } parseCages(): string[] { return this.rawPackages - .map((pkg: string) => pkg.match(/^cage_([A-Za-z]+)-cage$/)) - .filter((x: any) => x) - .map((x: string[]) => x[1].replace(/-[a-z]/g, (x) => x[1].toUpperCase())); + ?.map((pkg: string) => pkg?.match(/^cage_([A-Za-z]+)-cage$/)) + ?.filter((x: any) => x) + ?.map((x: string[]) => x[1]?.replace(/-[a-z]/g, (x) => x[1].toUpperCase())); } } @@ -182,7 +187,7 @@ class SkyWars { experience: number; level: number; levelProgress: any; - levelFormatted: string; + levelFormatted: string | null; prestige: SkyWarsPrestige; opals: number; avarice: number; @@ -217,71 +222,63 @@ class SkyWars { eggThrown: number; enderpearlsThrown: number; solo: SkywarsModeStats; - soloNormal: SkywarsMode; - soloInsane: SkywarsMode; team: SkywarsModeStats; - teamNormal: SkywarsMode; - teamInsane: SkywarsMode; mega: SkywarsMode; megaDoubles: SkywarsMode; lab: SkywarsMode; packages: SkywarsPackages; constructor(data: Record) { - this.coins = data.coins || 0; - this.souls = data.souls || 0; - this.tokens = data.cosmetic_tokens || 0; - this.experience = data.skywars_experience || 0; - this.level = getSkyWarsLevel(data.skywars_experience); - this.levelProgress = getSkyWarsLevelProgress(data.skywars_experience); - this.levelFormatted = data.levelFormatted - ? data.levelFormatted - .replace(/§l/gm, '**') - .replace(/§([a-f]|[1-9])/gm, '') - .replace(/§r/gm, '') + this.coins = data?.coins || 0; + this.souls = data?.souls || 0; + this.tokens = data?.cosmetic_tokens || 0; + this.experience = data?.skywars_experience || 0; + this.level = getSkyWarsLevel(data?.skywars_experience); + this.levelProgress = getSkyWarsLevelProgress(data?.skywars_experience); + this.levelFormatted = data?.levelFormatted + ? data?.levelFormatted + ?.replace(/§l/gm, '**') + ?.replace(/§([a-f]|[1-9])/gm, '') + ?.replace(/§r/gm, '') : null; this.prestige = getSkyWarsPrestige(this.level); - this.opals = data.opals || 0; - this.avarice = data.avarice || 0; - this.tenacity = data.tenacity || 0; - this.shards = data.shard || 0; - this.angelOfDeathLevel = data.angel_of_death_level || 0; - this.killstreak = data.killstreak || 0; - this.kills = data.kills || 0; - this.voidKills = data.void_kills || 0; - this.meleeKills = data.melee_kills || 0; - this.bowKills = data.bow_kills || 0; - this.mobKills = data.mob_kills || 0; - this.assists = data.assists || 0; - this.deaths = data.deaths || 0; - this.KDR = divide(data.kills, data.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; - this.WLR = divide(data.wins, data.losses); - this.gamesPlayed = data.games || 0; - this.survivedPlayers = data.survived_players || 0; - this.chestsOpened = data.chests_opened || 0; - this.timePlayed = data.time_played || 0; - this.shard = data.shard || 0; - this.longestBowShot = data.longest_bow_shot || 0; - this.arrowsShot = data.arrows_shot || 0; - this.arrowsHit = data.arrows_hit || 0; + this.opals = data?.opals || 0; + this.avarice = data?.avarice || 0; + this.tenacity = data?.tenacity || 0; + this.shards = data?.shard || 0; + this.angelOfDeathLevel = data?.angel_of_death_level || 0; + this.killstreak = data?.killstreak || 0; + this.kills = data?.kills || 0; + this.voidKills = data?.void_kills || 0; + this.meleeKills = data?.melee_kills || 0; + this.bowKills = data?.bow_kills || 0; + this.mobKills = data?.mob_kills || 0; + this.assists = data?.assists || 0; + this.deaths = data?.deaths || 0; + this.KDR = divide(data?.kills, data?.deaths); + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; + this.WLR = divide(data?.wins, data?.losses); + this.gamesPlayed = data?.games || 0; + this.survivedPlayers = data?.survived_players || 0; + this.chestsOpened = data?.chests_opened || 0; + this.timePlayed = data?.time_played || 0; + this.shard = data?.shard || 0; + this.longestBowShot = data?.longest_bow_shot || 0; + this.arrowsShot = data?.arrows_shot || 0; + this.arrowsHit = data?.arrows_hit || 0; this.bowAccuracy = divide(this.arrowsHit, this.arrowsShot); - this.fastestWin = data.fastest_win || 0; - this.heads = data.heads || 0; - this.blocksPlaced = data.blocks_placed || 0; - this.blocksBroken = data.blocks_broken || 0; - this.eggThrown = data.egg_thrown || 0; - this.enderpearlsThrown = data.enderpearls_thrown || 0; + this.fastestWin = data?.fastest_win || 0; + this.heads = data?.heads || 0; + this.blocksPlaced = data?.blocks_placed || 0; + this.blocksBroken = data?.blocks_broken || 0; + this.eggThrown = data?.egg_thrown || 0; + this.enderpearlsThrown = data?.enderpearls_thrown || 0; this.solo = new SkywarsModeStats(data, 'solo'); - this.soloNormal = new SkywarsMode(data, 'solo_normal'); - this.soloInsane = new SkywarsMode(data, 'solo_insane'); this.team = new SkywarsModeStats(data, 'team'); - this.teamNormal = new SkywarsMode(data, 'team_normal'); - this.teamInsane = new SkywarsMode(data, 'team_insane'); this.mega = new SkywarsMode(data, 'mega'); this.megaDoubles = new SkywarsMode(data, 'mega_doubles'); this.lab = new SkywarsMode(data, 'lab'); - this.packages = new SkywarsPackages(data.packages || []); + this.packages = new SkywarsPackages(data?.packages || []); } } diff --git a/src/structures/MiniGames/Skywars.test.ts b/src/structures/MiniGames/Skywars.test.ts new file mode 100644 index 00000000..3556c182 --- /dev/null +++ b/src/structures/MiniGames/Skywars.test.ts @@ -0,0 +1,414 @@ +import SkyWars, { SkyWarsPrestige, SkywarsMode, SkywarsModeStats, SkywarsPackages } from './SkyWars'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('SkyWars', () => { + const data = new SkyWars({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(SkyWars); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.souls).toBeDefined(); + expect(data.souls).greaterThanOrEqual(0); + expectTypeOf(data.souls).toEqualTypeOf(); + expect(data.tokens).toBeDefined(); + expect(data.tokens).greaterThanOrEqual(0); + expectTypeOf(data.tokens).toEqualTypeOf(); + expect(data.experience).toBeDefined(); + expect(data.experience).greaterThanOrEqual(0); + expectTypeOf(data.experience).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expect(data.level).greaterThanOrEqual(0); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.levelProgress).toBeDefined(); + expectTypeOf(data.levelProgress).toEqualTypeOf(); + expect(data.levelFormatted).toBeDefined(); + expectTypeOf(data.levelFormatted).toEqualTypeOf(); + expect(data.prestige).toBeDefined(); + expectTypeOf(data.prestige).toEqualTypeOf(); + expect(data.opals).toBeDefined(); + expect(data.opals).greaterThanOrEqual(0); + expectTypeOf(data.opals).toEqualTypeOf(); + expect(data.avarice).toBeDefined(); + expect(data.avarice).greaterThanOrEqual(0); + expectTypeOf(data.avarice).toEqualTypeOf(); + expect(data.tenacity).toBeDefined(); + expect(data.tenacity).greaterThanOrEqual(0); + expectTypeOf(data.tenacity).toEqualTypeOf(); + expect(data.shards).toBeDefined(); + expect(data.shards).greaterThanOrEqual(0); + expectTypeOf(data.shards).toEqualTypeOf(); + expect(data.angelOfDeathLevel).toBeDefined(); + expect(data.angelOfDeathLevel).greaterThanOrEqual(0); + expectTypeOf(data.angelOfDeathLevel).toEqualTypeOf(); + expect(data.killstreak).toBeDefined(); + expect(data.killstreak).greaterThanOrEqual(0); + expectTypeOf(data.killstreak).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.voidKills).toBeDefined(); + expect(data.voidKills).greaterThanOrEqual(0); + expectTypeOf(data.voidKills).toEqualTypeOf(); + expect(data.meleeKills).toBeDefined(); + expect(data.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.meleeKills).toEqualTypeOf(); + expect(data.bowKills).toBeDefined(); + expect(data.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.bowKills).toEqualTypeOf(); + expect(data.mobKills).toBeDefined(); + expect(data.mobKills).greaterThanOrEqual(0); + expectTypeOf(data.mobKills).toEqualTypeOf(); + expect(data.assists).toBeDefined(); + expect(data.assists).greaterThanOrEqual(0); + expectTypeOf(data.assists).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.gamesPlayed).toBeDefined(); + expect(data.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.gamesPlayed).toEqualTypeOf(); + expect(data.survivedPlayers).toBeDefined(); + expect(data.survivedPlayers).greaterThanOrEqual(0); + expectTypeOf(data.survivedPlayers).toEqualTypeOf(); + expect(data.chestsOpened).toBeDefined(); + expect(data.chestsOpened).greaterThanOrEqual(0); + expectTypeOf(data.chestsOpened).toEqualTypeOf(); + expect(data.timePlayed).toBeDefined(); + expect(data.timePlayed).greaterThanOrEqual(0); + expectTypeOf(data.timePlayed).toEqualTypeOf(); + expect(data.shard).toBeDefined(); + expect(data.shard).greaterThanOrEqual(0); + expectTypeOf(data.shard).toEqualTypeOf(); + expect(data.longestBowShot).toBeDefined(); + expect(data.longestBowShot).greaterThanOrEqual(0); + expectTypeOf(data.longestBowShot).toEqualTypeOf(); + expect(data.arrowsShot).toBeDefined(); + expect(data.arrowsShot).greaterThanOrEqual(0); + expectTypeOf(data.arrowsShot).toEqualTypeOf(); + expect(data.arrowsHit).toBeDefined(); + expect(data.arrowsHit).greaterThanOrEqual(0); + expectTypeOf(data.arrowsHit).toEqualTypeOf(); + expect(data.bowAccuracy).toBeDefined(); + expect(data.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.bowAccuracy).toEqualTypeOf(); + expect(data.fastestWin).toBeDefined(); + expect(data.fastestWin).greaterThanOrEqual(0); + expectTypeOf(data.fastestWin).toEqualTypeOf(); + expect(data.heads).toBeDefined(); + expect(data.heads).greaterThanOrEqual(0); + expectTypeOf(data.heads).toEqualTypeOf(); + expect(data.blocksPlaced).toBeDefined(); + expect(data.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blocksPlaced).toEqualTypeOf(); + expect(data.blocksBroken).toBeDefined(); + expect(data.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.blocksBroken).toEqualTypeOf(); + expect(data.eggThrown).toBeDefined(); + expect(data.eggThrown).greaterThanOrEqual(0); + expectTypeOf(data.eggThrown).toEqualTypeOf(); + expect(data.enderpearlsThrown).toBeDefined(); + expect(data.enderpearlsThrown).greaterThanOrEqual(0); + expectTypeOf(data.enderpearlsThrown).toEqualTypeOf(); + expect(data.solo).toBeDefined(); + expectTypeOf(data.solo).toEqualTypeOf(); + expect(data.solo.activeKit).toBeDefined(); + expectTypeOf(data.solo.activeKit).toEqualTypeOf(); + expect(data.solo.killstreak).toBeDefined(); + expect(data.solo.killstreak).greaterThanOrEqual(0); + expectTypeOf(data.solo.killstreak).toEqualTypeOf(); + expect(data.solo.kills).toBeDefined(); + expect(data.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.kills).toEqualTypeOf(); + expect(data.solo.voidKills).toBeDefined(); + expect(data.solo.voidKills).greaterThanOrEqual(0); + expectTypeOf(data.solo.voidKills).toEqualTypeOf(); + expect(data.solo.meleeKills).toBeDefined(); + expect(data.solo.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.solo.meleeKills).toEqualTypeOf(); + expect(data.solo.bowKills).toBeDefined(); + expect(data.solo.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.solo.bowKills).toEqualTypeOf(); + expect(data.solo.mobKills).toBeDefined(); + expect(data.solo.mobKills).greaterThanOrEqual(0); + expectTypeOf(data.solo.mobKills).toEqualTypeOf(); + expect(data.solo.assists).toBeDefined(); + expect(data.solo.assists).greaterThanOrEqual(0); + expectTypeOf(data.solo.assists).toEqualTypeOf(); + expect(data.solo.deaths).toBeDefined(); + expect(data.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.deaths).toEqualTypeOf(); + expect(data.solo.KDR).toBeDefined(); + expect(data.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.KDR).toEqualTypeOf(); + expect(data.solo.wins).toBeDefined(); + expect(data.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.wins).toEqualTypeOf(); + expect(data.solo.losses).toBeDefined(); + expect(data.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.solo.losses).toEqualTypeOf(); + expect(data.solo.WLR).toBeDefined(); + expect(data.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.solo.WLR).toEqualTypeOf(); + expect(data.solo.gamesPlayed).toBeDefined(); + expect(data.solo.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.solo.gamesPlayed).toEqualTypeOf(); + expect(data.solo.survivedPlayers).toBeDefined(); + expect(data.solo.survivedPlayers).greaterThanOrEqual(0); + expectTypeOf(data.solo.survivedPlayers).toEqualTypeOf(); + expect(data.solo.chestsOpened).toBeDefined(); + expect(data.solo.chestsOpened).greaterThanOrEqual(0); + expectTypeOf(data.solo.chestsOpened).toEqualTypeOf(); + expect(data.solo.timePlayed).toBeDefined(); + expect(data.solo.timePlayed).greaterThanOrEqual(0); + expectTypeOf(data.solo.timePlayed).toEqualTypeOf(); + expect(data.solo.shard).toBeDefined(); + expect(data.solo.shard).greaterThanOrEqual(0); + expectTypeOf(data.solo.shard).toEqualTypeOf(); + expect(data.solo.longestBowShot).toBeDefined(); + expect(data.solo.longestBowShot).greaterThanOrEqual(0); + expectTypeOf(data.solo.longestBowShot).toEqualTypeOf(); + expect(data.solo.arrowsShot).toBeDefined(); + expect(data.solo.arrowsShot).greaterThanOrEqual(0); + expectTypeOf(data.solo.arrowsShot).toEqualTypeOf(); + expect(data.solo.arrowsHit).toBeDefined(); + expect(data.solo.arrowsHit).greaterThanOrEqual(0); + expectTypeOf(data.solo.arrowsHit).toEqualTypeOf(); + expect(data.solo.bowAccuracy).toBeDefined(); + expect(data.solo.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.solo.bowAccuracy).toEqualTypeOf(); + expect(data.solo.fastestWin).toBeDefined(); + expect(data.solo.fastestWin).greaterThanOrEqual(0); + expectTypeOf(data.solo.fastestWin).toEqualTypeOf(); + expect(data.solo.heads).toBeDefined(); + expect(data.solo.heads).greaterThanOrEqual(0); + expectTypeOf(data.solo.heads).toEqualTypeOf(); + expect(data.solo.normal).toBeDefined(); + expectTypeOf(data.solo.normal).toEqualTypeOf(); + expect(data.solo.normal.kills).toBeDefined(); + expect(data.solo.normal.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.normal.kills).toEqualTypeOf(); + expect(data.solo.normal.deaths).toBeDefined(); + expect(data.solo.normal.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.normal.deaths).toEqualTypeOf(); + expect(data.solo.normal.KDR).toBeDefined(); + expect(data.solo.normal.KDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.normal.KDR).toEqualTypeOf(); + expect(data.solo.normal.wins).toBeDefined(); + expect(data.solo.normal.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.normal.wins).toEqualTypeOf(); + expect(data.solo.normal.losses).toBeDefined(); + expect(data.solo.normal.losses).greaterThanOrEqual(0); + expectTypeOf(data.solo.normal.losses).toEqualTypeOf(); + expect(data.solo.normal.WLR).toBeDefined(); + expect(data.solo.normal.WLR).greaterThanOrEqual(0); + expectTypeOf(data.solo.normal.WLR).toEqualTypeOf(); + expect(data.solo.insane).toBeDefined(); + expectTypeOf(data.solo.insane).toEqualTypeOf(); + expect(data.solo.insane.kills).toBeDefined(); + expect(data.solo.insane.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.insane.kills).toEqualTypeOf(); + expect(data.solo.insane.deaths).toBeDefined(); + expect(data.solo.insane.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.insane.deaths).toEqualTypeOf(); + expect(data.solo.insane.KDR).toBeDefined(); + expect(data.solo.insane.KDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.insane.KDR).toEqualTypeOf(); + expect(data.solo.insane.wins).toBeDefined(); + expect(data.solo.insane.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.insane.wins).toEqualTypeOf(); + expect(data.solo.insane.losses).toBeDefined(); + expect(data.solo.insane.losses).greaterThanOrEqual(0); + expectTypeOf(data.solo.insane.losses).toEqualTypeOf(); + expect(data.solo.insane.WLR).toBeDefined(); + expect(data.solo.insane.WLR).greaterThanOrEqual(0); + expectTypeOf(data.solo.insane.WLR).toEqualTypeOf(); + expect(data.team).toBeDefined(); + expectTypeOf(data.team).toEqualTypeOf(); + expect(data.team.activeKit).toBeDefined(); + expectTypeOf(data.team.activeKit).toEqualTypeOf(); + expect(data.team.killstreak).toBeDefined(); + expect(data.team.killstreak).greaterThanOrEqual(0); + expectTypeOf(data.team.killstreak).toEqualTypeOf(); + expect(data.team.kills).toBeDefined(); + expect(data.team.kills).greaterThanOrEqual(0); + expectTypeOf(data.team.kills).toEqualTypeOf(); + expect(data.team.voidKills).toBeDefined(); + expect(data.team.voidKills).greaterThanOrEqual(0); + expectTypeOf(data.team.voidKills).toEqualTypeOf(); + expect(data.team.meleeKills).toBeDefined(); + expect(data.team.meleeKills).greaterThanOrEqual(0); + expectTypeOf(data.team.meleeKills).toEqualTypeOf(); + expect(data.team.bowKills).toBeDefined(); + expect(data.team.bowKills).greaterThanOrEqual(0); + expectTypeOf(data.team.bowKills).toEqualTypeOf(); + expect(data.team.mobKills).toBeDefined(); + expect(data.team.mobKills).greaterThanOrEqual(0); + expectTypeOf(data.team.mobKills).toEqualTypeOf(); + expect(data.team.assists).toBeDefined(); + expect(data.team.assists).greaterThanOrEqual(0); + expectTypeOf(data.team.assists).toEqualTypeOf(); + expect(data.team.deaths).toBeDefined(); + expect(data.team.deaths).greaterThanOrEqual(0); + expectTypeOf(data.team.deaths).toEqualTypeOf(); + expect(data.team.KDR).toBeDefined(); + expect(data.team.KDR).greaterThanOrEqual(0); + expectTypeOf(data.team.KDR).toEqualTypeOf(); + expect(data.team.wins).toBeDefined(); + expect(data.team.wins).greaterThanOrEqual(0); + expectTypeOf(data.team.wins).toEqualTypeOf(); + expect(data.team.losses).toBeDefined(); + expect(data.team.losses).greaterThanOrEqual(0); + expectTypeOf(data.team.losses).toEqualTypeOf(); + expect(data.team.WLR).toBeDefined(); + expect(data.team.WLR).greaterThanOrEqual(0); + expectTypeOf(data.team.WLR).toEqualTypeOf(); + expect(data.team.gamesPlayed).toBeDefined(); + expect(data.team.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.team.gamesPlayed).toEqualTypeOf(); + expect(data.team.survivedPlayers).toBeDefined(); + expect(data.team.survivedPlayers).greaterThanOrEqual(0); + expectTypeOf(data.team.survivedPlayers).toEqualTypeOf(); + expect(data.team.chestsOpened).toBeDefined(); + expect(data.team.chestsOpened).greaterThanOrEqual(0); + expectTypeOf(data.team.chestsOpened).toEqualTypeOf(); + expect(data.team.timePlayed).toBeDefined(); + expect(data.team.timePlayed).greaterThanOrEqual(0); + expectTypeOf(data.team.timePlayed).toEqualTypeOf(); + expect(data.team.shard).toBeDefined(); + expect(data.team.shard).greaterThanOrEqual(0); + expectTypeOf(data.team.shard).toEqualTypeOf(); + expect(data.team.longestBowShot).toBeDefined(); + expect(data.team.longestBowShot).greaterThanOrEqual(0); + expectTypeOf(data.team.longestBowShot).toEqualTypeOf(); + expect(data.team.arrowsShot).toBeDefined(); + expect(data.team.arrowsShot).greaterThanOrEqual(0); + expectTypeOf(data.team.arrowsShot).toEqualTypeOf(); + expect(data.team.arrowsHit).toBeDefined(); + expect(data.team.arrowsHit).greaterThanOrEqual(0); + expectTypeOf(data.team.arrowsHit).toEqualTypeOf(); + expect(data.team.bowAccuracy).toBeDefined(); + expect(data.team.bowAccuracy).greaterThanOrEqual(0); + expectTypeOf(data.team.bowAccuracy).toEqualTypeOf(); + expect(data.team.fastestWin).toBeDefined(); + expect(data.team.fastestWin).greaterThanOrEqual(0); + expectTypeOf(data.team.fastestWin).toEqualTypeOf(); + expect(data.team.heads).toBeDefined(); + expect(data.team.heads).greaterThanOrEqual(0); + expectTypeOf(data.team.heads).toEqualTypeOf(); + expect(data.team.normal).toBeDefined(); + expectTypeOf(data.team.normal).toEqualTypeOf(); + expect(data.team.normal.kills).toBeDefined(); + expect(data.team.normal.kills).greaterThanOrEqual(0); + expectTypeOf(data.team.normal.kills).toEqualTypeOf(); + expect(data.team.normal.deaths).toBeDefined(); + expect(data.team.normal.deaths).greaterThanOrEqual(0); + expectTypeOf(data.team.normal.deaths).toEqualTypeOf(); + expect(data.team.normal.KDR).toBeDefined(); + expect(data.team.normal.KDR).greaterThanOrEqual(0); + expectTypeOf(data.team.normal.KDR).toEqualTypeOf(); + expect(data.team.normal.wins).toBeDefined(); + expect(data.team.normal.wins).greaterThanOrEqual(0); + expectTypeOf(data.team.normal.wins).toEqualTypeOf(); + expect(data.team.normal.losses).toBeDefined(); + expect(data.team.normal.losses).greaterThanOrEqual(0); + expectTypeOf(data.team.normal.losses).toEqualTypeOf(); + expect(data.team.normal.WLR).toBeDefined(); + expect(data.team.normal.WLR).greaterThanOrEqual(0); + expectTypeOf(data.team.normal.WLR).toEqualTypeOf(); + expect(data.team.insane).toBeDefined(); + expectTypeOf(data.team.insane).toEqualTypeOf(); + expect(data.team.insane.kills).toBeDefined(); + expect(data.team.insane.kills).greaterThanOrEqual(0); + expectTypeOf(data.team.insane.kills).toEqualTypeOf(); + expect(data.team.insane.deaths).toBeDefined(); + expect(data.team.insane.deaths).greaterThanOrEqual(0); + expectTypeOf(data.team.insane.deaths).toEqualTypeOf(); + expect(data.team.insane.KDR).toBeDefined(); + expect(data.team.insane.KDR).greaterThanOrEqual(0); + expectTypeOf(data.team.insane.KDR).toEqualTypeOf(); + expect(data.team.insane.wins).toBeDefined(); + expect(data.team.insane.wins).greaterThanOrEqual(0); + expectTypeOf(data.team.insane.wins).toEqualTypeOf(); + expect(data.team.insane.losses).toBeDefined(); + expect(data.team.insane.losses).greaterThanOrEqual(0); + expectTypeOf(data.team.insane.losses).toEqualTypeOf(); + expect(data.team.insane.WLR).toBeDefined(); + expect(data.team.insane.WLR).greaterThanOrEqual(0); + expectTypeOf(data.team.insane.WLR).toEqualTypeOf(); + expect(data.mega).toBeDefined(); + expectTypeOf(data.mega).toEqualTypeOf(); + expect(data.mega.kills).toBeDefined(); + expect(data.mega.kills).greaterThanOrEqual(0); + expectTypeOf(data.mega.kills).toEqualTypeOf(); + expect(data.mega.deaths).toBeDefined(); + expect(data.mega.deaths).greaterThanOrEqual(0); + expectTypeOf(data.mega.deaths).toEqualTypeOf(); + expect(data.mega.KDR).toBeDefined(); + expect(data.mega.KDR).greaterThanOrEqual(0); + expectTypeOf(data.mega.KDR).toEqualTypeOf(); + expect(data.mega.wins).toBeDefined(); + expect(data.mega.wins).greaterThanOrEqual(0); + expectTypeOf(data.mega.wins).toEqualTypeOf(); + expect(data.mega.losses).toBeDefined(); + expect(data.mega.losses).greaterThanOrEqual(0); + expectTypeOf(data.mega.losses).toEqualTypeOf(); + expect(data.mega.WLR).toBeDefined(); + expect(data.mega.WLR).greaterThanOrEqual(0); + expectTypeOf(data.mega.WLR).toEqualTypeOf(); + expect(data.megaDoubles).toBeDefined(); + expectTypeOf(data.megaDoubles).toEqualTypeOf(); + expect(data.megaDoubles.kills).toBeDefined(); + expect(data.megaDoubles.kills).greaterThanOrEqual(0); + expectTypeOf(data.megaDoubles.kills).toEqualTypeOf(); + expect(data.megaDoubles.deaths).toBeDefined(); + expect(data.megaDoubles.deaths).greaterThanOrEqual(0); + expectTypeOf(data.megaDoubles.deaths).toEqualTypeOf(); + expect(data.megaDoubles.KDR).toBeDefined(); + expect(data.megaDoubles.KDR).greaterThanOrEqual(0); + expectTypeOf(data.megaDoubles.KDR).toEqualTypeOf(); + expect(data.megaDoubles.wins).toBeDefined(); + expect(data.megaDoubles.wins).greaterThanOrEqual(0); + expectTypeOf(data.megaDoubles.wins).toEqualTypeOf(); + expect(data.megaDoubles.losses).toBeDefined(); + expect(data.megaDoubles.losses).greaterThanOrEqual(0); + expectTypeOf(data.megaDoubles.losses).toEqualTypeOf(); + expect(data.megaDoubles.WLR).toBeDefined(); + expect(data.megaDoubles.WLR).greaterThanOrEqual(0); + expectTypeOf(data.megaDoubles.WLR).toEqualTypeOf(); + expect(data.lab).toBeDefined(); + expectTypeOf(data.lab).toEqualTypeOf(); + expect(data.lab.kills).toBeDefined(); + expect(data.lab.kills).greaterThanOrEqual(0); + expectTypeOf(data.lab.kills).toEqualTypeOf(); + expect(data.lab.deaths).toBeDefined(); + expect(data.lab.deaths).greaterThanOrEqual(0); + expectTypeOf(data.lab.deaths).toEqualTypeOf(); + expect(data.lab.KDR).toBeDefined(); + expect(data.lab.KDR).greaterThanOrEqual(0); + expectTypeOf(data.lab.KDR).toEqualTypeOf(); + expect(data.lab.wins).toBeDefined(); + expect(data.lab.wins).greaterThanOrEqual(0); + expectTypeOf(data.lab.wins).toEqualTypeOf(); + expect(data.lab.losses).toBeDefined(); + expect(data.lab.losses).greaterThanOrEqual(0); + expectTypeOf(data.lab.losses).toEqualTypeOf(); + expect(data.lab.WLR).toBeDefined(); + expect(data.lab.WLR).greaterThanOrEqual(0); + expectTypeOf(data.lab.WLR).toEqualTypeOf(); + expect(data.packages).toBeDefined(); + expectTypeOf(data.packages).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/SmashHeroes.test.ts b/src/structures/MiniGames/SmashHeroes.test.ts new file mode 100644 index 00000000..42a70364 --- /dev/null +++ b/src/structures/MiniGames/SmashHeroes.test.ts @@ -0,0 +1,648 @@ +import SmashHeroes, { SmashHeoresHero, SmashHeroesMode } from './SmashHeroes'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('SmashHeroes', () => { + const data = new SmashHeroes({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(SmashHeroes); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expect(data.level).greaterThanOrEqual(0); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.winstreak).toBeDefined(); + expect(data.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.winstreak).toEqualTypeOf(); + expect(data.playedGames).toBeDefined(); + expect(data.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.playedGames).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.smashed).toBeDefined(); + expect(data.smashed).greaterThanOrEqual(0); + expectTypeOf(data.smashed).toEqualTypeOf(); + expect(data['1v1v1v1']).toBeDefined(); + expectTypeOf(data['1v1v1v1']).toEqualTypeOf(); + expect(data['1v1v1v1'].kills).toBeDefined(); + expect(data['1v1v1v1'].kills).greaterThanOrEqual(0); + expectTypeOf(data['1v1v1v1'].kills).toEqualTypeOf(); + expect(data['1v1v1v1'].deaths).toBeDefined(); + expect(data['1v1v1v1'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['1v1v1v1'].deaths).toEqualTypeOf(); + expect(data['1v1v1v1'].KDR).toBeDefined(); + expect(data['1v1v1v1'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['1v1v1v1'].KDR).toEqualTypeOf(); + expect(data['1v1v1v1'].wins).toBeDefined(); + expect(data['1v1v1v1'].wins).greaterThanOrEqual(0); + expectTypeOf(data['1v1v1v1'].wins).toEqualTypeOf(); + expect(data['1v1v1v1'].losses).toBeDefined(); + expect(data['1v1v1v1'].losses).greaterThanOrEqual(0); + expectTypeOf(data['1v1v1v1'].losses).toEqualTypeOf(); + expect(data['1v1v1v1'].WLR).toBeDefined(); + expect(data['1v1v1v1'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['1v1v1v1'].WLR).toEqualTypeOf(); + expect(data['2v2']).toBeDefined(); + expectTypeOf(data['2v2']).toEqualTypeOf(); + expect(data['2v2'].kills).toBeDefined(); + expect(data['2v2'].kills).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].kills).toEqualTypeOf(); + expect(data['2v2'].deaths).toBeDefined(); + expect(data['2v2'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].deaths).toEqualTypeOf(); + expect(data['2v2'].KDR).toBeDefined(); + expect(data['2v2'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].KDR).toEqualTypeOf(); + expect(data['2v2'].wins).toBeDefined(); + expect(data['2v2'].wins).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].wins).toEqualTypeOf(); + expect(data['2v2'].losses).toBeDefined(); + expect(data['2v2'].losses).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].losses).toEqualTypeOf(); + expect(data['2v2'].WLR).toBeDefined(); + expect(data['2v2'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['2v2'].WLR).toEqualTypeOf(); + expect(data['2v2v2']).toBeDefined(); + expectTypeOf(data['2v2v2']).toEqualTypeOf(); + expect(data['2v2v2'].kills).toBeDefined(); + expect(data['2v2v2'].kills).greaterThanOrEqual(0); + expectTypeOf(data['2v2v2'].kills).toEqualTypeOf(); + expect(data['2v2v2'].deaths).toBeDefined(); + expect(data['2v2v2'].deaths).greaterThanOrEqual(0); + expectTypeOf(data['2v2v2'].deaths).toEqualTypeOf(); + expect(data['2v2v2'].KDR).toBeDefined(); + expect(data['2v2v2'].KDR).greaterThanOrEqual(0); + expectTypeOf(data['2v2v2'].KDR).toEqualTypeOf(); + expect(data['2v2v2'].wins).toBeDefined(); + expect(data['2v2v2'].wins).greaterThanOrEqual(0); + expectTypeOf(data['2v2v2'].wins).toEqualTypeOf(); + expect(data['2v2v2'].losses).toBeDefined(); + expect(data['2v2v2'].losses).greaterThanOrEqual(0); + expectTypeOf(data['2v2v2'].losses).toEqualTypeOf(); + expect(data['2v2v2'].WLR).toBeDefined(); + expect(data['2v2v2'].WLR).greaterThanOrEqual(0); + expectTypeOf(data['2v2v2'].WLR).toEqualTypeOf(); + expect(data.activeClass).toBeDefined(); + expectTypeOf(data.activeClass).toEqualTypeOf(); + expect(data.theBulk).toBeDefined(); + expectTypeOf(data.theBulk).toEqualTypeOf(); + expect(data.theBulk.name).toBeDefined(); + expectTypeOf(data.theBulk.name).toEqualTypeOf(); + expect(data.theBulk.level).toBeDefined(); + expect(data.theBulk.level).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.level).toEqualTypeOf(); + expect(data.theBulk.xp).toBeDefined(); + expect(data.theBulk.xp).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.xp).toEqualTypeOf(); + expect(data.theBulk.prestige).toBeDefined(); + expect(data.theBulk.prestige).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.prestige).toEqualTypeOf(); + expect(data.theBulk.playedGames).toBeDefined(); + expect(data.theBulk.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.playedGames).toEqualTypeOf(); + expect(data.theBulk.kills).toBeDefined(); + expect(data.theBulk.kills).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.kills).toEqualTypeOf(); + expect(data.theBulk.deaths).toBeDefined(); + expect(data.theBulk.deaths).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.deaths).toEqualTypeOf(); + expect(data.theBulk.KDR).toBeDefined(); + expect(data.theBulk.KDR).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.KDR).toEqualTypeOf(); + expect(data.theBulk.wins).toBeDefined(); + expect(data.theBulk.wins).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.wins).toEqualTypeOf(); + expect(data.theBulk.losses).toBeDefined(); + expect(data.theBulk.losses).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.losses).toEqualTypeOf(); + expect(data.theBulk.WLR).toBeDefined(); + expect(data.theBulk.WLR).greaterThanOrEqual(0); + expectTypeOf(data.theBulk.WLR).toEqualTypeOf(); + expect(data.cakeMonster).toBeDefined(); + expectTypeOf(data.cakeMonster).toEqualTypeOf(); + expect(data.cakeMonster.name).toBeDefined(); + expectTypeOf(data.cakeMonster.name).toEqualTypeOf(); + expect(data.cakeMonster.level).toBeDefined(); + expect(data.cakeMonster.level).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.level).toEqualTypeOf(); + expect(data.cakeMonster.xp).toBeDefined(); + expect(data.cakeMonster.xp).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.xp).toEqualTypeOf(); + expect(data.cakeMonster.prestige).toBeDefined(); + expect(data.cakeMonster.prestige).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.prestige).toEqualTypeOf(); + expect(data.cakeMonster.playedGames).toBeDefined(); + expect(data.cakeMonster.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.playedGames).toEqualTypeOf(); + expect(data.cakeMonster.kills).toBeDefined(); + expect(data.cakeMonster.kills).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.kills).toEqualTypeOf(); + expect(data.cakeMonster.deaths).toBeDefined(); + expect(data.cakeMonster.deaths).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.deaths).toEqualTypeOf(); + expect(data.cakeMonster.KDR).toBeDefined(); + expect(data.cakeMonster.KDR).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.KDR).toEqualTypeOf(); + expect(data.cakeMonster.wins).toBeDefined(); + expect(data.cakeMonster.wins).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.wins).toEqualTypeOf(); + expect(data.cakeMonster.losses).toBeDefined(); + expect(data.cakeMonster.losses).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.losses).toEqualTypeOf(); + expect(data.cakeMonster.WLR).toBeDefined(); + expect(data.cakeMonster.WLR).greaterThanOrEqual(0); + expectTypeOf(data.cakeMonster.WLR).toEqualTypeOf(); + expect(data.generalCluck).toBeDefined(); + expectTypeOf(data.generalCluck).toEqualTypeOf(); + expect(data.generalCluck.name).toBeDefined(); + expectTypeOf(data.generalCluck.name).toEqualTypeOf(); + expect(data.generalCluck.level).toBeDefined(); + expect(data.generalCluck.level).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.level).toEqualTypeOf(); + expect(data.generalCluck.xp).toBeDefined(); + expect(data.generalCluck.xp).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.xp).toEqualTypeOf(); + expect(data.generalCluck.prestige).toBeDefined(); + expect(data.generalCluck.prestige).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.prestige).toEqualTypeOf(); + expect(data.generalCluck.playedGames).toBeDefined(); + expect(data.generalCluck.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.playedGames).toEqualTypeOf(); + expect(data.generalCluck.kills).toBeDefined(); + expect(data.generalCluck.kills).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.kills).toEqualTypeOf(); + expect(data.generalCluck.deaths).toBeDefined(); + expect(data.generalCluck.deaths).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.deaths).toEqualTypeOf(); + expect(data.generalCluck.KDR).toBeDefined(); + expect(data.generalCluck.KDR).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.KDR).toEqualTypeOf(); + expect(data.generalCluck.wins).toBeDefined(); + expect(data.generalCluck.wins).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.wins).toEqualTypeOf(); + expect(data.generalCluck.losses).toBeDefined(); + expect(data.generalCluck.losses).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.losses).toEqualTypeOf(); + expect(data.generalCluck.WLR).toBeDefined(); + expect(data.generalCluck.WLR).greaterThanOrEqual(0); + expectTypeOf(data.generalCluck.WLR).toEqualTypeOf(); + expect(data.botmun).toBeDefined(); + expectTypeOf(data.botmun).toEqualTypeOf(); + expect(data.botmun.name).toBeDefined(); + expectTypeOf(data.botmun.name).toEqualTypeOf(); + expect(data.botmun.level).toBeDefined(); + expect(data.botmun.level).greaterThanOrEqual(0); + expectTypeOf(data.botmun.level).toEqualTypeOf(); + expect(data.botmun.xp).toBeDefined(); + expect(data.botmun.xp).greaterThanOrEqual(0); + expectTypeOf(data.botmun.xp).toEqualTypeOf(); + expect(data.botmun.prestige).toBeDefined(); + expect(data.botmun.prestige).greaterThanOrEqual(0); + expectTypeOf(data.botmun.prestige).toEqualTypeOf(); + expect(data.botmun.playedGames).toBeDefined(); + expect(data.botmun.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.botmun.playedGames).toEqualTypeOf(); + expect(data.botmun.kills).toBeDefined(); + expect(data.botmun.kills).greaterThanOrEqual(0); + expectTypeOf(data.botmun.kills).toEqualTypeOf(); + expect(data.botmun.deaths).toBeDefined(); + expect(data.botmun.deaths).greaterThanOrEqual(0); + expectTypeOf(data.botmun.deaths).toEqualTypeOf(); + expect(data.botmun.KDR).toBeDefined(); + expect(data.botmun.KDR).greaterThanOrEqual(0); + expectTypeOf(data.botmun.KDR).toEqualTypeOf(); + expect(data.botmun.wins).toBeDefined(); + expect(data.botmun.wins).greaterThanOrEqual(0); + expectTypeOf(data.botmun.wins).toEqualTypeOf(); + expect(data.botmun.losses).toBeDefined(); + expect(data.botmun.losses).greaterThanOrEqual(0); + expectTypeOf(data.botmun.losses).toEqualTypeOf(); + expect(data.botmun.WLR).toBeDefined(); + expect(data.botmun.WLR).greaterThanOrEqual(0); + expectTypeOf(data.botmun.WLR).toEqualTypeOf(); + expect(data.marauder).toBeDefined(); + expectTypeOf(data.marauder).toEqualTypeOf(); + expect(data.marauder.name).toBeDefined(); + expectTypeOf(data.marauder.name).toEqualTypeOf(); + expect(data.marauder.level).toBeDefined(); + expect(data.marauder.level).greaterThanOrEqual(0); + expectTypeOf(data.marauder.level).toEqualTypeOf(); + expect(data.marauder.xp).toBeDefined(); + expect(data.marauder.xp).greaterThanOrEqual(0); + expectTypeOf(data.marauder.xp).toEqualTypeOf(); + expect(data.marauder.prestige).toBeDefined(); + expect(data.marauder.prestige).greaterThanOrEqual(0); + expectTypeOf(data.marauder.prestige).toEqualTypeOf(); + expect(data.marauder.playedGames).toBeDefined(); + expect(data.marauder.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.marauder.playedGames).toEqualTypeOf(); + expect(data.marauder.kills).toBeDefined(); + expect(data.marauder.kills).greaterThanOrEqual(0); + expectTypeOf(data.marauder.kills).toEqualTypeOf(); + expect(data.marauder.deaths).toBeDefined(); + expect(data.marauder.deaths).greaterThanOrEqual(0); + expectTypeOf(data.marauder.deaths).toEqualTypeOf(); + expect(data.marauder.KDR).toBeDefined(); + expect(data.marauder.KDR).greaterThanOrEqual(0); + expectTypeOf(data.marauder.KDR).toEqualTypeOf(); + expect(data.marauder.wins).toBeDefined(); + expect(data.marauder.wins).greaterThanOrEqual(0); + expectTypeOf(data.marauder.wins).toEqualTypeOf(); + expect(data.marauder.losses).toBeDefined(); + expect(data.marauder.losses).greaterThanOrEqual(0); + expectTypeOf(data.marauder.losses).toEqualTypeOf(); + expect(data.marauder.WLR).toBeDefined(); + expect(data.marauder.WLR).greaterThanOrEqual(0); + expectTypeOf(data.marauder.WLR).toEqualTypeOf(); + expect(data.pug).toBeDefined(); + expectTypeOf(data.pug).toEqualTypeOf(); + expect(data.pug.name).toBeDefined(); + expectTypeOf(data.pug.name).toEqualTypeOf(); + expect(data.pug.level).toBeDefined(); + expect(data.pug.level).greaterThanOrEqual(0); + expectTypeOf(data.pug.level).toEqualTypeOf(); + expect(data.pug.xp).toBeDefined(); + expect(data.pug.xp).greaterThanOrEqual(0); + expectTypeOf(data.pug.xp).toEqualTypeOf(); + expect(data.pug.prestige).toBeDefined(); + expect(data.pug.prestige).greaterThanOrEqual(0); + expectTypeOf(data.pug.prestige).toEqualTypeOf(); + expect(data.pug.playedGames).toBeDefined(); + expect(data.pug.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.pug.playedGames).toEqualTypeOf(); + expect(data.pug.kills).toBeDefined(); + expect(data.pug.kills).greaterThanOrEqual(0); + expectTypeOf(data.pug.kills).toEqualTypeOf(); + expect(data.pug.deaths).toBeDefined(); + expect(data.pug.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pug.deaths).toEqualTypeOf(); + expect(data.pug.KDR).toBeDefined(); + expect(data.pug.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pug.KDR).toEqualTypeOf(); + expect(data.pug.wins).toBeDefined(); + expect(data.pug.wins).greaterThanOrEqual(0); + expectTypeOf(data.pug.wins).toEqualTypeOf(); + expect(data.pug.losses).toBeDefined(); + expect(data.pug.losses).greaterThanOrEqual(0); + expectTypeOf(data.pug.losses).toEqualTypeOf(); + expect(data.pug.WLR).toBeDefined(); + expect(data.pug.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pug.WLR).toEqualTypeOf(); + expect(data.tinman).toBeDefined(); + expectTypeOf(data.tinman).toEqualTypeOf(); + expect(data.tinman.name).toBeDefined(); + expectTypeOf(data.tinman.name).toEqualTypeOf(); + expect(data.tinman.level).toBeDefined(); + expect(data.tinman.level).greaterThanOrEqual(0); + expectTypeOf(data.tinman.level).toEqualTypeOf(); + expect(data.tinman.xp).toBeDefined(); + expect(data.tinman.xp).greaterThanOrEqual(0); + expectTypeOf(data.tinman.xp).toEqualTypeOf(); + expect(data.tinman.prestige).toBeDefined(); + expect(data.tinman.prestige).greaterThanOrEqual(0); + expectTypeOf(data.tinman.prestige).toEqualTypeOf(); + expect(data.tinman.playedGames).toBeDefined(); + expect(data.tinman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.tinman.playedGames).toEqualTypeOf(); + expect(data.tinman.kills).toBeDefined(); + expect(data.tinman.kills).greaterThanOrEqual(0); + expectTypeOf(data.tinman.kills).toEqualTypeOf(); + expect(data.tinman.deaths).toBeDefined(); + expect(data.tinman.deaths).greaterThanOrEqual(0); + expectTypeOf(data.tinman.deaths).toEqualTypeOf(); + expect(data.tinman.KDR).toBeDefined(); + expect(data.tinman.KDR).greaterThanOrEqual(0); + expectTypeOf(data.tinman.KDR).toEqualTypeOf(); + expect(data.tinman.wins).toBeDefined(); + expect(data.tinman.wins).greaterThanOrEqual(0); + expectTypeOf(data.tinman.wins).toEqualTypeOf(); + expect(data.tinman.losses).toBeDefined(); + expect(data.tinman.losses).greaterThanOrEqual(0); + expectTypeOf(data.tinman.losses).toEqualTypeOf(); + expect(data.tinman.WLR).toBeDefined(); + expect(data.tinman.WLR).greaterThanOrEqual(0); + expectTypeOf(data.tinman.WLR).toEqualTypeOf(); + expect(data.spoderman).toBeDefined(); + expectTypeOf(data.spoderman).toEqualTypeOf(); + expect(data.spoderman.name).toBeDefined(); + expectTypeOf(data.spoderman.name).toEqualTypeOf(); + expect(data.spoderman.level).toBeDefined(); + expect(data.spoderman.level).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.level).toEqualTypeOf(); + expect(data.spoderman.xp).toBeDefined(); + expect(data.spoderman.xp).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.xp).toEqualTypeOf(); + expect(data.spoderman.prestige).toBeDefined(); + expect(data.spoderman.prestige).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.prestige).toEqualTypeOf(); + expect(data.spoderman.playedGames).toBeDefined(); + expect(data.spoderman.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.playedGames).toEqualTypeOf(); + expect(data.spoderman.kills).toBeDefined(); + expect(data.spoderman.kills).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.kills).toEqualTypeOf(); + expect(data.spoderman.deaths).toBeDefined(); + expect(data.spoderman.deaths).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.deaths).toEqualTypeOf(); + expect(data.spoderman.KDR).toBeDefined(); + expect(data.spoderman.KDR).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.KDR).toEqualTypeOf(); + expect(data.spoderman.wins).toBeDefined(); + expect(data.spoderman.wins).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.wins).toEqualTypeOf(); + expect(data.spoderman.losses).toBeDefined(); + expect(data.spoderman.losses).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.losses).toEqualTypeOf(); + expect(data.spoderman.WLR).toBeDefined(); + expect(data.spoderman.WLR).greaterThanOrEqual(0); + expectTypeOf(data.spoderman.WLR).toEqualTypeOf(); + expect(data.frosty).toBeDefined(); + expectTypeOf(data.frosty).toEqualTypeOf(); + expect(data.frosty.name).toBeDefined(); + expectTypeOf(data.frosty.name).toEqualTypeOf(); + expect(data.frosty.level).toBeDefined(); + expect(data.frosty.level).greaterThanOrEqual(0); + expectTypeOf(data.frosty.level).toEqualTypeOf(); + expect(data.frosty.xp).toBeDefined(); + expect(data.frosty.xp).greaterThanOrEqual(0); + expectTypeOf(data.frosty.xp).toEqualTypeOf(); + expect(data.frosty.prestige).toBeDefined(); + expect(data.frosty.prestige).greaterThanOrEqual(0); + expectTypeOf(data.frosty.prestige).toEqualTypeOf(); + expect(data.frosty.playedGames).toBeDefined(); + expect(data.frosty.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.frosty.playedGames).toEqualTypeOf(); + expect(data.frosty.kills).toBeDefined(); + expect(data.frosty.kills).greaterThanOrEqual(0); + expectTypeOf(data.frosty.kills).toEqualTypeOf(); + expect(data.frosty.deaths).toBeDefined(); + expect(data.frosty.deaths).greaterThanOrEqual(0); + expectTypeOf(data.frosty.deaths).toEqualTypeOf(); + expect(data.frosty.KDR).toBeDefined(); + expect(data.frosty.KDR).greaterThanOrEqual(0); + expectTypeOf(data.frosty.KDR).toEqualTypeOf(); + expect(data.frosty.wins).toBeDefined(); + expect(data.frosty.wins).greaterThanOrEqual(0); + expectTypeOf(data.frosty.wins).toEqualTypeOf(); + expect(data.frosty.losses).toBeDefined(); + expect(data.frosty.losses).greaterThanOrEqual(0); + expectTypeOf(data.frosty.losses).toEqualTypeOf(); + expect(data.frosty.WLR).toBeDefined(); + expect(data.frosty.WLR).greaterThanOrEqual(0); + expectTypeOf(data.frosty.WLR).toEqualTypeOf(); + expect(data.sergeantShield).toBeDefined(); + expectTypeOf(data.sergeantShield).toEqualTypeOf(); + expect(data.sergeantShield.name).toBeDefined(); + expectTypeOf(data.sergeantShield.name).toEqualTypeOf(); + expect(data.sergeantShield.level).toBeDefined(); + expect(data.sergeantShield.level).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.level).toEqualTypeOf(); + expect(data.sergeantShield.xp).toBeDefined(); + expect(data.sergeantShield.xp).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.xp).toEqualTypeOf(); + expect(data.sergeantShield.prestige).toBeDefined(); + expect(data.sergeantShield.prestige).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.prestige).toEqualTypeOf(); + expect(data.sergeantShield.playedGames).toBeDefined(); + expect(data.sergeantShield.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.playedGames).toEqualTypeOf(); + expect(data.sergeantShield.kills).toBeDefined(); + expect(data.sergeantShield.kills).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.kills).toEqualTypeOf(); + expect(data.sergeantShield.deaths).toBeDefined(); + expect(data.sergeantShield.deaths).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.deaths).toEqualTypeOf(); + expect(data.sergeantShield.KDR).toBeDefined(); + expect(data.sergeantShield.KDR).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.KDR).toEqualTypeOf(); + expect(data.sergeantShield.wins).toBeDefined(); + expect(data.sergeantShield.wins).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.wins).toEqualTypeOf(); + expect(data.sergeantShield.losses).toBeDefined(); + expect(data.sergeantShield.losses).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.losses).toEqualTypeOf(); + expect(data.sergeantShield.WLR).toBeDefined(); + expect(data.sergeantShield.WLR).greaterThanOrEqual(0); + expectTypeOf(data.sergeantShield.WLR).toEqualTypeOf(); + expect(data.skullfire).toBeDefined(); + expectTypeOf(data.skullfire).toEqualTypeOf(); + expect(data.skullfire.name).toBeDefined(); + expectTypeOf(data.skullfire.name).toEqualTypeOf(); + expect(data.skullfire.level).toBeDefined(); + expect(data.skullfire.level).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.level).toEqualTypeOf(); + expect(data.skullfire.xp).toBeDefined(); + expect(data.skullfire.xp).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.xp).toEqualTypeOf(); + expect(data.skullfire.prestige).toBeDefined(); + expect(data.skullfire.prestige).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.prestige).toEqualTypeOf(); + expect(data.skullfire.playedGames).toBeDefined(); + expect(data.skullfire.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.playedGames).toEqualTypeOf(); + expect(data.skullfire.kills).toBeDefined(); + expect(data.skullfire.kills).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.kills).toEqualTypeOf(); + expect(data.skullfire.deaths).toBeDefined(); + expect(data.skullfire.deaths).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.deaths).toEqualTypeOf(); + expect(data.skullfire.KDR).toBeDefined(); + expect(data.skullfire.KDR).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.KDR).toEqualTypeOf(); + expect(data.skullfire.wins).toBeDefined(); + expect(data.skullfire.wins).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.wins).toEqualTypeOf(); + expect(data.skullfire.losses).toBeDefined(); + expect(data.skullfire.losses).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.losses).toEqualTypeOf(); + expect(data.skullfire.WLR).toBeDefined(); + expect(data.skullfire.WLR).greaterThanOrEqual(0); + expectTypeOf(data.skullfire.WLR).toEqualTypeOf(); + expect(data.goku).toBeDefined(); + expectTypeOf(data.goku).toEqualTypeOf(); + expect(data.goku.name).toBeDefined(); + expectTypeOf(data.goku.name).toEqualTypeOf(); + expect(data.goku.level).toBeDefined(); + expect(data.goku.level).greaterThanOrEqual(0); + expectTypeOf(data.goku.level).toEqualTypeOf(); + expect(data.goku.xp).toBeDefined(); + expect(data.goku.xp).greaterThanOrEqual(0); + expectTypeOf(data.goku.xp).toEqualTypeOf(); + expect(data.goku.prestige).toBeDefined(); + expect(data.goku.prestige).greaterThanOrEqual(0); + expectTypeOf(data.goku.prestige).toEqualTypeOf(); + expect(data.goku.playedGames).toBeDefined(); + expect(data.goku.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.goku.playedGames).toEqualTypeOf(); + expect(data.goku.kills).toBeDefined(); + expect(data.goku.kills).greaterThanOrEqual(0); + expectTypeOf(data.goku.kills).toEqualTypeOf(); + expect(data.goku.deaths).toBeDefined(); + expect(data.goku.deaths).greaterThanOrEqual(0); + expectTypeOf(data.goku.deaths).toEqualTypeOf(); + expect(data.goku.KDR).toBeDefined(); + expect(data.goku.KDR).greaterThanOrEqual(0); + expectTypeOf(data.goku.KDR).toEqualTypeOf(); + expect(data.goku.wins).toBeDefined(); + expect(data.goku.wins).greaterThanOrEqual(0); + expectTypeOf(data.goku.wins).toEqualTypeOf(); + expect(data.goku.losses).toBeDefined(); + expect(data.goku.losses).greaterThanOrEqual(0); + expectTypeOf(data.goku.losses).toEqualTypeOf(); + expect(data.goku.WLR).toBeDefined(); + expect(data.goku.WLR).greaterThanOrEqual(0); + expectTypeOf(data.goku.WLR).toEqualTypeOf(); + expect(data.sanic).toBeDefined(); + expectTypeOf(data.sanic).toEqualTypeOf(); + expect(data.sanic.name).toBeDefined(); + expectTypeOf(data.sanic.name).toEqualTypeOf(); + expect(data.sanic.level).toBeDefined(); + expect(data.sanic.level).greaterThanOrEqual(0); + expectTypeOf(data.sanic.level).toEqualTypeOf(); + expect(data.sanic.xp).toBeDefined(); + expect(data.sanic.xp).greaterThanOrEqual(0); + expectTypeOf(data.sanic.xp).toEqualTypeOf(); + expect(data.sanic.prestige).toBeDefined(); + expect(data.sanic.prestige).greaterThanOrEqual(0); + expectTypeOf(data.sanic.prestige).toEqualTypeOf(); + expect(data.sanic.playedGames).toBeDefined(); + expect(data.sanic.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.sanic.playedGames).toEqualTypeOf(); + expect(data.sanic.kills).toBeDefined(); + expect(data.sanic.kills).greaterThanOrEqual(0); + expectTypeOf(data.sanic.kills).toEqualTypeOf(); + expect(data.sanic.deaths).toBeDefined(); + expect(data.sanic.deaths).greaterThanOrEqual(0); + expectTypeOf(data.sanic.deaths).toEqualTypeOf(); + expect(data.sanic.KDR).toBeDefined(); + expect(data.sanic.KDR).greaterThanOrEqual(0); + expectTypeOf(data.sanic.KDR).toEqualTypeOf(); + expect(data.sanic.wins).toBeDefined(); + expect(data.sanic.wins).greaterThanOrEqual(0); + expectTypeOf(data.sanic.wins).toEqualTypeOf(); + expect(data.sanic.losses).toBeDefined(); + expect(data.sanic.losses).greaterThanOrEqual(0); + expectTypeOf(data.sanic.losses).toEqualTypeOf(); + expect(data.sanic.WLR).toBeDefined(); + expect(data.sanic.WLR).greaterThanOrEqual(0); + expectTypeOf(data.sanic.WLR).toEqualTypeOf(); + expect(data.duskCrawler).toBeDefined(); + expectTypeOf(data.duskCrawler).toEqualTypeOf(); + expect(data.duskCrawler.name).toBeDefined(); + expectTypeOf(data.duskCrawler.name).toEqualTypeOf(); + expect(data.duskCrawler.level).toBeDefined(); + expect(data.duskCrawler.level).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.level).toEqualTypeOf(); + expect(data.duskCrawler.xp).toBeDefined(); + expect(data.duskCrawler.xp).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.xp).toEqualTypeOf(); + expect(data.duskCrawler.prestige).toBeDefined(); + expect(data.duskCrawler.prestige).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.prestige).toEqualTypeOf(); + expect(data.duskCrawler.playedGames).toBeDefined(); + expect(data.duskCrawler.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.playedGames).toEqualTypeOf(); + expect(data.duskCrawler.kills).toBeDefined(); + expect(data.duskCrawler.kills).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.kills).toEqualTypeOf(); + expect(data.duskCrawler.deaths).toBeDefined(); + expect(data.duskCrawler.deaths).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.deaths).toEqualTypeOf(); + expect(data.duskCrawler.KDR).toBeDefined(); + expect(data.duskCrawler.KDR).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.KDR).toEqualTypeOf(); + expect(data.duskCrawler.wins).toBeDefined(); + expect(data.duskCrawler.wins).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.wins).toEqualTypeOf(); + expect(data.duskCrawler.losses).toBeDefined(); + expect(data.duskCrawler.losses).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.losses).toEqualTypeOf(); + expect(data.duskCrawler.WLR).toBeDefined(); + expect(data.duskCrawler.WLR).greaterThanOrEqual(0); + expectTypeOf(data.duskCrawler.WLR).toEqualTypeOf(); + expect(data.shoopDaWhoop).toBeDefined(); + expectTypeOf(data.shoopDaWhoop).toEqualTypeOf(); + expect(data.shoopDaWhoop.name).toBeDefined(); + expectTypeOf(data.shoopDaWhoop.name).toEqualTypeOf(); + expect(data.shoopDaWhoop.level).toBeDefined(); + expect(data.shoopDaWhoop.level).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.level).toEqualTypeOf(); + expect(data.shoopDaWhoop.xp).toBeDefined(); + expect(data.shoopDaWhoop.xp).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.xp).toEqualTypeOf(); + expect(data.shoopDaWhoop.prestige).toBeDefined(); + expect(data.shoopDaWhoop.prestige).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.prestige).toEqualTypeOf(); + expect(data.shoopDaWhoop.playedGames).toBeDefined(); + expect(data.shoopDaWhoop.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.playedGames).toEqualTypeOf(); + expect(data.shoopDaWhoop.kills).toBeDefined(); + expect(data.shoopDaWhoop.kills).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.kills).toEqualTypeOf(); + expect(data.shoopDaWhoop.deaths).toBeDefined(); + expect(data.shoopDaWhoop.deaths).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.deaths).toEqualTypeOf(); + expect(data.shoopDaWhoop.KDR).toBeDefined(); + expect(data.shoopDaWhoop.KDR).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.KDR).toEqualTypeOf(); + expect(data.shoopDaWhoop.wins).toBeDefined(); + expect(data.shoopDaWhoop.wins).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.wins).toEqualTypeOf(); + expect(data.shoopDaWhoop.losses).toBeDefined(); + expect(data.shoopDaWhoop.losses).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.losses).toEqualTypeOf(); + expect(data.shoopDaWhoop.WLR).toBeDefined(); + expect(data.shoopDaWhoop.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shoopDaWhoop.WLR).toEqualTypeOf(); + expect(data.greenHood).toBeDefined(); + expectTypeOf(data.greenHood).toEqualTypeOf(); + expect(data.greenHood.name).toBeDefined(); + expectTypeOf(data.greenHood.name).toEqualTypeOf(); + expect(data.greenHood.level).toBeDefined(); + expect(data.greenHood.level).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.level).toEqualTypeOf(); + expect(data.greenHood.xp).toBeDefined(); + expect(data.greenHood.xp).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.xp).toEqualTypeOf(); + expect(data.greenHood.prestige).toBeDefined(); + expect(data.greenHood.prestige).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.prestige).toEqualTypeOf(); + expect(data.greenHood.playedGames).toBeDefined(); + expect(data.greenHood.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.playedGames).toEqualTypeOf(); + expect(data.greenHood.kills).toBeDefined(); + expect(data.greenHood.kills).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.kills).toEqualTypeOf(); + expect(data.greenHood.deaths).toBeDefined(); + expect(data.greenHood.deaths).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.deaths).toEqualTypeOf(); + expect(data.greenHood.KDR).toBeDefined(); + expect(data.greenHood.KDR).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.KDR).toEqualTypeOf(); + expect(data.greenHood.wins).toBeDefined(); + expect(data.greenHood.wins).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.wins).toEqualTypeOf(); + expect(data.greenHood.losses).toBeDefined(); + expect(data.greenHood.losses).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.losses).toEqualTypeOf(); + expect(data.greenHood.WLR).toBeDefined(); + expect(data.greenHood.WLR).greaterThanOrEqual(0); + expectTypeOf(data.greenHood.WLR).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/SmashHeroes.ts b/src/structures/MiniGames/SmashHeroes.ts index 66106622..bcb0c2a2 100644 --- a/src/structures/MiniGames/SmashHeroes.ts +++ b/src/structures/MiniGames/SmashHeroes.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class SmashHeroesMode { +export class SmashHeroesMode { kills: number; deaths: number; KDR: number; @@ -8,16 +8,16 @@ class SmashHeroesMode { losses: number; WLR: number; constructor(data: Record, mode: string) { - this.kills = data[`kills_${mode}`] || 0; - this.deaths = data[`deaths_${mode}`] || 0; + this.kills = data?.[`kills_${mode}`] || 0; + this.deaths = data?.[`deaths_${mode}`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`wins_${mode}`] || 0; - this.losses = data[`losses_${mode}`] || 0; + this.wins = data?.[`wins_${mode}`] || 0; + this.losses = data?.[`losses_${mode}`] || 0; this.WLR = divide(this.wins, this.losses); } } -class SmashHeoresHero { +export class SmashHeoresHero { name: string; level: number; xp: number; @@ -31,15 +31,15 @@ class SmashHeoresHero { WLR: number; constructor(data: Record, hero: string) { this.name = hero; - this.level = data[`lastLevel_${hero}`] || 0; - this.xp = data[`xp_${hero}`] || 0; - this.prestige = data[`pg_${hero}`] || 0; - this.playedGames = data.class_stats?.[hero]?.games || 0; - this.kills = data.class_stats?.[hero]?.kills || 0; - this.deaths = data.class_stats?.[hero]?.deaths || 0; + this.level = data?.[`lastLevel_${hero}`] || 0; + this.xp = data?.[`xp_${hero}`] || 0; + this.prestige = data?.[`pg_${hero}`] || 0; + this.playedGames = data?.class_stats?.[hero]?.games || 0; + this.kills = data?.class_stats?.[hero]?.kills || 0; + this.deaths = data?.class_stats?.[hero]?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.class_stats?.[hero]?.wins || 0; - this.losses = data.class_stats?.[hero]?.losses || 0; + this.wins = data?.class_stats?.[hero]?.wins || 0; + this.losses = data?.class_stats?.[hero]?.losses || 0; this.WLR = divide(this.wins, this.losses); } } @@ -77,21 +77,21 @@ class SmashHeroes { shoopDaWhoop: SmashHeoresHero; greenHood: SmashHeoresHero; constructor(data: Record) { - this.coins = data.coins || 0; - this.level = data.smash_level_total || 0; - this.winstreak = data.win_streak || 0; - this.playedGames = data.games || 0; - this.kills = data.kills || 0; - this.deaths = data.deaths || 0; + this.coins = data?.coins || 0; + this.level = data?.smash_level_total || 0; + this.winstreak = data?.win_streak || 0; + this.playedGames = data?.games || 0; + this.kills = data?.kills || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; this.WLR = divide(this.wins, this.losses); - this.smashed = data.smashed || 0; + this.smashed = data?.smashed || 0; this['1v1v1v1'] = new SmashHeroesMode(data, 'normal'); this['2v2'] = new SmashHeroesMode(data, '2v2'); this['2v2v2'] = new SmashHeroesMode(data, 'teams'); - this.activeClass = data.active_class || null; + this.activeClass = data?.active_class || null; this.theBulk = new SmashHeoresHero(data, 'THE_BULK'); this.cakeMonster = new SmashHeoresHero(data, 'CAKE_MONSTER'); this.generalCluck = new SmashHeoresHero(data, 'GENERAL_CLUCK'); diff --git a/src/structures/MiniGames/SpeedUHC.test.ts b/src/structures/MiniGames/SpeedUHC.test.ts new file mode 100644 index 00000000..6ff580a9 --- /dev/null +++ b/src/structures/MiniGames/SpeedUHC.test.ts @@ -0,0 +1,246 @@ +import SpeedUHC, { SpeedUHCMode } from './SpeedUHC'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('SpeedUHC', () => { + const data = new SpeedUHC({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(SpeedUHC); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.playedGames).toBeDefined(); + expect(data.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.playedGames).toEqualTypeOf(); + expect(data.winstreak).toBeDefined(); + expect(data.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.winstreak).toEqualTypeOf(); + expect(data.killstreak).toBeDefined(); + expect(data.killstreak).greaterThanOrEqual(0); + expectTypeOf(data.killstreak).toEqualTypeOf(); + expect(data.blocksBroken).toBeDefined(); + expect(data.blocksBroken).greaterThanOrEqual(0); + expectTypeOf(data.blocksBroken).toEqualTypeOf(); + expect(data.blocksPlaced).toBeDefined(); + expect(data.blocksPlaced).greaterThanOrEqual(0); + expectTypeOf(data.blocksPlaced).toEqualTypeOf(); + expect(data.quits).toBeDefined(); + expect(data.quits).greaterThanOrEqual(0); + expectTypeOf(data.quits).toEqualTypeOf(); + expect(data.itemsEnchanted).toBeDefined(); + expect(data.itemsEnchanted).greaterThanOrEqual(0); + expectTypeOf(data.itemsEnchanted).toEqualTypeOf(); + expect(data.assists).toBeDefined(); + expect(data.assists).greaterThanOrEqual(0); + expectTypeOf(data.assists).toEqualTypeOf(); + expect(data.solo).toBeDefined(); + expectTypeOf(data.solo).toEqualTypeOf(); + expect(data.solo.kills).toBeDefined(); + expect(data.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.kills).toEqualTypeOf(); + expect(data.solo.deaths).toBeDefined(); + expect(data.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.deaths).toEqualTypeOf(); + expect(data.solo.KDR).toBeDefined(); + expect(data.solo.KDR).greaterThanOrEqual(0); + expectTypeOf(data.solo.KDR).toEqualTypeOf(); + expect(data.solo.wins).toBeDefined(); + expect(data.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.wins).toEqualTypeOf(); + expect(data.solo.losses).toBeDefined(); + expect(data.solo.losses).greaterThanOrEqual(0); + expectTypeOf(data.solo.losses).toEqualTypeOf(); + expect(data.solo.WLR).toBeDefined(); + expect(data.solo.WLR).greaterThanOrEqual(0); + expectTypeOf(data.solo.WLR).toEqualTypeOf(); + expect(data.solo.playedGames).toBeDefined(); + expect(data.solo.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.solo.playedGames).toEqualTypeOf(); + expect(data.solo.winstreak).toBeDefined(); + expect(data.solo.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.solo.winstreak).toEqualTypeOf(); + expect(data.solo.killStreak).toBeDefined(); + expect(data.solo.killStreak).greaterThanOrEqual(0); + expectTypeOf(data.solo.killStreak).toEqualTypeOf(); + expect(data.solo.assists).toBeDefined(); + expect(data.solo.assists).greaterThanOrEqual(0); + expectTypeOf(data.solo.assists).toEqualTypeOf(); + expect(data.soloNormal).toBeDefined(); + expectTypeOf(data.soloNormal).toEqualTypeOf(); + expect(data.soloNormal.kills).toBeDefined(); + expect(data.soloNormal.kills).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.kills).toEqualTypeOf(); + expect(data.soloNormal.deaths).toBeDefined(); + expect(data.soloNormal.deaths).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.deaths).toEqualTypeOf(); + expect(data.soloNormal.KDR).toBeDefined(); + expect(data.soloNormal.KDR).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.KDR).toEqualTypeOf(); + expect(data.soloNormal.wins).toBeDefined(); + expect(data.soloNormal.wins).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.wins).toEqualTypeOf(); + expect(data.soloNormal.losses).toBeDefined(); + expect(data.soloNormal.losses).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.losses).toEqualTypeOf(); + expect(data.soloNormal.WLR).toBeDefined(); + expect(data.soloNormal.WLR).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.WLR).toEqualTypeOf(); + expect(data.soloNormal.playedGames).toBeDefined(); + expect(data.soloNormal.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.playedGames).toEqualTypeOf(); + expect(data.soloNormal.winstreak).toBeDefined(); + expect(data.soloNormal.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.winstreak).toEqualTypeOf(); + expect(data.soloNormal.killStreak).toBeDefined(); + expect(data.soloNormal.killStreak).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.killStreak).toEqualTypeOf(); + expect(data.soloNormal.assists).toBeDefined(); + expect(data.soloNormal.assists).greaterThanOrEqual(0); + expectTypeOf(data.soloNormal.assists).toEqualTypeOf(); + expect(data.soloInsane).toBeDefined(); + expectTypeOf(data.soloInsane).toEqualTypeOf(); + expect(data.soloInsane.kills).toBeDefined(); + expect(data.soloInsane.kills).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.kills).toEqualTypeOf(); + expect(data.soloInsane.deaths).toBeDefined(); + expect(data.soloInsane.deaths).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.deaths).toEqualTypeOf(); + expect(data.soloInsane.KDR).toBeDefined(); + expect(data.soloInsane.KDR).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.KDR).toEqualTypeOf(); + expect(data.soloInsane.wins).toBeDefined(); + expect(data.soloInsane.wins).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.wins).toEqualTypeOf(); + expect(data.soloInsane.losses).toBeDefined(); + expect(data.soloInsane.losses).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.losses).toEqualTypeOf(); + expect(data.soloInsane.WLR).toBeDefined(); + expect(data.soloInsane.WLR).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.WLR).toEqualTypeOf(); + expect(data.soloInsane.playedGames).toBeDefined(); + expect(data.soloInsane.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.playedGames).toEqualTypeOf(); + expect(data.soloInsane.winstreak).toBeDefined(); + expect(data.soloInsane.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.winstreak).toEqualTypeOf(); + expect(data.soloInsane.killStreak).toBeDefined(); + expect(data.soloInsane.killStreak).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.killStreak).toEqualTypeOf(); + expect(data.soloInsane.assists).toBeDefined(); + expect(data.soloInsane.assists).greaterThanOrEqual(0); + expectTypeOf(data.soloInsane.assists).toEqualTypeOf(); + expect(data.team).toBeDefined(); + expectTypeOf(data.team).toEqualTypeOf(); + expect(data.team.kills).toBeDefined(); + expect(data.team.kills).greaterThanOrEqual(0); + expectTypeOf(data.team.kills).toEqualTypeOf(); + expect(data.team.deaths).toBeDefined(); + expect(data.team.deaths).greaterThanOrEqual(0); + expectTypeOf(data.team.deaths).toEqualTypeOf(); + expect(data.team.KDR).toBeDefined(); + expect(data.team.KDR).greaterThanOrEqual(0); + expectTypeOf(data.team.KDR).toEqualTypeOf(); + expect(data.team.wins).toBeDefined(); + expect(data.team.wins).greaterThanOrEqual(0); + expectTypeOf(data.team.wins).toEqualTypeOf(); + expect(data.team.losses).toBeDefined(); + expect(data.team.losses).greaterThanOrEqual(0); + expectTypeOf(data.team.losses).toEqualTypeOf(); + expect(data.team.WLR).toBeDefined(); + expect(data.team.WLR).greaterThanOrEqual(0); + expectTypeOf(data.team.WLR).toEqualTypeOf(); + expect(data.team.playedGames).toBeDefined(); + expect(data.team.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.team.playedGames).toEqualTypeOf(); + expect(data.team.winstreak).toBeDefined(); + expect(data.team.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.team.winstreak).toEqualTypeOf(); + expect(data.team.killStreak).toBeDefined(); + expect(data.team.killStreak).greaterThanOrEqual(0); + expectTypeOf(data.team.killStreak).toEqualTypeOf(); + expect(data.team.assists).toBeDefined(); + expect(data.team.assists).greaterThanOrEqual(0); + expectTypeOf(data.team.assists).toEqualTypeOf(); + expect(data.teamNormal).toBeDefined(); + expectTypeOf(data.teamNormal).toEqualTypeOf(); + expect(data.teamNormal.kills).toBeDefined(); + expect(data.teamNormal.kills).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.kills).toEqualTypeOf(); + expect(data.teamNormal.deaths).toBeDefined(); + expect(data.teamNormal.deaths).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.deaths).toEqualTypeOf(); + expect(data.teamNormal.KDR).toBeDefined(); + expect(data.teamNormal.KDR).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.KDR).toEqualTypeOf(); + expect(data.teamNormal.wins).toBeDefined(); + expect(data.teamNormal.wins).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.wins).toEqualTypeOf(); + expect(data.teamNormal.losses).toBeDefined(); + expect(data.teamNormal.losses).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.losses).toEqualTypeOf(); + expect(data.teamNormal.WLR).toBeDefined(); + expect(data.teamNormal.WLR).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.WLR).toEqualTypeOf(); + expect(data.teamNormal.playedGames).toBeDefined(); + expect(data.teamNormal.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.playedGames).toEqualTypeOf(); + expect(data.teamNormal.winstreak).toBeDefined(); + expect(data.teamNormal.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.winstreak).toEqualTypeOf(); + expect(data.teamNormal.killStreak).toBeDefined(); + expect(data.teamNormal.killStreak).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.killStreak).toEqualTypeOf(); + expect(data.teamNormal.assists).toBeDefined(); + expect(data.teamNormal.assists).greaterThanOrEqual(0); + expectTypeOf(data.teamNormal.assists).toEqualTypeOf(); + expect(data.teamInsane).toBeDefined(); + expectTypeOf(data.teamInsane).toEqualTypeOf(); + expect(data.teamInsane.kills).toBeDefined(); + expect(data.teamInsane.kills).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.kills).toEqualTypeOf(); + expect(data.teamInsane.deaths).toBeDefined(); + expect(data.teamInsane.deaths).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.deaths).toEqualTypeOf(); + expect(data.teamInsane.KDR).toBeDefined(); + expect(data.teamInsane.KDR).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.KDR).toEqualTypeOf(); + expect(data.teamInsane.wins).toBeDefined(); + expect(data.teamInsane.wins).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.wins).toEqualTypeOf(); + expect(data.teamInsane.losses).toBeDefined(); + expect(data.teamInsane.losses).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.losses).toEqualTypeOf(); + expect(data.teamInsane.WLR).toBeDefined(); + expect(data.teamInsane.WLR).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.WLR).toEqualTypeOf(); + expect(data.teamInsane.playedGames).toBeDefined(); + expect(data.teamInsane.playedGames).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.playedGames).toEqualTypeOf(); + expect(data.teamInsane.winstreak).toBeDefined(); + expect(data.teamInsane.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.winstreak).toEqualTypeOf(); + expect(data.teamInsane.killStreak).toBeDefined(); + expect(data.teamInsane.killStreak).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.killStreak).toEqualTypeOf(); + expect(data.teamInsane.assists).toBeDefined(); + expect(data.teamInsane.assists).greaterThanOrEqual(0); + expectTypeOf(data.teamInsane.assists).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/SpeedUHC.ts b/src/structures/MiniGames/SpeedUHC.ts index b3239f3e..c521a9c5 100644 --- a/src/structures/MiniGames/SpeedUHC.ts +++ b/src/structures/MiniGames/SpeedUHC.ts @@ -1,23 +1,27 @@ import divide from '../../utils/divide'; -class SpeedUHCMode { +export class SpeedUHCMode { kills: number; deaths: number; + KDR: number; wins: number; losses: number; + WLR: number; playedGames: number; winstreak: number; killStreak: number; assists: number; constructor(data: Record, mode: string) { - this.kills = data[`kills_${mode}`] || 0; - this.deaths = data[`deaths_${mode}`] || 0; - this.wins = data[`wins_${mode}`] || 0; - this.losses = data[`losses_${mode}`] || 0; - this.playedGames = data[`games_${mode}`] || 0; - this.winstreak = data[`win_streak_${mode}`] || 0; - this.killStreak = data[`killstreak_${mode}`] || 0; - this.assists = data[`assists_${mode}`] || 0; + this.kills = data?.[`kills_${mode}`] || 0; + this.deaths = data?.[`deaths_${mode}`] || 0; + this.KDR = divide(this.kills, this.deaths); + this.wins = data?.[`wins_${mode}`] || 0; + this.losses = data?.[`losses_${mode}`] || 0; + this.WLR = divide(this.wins, this.losses); + this.playedGames = data?.[`games_${mode}`] || 0; + this.winstreak = data?.[`win_streak_${mode}`] || 0; + this.killStreak = data?.[`killstreak_${mode}`] || 0; + this.assists = data?.[`assists_${mode}`] || 0; } } @@ -44,21 +48,21 @@ class SpeedUHC { teamNormal: SpeedUHCMode; teamInsane: SpeedUHCMode; constructor(data: Record) { - this.coins = data.coins || 0; - this.kills = data.kills || 0; - this.deaths = data.deaths || 0; + this.coins = data?.coins || 0; + this.kills = data?.kills || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; this.WLR = divide(this.wins, this.losses); - this.playedGames = data.games || 0; - this.winstreak = data.win_streak || 0; - this.killstreak = data.killstreak || 0; - this.blocksBroken = data.blocks_broken || 0; - this.blocksPlaced = data.blocks_placed || 0; - this.quits = data.quits || 0; - this.itemsEnchanted = data.items_enchanted || 0; - this.assists = data.assists || 0; + this.playedGames = data?.games || 0; + this.winstreak = data?.win_streak || 0; + this.killstreak = data?.killstreak || 0; + this.blocksBroken = data?.blocks_broken || 0; + this.blocksPlaced = data?.blocks_placed || 0; + this.quits = data?.quits || 0; + this.itemsEnchanted = data?.items_enchanted || 0; + this.assists = data?.assists || 0; this.solo = new SpeedUHCMode(data, 'solo'); this.soloNormal = new SpeedUHCMode(data, 'solo_normal'); this.soloInsane = new SpeedUHCMode(data, 'solo_insane'); diff --git a/src/structures/MiniGames/TNTGames.test.ts b/src/structures/MiniGames/TNTGames.test.ts new file mode 100644 index 00000000..5d9e369f --- /dev/null +++ b/src/structures/MiniGames/TNTGames.test.ts @@ -0,0 +1,140 @@ +import TNTGames, { BowSpleef, PVPRun, TNTRun, TNTTag, TNTWizards } from './TNTGames'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('TNTGames', () => { + const data = new TNTGames({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(TNTGames); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.winstreak).toBeDefined(); + expect(data.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.winstreak).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.tntrun).toBeDefined(); + expectTypeOf(data.tntrun).toEqualTypeOf(); + expect(data.tntrun.wins).toBeDefined(); + expect(data.tntrun.wins).greaterThanOrEqual(0); + expectTypeOf(data.tntrun.wins).toEqualTypeOf(); + expect(data.tntrun.bestTime).toBeDefined(); + expect(data.tntrun.bestTime).greaterThanOrEqual(0); + expectTypeOf(data.tntrun.bestTime).toEqualTypeOf(); + expect(data.tntrun.deaths).toBeDefined(); + expect(data.tntrun.deaths).greaterThanOrEqual(0); + expectTypeOf(data.tntrun.deaths).toEqualTypeOf(); + expect(data.tntrun.slownessPotions).toBeDefined(); + expect(data.tntrun.slownessPotions).greaterThanOrEqual(0); + expectTypeOf(data.tntrun.slownessPotions).toEqualTypeOf(); + expect(data.tntrun.speedPotions).toBeDefined(); + expect(data.tntrun.speedPotions).greaterThanOrEqual(0); + expectTypeOf(data.tntrun.speedPotions).toEqualTypeOf(); + expect(data.tntrun.doubleJumps).toBeDefined(); + expect(data.tntrun.doubleJumps).greaterThanOrEqual(0); + expectTypeOf(data.tntrun.doubleJumps).toEqualTypeOf(); + expect(data.tntrun.prefix).toBeDefined(); + expectTypeOf(data.tntrun.prefix).toEqualTypeOf(); + expect(data.pvpRun).toBeDefined(); + expectTypeOf(data.pvpRun).toEqualTypeOf(); + expect(data.pvpRun.wins).toBeDefined(); + expect(data.pvpRun.wins).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.wins).toEqualTypeOf(); + expect(data.pvpRun.bestTime).toBeDefined(); + expect(data.pvpRun.bestTime).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.bestTime).toEqualTypeOf(); + expect(data.pvpRun.kills).toBeDefined(); + expect(data.pvpRun.kills).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.kills).toEqualTypeOf(); + expect(data.pvpRun.deaths).toBeDefined(); + expect(data.pvpRun.deaths).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.deaths).toEqualTypeOf(); + expect(data.pvpRun.KDR).toBeDefined(); + expect(data.pvpRun.KDR).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.KDR).toEqualTypeOf(); + expect(data.pvpRun.regeneration).toBeDefined(); + expect(data.pvpRun.regeneration).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.regeneration).toEqualTypeOf(); + expect(data.pvpRun.notoriety).toBeDefined(); + expect(data.pvpRun.notoriety).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.notoriety).toEqualTypeOf(); + expect(data.pvpRun.fortitude).toBeDefined(); + expect(data.pvpRun.fortitude).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.fortitude).toEqualTypeOf(); + expect(data.pvpRun.doubleJumps).toBeDefined(); + expect(data.pvpRun.doubleJumps).greaterThanOrEqual(0); + expectTypeOf(data.pvpRun.doubleJumps).toEqualTypeOf(); + expect(data.pvpRun.prefix).toBeDefined(); + expectTypeOf(data.pvpRun.prefix).toEqualTypeOf(); + expect(data.bowSpleef).toBeDefined(); + expectTypeOf(data.bowSpleef).toEqualTypeOf(); + expect(data.bowSpleef.wins).toBeDefined(); + expect(data.bowSpleef.wins).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.wins).toEqualTypeOf(); + expect(data.bowSpleef.tags).toBeDefined(); + expect(data.bowSpleef.tags).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.tags).toEqualTypeOf(); + expect(data.bowSpleef.deaths).toBeDefined(); + expect(data.bowSpleef.deaths).greaterThanOrEqual(0); + expectTypeOf(data.bowSpleef.deaths).toEqualTypeOf(); + expect(data.bowSpleef.prefix).toBeDefined(); + expectTypeOf(data.bowSpleef.prefix).toEqualTypeOf(); + expect(data.tnttag).toBeDefined(); + expectTypeOf(data.tnttag).toEqualTypeOf(); + expect(data.tnttag.wins).toBeDefined(); + expect(data.tnttag.wins).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.wins).toEqualTypeOf(); + expect(data.tnttag.kills).toBeDefined(); + expect(data.tnttag.kills).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.kills).toEqualTypeOf(); + expect(data.tnttag.deaths).toBeDefined(); + expect(data.tnttag.deaths).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.deaths).toEqualTypeOf(); + expect(data.tnttag.KDR).toBeDefined(); + expect(data.tnttag.KDR).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.KDR).toEqualTypeOf(); + expect(data.tnttag.speed).toBeDefined(); + expect(data.tnttag.speed).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.speed).toEqualTypeOf(); + expect(data.tnttag.blastProtection).toBeDefined(); + expect(data.tnttag.blastProtection).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.blastProtection).toEqualTypeOf(); + expect(data.tnttag.speedItUp).toBeDefined(); + expect(data.tnttag.speedItUp).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.speedItUp).toEqualTypeOf(); + expect(data.tnttag.slowItDown).toBeDefined(); + expect(data.tnttag.slowItDown).greaterThanOrEqual(0); + expectTypeOf(data.tnttag.slowItDown).toEqualTypeOf(); + expect(data.tnttag.prefix).toBeDefined(); + expectTypeOf(data.tnttag.prefix).toEqualTypeOf(); + expect(data.wizards).toBeDefined(); + expectTypeOf(data.wizards).toEqualTypeOf(); + expect(data.wizards.wins).toBeDefined(); + expect(data.wizards.wins).greaterThanOrEqual(0); + expectTypeOf(data.wizards.wins).toEqualTypeOf(); + expect(data.wizards.kills).toBeDefined(); + expect(data.wizards.kills).greaterThanOrEqual(0); + expectTypeOf(data.wizards.kills).toEqualTypeOf(); + expect(data.wizards.assists).toBeDefined(); + expect(data.wizards.assists).greaterThanOrEqual(0); + expectTypeOf(data.wizards.assists).toEqualTypeOf(); + expect(data.wizards.deaths).toBeDefined(); + expect(data.wizards.deaths).greaterThanOrEqual(0); + expectTypeOf(data.wizards.deaths).toEqualTypeOf(); + expect(data.wizards.KDR).toBeDefined(); + expect(data.wizards.KDR).greaterThanOrEqual(0); + expectTypeOf(data.wizards.KDR).toEqualTypeOf(); + expect(data.wizards.points).toBeDefined(); + expect(data.wizards.points).greaterThanOrEqual(0); + expectTypeOf(data.wizards.points).toEqualTypeOf(); + expect(data.wizards.kineticHealing).toBeDefined(); + expect(data.wizards.kineticHealing).greaterThanOrEqual(0); + expectTypeOf(data.wizards.kineticHealing).toEqualTypeOf(); + expect(data.wizards.airTime).toBeDefined(); + expect(data.wizards.airTime).greaterThanOrEqual(0); + expectTypeOf(data.wizards.airTime).toEqualTypeOf(); + expect(data.wizards.prefix).toBeDefined(); + expectTypeOf(data.wizards.prefix).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/TNTGames.ts b/src/structures/MiniGames/TNTGames.ts index 51e39f6e..6a40b70f 100644 --- a/src/structures/MiniGames/TNTGames.ts +++ b/src/structures/MiniGames/TNTGames.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class TNTRun { +export class TNTRun { wins: number; bestTime: number; deaths: number; @@ -9,17 +9,17 @@ class TNTRun { doubleJumps: number; prefix: string; constructor(data: Record) { - this.wins = data.wins_tntrun || 0; - this.bestTime = data.record_tntrun || 0; - this.deaths = data.deaths_tntrun || 0; - this.slownessPotions = data.new_tntrun_slowness_potions || 0; - this.speedPotions = data.new_tntrun_speed_potions || 0; - this.doubleJumps = data.new_tntrun_double_jumps || 0; - this.prefix = data.prefix_tntrun || ''; + this.wins = data?.wins_tntrun || 0; + this.bestTime = data?.record_tntrun || 0; + this.deaths = data?.deaths_tntrun || 0; + this.slownessPotions = data?.new_tntrun_slowness_potions || 0; + this.speedPotions = data?.new_tntrun_speed_potions || 0; + this.doubleJumps = data?.new_tntrun_double_jumps || 0; + this.prefix = data?.prefix_tntrun || ''; } } -class PVPRun { +export class PVPRun { wins: number; bestTime: number; kills: number; @@ -31,32 +31,33 @@ class PVPRun { doubleJumps: number; prefix: string; constructor(data: Record) { - this.wins = data.wins_pvprun || 0; - this.bestTime = data.record_pvprun || 0; - this.kills = data.kills_pvprun || 0; - this.deaths = data.deaths_pvprun || 0; + this.wins = data?.wins_pvprun || 0; + this.bestTime = data?.record_pvprun || 0; + this.kills = data?.kills_pvprun || 0; + this.deaths = data?.deaths_pvprun || 0; this.KDR = divide(this.kills, this.deaths); - this.regeneration = data.new_pvprun_regeneration || 0; - this.notoriety = data.new_pvprun_notoriety || 0; - this.fortitude = data.new_pvprun_fortitude || 0; - this.doubleJumps = data.new_pvprun_double_jumps || 0; - this.prefix = data.prefix_pvprun || ''; + this.regeneration = data?.new_pvprun_regeneration || 0; + this.notoriety = data?.new_pvprun_notoriety || 0; + this.fortitude = data?.new_pvprun_fortitude || 0; + this.doubleJumps = data?.new_pvprun_double_jumps || 0; + this.prefix = data?.prefix_pvprun || ''; } } -class BowSpleef { +export class BowSpleef { wins: number; tags: number; deaths: number; prefix: string; constructor(data: Record) { - this.wins = data.wins_bowspleef || 0; - this.tags = data.tags_bowspleef || 0; - this.deaths = data.deaths_bowspleef || 0; - this.prefix = data.prefix_bowspleef || ''; + this.wins = data?.wins_bowspleef || 0; + this.tags = data?.tags_bowspleef || 0; + this.deaths = data?.deaths_bowspleef || 0; + this.prefix = data?.prefix_bowspleef || ''; } } -class TNTTag { + +export class TNTTag { wins: number; kills: number; deaths: number; @@ -67,19 +68,19 @@ class TNTTag { slowItDown: number; prefix: string; constructor(data: Record) { - this.wins = data.wins_tntag || 0; - this.kills = data.kills_tntag || 0; - this.deaths = data.deaths_tntag || 0; + this.wins = data?.wins_tntag || 0; + this.kills = data?.kills_tntag || 0; + this.deaths = data?.deaths_tntag || 0; this.KDR = divide(this.kills, this.deaths); - this.speed = data.new_tntag_speedy || 0; - this.blastProtection = data.tag_blastprotection || 0; - this.speedItUp = data.tag_speeditup || 0; - this.slowItDown = data.tag_slowitdown || 0; - this.prefix = data.prefix_tntag || ''; + this.speed = data?.new_tntag_speedy || 0; + this.blastProtection = data?.tag_blastprotection || 0; + this.speedItUp = data?.tag_speeditup || 0; + this.slowItDown = data?.tag_slowitdown || 0; + this.prefix = data?.prefix_tntag || ''; } } -class TNTWizards { +export class TNTWizards { wins: number; kills: number; assists: number; @@ -90,15 +91,15 @@ class TNTWizards { airTime: number; prefix: string; constructor(data: Record) { - this.wins = data.wins_capture || 0; - this.kills = data.kills_capture || 0; - this.assists = data.assists_capture || 0; - this.deaths = data.deaths_capture || 0; + this.wins = data?.wins_capture || 0; + this.kills = data?.kills_capture || 0; + this.assists = data?.assists_capture || 0; + this.deaths = data?.deaths_capture || 0; this.KDR = divide(this.kills, this.deaths); - this.points = data.points_capture || 0; - this.kineticHealing = data.kinetic_healing_capture || 0; - this.airTime = data.air_time_capture || 0; - this.prefix = data.prefix_capture || ''; + this.points = data?.points_capture || 0; + this.kineticHealing = data?.kinetic_healing_capture || 0; + this.airTime = data?.air_time_capture || 0; + this.prefix = data?.prefix_capture || ''; } } @@ -112,9 +113,9 @@ class TNTGames { tnttag: TNTTag; wizards: TNTWizards; constructor(data: Record) { - this.coins = data.coins || 0; - this.winstreak = data.winstreak || 0; - this.wins = data.wins || 0; + this.coins = data?.coins || 0; + this.winstreak = data?.winstreak || 0; + this.wins = data?.wins || 0; this.tntrun = new TNTRun(data); this.pvpRun = new PVPRun(data); this.bowSpleef = new BowSpleef(data); diff --git a/src/structures/MiniGames/TurboKartRacers.test.ts b/src/structures/MiniGames/TurboKartRacers.test.ts new file mode 100644 index 00000000..7c897976 --- /dev/null +++ b/src/structures/MiniGames/TurboKartRacers.test.ts @@ -0,0 +1,143 @@ +import TurboKartRacers, { TurboKartRacersMap } from './TurboKartRacers'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('TurboKartRacers', () => { + const data = new TurboKartRacers({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(TurboKartRacers); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.completedLaps).toBeDefined(); + expect(data.completedLaps).greaterThanOrEqual(0); + expectTypeOf(data.completedLaps).toEqualTypeOf(); + expect(data.bronzeTrophies).toBeDefined(); + expect(data.bronzeTrophies).greaterThanOrEqual(0); + expectTypeOf(data.bronzeTrophies).toEqualTypeOf(); + expect(data.silverTrophies).toBeDefined(); + expect(data.silverTrophies).greaterThanOrEqual(0); + expectTypeOf(data.silverTrophies).toEqualTypeOf(); + expect(data.goldTrophies).toBeDefined(); + expect(data.goldTrophies).greaterThanOrEqual(0); + expectTypeOf(data.goldTrophies).toEqualTypeOf(); + expect(data.boxPickups).toBeDefined(); + expect(data.boxPickups).greaterThanOrEqual(0); + expectTypeOf(data.boxPickups).toEqualTypeOf(); + expect(data.horn).toBeDefined(); + expectTypeOf(data.horn).toEqualTypeOf< + 'DEFAULT' | 'SHY' | 'ALIEN' | 'TAXI' | 'KLAXON' | 'TRICYCLE' | 'ALARM' | 'KLOON' | 'TEDDY' | 'TRUCK' | 'JERRY' + >(); + expect(data.retro).toBeDefined(); + expectTypeOf(data.retro).toEqualTypeOf(); + expect(data.retro.map).toBeDefined(); + expectTypeOf(data.retro.map).toEqualTypeOf(); + expect(data.retro.plays).toBeDefined(); + expect(data.retro.plays).greaterThanOrEqual(0); + expectTypeOf(data.retro.plays).toEqualTypeOf(); + expect(data.retro.boxPickups).toBeDefined(); + expect(data.retro.boxPickups).greaterThanOrEqual(0); + expectTypeOf(data.retro.boxPickups).toEqualTypeOf(); + expect(data.retro.bronzeTrophies).toBeDefined(); + expect(data.retro.bronzeTrophies).greaterThanOrEqual(0); + expectTypeOf(data.retro.bronzeTrophies).toEqualTypeOf(); + expect(data.retro.silverTrophies).toBeDefined(); + expect(data.retro.silverTrophies).greaterThanOrEqual(0); + expectTypeOf(data.retro.silverTrophies).toEqualTypeOf(); + expect(data.retro.goldTrophies).toBeDefined(); + expect(data.retro.goldTrophies).greaterThanOrEqual(0); + expectTypeOf(data.retro.goldTrophies).toEqualTypeOf(); + expect(data.hypixelgp).toBeDefined(); + expectTypeOf(data.hypixelgp).toEqualTypeOf(); + expect(data.hypixelgp.map).toBeDefined(); + expectTypeOf(data.hypixelgp.map).toEqualTypeOf(); + expect(data.hypixelgp.plays).toBeDefined(); + expect(data.hypixelgp.plays).greaterThanOrEqual(0); + expectTypeOf(data.hypixelgp.plays).toEqualTypeOf(); + expect(data.hypixelgp.boxPickups).toBeDefined(); + expect(data.hypixelgp.boxPickups).greaterThanOrEqual(0); + expectTypeOf(data.hypixelgp.boxPickups).toEqualTypeOf(); + expect(data.hypixelgp.bronzeTrophies).toBeDefined(); + expect(data.hypixelgp.bronzeTrophies).greaterThanOrEqual(0); + expectTypeOf(data.hypixelgp.bronzeTrophies).toEqualTypeOf(); + expect(data.hypixelgp.silverTrophies).toBeDefined(); + expect(data.hypixelgp.silverTrophies).greaterThanOrEqual(0); + expectTypeOf(data.hypixelgp.silverTrophies).toEqualTypeOf(); + expect(data.hypixelgp.goldTrophies).toBeDefined(); + expect(data.hypixelgp.goldTrophies).greaterThanOrEqual(0); + expectTypeOf(data.hypixelgp.goldTrophies).toEqualTypeOf(); + expect(data.olympus).toBeDefined(); + expectTypeOf(data.olympus).toEqualTypeOf(); + expect(data.olympus.map).toBeDefined(); + expectTypeOf(data.olympus.map).toEqualTypeOf(); + expect(data.olympus.plays).toBeDefined(); + expect(data.olympus.plays).greaterThanOrEqual(0); + expectTypeOf(data.olympus.plays).toEqualTypeOf(); + expect(data.olympus.boxPickups).toBeDefined(); + expect(data.olympus.boxPickups).greaterThanOrEqual(0); + expectTypeOf(data.olympus.boxPickups).toEqualTypeOf(); + expect(data.olympus.bronzeTrophies).toBeDefined(); + expect(data.olympus.bronzeTrophies).greaterThanOrEqual(0); + expectTypeOf(data.olympus.bronzeTrophies).toEqualTypeOf(); + expect(data.olympus.silverTrophies).toBeDefined(); + expect(data.olympus.silverTrophies).greaterThanOrEqual(0); + expectTypeOf(data.olympus.silverTrophies).toEqualTypeOf(); + expect(data.olympus.goldTrophies).toBeDefined(); + expect(data.olympus.goldTrophies).greaterThanOrEqual(0); + expectTypeOf(data.olympus.goldTrophies).toEqualTypeOf(); + expect(data.junglerush).toBeDefined(); + expectTypeOf(data.junglerush).toEqualTypeOf(); + expect(data.junglerush.map).toBeDefined(); + expectTypeOf(data.junglerush.map).toEqualTypeOf(); + expect(data.junglerush.plays).toBeDefined(); + expect(data.junglerush.plays).greaterThanOrEqual(0); + expectTypeOf(data.junglerush.plays).toEqualTypeOf(); + expect(data.junglerush.boxPickups).toBeDefined(); + expect(data.junglerush.boxPickups).greaterThanOrEqual(0); + expectTypeOf(data.junglerush.boxPickups).toEqualTypeOf(); + expect(data.junglerush.bronzeTrophies).toBeDefined(); + expect(data.junglerush.bronzeTrophies).greaterThanOrEqual(0); + expectTypeOf(data.junglerush.bronzeTrophies).toEqualTypeOf(); + expect(data.junglerush.silverTrophies).toBeDefined(); + expect(data.junglerush.silverTrophies).greaterThanOrEqual(0); + expectTypeOf(data.junglerush.silverTrophies).toEqualTypeOf(); + expect(data.junglerush.goldTrophies).toBeDefined(); + expect(data.junglerush.goldTrophies).greaterThanOrEqual(0); + expectTypeOf(data.junglerush.goldTrophies).toEqualTypeOf(); + expect(data.canyon).toBeDefined(); + expectTypeOf(data.canyon).toEqualTypeOf(); + expect(data.canyon.map).toBeDefined(); + expectTypeOf(data.canyon.map).toEqualTypeOf(); + expect(data.canyon.plays).toBeDefined(); + expect(data.canyon.plays).greaterThanOrEqual(0); + expectTypeOf(data.canyon.plays).toEqualTypeOf(); + expect(data.canyon.boxPickups).toBeDefined(); + expect(data.canyon.boxPickups).greaterThanOrEqual(0); + expectTypeOf(data.canyon.boxPickups).toEqualTypeOf(); + expect(data.canyon.bronzeTrophies).toBeDefined(); + expect(data.canyon.bronzeTrophies).greaterThanOrEqual(0); + expectTypeOf(data.canyon.bronzeTrophies).toEqualTypeOf(); + expect(data.canyon.silverTrophies).toBeDefined(); + expect(data.canyon.silverTrophies).greaterThanOrEqual(0); + expectTypeOf(data.canyon.silverTrophies).toEqualTypeOf(); + expect(data.canyon.goldTrophies).toBeDefined(); + expect(data.canyon.goldTrophies).greaterThanOrEqual(0); + expectTypeOf(data.canyon.goldTrophies).toEqualTypeOf(); + expect(data.bananaHitsReceived).toBeDefined(); + expect(data.bananaHitsReceived).greaterThanOrEqual(0); + expectTypeOf(data.bananaHitsReceived).toEqualTypeOf(); + expect(data.bananaHitsSent).toBeDefined(); + expect(data.bananaHitsSent).greaterThanOrEqual(0); + expectTypeOf(data.bananaHitsSent).toEqualTypeOf(); + expect(data.blueTorpedoHit).toBeDefined(); + expect(data.blueTorpedoHit).greaterThanOrEqual(0); + expectTypeOf(data.blueTorpedoHit).toEqualTypeOf(); + expect(data.grandPrix).toBeDefined(); + expectTypeOf(data.grandPrix).toEqualTypeOf(); + expect(data.grandPrixTokens).toBeDefined(); + expect(data.grandPrixTokens).greaterThanOrEqual(0); + expectTypeOf(data.grandPrixTokens).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/TurboKartRacers.ts b/src/structures/MiniGames/TurboKartRacers.ts index 268ca443..9e8adedf 100644 --- a/src/structures/MiniGames/TurboKartRacers.ts +++ b/src/structures/MiniGames/TurboKartRacers.ts @@ -1,4 +1,4 @@ -class TurboKartRacersMap { +export class TurboKartRacersMap { map: string; plays: number; boxPickups: number; @@ -7,11 +7,11 @@ class TurboKartRacersMap { goldTrophies: number; constructor(data: Record, mapName: string) { this.map = mapName; - this.plays = data[`${mapName}_plays`] || 0; - this.boxPickups = data[`box_pickups_${mapName}`] || 0; - this.bronzeTrophies = data[`bronze_trophy_${mapName}`] || 0; - this.silverTrophies = data[`silver_trophy_${mapName}`] || 0; - this.goldTrophies = data[`gold_trophy_${mapName}`] || 0; + this.plays = data?.[`${mapName}_plays`] || 0; + this.boxPickups = data?.[`box_pickups_${mapName}`] || 0; + this.bronzeTrophies = data?.[`bronze_trophy_${mapName}`] || 0; + this.silverTrophies = data?.[`silver_trophy_${mapName}`] || 0; + this.goldTrophies = data?.[`gold_trophy_${mapName}`] || 0; } } @@ -35,24 +35,24 @@ class TurboKartRacers { grandPrix: boolean; grandPrixTokens: number; constructor(data: Record) { - this.coins = data.coins || 0; - this.wins = data.wins || 0; - this.completedLaps = data.laps_completed || 0; - this.bronzeTrophies = data.bronze_trophy || 0; - this.silverTrophies = data.silver_trophy || 0; - this.goldTrophies = data.gold_trophy || 0; - this.boxPickups = data.box_pickups || 0; - this.horn = data.horn || 'DEFAULT'; + this.coins = data?.coins || 0; + this.wins = data?.wins || 0; + this.completedLaps = data?.laps_completed || 0; + this.bronzeTrophies = data?.bronze_trophy || 0; + this.silverTrophies = data?.silver_trophy || 0; + this.goldTrophies = data?.gold_trophy || 0; + this.boxPickups = data?.box_pickups || 0; + this.horn = data?.horn || 'DEFAULT'; this.retro = new TurboKartRacersMap(data, 'retro'); this.hypixelgp = new TurboKartRacersMap(data, 'hypixelgp'); this.olympus = new TurboKartRacersMap(data, 'olympus'); this.junglerush = new TurboKartRacersMap(data, 'junglerush'); this.canyon = new TurboKartRacersMap(data, 'canyon'); - this.bananaHitsReceived = data.banana_hits_received || 0; - this.bananaHitsSent = data.banana_hits_sent || 0; - this.blueTorpedoHit = data.blue_torpedo_hit || 0; - this.grandPrix = data.grand_prix || 'false'; - this.grandPrixTokens = data.grand_prix_tokens || 0; + this.bananaHitsReceived = data?.banana_hits_received || 0; + this.bananaHitsSent = data?.banana_hits_sent || 0; + this.blueTorpedoHit = data?.blue_torpedo_hit || 0; + this.grandPrix = data?.grand_prix || 'false'; + this.grandPrixTokens = data?.grand_prix_tokens || 0; } } diff --git a/src/structures/MiniGames/UHC.test.ts b/src/structures/MiniGames/UHC.test.ts new file mode 100644 index 00000000..332b2d5f --- /dev/null +++ b/src/structures/MiniGames/UHC.test.ts @@ -0,0 +1,181 @@ +import UHC, { UHCGamemode } from './UHC'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('UHC', () => { + const data = new UHC({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(UHC); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.score).toBeDefined(); + expect(data.score).greaterThanOrEqual(0); + expectTypeOf(data.score).toEqualTypeOf(); + expect(data.kit).toBeDefined(); + expectTypeOf(data.kit).toEqualTypeOf(); + expect(data.solo).toBeDefined(); + expectTypeOf(data.solo).toEqualTypeOf(); + expect(data.solo.kills).toBeDefined(); + expect(data.solo.kills).greaterThanOrEqual(0); + expectTypeOf(data.solo.kills).toEqualTypeOf(); + expect(data.solo.deaths).toBeDefined(); + expect(data.solo.deaths).greaterThanOrEqual(0); + expectTypeOf(data.solo.deaths).toEqualTypeOf(); + expect(data.solo.wins).toBeDefined(); + expect(data.solo.wins).greaterThanOrEqual(0); + expectTypeOf(data.solo.wins).toEqualTypeOf(); + expect(data.solo.headsEaten).toBeDefined(); + expect(data.solo.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.solo.headsEaten).toEqualTypeOf(); + expect(data.solo.ultimatesCrafted).toBeDefined(); + expect(data.solo.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.solo.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.team).toBeDefined(); + expectTypeOf(data.team).toEqualTypeOf(); + expect(data.team.kills).toBeDefined(); + expect(data.team.kills).greaterThanOrEqual(0); + expectTypeOf(data.team.kills).toEqualTypeOf(); + expect(data.team.deaths).toBeDefined(); + expect(data.team.deaths).greaterThanOrEqual(0); + expectTypeOf(data.team.deaths).toEqualTypeOf(); + expect(data.team.wins).toBeDefined(); + expect(data.team.wins).greaterThanOrEqual(0); + expectTypeOf(data.team.wins).toEqualTypeOf(); + expect(data.team.headsEaten).toBeDefined(); + expect(data.team.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.team.headsEaten).toEqualTypeOf(); + expect(data.team.ultimatesCrafted).toBeDefined(); + expect(data.team.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.redVsBlue).toBeDefined(); + expectTypeOf(data.redVsBlue).toEqualTypeOf(); + expect(data.redVsBlue.kills).toBeDefined(); + expect(data.redVsBlue.kills).greaterThanOrEqual(0); + expectTypeOf(data.redVsBlue.kills).toEqualTypeOf(); + expect(data.redVsBlue.deaths).toBeDefined(); + expect(data.redVsBlue.deaths).greaterThanOrEqual(0); + expectTypeOf(data.redVsBlue.deaths).toEqualTypeOf(); + expect(data.redVsBlue.wins).toBeDefined(); + expect(data.redVsBlue.wins).greaterThanOrEqual(0); + expectTypeOf(data.redVsBlue.wins).toEqualTypeOf(); + expect(data.redVsBlue.headsEaten).toBeDefined(); + expect(data.redVsBlue.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.redVsBlue.headsEaten).toEqualTypeOf(); + expect(data.redVsBlue.ultimatesCrafted).toBeDefined(); + expect(data.redVsBlue.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.redVsBlue.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.noDiamond).toBeDefined(); + expectTypeOf(data.noDiamond).toEqualTypeOf(); + expect(data.noDiamond.kills).toBeDefined(); + expect(data.noDiamond.kills).greaterThanOrEqual(0); + expectTypeOf(data.noDiamond.kills).toEqualTypeOf(); + expect(data.noDiamond.deaths).toBeDefined(); + expect(data.noDiamond.deaths).greaterThanOrEqual(0); + expectTypeOf(data.noDiamond.deaths).toEqualTypeOf(); + expect(data.noDiamond.wins).toBeDefined(); + expect(data.noDiamond.wins).greaterThanOrEqual(0); + expectTypeOf(data.noDiamond.wins).toEqualTypeOf(); + expect(data.noDiamond.headsEaten).toBeDefined(); + expect(data.noDiamond.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.noDiamond.headsEaten).toEqualTypeOf(); + expect(data.noDiamond.ultimatesCrafted).toBeDefined(); + expect(data.noDiamond.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.noDiamond.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.brawl).toBeDefined(); + expectTypeOf(data.brawl).toEqualTypeOf(); + expect(data.brawl.kills).toBeDefined(); + expect(data.brawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.brawl.kills).toEqualTypeOf(); + expect(data.brawl.deaths).toBeDefined(); + expect(data.brawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.brawl.deaths).toEqualTypeOf(); + expect(data.brawl.wins).toBeDefined(); + expect(data.brawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.brawl.wins).toEqualTypeOf(); + expect(data.brawl.headsEaten).toBeDefined(); + expect(data.brawl.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.brawl.headsEaten).toEqualTypeOf(); + expect(data.brawl.ultimatesCrafted).toBeDefined(); + expect(data.brawl.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.brawl.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.soloBrawl).toBeDefined(); + expectTypeOf(data.soloBrawl).toEqualTypeOf(); + expect(data.soloBrawl.kills).toBeDefined(); + expect(data.soloBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.soloBrawl.kills).toEqualTypeOf(); + expect(data.soloBrawl.deaths).toBeDefined(); + expect(data.soloBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.soloBrawl.deaths).toEqualTypeOf(); + expect(data.soloBrawl.wins).toBeDefined(); + expect(data.soloBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.soloBrawl.wins).toEqualTypeOf(); + expect(data.soloBrawl.headsEaten).toBeDefined(); + expect(data.soloBrawl.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.soloBrawl.headsEaten).toEqualTypeOf(); + expect(data.soloBrawl.ultimatesCrafted).toBeDefined(); + expect(data.soloBrawl.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.soloBrawl.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.duoBrawl).toBeDefined(); + expectTypeOf(data.duoBrawl).toEqualTypeOf(); + expect(data.duoBrawl.kills).toBeDefined(); + expect(data.duoBrawl.kills).greaterThanOrEqual(0); + expectTypeOf(data.duoBrawl.kills).toEqualTypeOf(); + expect(data.duoBrawl.deaths).toBeDefined(); + expect(data.duoBrawl.deaths).greaterThanOrEqual(0); + expectTypeOf(data.duoBrawl.deaths).toEqualTypeOf(); + expect(data.duoBrawl.wins).toBeDefined(); + expect(data.duoBrawl.wins).greaterThanOrEqual(0); + expectTypeOf(data.duoBrawl.wins).toEqualTypeOf(); + expect(data.duoBrawl.headsEaten).toBeDefined(); + expect(data.duoBrawl.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.duoBrawl.headsEaten).toEqualTypeOf(); + expect(data.duoBrawl.ultimatesCrafted).toBeDefined(); + expect(data.duoBrawl.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.duoBrawl.ultimatesCrafted).toEqualTypeOf(); + expect(data.team.extraUltimatesCrafted).toBeDefined(); + expect(data.team.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.team.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.headsEaten).toBeDefined(); + expect(data.headsEaten).greaterThanOrEqual(0); + expectTypeOf(data.headsEaten).toEqualTypeOf(); + expect(data.ultimatesCrafted).toBeDefined(); + expect(data.ultimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.ultimatesCrafted).toEqualTypeOf(); + expect(data.extraUltimatesCrafted).toBeDefined(); + expect(data.extraUltimatesCrafted).greaterThanOrEqual(0); + expectTypeOf(data.extraUltimatesCrafted).toEqualTypeOf(); + expect(data.starLevel).toBeDefined(); + expect(data.starLevel).greaterThanOrEqual(0); + expectTypeOf(data.starLevel).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/UHC.ts b/src/structures/MiniGames/UHC.ts index a12863a0..b8a2f14e 100644 --- a/src/structures/MiniGames/UHC.ts +++ b/src/structures/MiniGames/UHC.ts @@ -8,7 +8,7 @@ function getStarLevel(kills: number, wins: number): number { return starLevel; } -class UHCGamemode { +export class UHCGamemode { kills: number; deaths: number; wins: number; @@ -17,12 +17,12 @@ class UHCGamemode { extraUltimatesCrafted: number; constructor(data: Record, mode?: string) { if (mode) mode = `_${mode}`; - this.kills = data[`kills${mode}`] || 0; - this.deaths = data[`deaths${mode}`] || 0; - this.wins = data[`wins${mode}`] || 0; - this.headsEaten = data[`heads_eaten${mode}`] || 0; - this.ultimatesCrafted = data[`ultimates_crafted${mode}`] || 0; - this.extraUltimatesCrafted = data[`extra_ultimates_crafted${mode}`] || 0; + this.kills = data?.[`kills${mode}`] || 0; + this.deaths = data?.[`deaths${mode}`] || 0; + this.wins = data?.[`wins${mode}`] || 0; + this.headsEaten = data?.[`heads_eaten${mode}`] || 0; + this.ultimatesCrafted = data?.[`ultimates_crafted${mode}`] || 0; + this.extraUltimatesCrafted = data?.[`extra_ultimates_crafted${mode}`] || 0; } } @@ -46,9 +46,9 @@ class UHC { extraUltimatesCrafted: number; starLevel: number; constructor(data: Record) { - this.coins = data.coins || 0; - this.score = data.score || 0; - this.kit = data.equippedKit || ''; + this.coins = data?.coins || 0; + this.score = data?.score || 0; + this.kit = data?.equippedKit || ''; this.solo = new UHCGamemode(data, 'solo'); this.team = new UHCGamemode(data); this.redVsBlue = new UHCGamemode(data, 'red_vs_blue'); diff --git a/src/structures/MiniGames/VampireZ.test.ts b/src/structures/MiniGames/VampireZ.test.ts new file mode 100644 index 00000000..e366570a --- /dev/null +++ b/src/structures/MiniGames/VampireZ.test.ts @@ -0,0 +1,60 @@ +import VampireZ, { VampireZRole } from './VampireZ'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('VampireZ', () => { + const data = new VampireZ({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(VampireZ); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).toBeGreaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.goldBought).toBeDefined(); + expect(data.goldBought).toBeGreaterThanOrEqual(0); + expectTypeOf(data.goldBought).toEqualTypeOf(); + expect(data.blood).toBeDefined(); + expectTypeOf(data.blood).toEqualTypeOf(); + expect(data.zombieKills).toBeDefined(); + expect(data.zombieKills).toBeGreaterThanOrEqual(0); + expectTypeOf(data.zombieKills).toEqualTypeOf(); + expect(data.human).toBeDefined(); + expectTypeOf(data.human).toEqualTypeOf(); + expect(data.human.kills).toBeDefined(); + expect(data.human.kills).greaterThanOrEqual(0); + expectTypeOf(data.human.kills).toEqualTypeOf(); + expect(data.human.deaths).toBeDefined(); + expect(data.human.deaths).greaterThanOrEqual(0); + expectTypeOf(data.human.deaths).toEqualTypeOf(); + expect(data.human.KDR).toBeDefined(); + expect(data.human.KDR).greaterThanOrEqual(0); + expectTypeOf(data.human.KDR).toEqualTypeOf(); + expect(data.human.wins).toBeDefined(); + expect(data.human.wins).greaterThanOrEqual(0); + expectTypeOf(data.human.wins).toEqualTypeOf(); + expect(data.vampire).toBeDefined(); + expectTypeOf(data.vampire).toEqualTypeOf(); + expect(data.vampire.kills).toBeDefined(); + expect(data.vampire.kills).greaterThanOrEqual(0); + expectTypeOf(data.vampire.kills).toEqualTypeOf(); + expect(data.vampire.deaths).toBeDefined(); + expect(data.vampire.deaths).greaterThanOrEqual(0); + expectTypeOf(data.vampire.deaths).toEqualTypeOf(); + expect(data.vampire.KDR).toBeDefined(); + expect(data.vampire.KDR).greaterThanOrEqual(0); + expectTypeOf(data.vampire.KDR).toEqualTypeOf(); + expect(data.vampire.wins).toBeDefined(); + expect(data.vampire.wins).greaterThanOrEqual(0); + expectTypeOf(data.vampire.wins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).toBeGreaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).toBeGreaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).toBeGreaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).toBeGreaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/VampireZ.ts b/src/structures/MiniGames/VampireZ.ts index 0c2cbb3d..590b9f4b 100644 --- a/src/structures/MiniGames/VampireZ.ts +++ b/src/structures/MiniGames/VampireZ.ts @@ -1,15 +1,15 @@ import divide from '../../utils/divide'; -class VampireZRole { +export class VampireZRole { kills: number; deaths: number; KDR: number; wins: number; constructor(data: Record, role: string) { - this.kills = data[`${role}_kills`]; - this.deaths = data[`${role}_deaths`]; + this.kills = data?.[`${role}_kills`] || 0; + this.deaths = data?.[`${role}_deaths`] || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data[`${role}_wins`]; + this.wins = data?.[`${role}_wins`] || 0; } } @@ -25,16 +25,16 @@ class VampireZ { KDR: number; wins: number; constructor(data: Record) { - this.coins = data.coins || 0; - this.goldBought = data.gold_bought || 0; - this.blood = data.blood || false; - this.zombieKills = data.zombie_kills || 0; + this.coins = data?.coins || 0; + this.goldBought = data?.gold_bought || 0; + this.blood = data?.blood || false; + this.zombieKills = data?.zombie_kills || 0; this.human = new VampireZRole(data, 'human'); this.vampire = new VampireZRole(data, 'vampire'); - this.kills = this.human.kills + this.vampire.kills; - this.deaths = this.human.deaths + this.vampire.deaths; + this.kills = this.human?.kills + this.vampire?.kills; + this.deaths = this.human?.deaths + this.vampire?.deaths; this.KDR = divide(this.kills, this.deaths); - this.wins = this.human.wins + this.vampire.wins; + this.wins = this.human?.wins + this.vampire?.wins; } } diff --git a/src/structures/MiniGames/Walls.test.ts b/src/structures/MiniGames/Walls.test.ts new file mode 100644 index 00000000..71ea0ce2 --- /dev/null +++ b/src/structures/MiniGames/Walls.test.ts @@ -0,0 +1,33 @@ +import Walls from './Walls'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Walls', () => { + const data = new Walls({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Walls); + expectTypeOf(data).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.assists).toBeDefined(); + expect(data.assists).greaterThanOrEqual(0); + expectTypeOf(data.assists).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/Walls.ts b/src/structures/MiniGames/Walls.ts index 09d59162..00316cf7 100644 --- a/src/structures/MiniGames/Walls.ts +++ b/src/structures/MiniGames/Walls.ts @@ -10,14 +10,14 @@ class Walls { WLR: number; assists: number; constructor(data: Record) { - this.coins = data.coins || 0; - this.kills = data.kills || 0; - this.deaths = data.deaths || 0; + this.coins = data?.coins || 0; + this.kills = data?.kills || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; this.WLR = divide(this.wins, this.losses); - this.assists = data.assists || 0; + this.assists = data?.assists || 0; } } diff --git a/src/structures/MiniGames/Warlords.test.ts b/src/structures/MiniGames/Warlords.test.ts new file mode 100644 index 00000000..8a032b85 --- /dev/null +++ b/src/structures/MiniGames/Warlords.test.ts @@ -0,0 +1,407 @@ +import Warlords, { WarlordsClass } from './Warlords'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Warlords', () => { + const data = new Warlords({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Warlords); + expectTypeOf(data).toEqualTypeOf(); + + expect(data.coins).toBeDefined(); + expect(data.coins).greaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.kills).toBeDefined(); + expect(data.kills).greaterThanOrEqual(0); + expectTypeOf(data.kills).toEqualTypeOf(); + expect(data.deaths).toBeDefined(); + expect(data.deaths).greaterThanOrEqual(0); + expectTypeOf(data.deaths).toEqualTypeOf(); + expect(data.KDR).toBeDefined(); + expect(data.KDR).greaterThanOrEqual(0); + expectTypeOf(data.KDR).toEqualTypeOf(); + expect(data.wins).toBeDefined(); + expect(data.wins).greaterThanOrEqual(0); + expectTypeOf(data.wins).toEqualTypeOf(); + expect(data.losses).toBeDefined(); + expect(data.losses).greaterThanOrEqual(0); + expectTypeOf(data.losses).toEqualTypeOf(); + expect(data.WLR).toBeDefined(); + expect(data.WLR).greaterThanOrEqual(0); + expectTypeOf(data.WLR).toEqualTypeOf(); + expect(data.winstreak).toBeDefined(); + expect(data.winstreak).greaterThanOrEqual(0); + expectTypeOf(data.winstreak).toEqualTypeOf(); + expect(data.assists).toBeDefined(); + expect(data.assists).greaterThanOrEqual(0); + expectTypeOf(data.assists).toEqualTypeOf(); + expect(data.class).toBeDefined(); + expectTypeOf(data.class).toEqualTypeOf(); + expect(data.pyromancer).toBeDefined(); + expectTypeOf(data.pyromancer).toEqualTypeOf(); + expect(data.pyromancer.wins).toBeDefined(); + expect(data.pyromancer.wins).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.wins).toEqualTypeOf(); + expect(data.pyromancer.losses).toBeDefined(); + expect(data.pyromancer.losses).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.losses).toEqualTypeOf(); + expect(data.pyromancer.WLR).toBeDefined(); + expect(data.pyromancer.WLR).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.WLR).toEqualTypeOf(); + expect(data.pyromancer.gamesPlayed).toBeDefined(); + expect(data.pyromancer.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.gamesPlayed).toEqualTypeOf(); + expect(data.pyromancer.damage).toBeDefined(); + expect(data.pyromancer.damage).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.damage).toEqualTypeOf(); + expect(data.pyromancer.heal).toBeDefined(); + expect(data.pyromancer.heal).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.heal).toEqualTypeOf(); + expect(data.pyromancer.damagePrevented).toBeDefined(); + expect(data.pyromancer.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.pyromancer.damagePrevented).toEqualTypeOf(); + expect(data.mage).toBeDefined(); + expectTypeOf(data.mage).toEqualTypeOf(); + expect(data.mage.wins).toBeDefined(); + expect(data.mage.wins).greaterThanOrEqual(0); + expectTypeOf(data.mage.wins).toEqualTypeOf(); + expect(data.mage.losses).toBeDefined(); + expect(data.mage.losses).greaterThanOrEqual(0); + expectTypeOf(data.mage.losses).toEqualTypeOf(); + expect(data.mage.WLR).toBeDefined(); + expect(data.mage.WLR).greaterThanOrEqual(0); + expectTypeOf(data.mage.WLR).toEqualTypeOf(); + expect(data.mage.gamesPlayed).toBeDefined(); + expect(data.mage.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.mage.gamesPlayed).toEqualTypeOf(); + expect(data.mage.damage).toBeDefined(); + expect(data.mage.damage).greaterThanOrEqual(0); + expectTypeOf(data.mage.damage).toEqualTypeOf(); + expect(data.mage.heal).toBeDefined(); + expect(data.mage.heal).greaterThanOrEqual(0); + expectTypeOf(data.mage.heal).toEqualTypeOf(); + expect(data.mage.damagePrevented).toBeDefined(); + expect(data.mage.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.mage.damagePrevented).toEqualTypeOf(); + expect(data.thunderlord).toBeDefined(); + expectTypeOf(data.thunderlord).toEqualTypeOf(); + expect(data.thunderlord.wins).toBeDefined(); + expect(data.thunderlord.wins).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.wins).toEqualTypeOf(); + expect(data.thunderlord.losses).toBeDefined(); + expect(data.thunderlord.losses).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.losses).toEqualTypeOf(); + expect(data.thunderlord.WLR).toBeDefined(); + expect(data.thunderlord.WLR).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.WLR).toEqualTypeOf(); + expect(data.thunderlord.gamesPlayed).toBeDefined(); + expect(data.thunderlord.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.gamesPlayed).toEqualTypeOf(); + expect(data.thunderlord.damage).toBeDefined(); + expect(data.thunderlord.damage).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.damage).toEqualTypeOf(); + expect(data.thunderlord.heal).toBeDefined(); + expect(data.thunderlord.heal).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.heal).toEqualTypeOf(); + expect(data.thunderlord.damagePrevented).toBeDefined(); + expect(data.thunderlord.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.thunderlord.damagePrevented).toEqualTypeOf(); + expect(data.shaman).toBeDefined(); + expectTypeOf(data.shaman).toEqualTypeOf(); + expect(data.shaman.wins).toBeDefined(); + expect(data.shaman.wins).greaterThanOrEqual(0); + expectTypeOf(data.shaman.wins).toEqualTypeOf(); + expect(data.shaman.losses).toBeDefined(); + expect(data.shaman.losses).greaterThanOrEqual(0); + expectTypeOf(data.shaman.losses).toEqualTypeOf(); + expect(data.shaman.WLR).toBeDefined(); + expect(data.shaman.WLR).greaterThanOrEqual(0); + expectTypeOf(data.shaman.WLR).toEqualTypeOf(); + expect(data.shaman.gamesPlayed).toBeDefined(); + expect(data.shaman.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.shaman.gamesPlayed).toEqualTypeOf(); + expect(data.shaman.damage).toBeDefined(); + expect(data.shaman.damage).greaterThanOrEqual(0); + expectTypeOf(data.shaman.damage).toEqualTypeOf(); + expect(data.shaman.heal).toBeDefined(); + expect(data.shaman.heal).greaterThanOrEqual(0); + expectTypeOf(data.shaman.heal).toEqualTypeOf(); + expect(data.shaman.damagePrevented).toBeDefined(); + expect(data.shaman.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.shaman.damagePrevented).toEqualTypeOf(); + expect(data.earthwarden).toBeDefined(); + expectTypeOf(data.earthwarden).toEqualTypeOf(); + expect(data.earthwarden.wins).toBeDefined(); + expect(data.earthwarden.wins).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.wins).toEqualTypeOf(); + expect(data.earthwarden.losses).toBeDefined(); + expect(data.earthwarden.losses).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.losses).toEqualTypeOf(); + expect(data.earthwarden.WLR).toBeDefined(); + expect(data.earthwarden.WLR).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.WLR).toEqualTypeOf(); + expect(data.earthwarden.gamesPlayed).toBeDefined(); + expect(data.earthwarden.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.gamesPlayed).toEqualTypeOf(); + expect(data.earthwarden.damage).toBeDefined(); + expect(data.earthwarden.damage).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.damage).toEqualTypeOf(); + expect(data.earthwarden.heal).toBeDefined(); + expect(data.earthwarden.heal).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.heal).toEqualTypeOf(); + expect(data.earthwarden.damagePrevented).toBeDefined(); + expect(data.earthwarden.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.earthwarden.damagePrevented).toEqualTypeOf(); + expect(data.aquamancer).toBeDefined(); + expectTypeOf(data.aquamancer).toEqualTypeOf(); + expect(data.aquamancer.wins).toBeDefined(); + expect(data.aquamancer.wins).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.wins).toEqualTypeOf(); + expect(data.aquamancer.losses).toBeDefined(); + expect(data.aquamancer.losses).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.losses).toEqualTypeOf(); + expect(data.aquamancer.WLR).toBeDefined(); + expect(data.aquamancer.WLR).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.WLR).toEqualTypeOf(); + expect(data.aquamancer.gamesPlayed).toBeDefined(); + expect(data.aquamancer.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.gamesPlayed).toEqualTypeOf(); + expect(data.aquamancer.damage).toBeDefined(); + expect(data.aquamancer.damage).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.damage).toEqualTypeOf(); + expect(data.aquamancer.heal).toBeDefined(); + expect(data.aquamancer.heal).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.heal).toEqualTypeOf(); + expect(data.aquamancer.damagePrevented).toBeDefined(); + expect(data.aquamancer.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.aquamancer.damagePrevented).toEqualTypeOf(); + expect(data.paladin).toBeDefined(); + expectTypeOf(data.paladin).toEqualTypeOf(); + expect(data.paladin.wins).toBeDefined(); + expect(data.paladin.wins).greaterThanOrEqual(0); + expectTypeOf(data.paladin.wins).toEqualTypeOf(); + expect(data.paladin.losses).toBeDefined(); + expect(data.paladin.losses).greaterThanOrEqual(0); + expectTypeOf(data.paladin.losses).toEqualTypeOf(); + expect(data.paladin.WLR).toBeDefined(); + expect(data.paladin.WLR).greaterThanOrEqual(0); + expectTypeOf(data.paladin.WLR).toEqualTypeOf(); + expect(data.paladin.gamesPlayed).toBeDefined(); + expect(data.paladin.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.paladin.gamesPlayed).toEqualTypeOf(); + expect(data.paladin.damage).toBeDefined(); + expect(data.paladin.damage).greaterThanOrEqual(0); + expectTypeOf(data.paladin.damage).toEqualTypeOf(); + expect(data.paladin.heal).toBeDefined(); + expect(data.paladin.heal).greaterThanOrEqual(0); + expectTypeOf(data.paladin.heal).toEqualTypeOf(); + expect(data.paladin.damagePrevented).toBeDefined(); + expect(data.paladin.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.paladin.damagePrevented).toEqualTypeOf(); + expect(data.avenger).toBeDefined(); + expectTypeOf(data.avenger).toEqualTypeOf(); + expect(data.avenger.wins).toBeDefined(); + expect(data.avenger.wins).greaterThanOrEqual(0); + expectTypeOf(data.avenger.wins).toEqualTypeOf(); + expect(data.avenger.losses).toBeDefined(); + expect(data.avenger.losses).greaterThanOrEqual(0); + expectTypeOf(data.avenger.losses).toEqualTypeOf(); + expect(data.avenger.WLR).toBeDefined(); + expect(data.avenger.WLR).greaterThanOrEqual(0); + expectTypeOf(data.avenger.WLR).toEqualTypeOf(); + expect(data.avenger.gamesPlayed).toBeDefined(); + expect(data.avenger.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.avenger.gamesPlayed).toEqualTypeOf(); + expect(data.avenger.damage).toBeDefined(); + expect(data.avenger.damage).greaterThanOrEqual(0); + expectTypeOf(data.avenger.damage).toEqualTypeOf(); + expect(data.avenger.heal).toBeDefined(); + expect(data.avenger.heal).greaterThanOrEqual(0); + expectTypeOf(data.avenger.heal).toEqualTypeOf(); + expect(data.avenger.damagePrevented).toBeDefined(); + expect(data.avenger.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.avenger.damagePrevented).toEqualTypeOf(); + expect(data.warrior).toBeDefined(); + expectTypeOf(data.warrior).toEqualTypeOf(); + expect(data.warrior.wins).toBeDefined(); + expect(data.warrior.wins).greaterThanOrEqual(0); + expectTypeOf(data.warrior.wins).toEqualTypeOf(); + expect(data.warrior.losses).toBeDefined(); + expect(data.warrior.losses).greaterThanOrEqual(0); + expectTypeOf(data.warrior.losses).toEqualTypeOf(); + expect(data.warrior.WLR).toBeDefined(); + expect(data.warrior.WLR).greaterThanOrEqual(0); + expectTypeOf(data.warrior.WLR).toEqualTypeOf(); + expect(data.warrior.gamesPlayed).toBeDefined(); + expect(data.warrior.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.warrior.gamesPlayed).toEqualTypeOf(); + expect(data.warrior.damage).toBeDefined(); + expect(data.warrior.damage).greaterThanOrEqual(0); + expectTypeOf(data.warrior.damage).toEqualTypeOf(); + expect(data.warrior.heal).toBeDefined(); + expect(data.warrior.heal).greaterThanOrEqual(0); + expectTypeOf(data.warrior.heal).toEqualTypeOf(); + expect(data.warrior.damagePrevented).toBeDefined(); + expect(data.warrior.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.warrior.damagePrevented).toEqualTypeOf(); + expect(data.defender).toBeDefined(); + expectTypeOf(data.defender).toEqualTypeOf(); + expect(data.defender.wins).toBeDefined(); + expect(data.defender.wins).greaterThanOrEqual(0); + expectTypeOf(data.defender.wins).toEqualTypeOf(); + expect(data.defender.losses).toBeDefined(); + expect(data.defender.losses).greaterThanOrEqual(0); + expectTypeOf(data.defender.losses).toEqualTypeOf(); + expect(data.defender.WLR).toBeDefined(); + expect(data.defender.WLR).greaterThanOrEqual(0); + expectTypeOf(data.defender.WLR).toEqualTypeOf(); + expect(data.defender.gamesPlayed).toBeDefined(); + expect(data.defender.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.defender.gamesPlayed).toEqualTypeOf(); + expect(data.defender.damage).toBeDefined(); + expect(data.defender.damage).greaterThanOrEqual(0); + expectTypeOf(data.defender.damage).toEqualTypeOf(); + expect(data.defender.heal).toBeDefined(); + expect(data.defender.heal).greaterThanOrEqual(0); + expectTypeOf(data.defender.heal).toEqualTypeOf(); + expect(data.defender.damagePrevented).toBeDefined(); + expect(data.defender.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.defender.damagePrevented).toEqualTypeOf(); + expect(data.cryomancer).toBeDefined(); + expectTypeOf(data.cryomancer).toEqualTypeOf(); + expect(data.cryomancer.wins).toBeDefined(); + expect(data.cryomancer.wins).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.wins).toEqualTypeOf(); + expect(data.cryomancer.losses).toBeDefined(); + expect(data.cryomancer.losses).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.losses).toEqualTypeOf(); + expect(data.cryomancer.WLR).toBeDefined(); + expect(data.cryomancer.WLR).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.WLR).toEqualTypeOf(); + expect(data.cryomancer.gamesPlayed).toBeDefined(); + expect(data.cryomancer.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.gamesPlayed).toEqualTypeOf(); + expect(data.cryomancer.damage).toBeDefined(); + expect(data.cryomancer.damage).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.damage).toEqualTypeOf(); + expect(data.cryomancer.heal).toBeDefined(); + expect(data.cryomancer.heal).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.heal).toEqualTypeOf(); + expect(data.cryomancer.damagePrevented).toBeDefined(); + expect(data.cryomancer.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.cryomancer.damagePrevented).toEqualTypeOf(); + expect(data.crusader).toBeDefined(); + expectTypeOf(data.crusader).toEqualTypeOf(); + expect(data.crusader.wins).toBeDefined(); + expect(data.crusader.wins).greaterThanOrEqual(0); + expectTypeOf(data.crusader.wins).toEqualTypeOf(); + expect(data.crusader.losses).toBeDefined(); + expect(data.crusader.losses).greaterThanOrEqual(0); + expectTypeOf(data.crusader.losses).toEqualTypeOf(); + expect(data.crusader.WLR).toBeDefined(); + expect(data.crusader.WLR).greaterThanOrEqual(0); + expectTypeOf(data.crusader.WLR).toEqualTypeOf(); + expect(data.crusader.gamesPlayed).toBeDefined(); + expect(data.crusader.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.crusader.gamesPlayed).toEqualTypeOf(); + expect(data.crusader.damage).toBeDefined(); + expect(data.crusader.damage).greaterThanOrEqual(0); + expectTypeOf(data.crusader.damage).toEqualTypeOf(); + expect(data.crusader.heal).toBeDefined(); + expect(data.crusader.heal).greaterThanOrEqual(0); + expectTypeOf(data.crusader.heal).toEqualTypeOf(); + expect(data.crusader.damagePrevented).toBeDefined(); + expect(data.crusader.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.crusader.damagePrevented).toEqualTypeOf(); + expect(data.berserker).toBeDefined(); + expectTypeOf(data.berserker).toEqualTypeOf(); + expect(data.berserker.wins).toBeDefined(); + expect(data.berserker.wins).greaterThanOrEqual(0); + expectTypeOf(data.berserker.wins).toEqualTypeOf(); + expect(data.berserker.losses).toBeDefined(); + expect(data.berserker.losses).greaterThanOrEqual(0); + expectTypeOf(data.berserker.losses).toEqualTypeOf(); + expect(data.berserker.WLR).toBeDefined(); + expect(data.berserker.WLR).greaterThanOrEqual(0); + expectTypeOf(data.berserker.WLR).toEqualTypeOf(); + expect(data.berserker.gamesPlayed).toBeDefined(); + expect(data.berserker.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.berserker.gamesPlayed).toEqualTypeOf(); + expect(data.berserker.damage).toBeDefined(); + expect(data.berserker.damage).greaterThanOrEqual(0); + expectTypeOf(data.berserker.damage).toEqualTypeOf(); + expect(data.berserker.heal).toBeDefined(); + expect(data.berserker.heal).greaterThanOrEqual(0); + expectTypeOf(data.berserker.heal).toEqualTypeOf(); + expect(data.berserker.damagePrevented).toBeDefined(); + expect(data.berserker.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.berserker.damagePrevented).toEqualTypeOf(); + expect(data.protector).toBeDefined(); + expectTypeOf(data.protector).toEqualTypeOf(); + expect(data.protector.wins).toBeDefined(); + expect(data.protector.wins).greaterThanOrEqual(0); + expectTypeOf(data.protector.wins).toEqualTypeOf(); + expect(data.protector.losses).toBeDefined(); + expect(data.protector.losses).greaterThanOrEqual(0); + expectTypeOf(data.protector.losses).toEqualTypeOf(); + expect(data.protector.WLR).toBeDefined(); + expect(data.protector.WLR).greaterThanOrEqual(0); + expectTypeOf(data.protector.WLR).toEqualTypeOf(); + expect(data.protector.gamesPlayed).toBeDefined(); + expect(data.protector.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.protector.gamesPlayed).toEqualTypeOf(); + expect(data.protector.damage).toBeDefined(); + expect(data.protector.damage).greaterThanOrEqual(0); + expectTypeOf(data.protector.damage).toEqualTypeOf(); + expect(data.protector.heal).toBeDefined(); + expect(data.protector.heal).greaterThanOrEqual(0); + expectTypeOf(data.protector.heal).toEqualTypeOf(); + expect(data.protector.damagePrevented).toBeDefined(); + expect(data.protector.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.protector.damagePrevented).toEqualTypeOf(); + expect(data.revenant).toBeDefined(); + expectTypeOf(data.revenant).toEqualTypeOf(); + expect(data.revenant.wins).toBeDefined(); + expect(data.revenant.wins).greaterThanOrEqual(0); + expectTypeOf(data.revenant.wins).toEqualTypeOf(); + expect(data.revenant.losses).toBeDefined(); + expect(data.revenant.losses).greaterThanOrEqual(0); + expectTypeOf(data.revenant.losses).toEqualTypeOf(); + expect(data.revenant.WLR).toBeDefined(); + expect(data.revenant.WLR).greaterThanOrEqual(0); + expectTypeOf(data.revenant.WLR).toEqualTypeOf(); + expect(data.revenant.gamesPlayed).toBeDefined(); + expect(data.revenant.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.revenant.gamesPlayed).toEqualTypeOf(); + expect(data.revenant.damage).toBeDefined(); + expect(data.revenant.damage).greaterThanOrEqual(0); + expectTypeOf(data.revenant.damage).toEqualTypeOf(); + expect(data.revenant.heal).toBeDefined(); + expect(data.revenant.heal).greaterThanOrEqual(0); + expectTypeOf(data.revenant.heal).toEqualTypeOf(); + expect(data.revenant.damagePrevented).toBeDefined(); + expect(data.revenant.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.revenant.damagePrevented).toEqualTypeOf(); + expect(data.spiritguard).toBeDefined(); + expectTypeOf(data.spiritguard).toEqualTypeOf(); + expect(data.spiritguard.wins).toBeDefined(); + expect(data.spiritguard.wins).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.wins).toEqualTypeOf(); + expect(data.spiritguard.losses).toBeDefined(); + expect(data.spiritguard.losses).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.losses).toEqualTypeOf(); + expect(data.spiritguard.WLR).toBeDefined(); + expect(data.spiritguard.WLR).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.WLR).toEqualTypeOf(); + expect(data.spiritguard.gamesPlayed).toBeDefined(); + expect(data.spiritguard.gamesPlayed).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.gamesPlayed).toEqualTypeOf(); + expect(data.spiritguard.damage).toBeDefined(); + expect(data.spiritguard.damage).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.damage).toEqualTypeOf(); + expect(data.spiritguard.heal).toBeDefined(); + expect(data.spiritguard.heal).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.heal).toEqualTypeOf(); + expect(data.spiritguard.damagePrevented).toBeDefined(); + expect(data.spiritguard.damagePrevented).greaterThanOrEqual(0); + expectTypeOf(data.spiritguard.damagePrevented).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/Warlords.ts b/src/structures/MiniGames/Warlords.ts index bc9f328e..1445282f 100644 --- a/src/structures/MiniGames/Warlords.ts +++ b/src/structures/MiniGames/Warlords.ts @@ -1,6 +1,6 @@ import divide from '../../utils/divide'; -class WarlordsClass { +export class WarlordsClass { wins: number; losses: number; WLR: number; @@ -9,13 +9,13 @@ class WarlordsClass { heal: number; damagePrevented: number; constructor(data: Record, className: string) { - this.wins = data[`wins_${className}`] || 0; - this.losses = data[`losses_${className}`] || 0; + this.wins = data?.[`wins_${className}`] || 0; + this.losses = data?.[`losses_${className}`] || 0; this.WLR = divide(this.wins, this.losses); - this.gamesPlayed = data[`${className}_plays`]; - this.damage = data[`damage_${className}`] || 0; - this.heal = data[`heal_${className}`] || 0; - this.damagePrevented = data[`damage_prevented_${className}`] || 0; + this.gamesPlayed = data?.[`${className}_plays`] || 0; + this.damage = data?.[`damage_${className}`] || 0; + this.heal = data?.[`heal_${className}`] || 0; + this.damagePrevented = data?.[`damage_prevented_${className}`] || 0; } } @@ -47,16 +47,16 @@ class Warlords { revenant: WarlordsClass; spiritguard: WarlordsClass; constructor(data: Record) { - this.coins = data.coins || 0; - this.kills = data.kills || 0; - this.deaths = data.deaths || 0; + this.coins = data?.coins || 0; + this.kills = data?.kills || 0; + this.deaths = data?.deaths || 0; this.KDR = divide(this.kills, this.deaths); - this.wins = data.wins || 0; - this.losses = data.losses || 0; + this.wins = data?.wins || 0; + this.losses = data?.losses || 0; this.WLR = divide(this.wins, this.losses); - this.winstreak = data.win_streak || 0; - this.assists = data.assists || 0; - this.class = data.chosen_class || ''; + this.winstreak = data?.win_streak || 0; + this.assists = data?.assists || 0; + this.class = data?.chosen_class || ''; this.pyromancer = new WarlordsClass(data, 'pyromancer'); this.mage = new WarlordsClass(data, 'mage'); this.thunderlord = new WarlordsClass(data, 'thunderlord'); diff --git a/src/structures/MiniGames/WoolGames.test.ts b/src/structures/MiniGames/WoolGames.test.ts new file mode 100644 index 00000000..c38a867d --- /dev/null +++ b/src/structures/MiniGames/WoolGames.test.ts @@ -0,0 +1,156 @@ +import WoolGames, { CaptureTheWool, SheepWars, WoolGamesPrivateGameConfig, WoolWars, WoolWarsClass } from './WoolGames'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('WoolGames', () => { + const data = new WoolGames({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(WoolGames); + expectTypeOf(data).toEqualTypeOf(); + expect(data.layers).toBeDefined(); + expect(data.layers).toBeGreaterThanOrEqual(0); + expectTypeOf(data.layers).toEqualTypeOf(); + expect(data.xp).toBeDefined(); + expect(data.xp).toBeGreaterThanOrEqual(0); + expectTypeOf(data.exactLevel).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expect(data.level).toBeGreaterThanOrEqual(0); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.coins).toBeDefined(); + expect(data.coins).toBeGreaterThanOrEqual(0); + expectTypeOf(data.coins).toEqualTypeOf(); + expect(data.ownedCosmetics).toBeDefined(); + expectTypeOf(data.ownedCosmetics).toEqualTypeOf(); + expect(data.privateGamesConfig).toBeDefined(); + expectTypeOf(data.privateGamesConfig).toEqualTypeOf(); + expect(data.playtime).toBeDefined(); + expect(data.playtime).toBeGreaterThanOrEqual(0); + expectTypeOf(data.playtime).toEqualTypeOf(); + expect(data.woolWars).toBeDefined(); + expectTypeOf(data.woolWars).toEqualTypeOf(); + expect(data.woolWars.selectedClass).toBeDefined(); + expectTypeOf(data.woolWars.selectedClass).toEqualTypeOf< + 'ASSAULT' | 'TANK' | 'GOLEM' | 'SWORDSMAN' | 'ENGINEER' | 'ARCHER' | 'NONE' + >(); + expect(data.woolWars.wins).toBeDefined(); + expect(data.woolWars.wins).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.wins).toEqualTypeOf(); + expect(data.woolWars.kills).toBeDefined(); + expect(data.woolWars.kills).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.kills).toEqualTypeOf(); + expect(data.woolWars.assists).toBeDefined(); + expect(data.woolWars.assists).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.assists).toEqualTypeOf(); + expect(data.woolWars.deaths).toBeDefined(); + expect(data.woolWars.deaths).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.deaths).toEqualTypeOf(); + expect(data.woolWars.KDRatio).toBeDefined(); + expect(data.woolWars.KDRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.KDRatio).toEqualTypeOf(); + expect(data.woolWars.gamesPlayed).toBeDefined(); + expect(data.woolWars.gamesPlayed).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.gamesPlayed).toEqualTypeOf(); + expect(data.woolWars.woolsPlaced).toBeDefined(); + expect(data.woolWars.woolsPlaced).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.woolsPlaced).toEqualTypeOf(); + expect(data.woolWars.blocksBroken).toBeDefined(); + expect(data.woolWars.blocksBroken).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.blocksBroken).toEqualTypeOf(); + expect(data.woolWars.placeBreakRatio).toBeDefined(); + expect(data.woolWars.placeBreakRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.placeBreakRatio).toEqualTypeOf(); + expect(data.woolWars.powerups).toBeDefined(); + expect(data.woolWars.powerups).toBeGreaterThanOrEqual(0); + expectTypeOf(data.woolWars.powerups).toEqualTypeOf(); + expect(data.woolWars.assault).toBeDefined(); + expectTypeOf(data.woolWars.assault).toEqualTypeOf(); + expect(data.woolWars.tank).toBeDefined(); + expectTypeOf(data.woolWars.tank).toEqualTypeOf(); + expect(data.woolWars.golem).toBeDefined(); + expectTypeOf(data.woolWars.golem).toEqualTypeOf(); + expect(data.woolWars.swordsman).toBeDefined(); + expectTypeOf(data.woolWars.swordsman).toEqualTypeOf(); + expect(data.woolWars.engineer).toBeDefined(); + expectTypeOf(data.woolWars.engineer).toEqualTypeOf(); + expect(data.woolWars.archer).toBeDefined(); + expectTypeOf(data.woolWars.archer).toEqualTypeOf(); + + expect(data.captureTheWool).toBeDefined(); + expectTypeOf(data.captureTheWool).toEqualTypeOf(); + expect(data.captureTheWool.kills).toBeDefined(); + expect(data.captureTheWool.kills).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.kills).toEqualTypeOf(); + expect(data.captureTheWool.assists).toBeDefined(); + expect(data.captureTheWool.assists).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.assists).toEqualTypeOf(); + expect(data.captureTheWool.deaths).toBeDefined(); + expect(data.captureTheWool.deaths).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.deaths).toEqualTypeOf(); + expect(data.captureTheWool.KDRatio).toBeDefined(); + expect(data.captureTheWool.KDRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.KDRatio).toEqualTypeOf(); + expect(data.captureTheWool.killsWithWool).toBeDefined(); + expect(data.captureTheWool.killsWithWool).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.killsWithWool).toEqualTypeOf(); + expect(data.captureTheWool.deathsWithWool).toBeDefined(); + expect(data.captureTheWool.deathsWithWool).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.deathsWithWool).toEqualTypeOf(); + expect(data.captureTheWool.KDRatioWithWool).toBeDefined(); + expect(data.captureTheWool.KDRatioWithWool).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.KDRatioWithWool).toEqualTypeOf(); + expect(data.captureTheWool.woolCaptured).toBeDefined(); + expect(data.captureTheWool.woolCaptured).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.woolCaptured).toEqualTypeOf(); + expect(data.captureTheWool.woolStolen).toBeDefined(); + expect(data.captureTheWool.woolStolen).toBeGreaterThanOrEqual(0); + expectTypeOf(data.captureTheWool.woolStolen).toEqualTypeOf(); + expect(data.sheepWars).toBeDefined(); + expectTypeOf(data.sheepWars).toEqualTypeOf(); + expect(data.sheepWars.wins).toBeDefined(); + expect(data.sheepWars.wins).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.wins).toEqualTypeOf(); + expect(data.sheepWars.kills).toBeDefined(); + expect(data.sheepWars.kills).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.kills).toEqualTypeOf(); + expect(data.sheepWars.killsVoid).toBeDefined(); + expect(data.sheepWars.killsVoid).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.killsVoid).toEqualTypeOf(); + expect(data.sheepWars.killsBow).toBeDefined(); + expect(data.sheepWars.killsBow).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.killsBow).toEqualTypeOf(); + expect(data.sheepWars.killsExplosive).toBeDefined(); + expect(data.sheepWars.killsExplosive).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.killsExplosive).toEqualTypeOf(); + expect(data.sheepWars.deaths).toBeDefined(); + expect(data.sheepWars.deaths).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.deaths).toEqualTypeOf(); + expect(data.sheepWars.deathsVoid).toBeDefined(); + expect(data.sheepWars.deathsVoid).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.deathsVoid).toEqualTypeOf(); + expect(data.sheepWars.deathsMelee).toBeDefined(); + expect(data.sheepWars.deathsMelee).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.deathsMelee).toEqualTypeOf(); + expect(data.sheepWars.deathsExplosive).toBeDefined(); + expect(data.sheepWars.deathsExplosive).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.deathsExplosive).toEqualTypeOf(); + expect(data.sheepWars.KDRatio).toBeDefined(); + expect(data.sheepWars.KDRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.KDRatio).toEqualTypeOf(); + expect(data.sheepWars.losses).toBeDefined(); + expect(data.sheepWars.losses).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.losses).toEqualTypeOf(); + expect(data.sheepWars.WLRatio).toBeDefined(); + expect(data.sheepWars.WLRatio).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.WLRatio).toEqualTypeOf(); + expect(data.sheepWars.gamesPlayed).toBeDefined(); + expect(data.sheepWars.gamesPlayed).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.gamesPlayed).toEqualTypeOf(); + expect(data.sheepWars.damageDealt).toBeDefined(); + expect(data.sheepWars.damageDealt).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.damageDealt).toEqualTypeOf(); + expect(data.sheepWars.sheepThrown).toBeDefined(); + expect(data.sheepWars.sheepThrown).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.sheepThrown).toEqualTypeOf(); + expect(data.sheepWars.magicWoolHit).toBeDefined(); + expect(data.sheepWars.magicWoolHit).toBeGreaterThanOrEqual(0); + expectTypeOf(data.sheepWars.magicWoolHit).toEqualTypeOf(); +}); diff --git a/src/structures/MiniGames/WoolGames.ts b/src/structures/MiniGames/WoolGames.ts index 208f8ce0..0217dfb9 100644 --- a/src/structures/MiniGames/WoolGames.ts +++ b/src/structures/MiniGames/WoolGames.ts @@ -10,7 +10,7 @@ export interface WoolGamesPrivateGameConfig { respawn_enable: boolean; } -class WoolWarsClass { +export class WoolWarsClass { wins: number; kills: number; assists: number; @@ -35,7 +35,7 @@ class WoolWarsClass { } } -class WoolWars { +export class WoolWars { selectedClass: 'ASSAULT' | 'TANK' | 'GOLEM' | 'SWORDSMAN' | 'ENGINEER' | 'ARCHER' | 'NONE'; wins: number; kills: number; @@ -74,7 +74,7 @@ class WoolWars { } } -class CaptureTheWool { +export class CaptureTheWool { kills: number; assists: number; deaths: number; @@ -99,7 +99,7 @@ class CaptureTheWool { } } -class SheepWars { +export class SheepWars { wins: number; kills: number; killsVoid: number; diff --git a/src/structures/Pet.ts b/src/structures/Pet.ts index 82c670f6..7908c5fa 100644 --- a/src/structures/Pet.ts +++ b/src/structures/Pet.ts @@ -4,35 +4,36 @@ class Pet { isFavorite: boolean; name: string | null; active: boolean; - hunger: number | null; + hunger: number; lastFed: number | null; lastFedAt: Date | null; - thirst: number | null; + thirst: number; lastDrank: number | null; lastDrankAt: Date | null; - exercise: number | null; + exercise: number; lastExercised: number | null; lastExercisedAt: Date | null; - rawNickname: string | null; - nickname: string | null; + rawNickname: string; + nickname: string; experience: number; + constructor(name: string, data: Record) { - this.isFavorite = data.vanityFavorites ? Boolean(data.vanityFavorites.includes(name.toUpperCase())) : false; + this.isFavorite = data?.vanityFavorites ? Boolean(data?.vanityFavorites.includes(name.toUpperCase())) : false; name = name.replace('pet_', ''); this.name = recursive(name) || null; this.active = data?.currentPet === name.toUpperCase(); - const stats = data?.petStats && data.petStats[name.toUpperCase()]; - this.hunger = stats?.HUNGER ? stats.HUNGER.value : null; - this.lastFed = stats?.HUNGER ? stats.HUNGER.timestamp : null; + const stats = data?.petStats?.[name.toUpperCase()] || {}; + this.hunger = stats?.HUNGER?.value || 0; + this.lastFed = stats?.HUNGER?.timestamp || null; this.lastFedAt = this.lastFed ? new Date(this.lastFed) : null; - this.thirst = stats?.THIRST ? stats.THIRST.value : null; - this.lastDrank = stats?.THIRST ? stats.THIRST.timestamp : null; + this.thirst = stats?.THIRST?.value || 0; + this.lastDrank = stats?.THIRST?.timestamp || null; this.lastDrankAt = this.lastDrank ? new Date(this.lastDrank) : null; - this.exercise = stats?.EXERCISE ? stats.EXERCISE.value : null; - this.lastExercised = stats?.EXERCISE ? stats.EXERCISE.timestamp : null; + this.exercise = stats?.EXERCISE?.value || 0; + this.lastExercised = stats?.EXERCISE ? stats?.EXERCISE?.timestamp : null; this.lastExercisedAt = this.lastExercised ? new Date(this.lastExercised) : null; - this.rawNickname = stats?.name || null; - this.nickname = stats?.name ? stats.name.replace(/§([0-9]|[a-f])|§/gm, '') : null; + this.rawNickname = stats?.name || ''; + this.nickname = this.rawNickname.replace(/§([0-9]|[a-f])|§/gm, ''); this.experience = stats?.experience || 0; } } diff --git a/src/structures/Pets.ts b/src/structures/Pets.ts index 66d311a1..867ee185 100644 --- a/src/structures/Pets.ts +++ b/src/structures/Pets.ts @@ -35,7 +35,7 @@ class Pets { lastJourneyTimestamp: number | null; lastJourneyAt: Date | null; petConsumables: PetConsumables; - constructor(pets: string[], data: Record) { + constructor(data: Record, pets: string[]) { this.pets = pets.map((x) => new Pet(x, data)); this.lastJourneyTimestamp = data.petJourneyTimestamp || null; this.lastJourneyAt = this.lastJourneyTimestamp ? new Date(this.lastJourneyTimestamp) : null; diff --git a/src/structures/Player.test.ts b/src/structures/Player.test.ts new file mode 100644 index 00000000..6c592fd8 --- /dev/null +++ b/src/structures/Player.test.ts @@ -0,0 +1,102 @@ +import Color from './Color'; +import Guild from './Guild/Guild'; +import House from './House'; +import Player, { LevelProgress, PlayerRank, PlayerSocialMedia, PlayerStats, RanksPurchaseTime } from './Player'; +import PlayerCosmetics from './PlayerCosmetics'; +import RecentGame from './RecentGame'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Player', () => { + const data = new Player({ stats: 'meow' }, { guild: null, houses: null, recentGames: null }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Player); + expectTypeOf(data).toEqualTypeOf(); + expect(data.nickname).toBeDefined(); + expectTypeOf(data.nickname).toEqualTypeOf(); + expect(data.uuid).toBeDefined(); + expectTypeOf(data.uuid).toEqualTypeOf(); + expect(data.rank).toBeDefined(); + expectTypeOf(data.rank).toEqualTypeOf(); + expect(data.guild).toBeDefined(); + expectTypeOf(data.guild).toEqualTypeOf(); + expect(data.houses).toBeDefined(); + expectTypeOf(data.houses).toEqualTypeOf(); + expect(data.recentGames).toBeDefined(); + expectTypeOf(data.recentGames).toEqualTypeOf(); + expect(data.channel).toBeDefined(); + expectTypeOf(data.channel).toEqualTypeOf(); + expect(data.firstLoginTimestamp).toBeDefined(); + expectTypeOf(data.firstLoginTimestamp).toEqualTypeOf(); + expect(data.firstLogin).toBeDefined(); + expectTypeOf(data.firstLogin).toEqualTypeOf(); + expect(data.lastLoginTimestamp).toBeDefined(); + expectTypeOf(data.lastLoginTimestamp).toEqualTypeOf(); + expect(data.lastLogin).toBeDefined(); + expectTypeOf(data.lastLogin).toEqualTypeOf(); + expect(data.lastLogoutTimestamp).toBeDefined(); + expectTypeOf(data.lastLogoutTimestamp).toEqualTypeOf(); + expect(data.lastLogout).toBeDefined(); + expectTypeOf(data.lastLogout).toEqualTypeOf(); + expect(data.plusColor).toBeDefined(); + expectTypeOf(data.plusColor).toEqualTypeOf(); + expect(data.prefixColor).toBeDefined(); + expectTypeOf(data.prefixColor).toEqualTypeOf(); + expect(data.karma).toBeDefined(); + expect(data.karma).toBeGreaterThanOrEqual(0); + expectTypeOf(data.karma).toEqualTypeOf(); + expect(data.achievements).toBeDefined(); + expectTypeOf(data.achievements).toEqualTypeOf(); + expect(data.achievementPoints).toBeDefined(); + expect(data.achievementPoints).toBeGreaterThanOrEqual(0); + expectTypeOf(data.achievementPoints).toEqualTypeOf(); + expect(data.totalExperience).toBeDefined(); + expect(data.totalExperience).toBeGreaterThanOrEqual(0); + expectTypeOf(data.totalExperience).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expect(data.level).toBeGreaterThanOrEqual(0); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.socialMedia).toBeDefined(); + expectTypeOf(data.socialMedia).toEqualTypeOf(); + expect(data.giftBundlesSent).toBeDefined(); + expect(data.giftBundlesSent).toBeGreaterThanOrEqual(0); + expectTypeOf(data.giftBundlesSent).toEqualTypeOf(); + expect(data.giftBundlesReceived).toBeDefined(); + expect(data.giftBundlesReceived).toBeGreaterThanOrEqual(0); + expectTypeOf(data.giftBundlesReceived).toEqualTypeOf(); + expect(data.giftsSent).toBeDefined(); + expect(data.giftsSent).toBeGreaterThanOrEqual(0); + expectTypeOf(data.giftsSent).toEqualTypeOf(); + expect(data.isOnline).toBeDefined(); + expectTypeOf(data.isOnline).toEqualTypeOf(); + expect(data.lastDailyRewardTimestamp).toBeDefined(); + expectTypeOf(data.lastDailyRewardTimestamp).toEqualTypeOf(); + expect(data.lastDailyReward).toBeDefined(); + expectTypeOf(data.lastDailyReward).toEqualTypeOf(); + expect(data.totalRewards).toBeDefined(); + expect(data.totalRewards).toBeGreaterThanOrEqual(0); + expectTypeOf(data.totalRewards).toEqualTypeOf(); + expect(data.totalDailyRewards).toBeDefined(); + expect(data.totalDailyRewards).toBeGreaterThanOrEqual(0); + expectTypeOf(data.totalDailyRewards).toEqualTypeOf(); + expect(data.rewardStreak).toBeDefined(); + expect(data.rewardStreak).toBeGreaterThanOrEqual(0); + expectTypeOf(data.rewardStreak).toEqualTypeOf(); + expect(data.rewardScore).toBeDefined(); + expect(data.rewardScore).toBeGreaterThanOrEqual(0); + expectTypeOf(data.rewardScore).toEqualTypeOf(); + expect(data.rewardHighScore).toBeDefined(); + expect(data.rewardHighScore).toBeGreaterThanOrEqual(0); + expectTypeOf(data.rewardHighScore).toEqualTypeOf(); + expect(data.levelProgress).toBeDefined(); + expectTypeOf(data.levelProgress).toEqualTypeOf(); + expect(data.stats).toBeDefined(); + expectTypeOf(data.stats).toEqualTypeOf(); + expect(data.userLanguage).toBeDefined(); + expectTypeOf(data.userLanguage).toEqualTypeOf(); + expect(data.claimedLevelingRewards).toBeDefined(); + expectTypeOf(data.claimedLevelingRewards).toEqualTypeOf(); + expect(data.globalCosmetics).toBeDefined(); + expectTypeOf(data.globalCosmetics).toEqualTypeOf(); + expect(data.ranksPurchaseTime).toBeDefined(); + expectTypeOf(data.ranksPurchaseTime).toEqualTypeOf(); +}); diff --git a/src/structures/Player.ts b/src/structures/Player.ts index 850d27dc..d9422354 100644 --- a/src/structures/Player.ts +++ b/src/structures/Player.ts @@ -6,7 +6,6 @@ import BuildBattle from './MiniGames/BuildBattle'; import Color from './Color'; import CopsAndCrims from './MiniGames/CopsAndCrims'; import Duels from './MiniGames/Duels'; -import Game from './Game'; import Guild from './Guild/Guild'; import House from './House'; import MegaWalls from './MiniGames/MegaWalls'; @@ -43,6 +42,31 @@ export interface PlayerSocialMedia { id: string; } +export interface PlayerStats { + arcade: Arcade; + arena: ArenaBrawl; + bedwars: BedWars; + blitzsg: BlitzSurvivalGames; + buildbattle: BuildBattle; + copsandcrims: CopsAndCrims; + duels: Duels; + megawalls: MegaWalls; + murdermystery: MurderMystery; + paintball: Paintball; + pit: Pit; + quakecraft: Quakecraft; + skywars: SkyWars; + smashheroes: SmashHeroes; + speeduhc: SpeedUHC; + tntgames: TNTGames; + turbokartracers: TurboKartRacers; + uhc: UHC; + vampirez: VampireZ; + walls: Walls; + warlords: Warlords; + woolgames: WoolGames; +} + export type PlayerRank = | 'Default' | 'VIP' @@ -73,14 +97,13 @@ class Player { guild: Guild | null; houses: House[] | null; recentGames: RecentGame[] | null; - channel: string | null; + channel: string; firstLoginTimestamp: number | null; firstLogin: Date | null; lastLoginTimestamp: number | null; lastLogin: Date | null; lastLogoutTimestamp: number | null; lastLogout: Date | null; - recentlyPlayedGame: Game | null; plusColor: Color | null; prefixColor: Color | null; karma: number; @@ -93,15 +116,15 @@ class Player { giftBundlesReceived: number; giftsSent: number; isOnline: boolean; - lastDailyReward: Date | null; lastDailyRewardTimestamp: number | null; - totalRewards: number | null; - totalDailyRewards: number | null; - rewardStreak: number | null; - rewardScore: number | null; - rewardHighScore: number | null; + lastDailyReward: Date | null; + totalRewards: number; + totalDailyRewards: number; + rewardStreak: number; + rewardScore: number; + rewardHighScore: number; levelProgress: LevelProgress; - stats: object | null; + stats: PlayerStats; userLanguage: string; claimedLevelingRewards: number[]; globalCosmetics: PlayerCosmetics | null; @@ -111,83 +134,89 @@ class Player { data: Record, extra: { guild: Guild | null; houses: House[] | null; recentGames: RecentGame[] | null } ) { - this.nickname = data.displayname; - this.uuid = data.uuid; + this.nickname = data?.displayname || ''; + this.uuid = data?.uuid || ''; this.rank = getRank(data); - this.guild = extra.guild; - this.houses = extra.houses; - this.recentGames = extra.recentGames; - this.channel = data.channel || null; - this.firstLoginTimestamp = data.firstLogin || null; - this.firstLogin = data.firstLogin ? new Date(data.firstLogin) : null; - this.lastLoginTimestamp = data.lastLogin || null; - this.lastLogin = data.lastLogin ? new Date(data.lastLogin) : null; - this.lastLogoutTimestamp = data.lastLogout || null; - this.lastLogout = data.lastLogout ? new Date(data.lastLogout) : null; - this.recentlyPlayedGame = data.mostRecentGameType ? new Game(data.mostRecentGameType) : null; + this.guild = extra?.guild; + this.houses = extra?.houses; + this.recentGames = extra?.recentGames; + this.channel = data?.channel || 'ALL'; + this.firstLoginTimestamp = data?.firstLogin || null; + this.firstLogin = data?.firstLogin ? new Date(data?.firstLogin) : null; + this.lastLoginTimestamp = data?.lastLogin || null; + this.lastLogin = data?.lastLogin ? new Date(data?.lastLogin) : null; + this.lastLogoutTimestamp = data?.lastLogout || null; + this.lastLogout = data?.lastLogout ? new Date(data?.lastLogout) : null; this.plusColor = 'MVP+' === this.rank || 'MVP++' === this.rank - ? data.rankPlusColor - ? new Color(data.rankPlusColor) + ? data?.rankPlusColor + ? new Color(data?.rankPlusColor) : new Color('RED') : null; this.prefixColor = - 'MVP++' === this.rank ? (data.monthlyRankColor ? new Color(data.monthlyRankColor) : new Color('GOLD')) : null; - this.karma = data.karma || 0; - this.achievements = recursive(data.achievements); - this.achievementPoints = data.achievementPoints || 0; - this.totalExperience = data.networkExp || 0; + 'MVP++' === this.rank ? (data?.monthlyRankColor ? new Color(data?.monthlyRankColor) : new Color('GOLD')) : null; + this.karma = data?.karma || 0; + this.achievements = recursive(data?.achievements) || {}; + this.achievementPoints = data?.achievementPoints || 0; + this.totalExperience = data?.networkExp || 0; this.level = getPlayerLevel(this.totalExperience) || 0; - this.socialMedia = getSocialMedia(data.socialMedia) || []; - this.giftBundlesSent = data.giftingMeta ? data.giftingMeta.realBundlesGiven || 0 : null; - this.giftBundlesReceived = data.giftingMeta ? data.giftingMeta.realBundlesReceived || 0 : null; - this.giftsSent = data.giftingMeta ? data.giftingMeta.giftsGiven || 0 : null; + this.socialMedia = getSocialMedia(data?.socialMedia) || []; + this.giftBundlesSent = data?.giftingMeta?.realBundlesGiven || 0; + this.giftBundlesReceived = data?.giftingMeta?.realBundlesReceived || 0; + this.giftsSent = data?.giftingMeta?.giftsGiven || 0; this.isOnline = null !== this.lastLoginTimestamp && null !== this.lastLogoutTimestamp && this.lastLoginTimestamp > this.lastLogoutTimestamp; + this.lastDailyRewardTimestamp = data?.lastAdsenseGenerateTime || null; + this.lastDailyReward = this.lastDailyRewardTimestamp ? new Date(this.lastDailyRewardTimestamp) : null; + this.totalRewards = data?.totalRewards || 0; + this.totalDailyRewards = data?.totalDailyRewards || 0; + this.rewardStreak = data?.rewardStreak || 0; + this.rewardScore = data?.rewardScore || 0; + this.rewardHighScore = data?.rewardHighScore || 0; + this.levelProgress = playerLevelProgress(data?.networkExp); + this.stats = { + arcade: new Arcade({ ...data?.stats?.Arcade, ...data?.achievements }), + arena: new ArenaBrawl(data?.stats?.Arena), + bedwars: new BedWars(data?.stats?.Bedwars), + blitzsg: new BlitzSurvivalGames(data?.stats?.HungerGames), + buildbattle: new BuildBattle(data?.stats?.BuildBattle), + copsandcrims: new CopsAndCrims(data?.stats?.MCGO), + duels: new Duels(data?.stats?.Duels), + megawalls: new MegaWalls(data?.stats?.Walls3), + murdermystery: new MurderMystery(data?.stats?.MurderMystery), + paintball: new Paintball(data?.stats?.Paintball), + pit: new Pit(data?.stats?.Pit), + quakecraft: new Quakecraft(data?.stats?.Quake), + skywars: new SkyWars(data?.stats?.SkyWars), + smashheroes: new SmashHeroes(data?.stats?.SuperSmash), + speeduhc: new SpeedUHC(data?.stats?.SpeedUHC), + tntgames: new TNTGames(data?.stats?.TNTGames), + turbokartracers: new TurboKartRacers(data?.stats?.GingerBread), + uhc: new UHC(data?.stats?.UHC), + vampirez: new VampireZ(data?.stats?.VampireZ), + walls: new Walls(data?.stats?.Walls), + warlords: new Warlords(data?.stats?.Battleground), + woolgames: new WoolGames(data?.stats?.WoolGames) + }; + this.userLanguage = data?.userLanguage || 'ENGLISH'; this.lastDailyReward = data.lastAdsenseGenerateTime ? new Date(data.lastAdsenseGenerateTime) : null; this.lastDailyRewardTimestamp = data.lastAdsenseGenerateTime || null; - this.totalRewards = data.totalRewards || null; - this.totalDailyRewards = data.totalDailyRewards || null; - this.rewardStreak = data.rewardStreak || null; - this.rewardScore = data.rewardScore || null; - this.rewardHighScore = data.rewardHighScore || null; + this.totalRewards = data.totalRewards || 0; + this.totalDailyRewards = data.totalDailyRewards || 0; + this.rewardStreak = data.rewardStreak || 0; + this.rewardScore = data.rewardScore || 0; + this.rewardHighScore = data.rewardHighScore || 0; this.levelProgress = playerLevelProgress(data.networkExp); - this.stats = data.stats - ? { - arcade: data.stats.Arcade ? new Arcade({ ...data.stats.Arcade, ...data.achievements }) : null, - arena: data.stats.Arena ? new ArenaBrawl(data.stats.Arena) : null, - bedwars: data.stats.Bedwars ? new BedWars(data.stats.Bedwars) : null, - blitzsg: data.stats.HungerGames ? new BlitzSurvivalGames(data.stats.HungerGames) : null, - buildbattle: data.stats.BuildBattle ? new BuildBattle(data.stats.BuildBattle) : null, - copsandcrims: data.stats.MCGO ? new CopsAndCrims(data.stats.MCGO) : null, - duels: data.stats.Duels ? new Duels(data.stats.Duels) : null, - megawalls: data.stats.Walls3 ? new MegaWalls(data.stats.Walls3) : null, - murdermystery: data.stats.MurderMystery ? new MurderMystery(data.stats.MurderMystery) : null, - paintball: data.stats.Paintball ? new Paintball(data.stats.Paintball) : null, - pit: data.stats.Pit ? new Pit(data.stats.Pit) : null, - quakecraft: data.stats.Quake ? new Quakecraft(data.stats.Quake) : null, - skywars: data.stats.SkyWars ? new SkyWars(data.stats.SkyWars) : null, - smashheroes: data.stats.SuperSmash ? new SmashHeroes(data.stats.SuperSmash) : null, - speeduhc: data.stats.SpeedUHC ? new SpeedUHC(data.stats.SpeedUHC) : null, - tntgames: data.stats.TNTGames ? new TNTGames(data.stats.TNTGames) : null, - turbokartracers: data.stats.GingerBread ? new TurboKartRacers(data.stats.GingerBread) : null, - uhc: data.stats.UHC ? new UHC(data.stats.UHC) : null, - vampirez: data.stats.VampireZ ? new VampireZ(data.stats.VampireZ) : null, - walls: data.stats.Walls ? new Walls(data.stats.Walls) : null, - warlords: data.stats.Battleground ? new Warlords(data.stats.Battleground) : null, - woolgames: data.stats.WoolGames ? new WoolGames(data.stats.WoolGames) : null - } - : null; this.userLanguage = data.userLanguage || 'ENGLISH'; this.claimedLevelingRewards = parseClaimedRewards(data) || []; - this.globalCosmetics = data ? new PlayerCosmetics(data) : null; + this.globalCosmetics = new PlayerCosmetics(data); this.ranksPurchaseTime = { - VIP: data.levelUp_VIP ? new Date(data.levelUp_VIP) : null, - VIP_PLUS: data.levelUp_VIP_PLUS ? new Date(data.levelUp_VIP_PLUS) : null, - MVP: data.levelUp_MVP ? new Date(data.levelUp_MVP) : null, - MVP_PLUS: data.levelUp_MVP_PLUS ? new Date(data.levelUp_MVP_PLUS) : null + VIP: data?.levelUp_VIP ? new Date(data?.levelUp_VIP) : null, + VIP_PLUS: data?.levelUp_VIP_PLUS ? new Date(data?.levelUp_VIP_PLUS) : null, + MVP: data?.levelUp_MVP ? new Date(data?.levelUp_MVP) : null, + MVP_PLUS: data?.levelUp_MVP_PLUS ? new Date(data?.levelUp_MVP_PLUS) : null }; } diff --git a/src/structures/PlayerCosmetics.ts b/src/structures/PlayerCosmetics.ts index fc2fc32a..b72bad73 100644 --- a/src/structures/PlayerCosmetics.ts +++ b/src/structures/PlayerCosmetics.ts @@ -1,128 +1,57 @@ -/* eslint-disable no-underscore-dangle */ import Pets from './Pets'; import { removeSnakeCaseString } from '../utils/removeSnakeCase'; +/** + * Player Cosmetics class + */ class PlayerCosmetics { - allCosmetics: string[]; - petManager: Pets | null; - _suits: any; - _hats: any; - _gadgets: any; - _morphs: any; - _cloaks: any; - _taunts: any; - _rankColors: any; - _particle: any; - _particlepacks: any; - _clickfx: any; + cosmetics: string[]; + pets: Pets; + suits: string[]; + hats: string[]; + gadgets: string[]; + morphs: string[]; + cloaks: string[]; + taunts: string[]; + rankColors: string[]; + particlePacks: string[]; + clickfx: string[]; constructor(data: Record) { - this.allCosmetics = data?.vanityMeta?.packages || undefined; - this.petManager = this.allCosmetics - ? new Pets( - this.allCosmetics.filter((x) => x.startsWith('pet_')), - data - ) - : null; - } - - suits(): string[] { - if (!this._suits) { - this._suits = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('suit_')) - .map((x) => removeSnakeCaseString(x.replace('suit_', ''))) || [] - : []; - } - return this._suits; - } - - hats(): string[] { - if (!this._hats) { - this._hats = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('hat_')) - .map((x) => removeSnakeCaseString(x.replace('hat_', ''))) || [] - : []; - } - return this._hats; - } - - gadgets(): string[] { - if (!this._gadgets) { - this._gadgets = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('gadget_')) - .map((x) => removeSnakeCaseString(x.replace('gadget_', ''))) || [] - : []; - } - return this._gadgets; - } - - morphs(): string[] { - if (!this._morphs) { - this._morphs = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('morph_')) - .map((x) => removeSnakeCaseString(x.replace('morph_', ''))) || [] - : []; - } - return this._morphs; - } - - cloaks(): string[] { - if (!this._cloaks) { - this._cloaks = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('cloak_')) - .map((x) => removeSnakeCaseString(x.replace('cloak_', ''))) || [] - : []; - } - return this._cloaks; - } - - taunts(): string[] { - if (!this._taunts) { - this._taunts = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('taunt_')) - .map((x) => removeSnakeCaseString(x.replace('taunt_', ''))) || [] - : []; - } - return this._taunts; - } - - rankColors(): string[] { - if (!this._rankColors) { - this._rankColors = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('rankcolor_')) - .map((x) => removeSnakeCaseString(x.replace('rankcolor_', ''))) || [] - : []; - } - return this._rankColors; - } - - particlePacks(): string[] { - if (!this._particle) { - this._particle = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('particlepack_')) - .map((x) => removeSnakeCaseString(x.replace('particlepack_', ''))) || [] - : []; - } - return this._particlepacks; - } - - clickEffects(): string[] { - if (!this._clickfx) { - this._clickfx = this.allCosmetics - ? this.allCosmetics - .filter((x) => x.startsWith('clickeffects_')) - .map((x) => removeSnakeCaseString(x.replace('clickeffects_', ''))) || [] - : []; - } - return this._clickfx; + this.cosmetics = data?.vanityMeta?.packages || []; + this.pets = new Pets( + data, + this.cosmetics.filter((x) => x.startsWith('pet_')) + ); + this.suits = + this.cosmetics.filter((x) => x.startsWith('suit_')).map((x) => removeSnakeCaseString(x.replace('suit_', ''))) || + []; + this.hats = + this.cosmetics.filter((x) => x.startsWith('hat_')).map((x) => removeSnakeCaseString(x.replace('hat_', ''))) || []; + this.gadgets = + this.cosmetics + .filter((x) => x.startsWith('gadget_')) + .map((x) => removeSnakeCaseString(x.replace('gadget_', ''))) || []; + this.morphs = + this.cosmetics.filter((x) => x.startsWith('morph_')).map((x) => removeSnakeCaseString(x.replace('morph_', ''))) || + []; + this.cloaks = + this.cosmetics.filter((x) => x.startsWith('cloak_')).map((x) => removeSnakeCaseString(x.replace('cloak_', ''))) || + []; + this.taunts = + this.cosmetics.filter((x) => x.startsWith('taunt_')).map((x) => removeSnakeCaseString(x.replace('taunt_', ''))) || + []; + this.rankColors = + this.cosmetics + .filter((x) => x.startsWith('rankcolor_')) + .map((x) => removeSnakeCaseString(x.replace('rankcolor_', ''))) || []; + this.particlePacks = + this.cosmetics + .filter((x) => x.startsWith('particlepack_')) + .map((x) => removeSnakeCaseString(x.replace('particlepack_', ''))) || []; + this.clickfx = + this.cosmetics + .filter((x) => x.startsWith('clickeffects_')) + .map((x) => removeSnakeCaseString(x.replace('clickeffects_', ''))) || []; } } - export default PlayerCosmetics; diff --git a/src/structures/RecentGame.ts b/src/structures/RecentGame.ts index 8ef5d222..afd54705 100644 --- a/src/structures/RecentGame.ts +++ b/src/structures/RecentGame.ts @@ -1,6 +1,7 @@ import Game from './Game'; -class RecentGame extends Game { +class RecentGame { + game: Game | null; dateTimestamp: number | null; dateAt: Date | null; mode: string | null; @@ -9,17 +10,17 @@ class RecentGame extends Game { endedTimestamp: number | null; endedAt: Date | null; constructor(data: Record) { - super(data.gameType); - this.dateTimestamp = data.date || null; + this.game = data?.gameType ? new Game(data.gameType) : null; + this.dateTimestamp = data?.date || null; this.dateAt = this.dateTimestamp ? new Date(this.dateTimestamp) : null; - this.mode = data.mode || null; - this.map = data.map || null; - this.ongoing = Boolean(!data.ended || 0); - this.endedTimestamp = data.ended ? data.ended : null; + this.mode = data?.mode || null; + this.map = data?.map || null; + this.ongoing = Boolean(!data?.ended || 0) || false; + this.endedTimestamp = data?.ended ? data?.ended : null; this.endedAt = this.endedTimestamp ? new Date(this.endedTimestamp) : null; } - toString(): any { + toString(): string | null { return this.mode; } } diff --git a/src/structures/RecentGames.test.ts b/src/structures/RecentGames.test.ts new file mode 100644 index 00000000..3b9d60cd --- /dev/null +++ b/src/structures/RecentGames.test.ts @@ -0,0 +1,29 @@ +import Game from './Game'; +import RecentGame from './RecentGame'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('RecentGame', () => { + const data = new RecentGame({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(RecentGame); + expectTypeOf(data).toEqualTypeOf(); + expect(data.game).toBeDefined(); + expectTypeOf(data.game).toEqualTypeOf(); + expect(data.dateTimestamp).toBeDefined(); + expectTypeOf(data.dateTimestamp).toEqualTypeOf(); + expect(data.dateAt).toBeDefined(); + expectTypeOf(data.dateAt).toEqualTypeOf(); + expect(data.mode).toBeDefined(); + expectTypeOf(data.mode).toEqualTypeOf(); + expect(data.map).toBeDefined(); + expectTypeOf(data.map).toEqualTypeOf(); + expect(data.ongoing).toBeDefined(); + expectTypeOf(data.ongoing).toEqualTypeOf(); + expect(data.endedTimestamp).toBeDefined(); + expectTypeOf(data.endedTimestamp).toEqualTypeOf(); + expect(data.endedAt).toBeDefined(); + expectTypeOf(data.endedAt).toEqualTypeOf(); + expect(data.toString()).toBeDefined(); + expect(data.toString()).toEqual(data.mode); + expectTypeOf(data.toString()).toEqualTypeOf(); +}); diff --git a/src/structures/ServerInfo.ts b/src/structures/ServerInfo.ts deleted file mode 100644 index 0c337db4..00000000 --- a/src/structures/ServerInfo.ts +++ /dev/null @@ -1,40 +0,0 @@ -export interface PlayerInfo { - max: number; - online: number; - players: any[]; - toString(): string; -} - -class ServerInfo { - protocolUsed: number; - versionInfo: string; - players: PlayerInfo; - rawMOTD: string; - cleanMOTD: string; - textMOTD: string; - faviconB64: string; - favicon: Buffer; - ping: number; - constructor(data: Record, ping: string | number) { - this.protocolUsed = data.version.protocol || 736; - this.versionInfo = data.version.name || 'Unknown'; - this.players = { - max: data.players.max || 0, - online: data.players.online || 0, - players: data.players.sample || [], - toString: () => `${this.players.online}/${this.players.max}` - }; - this.rawMOTD = data.description || ''; - this.cleanMOTD = this.rawMOTD.replace(/§[a-z0-9]/gi, ''); - this.textMOTD = this.cleanMOTD.replace(/^\s+/gm, ''); - this.faviconB64 = data.favicon; - this.favicon = Buffer.from(this.faviconB64, 'base64'); - this.ping = parseInt(String(ping), 10); - } - - toString(): string { - return `${this.textMOTD} - ${this.players} Players (${this.ping} ms) - ${this.versionInfo}`; - } -} - -export default ServerInfo; diff --git a/src/structures/SkyBlock/Auctions/Auction.ts b/src/structures/SkyBlock/Auctions/Auction.ts index 83def53f..02487148 100644 --- a/src/structures/SkyBlock/Auctions/Auction.ts +++ b/src/structures/SkyBlock/Auctions/Auction.ts @@ -1,6 +1,6 @@ import BaseAuction from './BaseAuction'; import Bid from './Bid'; -import { SkyblockRarity } from '../../../utils/SkyblockUtils'; +import { Rarity } from '../SkyblockMemberTypes'; class Auction extends BaseAuction { coop: string[]; @@ -11,7 +11,7 @@ class Auction extends BaseAuction { item: string; itemLore: string; itemLoreRaw: string; - rarity: SkyblockRarity; + rarity: Rarity; startingBid: number; highestBid: number; bids: Bid[]; diff --git a/src/structures/SkyBlock/Auctions/AuctionInfo.ts b/src/structures/SkyBlock/Auctions/AuctionInfo.ts index 9e5d18c6..a133f178 100644 --- a/src/structures/SkyBlock/Auctions/AuctionInfo.ts +++ b/src/structures/SkyBlock/Auctions/AuctionInfo.ts @@ -11,10 +11,6 @@ class AuctionInfo { this.lastUpdatedTimestamp = data.lastUpdated; this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp); } - - toString(): string { - return `${this.page}/${this.totalPages}`; - } } export default AuctionInfo; diff --git a/src/structures/SkyBlock/Auctions/BaseAuction.test.ts b/src/structures/SkyBlock/Auctions/BaseAuction.test.ts new file mode 100644 index 00000000..0dd9f4d2 --- /dev/null +++ b/src/structures/SkyBlock/Auctions/BaseAuction.test.ts @@ -0,0 +1,22 @@ +import BaseAuction from './BaseAuction'; +import ItemBytes from '../../ItemBytes'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('BaseAuction', () => { + const data = new BaseAuction({ stats: 'meow' }, false); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(BaseAuction); + expectTypeOf(data).toEqualTypeOf(); + expect(data.auctionId).toBeDefined(); + expectTypeOf(data.auctionId).toEqualTypeOf(); + expect(data.auctioneerUuid).toBeDefined(); + expectTypeOf(data.auctioneerUuid).toEqualTypeOf(); + expect(data.auctioneerProfile).toBeDefined(); + expectTypeOf(data.auctioneerProfile).toEqualTypeOf(); + expect(data.bin).toBeDefined(); + expectTypeOf(data.bin).toEqualTypeOf(); + expect(data.itemBytes).toBeDefined(); + expectTypeOf(data.itemBytes).toEqualTypeOf(); + expect(data.toString()).toBeDefined(); + expectTypeOf(data.toString()).toEqualTypeOf(); +}); diff --git a/src/structures/SkyBlock/Auctions/Bid.ts b/src/structures/SkyBlock/Auctions/Bid.ts index 6d338924..8bfaae1f 100644 --- a/src/structures/SkyBlock/Auctions/Bid.ts +++ b/src/structures/SkyBlock/Auctions/Bid.ts @@ -1,17 +1,17 @@ class Bid { - auctionId: string | null; - profileId: string | null; + auctionId: string; + profileId: string; amount: number; - timestamp: number | null; - at: Date | null; - bidder: string | null; + timestamp: number; + at: Date; + bidder: string; constructor(data: Record) { - this.auctionId = data.auction_id || null; - this.profileId = data.profile_id || null; - this.amount = data.amount || 0; - this.timestamp = data.timestamp || null; - this.at = this.timestamp ? new Date(this.timestamp) : null; - this.bidder = data.bidder || null; + this.auctionId = data.auction_id; + this.profileId = data.profile_id; + this.amount = data.amount; + this.timestamp = data.timestamp; + this.at = new Date(this.timestamp); + this.bidder = data.bidder; } toString(): string { diff --git a/src/structures/SkyBlock/Bazaar/Order.test.ts b/src/structures/SkyBlock/Bazaar/Order.test.ts new file mode 100644 index 00000000..93ca3a31 --- /dev/null +++ b/src/structures/SkyBlock/Bazaar/Order.test.ts @@ -0,0 +1,24 @@ +import Order from './Order'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Order', () => { + const data = new Order({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Order); + expectTypeOf(data).toEqualTypeOf(); + expect(data.amount).toBeDefined(); + expect(data.amount).greaterThanOrEqual(0); + expectTypeOf(data.amount).toEqualTypeOf(); + expect(data.pricePerUnit).toBeDefined(); + expect(data.pricePerUnit).greaterThanOrEqual(0); + expectTypeOf(data.pricePerUnit).toEqualTypeOf(); + expect(data.totalPrice).toBeDefined(); + expect(data.totalPrice).greaterThanOrEqual(0); + expectTypeOf(data.totalPrice).toEqualTypeOf(); + expect(data.orders).toBeDefined(); + expect(data.orders).greaterThanOrEqual(0); + expectTypeOf(data.orders).toEqualTypeOf(); + expect(data.toString()).toBeDefined(); + expectTypeOf(data.toString()).toEqualTypeOf(); + expect(data.toString()).toBe(data.totalPrice); +}); diff --git a/src/structures/SkyBlock/Bazzar/Order.ts b/src/structures/SkyBlock/Bazaar/Order.ts similarity index 100% rename from src/structures/SkyBlock/Bazzar/Order.ts rename to src/structures/SkyBlock/Bazaar/Order.ts diff --git a/src/structures/SkyBlock/Bazaar/Product.test.ts b/src/structures/SkyBlock/Bazaar/Product.test.ts new file mode 100644 index 00000000..4288df57 --- /dev/null +++ b/src/structures/SkyBlock/Bazaar/Product.test.ts @@ -0,0 +1,47 @@ +import Product from './Product'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Product', () => { + const data = new Product({ + product_id: 'INK_SACK:3', + sell_summary: [ + { amount: 133865, pricePerUnit: 1.4, orders: 2 }, + { amount: 816353, pricePerUnit: 1.3, orders: 12 }, + { amount: 71680, pricePerUnit: 1.1, orders: 3 } + ], + buy_summary: [ + { amount: 46654, pricePerUnit: 4, orders: 1 }, + { amount: 71680, pricePerUnit: 5.5, orders: 1 }, + { amount: 20657, pricePerUnit: 6.9, orders: 2 }, + { amount: 30618, pricePerUnit: 7, orders: 2 }, + { amount: 53616, pricePerUnit: 7.6, orders: 1 }, + { amount: 249908, pricePerUnit: 7.7, orders: 4 }, + { amount: 203944, pricePerUnit: 7.8, orders: 12 }, + { amount: 36816, pricePerUnit: 7.9, orders: 1 }, + { amount: 92527, pricePerUnit: 8, orders: 5 }, + { amount: 53129, pricePerUnit: 8.3, orders: 2 }, + { amount: 11165, pricePerUnit: 8.4, orders: 1 }, + { amount: 184653, pricePerUnit: 8.5, orders: 4 }, + { amount: 22548, pricePerUnit: 8.6, orders: 1 }, + { amount: 949628, pricePerUnit: 8.7, orders: 14 }, + { amount: 81014, pricePerUnit: 8.8, orders: 2 }, + { amount: 13239, pricePerUnit: 8.9, orders: 2 }, + { amount: 351416, pricePerUnit: 9.7, orders: 6 }, + { amount: 779336, pricePerUnit: 9.8, orders: 12 } + ], + quick_status: { + productId: 'INK_SACK:3', + sellPrice: 1.4, + sellVolume: 1421724, + sellMovingWeek: 85720502, + sellOrders: 24, + buyPrice: 5.204576555316532, + buyVolume: 6646255, + buyMovingWeek: 39972807, + buyOrders: 152 + } + }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Product); + expectTypeOf(data).toEqualTypeOf(); +}); diff --git a/src/structures/SkyBlock/Bazaar/Product.ts b/src/structures/SkyBlock/Bazaar/Product.ts new file mode 100644 index 00000000..8f5f6d5d --- /dev/null +++ b/src/structures/SkyBlock/Bazaar/Product.ts @@ -0,0 +1,36 @@ +import Order from './Order'; + +export interface ProductStatus { + sellPrice: number; + buyPrice: number; + sellVolume: number; + buyVolume: number; + sellMovingWeek: number; + buyMovingWeek: number; + sellOrders: number; + buyOrders: number; +} + +class Product { + productId: string; + sellSummary: Order[]; + buySummary: Order[]; + status: ProductStatus; + constructor(data: Record) { + this.productId = data.product_id; + this.sellSummary = data.sell_summary.map((sellOrder: Record) => new Order(sellOrder)); + this.buySummary = data.buy_summary.map((buyOrder: Record) => new Order(buyOrder)); + this.status = { + sellPrice: Math.round(data.quick_status.sellPrice * 100) / 100, + buyPrice: Math.round(data.quick_status.buyPrice * 100) / 100, + sellVolume: data.quick_status.sellVolume, + buyVolume: data.quick_status.buyVolume, + sellMovingWeek: data.quick_status.sellMovingWeek, + buyMovingWeek: data.quick_status.buyMovingWeek, + sellOrders: data.quick_status.sellOrders, + buyOrders: data.quick_status.buyOrders + }; + } +} + +export default Product; diff --git a/src/structures/SkyBlock/Bazzar/Product.ts b/src/structures/SkyBlock/Bazzar/Product.ts deleted file mode 100644 index 5b051254..00000000 --- a/src/structures/SkyBlock/Bazzar/Product.ts +++ /dev/null @@ -1,40 +0,0 @@ -import Order from './Order'; - -export interface ProductStatus { - sellPrice: number; - buyPrice: number; - sellVolume: number; - buyVolume: number; - sellMovingWeek: number; - buyMovingWeek: number; - sellOrders: number; - buyOrders: number; -} - -class Product { - productId: string; - sellSummary: Order[]; - buySummary: Order[]; - status: ProductStatus; - constructor(data: Record) { - this.productId = data.product_id; - this.sellSummary = data.sell_summary.length - ? data.sell_summary.map((sellOrder: Record) => new Order(sellOrder)) - : []; - this.buySummary = data.buy_summary.length - ? data.buy_summary.map((buyOrder: Record) => new Order(buyOrder)) - : []; - this.status = { - sellPrice: isNaN(data.quick_status.sellPrice) ? 0 : Math.round(data.quick_status.sellPrice * 100) / 100, - buyPrice: isNaN(data.quick_status.buyPrice) ? 0 : Math.round(data.quick_status.buyPrice * 100) / 100, - sellVolume: isNaN(data.quick_status.sellVolume) ? 0 : data.quick_status.sellVolume, - buyVolume: isNaN(data.quick_status.buyVolume) ? 0 : data.quick_status.buyVolume, - sellMovingWeek: isNaN(data.quick_status.sellMovingWeek) ? 0 : data.quick_status.sellMovingWeek, - buyMovingWeek: isNaN(data.quick_status.buyMovingWeek) ? 0 : data.quick_status.buyMovingWeek, - sellOrders: isNaN(data.quick_status.sellOrders) ? 0 : data.quick_status.sellOrders, - buyOrders: isNaN(data.quick_status.buyOrders) ? 0 : data.quick_status.buyOrders - }; - } -} - -export default Product; diff --git a/src/structures/SkyBlock/SkyblockGarden.test.ts b/src/structures/SkyBlock/SkyblockGarden.test.ts new file mode 100644 index 00000000..59de814b --- /dev/null +++ b/src/structures/SkyBlock/SkyblockGarden.test.ts @@ -0,0 +1,29 @@ +import SkyblockGarden, { + SkyblockGardenComposter, + SkyblockGardenCropMilestones, + SkyblockGardenVisitor, + SkyblockGarenCrops +} from './SkyblockGarden'; +import { SkillLevel } from './SkyblockMemberTypes'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('SkyblockGarden', () => { + const data = new SkyblockGarden({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(SkyblockGarden); + expectTypeOf(data).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.barnSkin).toBeDefined(); + expectTypeOf(data.barnSkin).toEqualTypeOf(); + expect(data.unlockedPlots).toBeDefined(); + expectTypeOf(data.unlockedPlots).toEqualTypeOf(); + expect(data.visitors).toBeDefined(); + expectTypeOf(data.visitors).toEqualTypeOf(); + expect(data.cropMilestones).toBeDefined(); + expectTypeOf(data.cropMilestones).toEqualTypeOf(); + expect(data.composter).toBeDefined(); + expectTypeOf(data.composter).toEqualTypeOf(); + expect(data.cropUpgrades).toBeDefined(); + expectTypeOf(data.cropUpgrades).toEqualTypeOf(); +}); diff --git a/src/structures/SkyBlock/SkyblockGarden.ts b/src/structures/SkyBlock/SkyblockGarden.ts index 07e7b04f..4b705a1b 100644 --- a/src/structures/SkyBlock/SkyblockGarden.ts +++ b/src/structures/SkyBlock/SkyblockGarden.ts @@ -1,4 +1,5 @@ -import { SkyblockSkillLevel, getLevelByXp } from '../../utils/SkyblockUtils'; +import { SkillLevel } from './SkyblockMemberTypes'; +import { getLevelByXp } from '../../utils/SkyblockUtils'; export interface SkyblockGardenVisitorServed { total: number; @@ -42,20 +43,20 @@ export interface SkyblockGarenCrops { } export interface SkyblockGardenCropMilestones { - wheat: SkyblockSkillLevel; - carrot: SkyblockSkillLevel; - sugarCane: SkyblockSkillLevel; - potato: SkyblockSkillLevel; - pumpkin: SkyblockSkillLevel; - melon: SkyblockSkillLevel; - cactus: SkyblockSkillLevel; - cocoaBeans: SkyblockSkillLevel; - mushroom: SkyblockSkillLevel; - netherWart: SkyblockSkillLevel; + wheat: SkillLevel; + carrot: SkillLevel; + sugarCane: SkillLevel; + potato: SkillLevel; + pumpkin: SkillLevel; + melon: SkillLevel; + cactus: SkillLevel; + cocoaBeans: SkillLevel; + mushroom: SkillLevel; + netherWart: SkillLevel; } class SkyblockGarden { - level: SkyblockSkillLevel; + level: SkillLevel; barnSkin: string; unlockedPlots: string[]; visitors: SkyblockGardenVisitor; diff --git a/src/structures/SkyBlock/SkyblockMember.test.ts b/src/structures/SkyBlock/SkyblockMember.test.ts new file mode 100644 index 00000000..e238ff1d --- /dev/null +++ b/src/structures/SkyBlock/SkyblockMember.test.ts @@ -0,0 +1,76 @@ +import SkyblockGarden from './SkyblockGarden'; +import SkyblockMember, { MemberStats } from './SkyblockMember'; +import SkyblockMuseum from './SkyblockMuseum'; +import SkyblockPet from './SkyblockPet'; +import { ChocolateFactoryData, CrimsonIsle, Dungeons, HOTM, JacobData, Skills, Slayer } from './SkyblockMemberTypes'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('SkyblockMember', () => { + const data = new SkyblockMember({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(SkyblockMember); + expectTypeOf(data).toEqualTypeOf(); + expect(data.uuid).toBeDefined(); + expectTypeOf(data.uuid).toEqualTypeOf(); + expect(data.gameMode).toBeDefined(); + expectTypeOf(data.gameMode).toEqualTypeOf(); + expect(data.selected).toBeDefined(); + expectTypeOf(data.selected).toEqualTypeOf(); + expect(data.garden).toBeDefined(); + expect(data.garden).toBeNull(); + expectTypeOf(data.garden).toEqualTypeOf(); + expect(data.museum).toBeDefined(); + expect(data.museum).toBeNull(); + expectTypeOf(data.museum).toEqualTypeOf(); + expect(data.profileName).toBeDefined(); + expectTypeOf(data.profileName).toEqualTypeOf(); + expect(data.profileId).toBeDefined(); + expectTypeOf(data.profileId).toEqualTypeOf(); + expect(data.firstJoinTimestamp).toBeDefined(); + expectTypeOf(data.firstJoinTimestamp).toEqualTypeOf(); + expect(data.firstJoinAt).toBeDefined(); + expectTypeOf(data.firstJoinAt).toEqualTypeOf(); + expect(data.experience).toBeDefined(); + expect(data.experience).toBeGreaterThanOrEqual(0); + expectTypeOf(data.experience).toEqualTypeOf(); + expect(data.level).toBeDefined(); + expect(data.level).toBeGreaterThanOrEqual(0); + expectTypeOf(data.level).toEqualTypeOf(); + expect(data.hotm).toBeDefined(); + expectTypeOf(data.hotm).toEqualTypeOf(); + expect(data.highestMagicalPower).toBeDefined(); + expect(data.highestMagicalPower).toBeGreaterThanOrEqual(0); + expectTypeOf(data.highestMagicalPower).toEqualTypeOf(); + expect(data.fairySouls).toBeDefined(); + expect(data.fairySouls).toBeGreaterThanOrEqual(0); + expectTypeOf(data.fairySouls).toEqualTypeOf(); + expect(data.fairyExchanges).toBeDefined(); + expect(data.fairyExchanges).toBeGreaterThanOrEqual(0); + expectTypeOf(data.fairyExchanges).toEqualTypeOf(); + expect(data.skills).toBeDefined(); + expectTypeOf(data.skills).toEqualTypeOf(); + expect(data.bestiary).toBeDefined(); + expectTypeOf(data.bestiary).toEqualTypeOf(); + expect(data.slayer).toBeDefined(); + expectTypeOf(data.slayer).toEqualTypeOf(); + expect(data.crimsonIsle).toBeDefined(); + expectTypeOf(data.crimsonIsle).toEqualTypeOf(); + expect(data.dungeons).toBeDefined(); + expectTypeOf(data.dungeons).toEqualTypeOf(); + expect(data.collections).toBeDefined(); + expectTypeOf(data.collections).toEqualTypeOf>(); + expect(data.purse).toBeDefined(); + expect(data.purse).toBeGreaterThanOrEqual(0); + expectTypeOf(data.purse).toEqualTypeOf(); + expect(data.stats).toBeDefined(); + expectTypeOf(data.stats).toEqualTypeOf(); + expect(data.pets).toBeDefined(); + expectTypeOf(data.pets).toEqualTypeOf(); + expect(data.jacob).toBeDefined(); + expectTypeOf(data.jacob).toEqualTypeOf(); + expect(data.chocolate).toBeDefined(); + expectTypeOf(data.chocolate).toEqualTypeOf(); + expect(data.toString()).toBeDefined(); + expect(data.toString()).toBe(data.uuid); + expectTypeOf(data.toString()).toEqualTypeOf(); +}); diff --git a/src/structures/SkyBlock/SkyblockMember.ts b/src/structures/SkyBlock/SkyblockMember.ts index 1f95ce0a..92ba6e1e 100644 --- a/src/structures/SkyBlock/SkyblockMember.ts +++ b/src/structures/SkyBlock/SkyblockMember.ts @@ -3,17 +3,26 @@ import SkyblockGarden from './SkyblockGarden'; import SkyblockInventoryItem from './SkyblockInventoryItem'; import SkyblockMuseum from './SkyblockMuseum'; import SkyblockPet from './SkyblockPet'; +import { + Armor, + ChocolateFactoryData, + CrimsonIsle, + Dungeons, + Equipment, + HOTM, + JacobData, + MemberStatsAuctions, + MemberStatsCandy, + MemberStatsFishing, + MemberStatsGifts, + MemberStatsMythos, + MemberStatsPetMilestones, + Skills, + Slayer +} from './SkyblockMemberTypes'; import { NetworthResult, getNetworth } from 'skyhelper-networth'; +import { createFarmingWeightCalculator } from 'farming-weight'; import { - SkyblockMemberChocolateFactoryData, - SkyblockMemberCrimson, - SkyblockMemberDungeons, - SkyblockMemberHOTM, - SkyblockMemberJacobData, - SkyblockMemberSkills, - SkyblockMemberSlayer, - SkyblockMemberStats, - SkyblockMemberTrophyFishRank, decode, getBestiaryLevel, getChocolateFactory, @@ -21,26 +30,139 @@ import { getDungeons, getHOTM, getJacobData, - getMemberStats, getPetLevel, getSkills, - getSlayer, - getTrophyFishRank + getSlayer } from '../../utils/SkyblockUtils'; -import { createFarmingWeightCalculator } from 'farming-weight'; -export interface SkyblockMemberEquipment { - gauntlet: SkyblockInventoryItem | null; - belt: SkyblockInventoryItem | null; - cloak: SkyblockInventoryItem | null; - necklace: SkyblockInventoryItem | null; -} - -export interface SkyblockMemberArmor { - helmet: SkyblockInventoryItem | null; - chestplate: SkyblockInventoryItem | null; - leggings: SkyblockInventoryItem | null; - boots: SkyblockInventoryItem | null; +export class MemberStats { + candy: MemberStatsCandy; + petMilestones: MemberStatsPetMilestones; + highestCriticalDamage: number; + highestDamage: number; + glowingMusroomsBroken: number; + kills: Record; + deaths: Record; + auctions: MemberStatsAuctions; + gifts: MemberStatsGifts; + itemsFished: MemberStatsFishing; + mythos: MemberStatsMythos; + constructor(data: Record) { + this.candy = { + green: data?.candy_collected?.green_candy || 0, + purple: data?.candy_collected?.purple_candy || 0, + total: data?.candy_collected?.total || 0, + festivals: [] + }; + Object.keys(data?.candy_collected || {}).forEach((year: string) => { + if ('total' !== year && 'green_candy' !== year && 'purple_candy' !== year) { + this.candy?.festivals?.push({ + year: Number(data?.candy_collected?.[`spooky_festival_${year}`] || '0'), + collected: { + green: data?.candy_collected?.[`spooky_festival_${year}`]?.green_candy || 0, + purple: data?.candy_collected?.[`spooky_festival_${year}`]?.purple_candy || 0, + total: data?.candy_collected?.[`spooky_festival_${year}`]?.total || 0 + } + }); + } + }); + this.petMilestones = { + oresMinned: data?.pets?.milestones?.ores_mined || 0, + seaCreaturesKilled: data?.pets?.milestones?.sea_creatures_killed || 0 + }; + this.highestCriticalDamage = data?.highest_critical_damage || 0; + this.highestDamage = data?.highest_damage || 0; + this.glowingMusroomsBroken = data?.glowing_mushrooms_broken || 0; + this.kills = { + total: Object.values(data?.kills || {})?.reduce((acc: any, curr) => acc + curr, 0) as number, + ...Object.keys(data?.kills || {}) + .filter((key) => 'total' !== key) + .sort((a, b) => data?.kills[b] - data?.kills[a]) + .map((key) => ({ [key]: data?.kills[key] })) + .reduce((acc, curr) => ({ ...acc, ...curr }), {}) + }; + this.deaths = { + total: Object.values(data?.deaths || {})?.reduce((acc: any, curr) => acc + curr, 0) as number, + ...Object.keys(data?.deaths || {}) + .filter((key) => 'total' !== key) + .sort((a, b) => data?.deaths[b] - data?.deaths[a]) + .map((key) => ({ [key]: data?.deaths[key] })) + .reduce((acc, curr) => ({ ...acc, ...curr }), {}) + }; + this.auctions = { + bids: data?.auctions?.bids || 0, + highestBid: data?.auctions?.highest_bid || 0, + goldSpent: data?.auctions?.gold_spent || 0, + goldEarnt: data?.auctions?.gold_earnt || 0, + auctionsWon: data?.auctions?.won || 0, + auctionsCompleted: data?.auctions?.completed || 0, + auctionsCreated: data?.auctions?.created || 0, + auctionFees: data?.auctions?.auction_fees || 0, + auctionsWithOutBids: data?.auctions?.no_bids || 0, + bought: { + uncommon: data?.auctions?.total_bought?.uncommon || 0, + common: data?.auctions?.total_bought?.common || 0, + rare: data?.auctions?.total_bought?.rare || 0, + epic: data?.auctions?.total_bought?.epic || 0, + legendary: data?.auctions?.total_bought?.legendary || 0, + special: data?.auctions?.total_bought?.special || 0, + mythic: data?.auctions?.total_bought?.mythic || 0, + total: + data?.auctions?.total_bought?.uncommon || + 0 + data?.auctions?.total_bought?.common || + 0 + data?.auctions?.total_bought?.rare || + 0 + data?.auctions?.total_bought?.epic || + 0 + data?.auctions?.total_bought?.legendary || + 0 + data?.auctions?.total_bought?.special || + 0 + data?.auctions?.total_bought?.mythic || + 0 + }, + sold: { + uncommon: data?.auctions?.total_sold?.uncommon || 0, + common: data?.auctions?.total_sold?.common || 0, + rare: data?.auctions?.total_sold?.rare || 0, + epic: data?.auctions?.total_sold?.epic || 0, + legendary: data?.auctions?.total_sold?.legendary || 0, + special: data?.auctions?.total_sold?.special || 0, + mythic: data?.auctions?.total_sold?.mythic || 0, + total: + data?.auctions?.total_sold?.uncommon || + 0 + data?.auctions?.total_sold?.common || + 0 + data?.auctions?.total_sold?.rare || + 0 + data?.auctions?.total_sold?.epic || + 0 + data?.auctions?.total_sold?.legendary || + 0 + data?.auctions?.total_sold?.special || + 0 + data?.auctions?.total_sold?.mythic || + 0 + } + }; + this.gifts = { given: data?.gifts?.total_given || 0, received: data?.gifts?.total_received || 0 }; + this.itemsFished = { + total: data?.items_fished?.total || 0, + normal: data?.items_fished?.normal || 0, + tresure: data?.items_fished?.treasure || 0, + largeTresure: data?.items_fished?.large_treasure || 0 + }; + this.mythos = { + kills: data?.mythos?.kills || 0, + burrowsDugNext: { + total: data?.mythos?.burrows_dug_next?.total || 0, + common: data?.mythos?.burrows_dug_next?.common || 0 + }, + burrowsDugCombat: { + total: data?.mythos?.burrows_dug_combat?.total || 0, + common: data?.mythos?.burrows_dug_combat?.common || 0 + }, + burrowsDugTreasure: { + total: data?.mythos?.burrows_dug_treasure?.total || 0, + common: data?.mythos?.burrows_dug_treasure?.common || 0 + }, + burrowsDugComplate: { + total: data?.mythos?.burrows_dug_complete?.total || 0, + common: data?.mythos?.burrows_dug_complete?.common || 0 + } + }; + } } class SkyblockMemberMinion { @@ -78,7 +200,7 @@ class SkyblockMemberMinion { } } -class SkyblockMemberMinions { +export class SkyblockMemberMinions { [key: string]: SkyblockMemberMinion; constructor(data: string[]) { const parsed = this.#parse(data); @@ -110,78 +232,76 @@ class SkyblockMember { museum: SkyblockMuseum | null; profileName: string; profileId: string; - firstJoinTimestamp: number; - firstJoinAt: Date; + firstJoinTimestamp: number | null; + firstJoinAt: Date | null; experience: number; level: number; - hotm: SkyblockMemberHOTM; - trophyFish: SkyblockMemberTrophyFishRank; + hotm: HOTM; highestMagicalPower: number; fairySouls: number; fairyExchanges: number; - skills: SkyblockMemberSkills; + skills: Skills; bestiary: number; - slayer: SkyblockMemberSlayer | null; - crimsonIsle: SkyblockMemberCrimson; - dungeons: SkyblockMemberDungeons; + slayer: Slayer | null; + crimsonIsle: CrimsonIsle; + dungeons: Dungeons; collections: Record; purse: number; - stats: SkyblockMemberStats | null; + stats: MemberStats; pets: SkyblockPet[]; - jacob: SkyblockMemberJacobData; - chocolate: SkyblockMemberChocolateFactoryData; + jacob: JacobData; + chocolate: ChocolateFactoryData; minions: SkyblockMemberMinions; - getArmor: () => Promise; + getArmor: () => Promise; getWardrobe: () => Promise; getEnderChest: () => Promise; getInventory: () => Promise; getPetScore: () => number; - getEquipment: () => Promise; + getEquipment: () => Promise; getPersonalVault: () => Promise; getNetworth: () => Promise; getFarmingWeight: () => number; constructor(data: Record) { - this.uuid = data.uuid; - this.gameMode = data.gameMode; - this.selected = data.selected; - this.garden = data.garden; - this.museum = data.museum; - this.profileName = data.profileName; - this.profileId = data.profileId; - this.firstJoinTimestamp = data.m.profile?.first_join; - this.firstJoinAt = new Date(data.m.profile?.first_join); - this.experience = data.m.leveling?.experience ?? 0; + this.uuid = data?.uuid || ''; + this.gameMode = data?.gameMode || null; + this.selected = data?.selected || false; + this.garden = data?.garden || null; + this.museum = data?.museum || null; + this.profileName = data?.profileName || ''; + this.profileId = data?.profileId || ''; + this.firstJoinTimestamp = data?.m?.profile?.first_join || 0; + this.firstJoinAt = new Date(data?.m?.profile?.first_join); + this.experience = data?.m?.leveling?.experience || 0; this.level = this.experience ? this.experience / 100 : 0; this.hotm = getHOTM(data.m); - this.trophyFish = getTrophyFishRank(data.m.trophy_fish?.rewards?.length ?? 0); - this.highestMagicalPower = data.m.accessory_bag_storage?.highest_magical_power ?? 0; - this.fairySouls = data.m?.fairy_soul?.total_collected ?? 0; - this.fairyExchanges = data.m?.fairy_soul?.fairy_exchanges ?? 0; + this.highestMagicalPower = data?.m?.accessory_bag_storage?.highest_magical_power || 0; + this.fairySouls = data?.m?.fairy_soul?.total_collected || 0; + this.fairyExchanges = data?.m?.fairy_soul?.fairy_exchanges || 0; this.skills = getSkills(data.m); this.bestiary = getBestiaryLevel(data.m); this.slayer = getSlayer(data.m); this.crimsonIsle = getCrimsonIsle(data.m); this.dungeons = getDungeons(data.m); - this.collections = data.m.collection ? data.m.collection : null; - this.purse = data.m?.currencies?.coin_purse ?? 0; - this.stats = data.m.player_stats ? getMemberStats(data.m.player_stats) : null; - this.pets = data.m?.pets_data?.pets ? data.m.pets_data.pets.map((pet: any) => new SkyblockPet(pet)) : []; + this.collections = data?.m?.collection || {}; + this.purse = data?.m?.currencies?.coin_purse || 0; + this.stats = new MemberStats(data?.m?.player_stats); + this.pets = data?.m?.pets_data?.pets ? data.m.pets_data.pets.map((pet: any) => new SkyblockPet(pet)) : []; this.jacob = getJacobData(data.m); this.chocolate = getChocolateFactory(data.m); this.minions = new SkyblockMemberMinions(data.m?.player_data?.crafted_generators ?? []); this.getArmor = async () => { - const base64 = data.m.inventory.inv_armor; - const decoded = await decode(base64.data); + const base64 = data?.m?.inventory?.inv_armor; + const decoded = await decode(base64?.data); const armor = { - helmet: decoded[3].id ? new SkyblockInventoryItem(decoded[3]) : null, - chestplate: decoded[2].id ? new SkyblockInventoryItem(decoded[2]) : null, - leggings: decoded[1].id ? new SkyblockInventoryItem(decoded[1]) : null, - boots: decoded[0].id ? new SkyblockInventoryItem(decoded[0]) : null + helmet: decoded[3]?.id ? new SkyblockInventoryItem(decoded[3]) : null, + chestplate: decoded[2]?.id ? new SkyblockInventoryItem(decoded[2]) : null, + leggings: decoded[1]?.id ? new SkyblockInventoryItem(decoded[1]) : null, + boots: decoded[0]?.id ? new SkyblockInventoryItem(decoded[0]) : null }; return armor; }; this.getWardrobe = async () => { - const base64 = data.m?.inventory?.wardrobe_contents?.data; + const base64 = data?.m?.inventory?.wardrobe_contents?.data; if (!base64) return []; const decoded = await decode(base64); const armor = decoded @@ -190,15 +310,13 @@ class SkyblockMember { return armor; }; this.getEnderChest = async () => { - let chest = data.m.inventory.ender_chest_contents; + let chest = data?.m?.inventory?.ender_chest_contents; if (!chest) return []; try { - chest = await decode(chest.data); + chest = await decode(chest?.data); const edited = []; for (let i = 0; i < chest.length; i++) { - if (!chest[i].id) { - continue; - } + if (!chest[i]?.id) continue; edited.push(new SkyblockInventoryItem(chest[i])); } return edited; @@ -207,15 +325,13 @@ class SkyblockMember { } }; this.getInventory = async () => { - let inventory = data.m.inventory.inv_contents; + let inventory = data?.m?.inventory?.inv_contents; if (!inventory) return []; try { - inventory = await decode(inventory.data); + inventory = await decode(inventory?.data); const edited = []; for (let i = 0; i < inventory.length; i++) { - if (!inventory[i].id) { - continue; - } + if (!inventory[i]?.id) continue; edited.push(new SkyblockInventoryItem(inventory[i])); } return edited; @@ -225,23 +341,23 @@ class SkyblockMember { }; this.getPetScore = () => { const highestRarity: { [key: string]: any } = {}; - for (const pet of data.m.pets_data.pets) { + for (const pet of data?.m?.pets_data?.pets) { if ( - !(pet.type in highestRarity) || - (Constants.petScore as { [key: number]: number })[pet.tier] > highestRarity[pet.type] + !(pet?.type in highestRarity) || + (Constants.petScore as { [key: number]: number })[pet?.tier] > highestRarity[pet?.type] ) { - highestRarity[pet.type] = (Constants.petScore as { [key: number]: number })[pet.tier]; + highestRarity[pet?.type] = (Constants.petScore as { [key: number]: number })[pet?.tier]; } } const highestLevel: { [key: string]: any } = {}; - for (const pet of data.m.pets_data.pets) { - const maxLevel = 'GOLDEN_DRAGON' === pet.type ? 200 : 100; - const petLevel = getPetLevel(pet.exp, pet.tier, maxLevel); - if (!(pet.type in highestLevel) || petLevel.level > highestLevel[pet.type]) { - if (petLevel.level < maxLevel) { + for (const pet of data?.m?.pets_data?.pets) { + const maxLevel = 'GOLDEN_DRAGON' === pet?.type ? 200 : 100; + const petLevel = getPetLevel(pet?.exp, pet?.tier, maxLevel); + if (!(pet?.type in highestLevel) || petLevel?.level > highestLevel[pet?.type]) { + if (petLevel?.level < maxLevel) { continue; } - highestLevel[pet.type] = 1; + highestLevel[pet?.type] = 1; } } return ( @@ -249,17 +365,17 @@ class SkyblockMember { ); }; this.getEquipment = async () => { - let equipment = data.m.inventory.equipment_contents; + let equipment = data?.m?.inventory?.equipment_contents; if (!equipment) { return { gauntlet: null, belt: null, cloak: null, necklace: null }; } try { - equipment = await decode(equipment.data); + equipment = await decode(equipment?.data); const playerEquipment = { - gauntlet: equipment[3].id ? new SkyblockInventoryItem(equipment[3]) : null, - belt: equipment[2].id ? new SkyblockInventoryItem(equipment[2]) : null, - cloak: equipment[1].id ? new SkyblockInventoryItem(equipment[1]) : null, - necklace: equipment[0].id ? new SkyblockInventoryItem(equipment[0]) : null + gauntlet: equipment?.[3]?.id ? new SkyblockInventoryItem(equipment[3]) : null, + belt: equipment?.[2]?.id ? new SkyblockInventoryItem(equipment[2]) : null, + cloak: equipment?.[1]?.id ? new SkyblockInventoryItem(equipment[1]) : null, + necklace: equipment?.[0]?.id ? new SkyblockInventoryItem(equipment[0]) : null }; return playerEquipment; } catch { @@ -267,15 +383,13 @@ class SkyblockMember { } }; this.getPersonalVault = async () => { - let vault = data.m.inventory.personal_vault_contents; + let vault = data?.m?.inventory?.personal_vault_contents; if (!vault) return []; try { - vault = await decode(vault.data); + vault = await decode(vault?.data); const edited = []; - for (let i = 0; i < vault.length; i++) { - if (!vault[i].id) { - continue; - } + for (let i = 0; i < vault?.length; i++) { + if (!vault[i]?.id) continue; edited.push(new SkyblockInventoryItem(vault[i])); } return edited; @@ -285,11 +399,11 @@ class SkyblockMember { }; this.getNetworth = async () => { try { - const nw = await getNetworth(data.m, data.banking?.balance ?? 0, { + const nw = await getNetworth(data?.m, data?.banking?.balance ?? 0, { onlyNetworth: true, v2Endpoint: true, cache: true, - museumData: data.museum?.raw ?? {} + museumData: data?.museum?.raw ?? {} }); return nw; } catch { @@ -303,9 +417,9 @@ class SkyblockMember { farmingXp: this.skills.farming.xp, levelCapUpgrade: this.jacob.perks.farmingLevelCap, anitaBonusFarmingFortuneLevel: this.jacob.perks.doubleDrops, - minions: data.m.player_data.crafted_generators, + minions: data?.m?.player_data?.crafted_generators, contests: Object.values(this.jacob.contests), - pests: data.m.bestiary.kills + pests: data?.m?.bestiary?.kills }).getWeightInfo().totalWeight; } catch { return 0; diff --git a/src/structures/SkyBlock/SkyblockMemberTypes.d.ts b/src/structures/SkyBlock/SkyblockMemberTypes.d.ts new file mode 100644 index 00000000..52f3cace --- /dev/null +++ b/src/structures/SkyBlock/SkyblockMemberTypes.d.ts @@ -0,0 +1,343 @@ +import SkyblockInventoryItem from './SkyblockInventoryItem'; + +type TrophyFishRank = 'Bronze' | 'Silver' | 'Gold' | 'Diamond'; +type DungeonClass = 'healer' | 'mage' | 'berserk' | 'archer' | 'tank'; +type CrimsonIsleFactions = 'mages' | 'barbarians'; +type CrimsonIsleBelt = 'White' | 'Yellow' | 'Green' | 'Blue' | 'Brown' | 'Black'; +type CrimsonIsleDojoRank = 'S' | 'A' | 'B' | 'C' | 'D' | 'F'; + +interface Equipment { + gauntlet: SkyblockInventoryItem | null; + belt: SkyblockInventoryItem | null; + cloak: SkyblockInventoryItem | null; + necklace: SkyblockInventoryItem | null; +} + +interface Armor { + helmet: SkyblockInventoryItem | null; + chestplate: SkyblockInventoryItem | null; + leggings: SkyblockInventoryItem | null; + boots: SkyblockInventoryItem | null; +} + +interface MemberStatsCandyCollected { + green: number; + purple: number; + total: number; +} + +interface MemberStatsFestival { + year: number; + collected: MemberStatsCandyCollected; +} + +interface MemberStatsCandy extends MemberStatsCandyCollected { + festivals: MemberStatsFestival[]; +} + +interface MemberStatsPetMilestones { + oresMinned: number; + seaCreaturesKilled: number; +} + +interface MemberStatsAuctionsStats { + uncommon: number; + common: number; + rare: number; + epic: number; + legendary: number; + special: number; + mythic: number; + total: number; +} + +interface MemberStatsAuctions { + bids: number; + highestBid: number; + goldSpent: number; + goldEarnt: number; + auctionsWon: number; + auctionsCompleted: number; + auctionsCreated: number; + auctionFees: number; + auctionsWithOutBids: number; + sold: MemberStatsAuctionsStats; + bought: MemberStatsAuctionsStats; +} + +interface MemberStatsGifts { + given: number; + received: number; +} + +interface MemberStatsFishing { + total: number; + normal: number; + tresure: number; + largeTresure: number; +} + +interface MemberStatsBurrow { + total: number; + common: number; +} + +interface MemberStatsMythos { + kills: number; + burrowsDugNext: MemberStatsBurrow; + burrowsDugCombat: MemberStatsBurrow; + burrowsDugTreasure: MemberStatsBurrow; + burrowsDugComplate: MemberStatsBurrow; +} + +type Rarity = 'COMMON' | 'UNCOMMON' | 'RARE' | 'EPIC' | 'LEGENDARY' | 'MYTHIC' | 'DIVINE' | 'SPECIAL' | 'VERY_SPECIAL'; + +interface JacobDataMedals { + gold: number; + silver: number; + bronze: number; +} + +interface JacobDataPerks { + doubleDrops: number; + farmingLevelCap: number; + personalBests: boolean; +} + +interface JacobData { + medals: JacobDataMedals; + perks: JacobDataPerks; + contests: Record; +} + +interface ChocolateFactoryDataEmployees { + bro: number; + cousin: number; + sis: number; + father: number; + grandma: number; + dog: number; + uncle: number; +} + +interface ChocolateFactoryDataChocolate { + current: number; + total: number; + sincePrestige: number; +} + +interface ChocolateFactoryDataTimeTower { + charges: number; + level: number; +} + +interface ChocolateFactoryDataUpgrades { + click: number; + multiplier: number; + rabbitRarity: number; +} + +interface ChocolateFactoryDataGoldenClick { + amount: number; + year: number; +} + +interface ChocolateFactoryData { + employees: ChocolateFactoryDataEmployees; + chocolate: ChocolateFactoryDataChocolate; + timeTower: ChocolateFactoryDataTimeTower; + upgrades: ChocolateFactoryDataUpgrades; + goldenClick: ChocolateFactoryDataGoldenClick; + barnCapacity: number; + prestige: number; +} + +interface SlayerData { + xp: number; + tier1: number; + tier2: number; + tier3: number; + tier4: number; + tier5: number; + level: number; +} + +interface Slayer { + zombie: SlayerData; + spider: SlayerData; + wolf: SlayerData; + enderman: SlayerData; + blaze: SlayerData; + vampire: SlayerData; +} +interface SkillLevel { + xp: number; + level: number; + maxLevel: number; + xpCurrent: number; + xpForNext: number; + progress: number; + cosmetic: boolean; +} + +interface Skills { + combat: SkillLevel; + farming: SkillLevel; + fishing: SkillLevel; + mining: SkillLevel; + foraging: SkillLevel; + enchanting: SkillLevel; + alchemy: SkillLevel; + carpentry: SkillLevel; + runecrafting: SkillLevel; + taming: SkillLevel; + social: SkillLevel; + average: number; +} + +interface RawDungeonRun { + timestamp: number; + score_exploration: number; + score_speed: number; + score_skill: number; + score_bonus: number; + dungeon_class: DungeonClass; + teammates: string[]; + elapsed_time: number; + damage_dealt: number; + deaths: number; + mobs_killed: number; + secrets_found: number; + damage_mitigated: number; + ally_healing: number; +} + +interface DungeonsFloorStats { + fastestRun: RawDungeonRun; + fastestSRun: RawDungeonRun; + fastestSPlusRun: RawDungeonRun; + completions: number; +} + +interface DungeonsFloors { + entrance: DungeonsFloorStats; + floor1: DungeonsFloorStats; + floor2: DungeonsFloorStats; + floor3: DungeonsFloorStats; + floor4: DungeonsFloorStats; + floor5: DungeonsFloorStats; + floor6: DungeonsFloorStats; + floor7: DungeonsFloorStats; + masterMode1: DungeonsFloorStats; + masterMode2: DungeonsFloorStats; + masterMode3: DungeonsFloorStats; + masterMode4: DungeonsFloorStats; + masterMode5: DungeonsFloorStats; + masterMode6: DungeonsFloorStats; + masterMode7: DungeonsFloorStats; +} + +interface DungeonsClasses { + healer: SkillLevel; + mage: SkillLevel; + berserk: SkillLevel; + archer: SkillLevel; + tank: SkillLevel; + selected: DungeonClass; +} + +interface DungeonsEssence { + diamond: number; + dragon: number; + spider: number; + wither: number; + undead: number; + gold: number; + ice: number; + crimson: number; +} +interface DungeonsCompletions { + catacombs: Record; + masterMode: Record; +} + +interface Dungeons { + experience: SkillLevel; + secrets: number; + completions: DungeonsCompletions; + floors: DungeonsFloors; + classes: DungeonsClasses; + essence: DungeonsEssence; +} + +interface CrimsonIsleKuudra { + none: number; + hot: number; + burning: number; + fiery: number; + highestWaveHot: number; + highestWaveFiery: number; + infernal: number; + highestWaveInfernal: number; + highestWaveBurning: number; +} + +interface CrimsonIsleReputation { + mages: number; + barbarians: number; +} + +interface CrimsonIsleTrophyFishCaught { + total: number; + bronze: number; + silver: number; + gold: number; + diamond: number; +} + +interface CrimsonIsleTrophyFish { + rank: TrophyFishRank; + caught: CrimsonIsleTrophyFishCaught; +} + +interface CrimsonIsleDojoMinigame { + points: number; + rank: CrimsonIsleDojoRank; +} + +interface CrimsonIsleDojo { + belt: CrimsonIsleBelt; + force: CrimsonIsleDojoMinigame; + stamina: CrimsonIsleDojoMinigame; + mastery: CrimsonIsleDojoMinigame; + discipline: CrimsonIsleDojoMinigame; + swiftness: CrimsonIsleDojoMinigame; + control: CrimsonIsleDojoMinigame; + tenacity: CrimsonIsleDojoMinigame; +} + +interface CrimsonIsle { + faction: CrimsonIsleFactions | null; + reputation: CrimsonIsleReputation; + trophyFish: CrimsonIsleTrophyFish; + dojo: CrimsonIsleDojo; + kuudra: CrimsonIsleKuudra; +} + +interface HOTMPowderData { + spent: number; + current: number; + total: number; +} + +interface HOTMPowder { + mithril: HOTMPowderData; + gemstone: HOTMPowderData; + glacite: HOTMPowderData; +} + +interface HOTM { + experience: SkillLevel; + ability: string; + powder: HOTMPowder; +} diff --git a/src/structures/SkyBlock/SkyblockPet.ts b/src/structures/SkyBlock/SkyblockPet.ts index e681eca3..1597ffca 100644 --- a/src/structures/SkyBlock/SkyblockPet.ts +++ b/src/structures/SkyBlock/SkyblockPet.ts @@ -1,12 +1,12 @@ import Constants from '../../utils/Constants'; -import { SkyblockRarity } from '../../utils/SkyblockUtils'; +import { Rarity } from './SkyblockMemberTypes'; class SkyblockPet { uuid: string; name: string; xp: number; active: boolean; - rarity: SkyblockRarity; + rarity: Rarity; petScore: number; heldItem: string | null; candyUsed: number; @@ -17,11 +17,12 @@ class SkyblockPet { this.xp = data.exp || 0; this.active = Boolean(data.active); this.rarity = data.tier; - this.petScore = (Constants.petScore as { [key: number]: number })[data.tier] || 0; + this.petScore = (Constants.petScore as { [key: string]: number })[this.rarity] || 0; this.heldItem = data.heldItem ? data.heldItem.replace(/^PET_ITEM_/, '') : null; this.candyUsed = data.candyUsed || 0; this.skin = data.skin; } + toString(): string { return this.name; } diff --git a/src/structures/SkyBlock/Static/FireSale.ts b/src/structures/SkyBlock/Static/FireSale.ts index 8393b56d..acf47488 100644 --- a/src/structures/SkyBlock/Static/FireSale.ts +++ b/src/structures/SkyBlock/Static/FireSale.ts @@ -1,5 +1,5 @@ class FireSale { - itemId: string | null; + itemId: string; startTimestamp: number; startAt: Date; endTimestamp: number; @@ -7,16 +7,16 @@ class FireSale { amount: number; price: number; constructor(data: Record) { - this.itemId = data.item_id || null; + this.itemId = data.item_id; this.startTimestamp = parseInt(data.start, 10); this.startAt = new Date(this.startTimestamp); this.endTimestamp = parseInt(data.end, 10); this.endAt = new Date(this.endTimestamp); - this.amount = data.amount || 0; - this.price = data.price || 0; + this.amount = data.amount; + this.price = data.price; } - toString(): string | null { + toString(): string { return this.itemId; } } diff --git a/src/structures/Static/GameQuests.ts b/src/structures/Static/GameQuests.ts index 136482e2..3c74e2c0 100644 --- a/src/structures/Static/GameQuests.ts +++ b/src/structures/Static/GameQuests.ts @@ -6,7 +6,7 @@ class GameQuests { quests: Quest[]; constructor(name: StaticGameNames, data: Record) { this.game = name; - this.quests = (data || []).map((x: any) => new Quest(x)); + this.quests = data.map((x: any) => new Quest(x)); } } diff --git a/src/structures/Status.test.ts b/src/structures/Status.test.ts new file mode 100644 index 00000000..7d105eec --- /dev/null +++ b/src/structures/Status.test.ts @@ -0,0 +1,20 @@ +import Game from './Game'; +import Status from './Status'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('Status', () => { + const data = new Status({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(Status); + expectTypeOf(data).toEqualTypeOf(); + expect(data.online).toBeDefined(); + expectTypeOf(data.online).toEqualTypeOf(); + expect(data.game).toBeDefined(); + expectTypeOf(data.game).toEqualTypeOf(); + expect(data.mode).toBeDefined(); + expectTypeOf(data.mode).toEqualTypeOf(); + expect(data.map).toBeDefined(); + expectTypeOf(data.map).toEqualTypeOf(); + expect(data.toString()).toBeDefined(); + expectTypeOf(data.toString()).toEqualTypeOf<'Online' | 'Offline'>(); +}); diff --git a/src/structures/Status.ts b/src/structures/Status.ts index 67d283d9..230634af 100644 --- a/src/structures/Status.ts +++ b/src/structures/Status.ts @@ -6,10 +6,10 @@ class Status { mode: string | null; map: string | null; constructor(data: Record) { - this.online = data.online; + this.online = data?.online || false; this.game = data.gameType ? new Game(data.gameType) : null; - this.mode = data.mode ?? null; - this.map = data.map ?? null; + this.mode = data?.mode || null; + this.map = data?.map || null; } toString(): 'Online' | 'Offline' { diff --git a/src/structures/Watchdog/Stats.ts b/src/structures/Watchdog/Stats.ts deleted file mode 100644 index 10552e72..00000000 --- a/src/structures/Watchdog/Stats.ts +++ /dev/null @@ -1,16 +0,0 @@ -class WatchdogStats { - byWatchdogTotal: number; - byWatchdogLastMinute: number; - byWatchdogRollingDay: number; - byStaffTotal: number; - byStaffRollingDay: number; - constructor(data: Record) { - this.byWatchdogTotal = data.watchdog_total; - this.byWatchdogLastMinute = data.watchdog_lastMinute; - this.byWatchdogRollingDay = data.watchdog_rollingDaily; - this.byStaffTotal = data.staff_total; - this.byStaffRollingDay = data.staff_rollingDaily; - } -} - -export default WatchdogStats; diff --git a/src/structures/WatchdogStats.test.ts b/src/structures/WatchdogStats.test.ts new file mode 100644 index 00000000..e3ebf7cc --- /dev/null +++ b/src/structures/WatchdogStats.test.ts @@ -0,0 +1,24 @@ +import WatchdogStats from './WatchdogStats'; +import { expect, expectTypeOf, test } from 'vitest'; + +test('WatchdogStats', () => { + const data = new WatchdogStats({ stats: 'meow' }); + expect(data).toBeDefined(); + expect(data).toBeInstanceOf(WatchdogStats); + expectTypeOf(data).toEqualTypeOf(); + expect(data.byWatchdogTotal).toBeDefined(); + expect(data.byWatchdogTotal).greaterThanOrEqual(0); + expectTypeOf(data.byWatchdogTotal).toEqualTypeOf(); + expect(data.byWatchdogLastMinute).toBeDefined(); + expect(data.byWatchdogLastMinute).greaterThanOrEqual(0); + expectTypeOf(data.byWatchdogLastMinute).toEqualTypeOf(); + expect(data.byWatchdogRollingDay).toBeDefined(); + expect(data.byWatchdogRollingDay).greaterThanOrEqual(0); + expectTypeOf(data.byWatchdogRollingDay).toEqualTypeOf(); + expect(data.byStaffTotal).toBeDefined(); + expect(data.byStaffTotal).greaterThanOrEqual(0); + expectTypeOf(data.byStaffTotal).toEqualTypeOf(); + expect(data.byStaffRollingDay).toBeDefined(); + expect(data.byStaffRollingDay).greaterThanOrEqual(0); + expectTypeOf(data.byStaffRollingDay).toEqualTypeOf(); +}); diff --git a/src/structures/WatchdogStats.ts b/src/structures/WatchdogStats.ts new file mode 100644 index 00000000..0c0df19b --- /dev/null +++ b/src/structures/WatchdogStats.ts @@ -0,0 +1,16 @@ +class WatchdogStats { + byWatchdogTotal: number; + byWatchdogLastMinute: number; + byWatchdogRollingDay: number; + byStaffTotal: number; + byStaffRollingDay: number; + constructor(data: Record) { + this.byWatchdogTotal = data?.watchdog_total || 0; + this.byWatchdogLastMinute = data?.watchdog_lastMinute || 0; + this.byWatchdogRollingDay = data?.watchdog_rollingDaily || 0; + this.byStaffTotal = data?.staff_total || 0; + this.byStaffRollingDay = data?.staff_rollingDaily || 0; + } +} + +export default WatchdogStats; diff --git a/src/utils/Constants.ts b/src/utils/Constants.ts index 92d77fd1..b811dd82 100644 --- a/src/utils/Constants.ts +++ b/src/utils/Constants.ts @@ -1,17 +1,71 @@ +import { GameCode, GameID, GameString } from '../structures/Game'; + +export const games: { name: GameString; code: GameCode; id: GameID }[] = [ + { name: 'Quake Craft', code: 'QUAKECRAFT', id: 2 }, + { name: 'Walls', code: 'WALLS', id: 3 }, + { name: 'Paintball', code: 'PAINTBALL', id: 4 }, + { name: 'Blitz Survival Games', code: 'SURVIVAL_GAMES', id: 5 }, + { name: 'The TNT Games', code: 'TNTGAMES', id: 6 }, + { name: 'VampireZ', code: 'VAMPIREZ', id: 7 }, + { name: 'Mega Walls', code: 'WALLS3', id: 13 }, + { name: 'Arcade', code: 'ARCADE', id: 14 }, + { name: 'Arena Brawl', code: 'ARENA', id: 17 }, + { name: 'UHC Champions', code: 'UHC', id: 20 }, + { name: 'Cops and Crims', code: 'MCGO', id: 21 }, + { name: 'Warlords', code: 'BATTLEGROUND', id: 23 }, + { name: 'Smash Heroes', code: 'SUPER_SMASH', id: 24 }, + { name: 'Turbo Kart Racers', code: 'GINGERBREAD', id: 25 }, + { name: 'Housing', code: 'HOUSING', id: 26 }, + { name: 'SkyWars', code: 'SKYWARS', id: 51 }, + { name: 'Crazy Walls', code: 'TRUE_COMBAT', id: 52 }, + { name: 'Speed UHC', code: 'SPEED_UHC', id: 54 }, + { name: 'SkyClash', code: 'SKYCLASH', id: 55 }, + { name: 'Classic Games', code: 'LEGACY', id: 56 }, + { name: 'Prototype', code: 'PROTOTYPE', id: 57 }, + { name: 'Bed Wars', code: 'BEDWARS', id: 58 }, + { name: 'Murder Mystery', code: 'MURDER_MYSTERY', id: 59 }, + { name: 'Build Battle', code: 'BUILD_BATTLE', id: 60 }, + { name: 'Duels', code: 'DUELS', id: 61 }, + { name: 'SkyBlock', code: 'SKYBLOCK', id: 63 }, + { name: 'The Pit', code: 'PIT', id: 64 }, + { name: 'Replay', code: 'REPLAY', id: 65 }, + { name: 'SMP', code: 'SMP', id: 67 }, + { name: 'Wool Wars', code: 'WOOL_GAMES', id: 68 }, + { name: 'Limbo', code: 'LIMBO', id: -2 }, + { name: 'Queue', code: 'QUEUE', id: -3 }, + { name: 'Main Lobby', code: 'MAIN_LOBBY', id: -4 }, + { name: 'Tournament Lobby', code: 'TOURNAMENT_LOBBY', id: -5 }, + { name: 'Idle', code: 'IDLE', id: -6 } +]; + +export type DuelsBaseDivision = + | 'Rookie' + | 'Iron' + | 'Gold' + | 'Diamond' + | 'Master' + | 'Legend' + | 'Grandmaster' + | 'Godlike' + | 'Celestial' + | 'Divine' + | 'Ascended'; + +export const duelsDivisions: { name: DuelsBaseDivision; key: string }[] = [ + { name: 'Rookie', key: 'rookie' }, + { name: 'Iron', key: 'iron' }, + { name: 'Gold', key: 'gold' }, + { name: 'Diamond', key: 'diamond' }, + { name: 'Master', key: 'master' }, + { name: 'Legend', key: 'legend' }, + { name: 'Grandmaster', key: 'grandmaster' }, + { name: 'Godlike', key: 'godlike' }, + { name: 'Celestial', key: 'celestial' }, + { name: 'Divine', key: 'divine' }, + { name: 'Ascended', key: 'ascended' } +]; + export default { - duelsDivisions: [ - { name: 'Rookie', key: 'rookie' }, - { name: 'Iron', key: 'iron' }, - { name: 'Gold', key: 'gold' }, - { name: 'Diamond', key: 'diamond' }, - { name: 'Master', key: 'master' }, - { name: 'Legend', key: 'legend' }, - { name: 'Grandmaster', key: 'grandmaster' }, - { name: 'Godlike', key: 'godlike' }, - { name: 'Celestial', key: 'celestial' }, - { name: 'Divine', key: 'divine' }, - { name: 'Ascended', key: 'ascended' } - ], levelingXp: { 1: 50, 2: 125, @@ -714,31 +768,6 @@ export default { 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700, 1886700 ], - leaderboardNames: { - ARENA: 'ARENA', - COPS_AND_CRIMS: 'MCGO', - WARLORDS: 'BATTLEGROUND', - BLITZ_SURVIVAL_GAMES: 'SURVIVAL_GAMES', - UHC: 'UHC', - WALLS: 'WALLS', - PROTOTYPE: 'PROTOTYPE', - PAINTBALL: 'PAINTBALL', - SKYWARS: 'SKYWARS', - MURDER_MYSTERY: 'MURDER_MYSTERY', - SMASH_HEROES: 'SUPER_SMASH', - DUELS: 'DUELS', - SPEED_UHC: 'SPEED_UHC', - TNTGAMES: 'TNTGAMES', - BEDWARS: 'BEDWARS', - TURBO_KART_RACERS: 'GINGERBREAD', - BUILD_BATTLE: 'BUILD_BATTLE', - ARCADE: 'ARCADE', - SKYCLASH: 'SKYCLASH', - QUAKECRAFT: 'QUAKECRAFT', - CRAZY_WALLS: 'TRUE_COMBAT', - MEGA_WALLS: 'WALLS3', - VAMPIREZ: 'VAMPIREZ' - }, MiniGamesString: { QUAKECRAFT: 'Quakecraft', WALLS: 'Walls', @@ -802,44 +831,8 @@ export default { mythic_prestige: 'ಠ_ಠ', favor_of_the_angel_prestige: '⚔' }, - games: [ - { name: 'Quake Craft', code: 'QUAKECRAFT', id: 2 }, - { name: 'Walls', code: 'WALLS', id: 3 }, - { name: 'Paintball', code: 'PAINTBALL', id: 4 }, - { name: 'Blitz Survival Games', code: 'SURVIVAL_GAMES', id: 5 }, - { name: 'The TNT Games', code: 'TNTGAMES', id: 6 }, - { name: 'VampireZ', code: 'VAMPIREZ', id: 7 }, - { name: 'Mega Walls', code: 'WALLS3', id: 13 }, - { name: 'Arcade', code: 'ARCADE', id: 14 }, - { name: 'Arena Brawl', code: 'ARENA', id: 17 }, - { name: 'UHC Champions', code: 'UHC', id: 20 }, - { name: 'Cops and Crims', code: 'MCGO', id: 21 }, - { name: 'Warlords', code: 'BATTLEGROUND', id: 23 }, - { name: 'Smash Heroes', code: 'SUPER_SMASH', id: 24 }, - { name: 'Turbo Kart Racers', code: 'GINGERBREAD', id: 25 }, - { name: 'Housing', code: 'HOUSING', id: 26 }, - { name: 'SkyWars', code: 'SKYWARS', id: 51 }, - { name: 'Crazy Walls', code: 'TRUE_COMBAT', id: 52 }, - { name: 'Speed UHC', code: 'SPEED_UHC', id: 54 }, - { name: 'SkyClash', code: 'SKYCLASH', id: 55 }, - { name: 'Classic Games', code: 'LEGACY', id: 56 }, - { name: 'Prototype', code: 'PROTOTYPE', id: 57 }, - { name: 'Bed Wars', code: 'BEDWARS', id: 58 }, - { name: 'Murder Mystery', code: 'MURDER_MYSTERY', id: 59 }, - { name: 'Build Battle', code: 'BUILD_BATTLE', id: 60 }, - { name: 'Duels', code: 'DUELS', id: 61 }, - { name: 'SkyBlock', code: 'SKYBLOCK', id: 63 }, - { name: 'The Pit', code: 'PIT', id: 64 }, - { name: 'Replay', code: 'REPLAY', id: 65 }, - { name: 'SMP', code: 'SMP', id: 67 }, - { name: 'Wool Wars', code: 'WOOL_GAMES', id: 68 }, - { name: 'Limbo', code: 'LIMBO', id: -2 }, - { name: 'Queue', code: 'QUEUE', id: -3 }, - { name: 'Main Lobby', code: 'MAIN_LOBBY', id: -4 }, - { name: 'Tournament Lobby', code: 'TOURNAMENT_LOBBY', id: -5 }, - { name: 'Idle', code: 'IDLE', id: -6 } - ], - /* eslint-disable camelcase */ bestiary: { + /* eslint-disable camelcase */ + bestiary: { dynamic: { name: 'Private Island', mobs: [ diff --git a/src/utils/Player.test.ts b/src/utils/Player.test.ts new file mode 100644 index 00000000..206ad37a --- /dev/null +++ b/src/utils/Player.test.ts @@ -0,0 +1,100 @@ +/* eslint-disable camelcase */ +import { describe, expect, test } from 'vitest'; +import { + getPlayerLevel, + getRank, + getSocialMedia, + levelToXP, + parseClaimedRewards, + playerLevelProgress, + xpToNextLevel +} from '../utils/Player'; + +test('getRank', () => { + expect(getRank({ prefix: '[EVENTS]' })).toBe('Events'); + expect(getRank({ prefix: '[MOJANG]' })).toBe('Mojang'); + expect(getRank({ prefix: '[PIG+++]' })).toBe('PIG+++'); + expect(getRank({ prefix: '[INNIT]' })).toBe('Innit'); + expect(getRank({ prefix: '[meow]' })).toBe('Default'); + + expect(getRank({ rank: 'ADMIN' })).toBe('Admin'); + expect(getRank({ rank: 'GAME_MASTER' })).toBe('Game Master'); + expect(getRank({ rank: 'Meow' })).toBe('Default'); + + expect(getRank({ newPackageRank: 'MVP_PLUS', monthlyPackageRank: 'SUPERSTAR' })).toBe('MVP++'); + expect(getRank({ newPackageRank: 'MVP_PLUS', monthlyPackageRank: 'Meow' })).toBe('MVP+'); + expect(getRank({ newPackageRank: 'MVP' })).toBe('MVP'); + expect(getRank({ newPackageRank: 'VIP_PLUS' })).toBe('VIP+'); + expect(getRank({ newPackageRank: 'VIP' })).toBe('VIP'); + expect(getRank({ newPackageRank: 'meow' })).toBe('Default'); +}); + +test('getPlayerLevel', () => { + describe('should calculate the player level correctly', () => { + const exp = 10000; + expect(getPlayerLevel(exp)).toBe(1); + }); +}); + +test('xpToNextLevel', () => { + describe('should calculate the XP required for the next level correctly', () => { + const xp = 10000; + expect(xpToNextLevel(xp)).toBe(25000); + }); + + describe('should return 10000 if the XP is less than 10000', () => { + const xp = 5000; + expect(xpToNextLevel(xp)).toBe(10000); + }); +}); + +test('levelToXP', () => { + describe('should calculate the XP required for a given level correctly', () => { + const level = 2; + expect(levelToXP(level)).toBe(20000); + }); +}); + +test('playerLevelProgress', () => { + describe('should calculate the player level progress correctly', () => { + const xp = 15000; + const expectedProgress = { + xpToNext: 37500, + remainingXP: 22500, + currentXP: 12500, + percent: 33.33, + percentRemaining: 66.67 + }; + expect(playerLevelProgress(xp)).toEqual(expectedProgress); + }); +}); + +test('getSocialMedia', () => { + describe('should return the formatted social media links', () => { + const data = { + links: { + TWITTER: 'https://twitter.com/example', + YOUTUBE: 'https://youtube.com/example', + INSTAGRAM: 'https://instagram.com/example' + } + }; + const expectedSocialMedia = [ + { name: 'Twitter', link: 'https://twitter.com/example', id: 'TWITTER' }, + { name: 'YouTube', link: 'https://youtube.com/example', id: 'YOUTUBE' }, + { name: 'Instagram', link: 'https://instagram.com/example', id: 'INSTAGRAM' } + ]; + expect(getSocialMedia(data)).toEqual(expectedSocialMedia); + }); +}); + +test('parseClaimedRewards', () => { + describe('should parse the claimed rewards correctly', () => { + const data = { + levelingReward_1: true, + levelingReward_3: true, + levelingReward_5: true + }; + const expectedRewards = [1, 3, 5]; + expect(parseClaimedRewards(data)).toEqual(expectedRewards); + }); +}); diff --git a/src/utils/Player.ts b/src/utils/Player.ts index 46ab1ec5..eb365170 100644 --- a/src/utils/Player.ts +++ b/src/utils/Player.ts @@ -75,7 +75,7 @@ export function playerLevelProgress(xp: number): LevelProgress { } export function getSocialMedia(data: Record): PlayerSocialMedia[] { - const links = data.links; + const links = data?.links || {}; const formattedNames = ['Twitter', 'YouTube', 'Instagram', 'Twitch', 'Hypixel', 'Discord']; const upperNames = ['TWITTER', 'YOUTUBE', 'INSTAGRAM', 'TWITCH', 'HYPIXEL', 'DISCORD']; return Object.keys(links) diff --git a/src/utils/SkyblockUtils.ts b/src/utils/SkyblockUtils.ts index 21e2d660..530e0af0 100644 --- a/src/utils/SkyblockUtils.ts +++ b/src/utils/SkyblockUtils.ts @@ -1,204 +1,22 @@ import Constants from './Constants'; +import { + ChocolateFactoryData, + CrimsonIsle, + CrimsonIsleBelt, + CrimsonIsleDojoRank, + Dungeons, + HOTM, + JacobData, + Rarity, + RawDungeonRun, + SkillLevel, + Skills, + Slayer, + SlayerData, + TrophyFishRank +} from '../structures/SkyBlock/SkyblockMemberTypes'; import { parse, simplify } from 'prismarine-nbt'; -export type SkyblockRarity = - | 'COMMON' - | 'UNCOMMON' - | 'RARE' - | 'EPIC' - | 'LEGENDARY' - | 'MYTHIC' - | 'DIVINE' - | 'SPECIAL' - | 'VERY_SPECIAL'; - -export interface SkyblockMemberJacobDataMedals { - gold: number; - silver: number; - bronze: number; -} - -export interface SkyblockMemberJacobDataPerks { - doubleDrops: number; - farmingLevelCap: number; - personalBests: boolean; -} - -export interface SkyblockMemberJacobData { - medals: SkyblockMemberJacobDataMedals; - perks: SkyblockMemberJacobDataPerks; - contests: Record; -} - -export interface SkyblockMemberChocolateFactoryDataEmployees { - bro: number; - cousin: number; - sis: number; - father: number; - grandma: number; - dog: number; - uncle: number; -} - -export interface SkyblockMemberChocolateFactoryDataChocolate { - current: number; - total: number; - sincePrestige: number; -} - -export interface SkyblockMemberChocolateFactoryDataTimeTower { - charges: number; - level: number; -} - -export interface SkyblockMemberChocolateFactoryDataUpgrades { - click: number; - multiplier: number; - rabbitRarity: number; -} - -export interface SkyblockMemberChocolateFactoryDataGoldenClick { - amount: number; - year: number; -} - -export interface SkyblockMemberChocolateFactoryData { - employees: SkyblockMemberChocolateFactoryDataEmployees; - chocolate: SkyblockMemberChocolateFactoryDataChocolate; - timeTower: SkyblockMemberChocolateFactoryDataTimeTower; - upgrades: SkyblockMemberChocolateFactoryDataUpgrades; - goldenClick: SkyblockMemberChocolateFactoryDataGoldenClick; - barnCapacity: number; - prestige: number; -} - -export interface SkyblockMemberSlayerLevel { - xp: number; - tier1: number; - tier2: number; - tier3: number; - tier4: number; - tier5: number; - level: number; -} - -export interface SkyblockMemberSlayer { - zombie: SkyblockMemberSlayerLevel; - spider: SkyblockMemberSlayerLevel; - wolf: SkyblockMemberSlayerLevel; - enderman: SkyblockMemberSlayerLevel; - blaze: SkyblockMemberSlayerLevel; - vampire: SkyblockMemberSlayerLevel; -} -export type SkyblockMemberTrophyFishRank = 'Bronze' | 'Silver' | 'Gold' | 'Diamond'; -export interface SkyblockSkillLevel { - xp: number; - level: number; - maxLevel: number; - xpCurrent: number; - xpForNext: number; - progress: number; - cosmetic: boolean; -} - -export interface SkyblockMemberStats { - kills: Record; - deaths: Record; -} - -export interface SkyblockMemberSkills { - combat: SkyblockSkillLevel; - farming: SkyblockSkillLevel; - fishing: SkyblockSkillLevel; - mining: SkyblockSkillLevel; - foraging: SkyblockSkillLevel; - enchanting: SkyblockSkillLevel; - alchemy: SkyblockSkillLevel; - carpentry: SkyblockSkillLevel; - runecrafting: SkyblockSkillLevel; - taming: SkyblockSkillLevel; - social: SkyblockSkillLevel; - average: number; -} - -export interface SkyblockMemberDungeonsCompletions { - catacombs: Record; - masterMode: Record; -} - -export type SkyblockDungeonClass = 'healer' | 'mage' | 'berserk' | 'archer' | 'tank'; - -export interface RawSkyblockDungeonRun { - timestamp: number; - score_exploration: number; - score_speed: number; - score_skill: number; - score_bonus: number; - dungeon_class: SkyblockDungeonClass; - teammates: string[]; - elapsed_time: number; - damage_dealt: number; - deaths: number; - mobs_killed: number; - secrets_found: number; - damage_mitigated: number; - ally_healing: number; -} - -export interface DungeonsFloorStats { - fastestRun: RawSkyblockDungeonRun; - fastestSRun: RawSkyblockDungeonRun; - fastestSPlusRun: RawSkyblockDungeonRun; - completions: number; -} - -export interface SkyblockMemberDungeonsFloors { - entrance: DungeonsFloorStats; - floor1: DungeonsFloorStats; - floor2: DungeonsFloorStats; - floor3: DungeonsFloorStats; - floor4: DungeonsFloorStats; - floor5: DungeonsFloorStats; - floor6: DungeonsFloorStats; - floor7: DungeonsFloorStats; - masterMode1: DungeonsFloorStats; - masterMode2: DungeonsFloorStats; - masterMode3: DungeonsFloorStats; - masterMode4: DungeonsFloorStats; - masterMode5: DungeonsFloorStats; - masterMode6: DungeonsFloorStats; - masterMode7: DungeonsFloorStats; -} - -export interface SkyblockMemberDungeonsClasses { - healer: SkyblockSkillLevel; - mage: SkyblockSkillLevel; - berserk: SkyblockSkillLevel; - archer: SkyblockSkillLevel; - tank: SkyblockSkillLevel; - selected: SkyblockDungeonClass; -} - -export interface SkyblockMemberDungeonsEssence { - diamond: number; - dragon: number; - spider: number; - wither: number; - undead: number; - gold: number; - ice: number; - crimson: number; -} - -export interface SkyblockMemberDungeons { - experience: SkyblockSkillLevel; - secrets: number; - completions: SkyblockMemberDungeonsCompletions; - floors: SkyblockMemberDungeonsFloors; - classes: SkyblockMemberDungeonsClasses; - essence: SkyblockMemberDungeonsEssence; -} - export async function decode(base64: any, isBuffer: boolean = false): Promise { // Credit: https://github.com/SkyCryptWebsite/SkyCryptv2/blob/3b5b3ae4fe77c60eff90691797f09024baf68872/src/lib/server/stats/items/processing.ts#L215-L218 const buffer = isBuffer ? base64 : Buffer.from(base64, 'base64'); @@ -211,7 +29,7 @@ export async function decode(base64: any, isBuffer: boolean = false): Promise; switch (type) { case 'runecrafting': @@ -301,7 +119,7 @@ export function getLevelByXp(xp: number, type: string): SkyblockSkillLevel { }; } -export function getSlayerLevel(slayer: Record): SkyblockMemberSlayerLevel { +export function getSlayerLevel(slayer: Record): SlayerData { if (!slayer) { return { xp: 0, tier1: 0, tier2: 0, tier3: 0, tier4: 0, tier5: 0, level: 0 }; } @@ -328,28 +146,7 @@ export function getSlayerLevel(slayer: Record): SkyblockMemberSlaye }; } -export function getMemberStats(obj: Record): SkyblockMemberStats { - return Object.keys(obj).reduce( - (result, currentKey) => { - const key = currentKey.replace(/_[a-z]/gi, (match) => match[1].toUpperCase()); - if (currentKey.startsWith('kills') || currentKey.startsWith('deaths')) { - const category = currentKey.startsWith('kills') ? 'kills' : 'deaths'; - const subKey = key === category ? 'total' : key; - result[category as keyof typeof result][ - subKey.replace(category, (sub, _, key) => { - return key[sub.length].toLowerCase() + key.slice(sub.length + 1); - }) - ] = obj[currentKey]; - } else { - result[key as keyof typeof result] = obj[currentKey]; - } - return result; - }, - { kills: {}, deaths: {} } as { kills: Record; deaths: Record } - ); -} - -export function getTrophyFishRank(level: number): SkyblockMemberTrophyFishRank { +export function getTrophyFishRank(level: number): TrophyFishRank { if (1 === level) { return 'Bronze'; } else if (2 === level) { @@ -362,8 +159,8 @@ export function getTrophyFishRank(level: number): SkyblockMemberTrophyFishRank { return 'Bronze'; } -export function getSkills(data: Record): SkyblockMemberSkills { - const skillsObject: SkyblockMemberSkills = { +export function getSkills(data: Record): Skills { + const skillsObject: Skills = { combat: getLevelByXp(data?.player_data?.experience?.SKILL_COMBAT ?? 0, 'combat'), farming: getLevelByXp(data?.player_data?.experience?.SKILL_FARMING ?? 0, 'farming'), fishing: getLevelByXp(data?.player_data?.experience?.SKILL_FISHING ?? 0, 'fishing'), @@ -399,32 +196,28 @@ function formatBestiaryMobs(userProfile: Record, mobs: any) { } export function getBestiaryLevel(userProfile: Record): number { - try { - if (userProfile.bestiary?.kills === undefined) { - return 0; - } - const output: { [key: string]: any } = {}; - let tiersUnlocked = 0; - for (const [category, data] of Object.entries(Constants.bestiary)) { - const { mobs } = data as { mobs: any }; - output[category] = {}; - if ('fishing' === category) { - for (const [key, value] of Object.entries(data)) { - output[category][key] = { mobs: formatBestiaryMobs(userProfile, value.mobs) }; - tiersUnlocked += output[category][key].mobs.reduce((acc: any, cur: any) => acc + cur.tier, 0); - } - } else { - output[category].mobs = formatBestiaryMobs(userProfile, mobs); - tiersUnlocked += output[category].mobs.reduce((acc: any, cur: any) => acc + cur.tier, 0); + if (userProfile?.bestiary?.kills === undefined) { + return 0; + } + const output: { [key: string]: any } = {}; + let tiersUnlocked = 0; + for (const [category, data] of Object.entries(Constants.bestiary)) { + const { mobs } = data as { mobs: any }; + output[category] = {}; + if ('fishing' === category) { + for (const [key, value] of Object.entries(data)) { + output[category][key] = { mobs: formatBestiaryMobs(userProfile, value.mobs) }; + tiersUnlocked += output[category][key].mobs.reduce((acc: any, cur: any) => acc + cur.tier, 0); } + } else { + output[category].mobs = formatBestiaryMobs(userProfile, mobs); + tiersUnlocked += output[category].mobs.reduce((acc: any, cur: any) => acc + cur.tier, 0); } - return tiersUnlocked / 10; - } catch { - return 0; } + return tiersUnlocked / 10; } -export function getSlayer(data: Record): SkyblockMemberSlayer | null { +export function getSlayer(data: Record): Slayer | null { if (!data?.slayer?.slayer_bosses) return null; return { zombie: getSlayerLevel(data?.slayer?.slayer_bosses?.zombie), @@ -453,25 +246,23 @@ function getDungeonsFloor( ) { return { fastestRun: (data?.dungeons?.dungeon_types?.[type]?.best_runs?.[floor] || [])?.sort( - (a: RawSkyblockDungeonRun, b: RawSkyblockDungeonRun) => a?.elapsed_time - b?.elapsed_time + (a: RawDungeonRun, b: RawDungeonRun) => a?.elapsed_time - b?.elapsed_time )[0], fastestSRun: (data?.dungeons?.dungeon_types?.[type]?.best_runs?.[floor] || []) ?.filter( - (run: RawSkyblockDungeonRun) => - 270 >= run?.score_exploration + run?.score_speed + run?.score_skill + run?.score_bonus + (run: RawDungeonRun) => 270 >= run?.score_exploration + run?.score_speed + run?.score_skill + run?.score_bonus ) - ?.sort((a: RawSkyblockDungeonRun, b: RawSkyblockDungeonRun) => a?.elapsed_time - b?.elapsed_time)[0], + ?.sort((a: RawDungeonRun, b: RawDungeonRun) => a?.elapsed_time - b?.elapsed_time)[0], fastestSPlusRun: (data?.dungeons?.dungeon_type?.s[type]?.best_runs?.[floor] || []) ?.filter( - (run: RawSkyblockDungeonRun) => - 300 >= run?.score_exploration + run?.score_speed + run?.score_skill + run?.score_bonus + (run: RawDungeonRun) => 300 >= run?.score_exploration + run?.score_speed + run?.score_skill + run?.score_bonus ) - ?.sort((a: RawSkyblockDungeonRun, b: RawSkyblockDungeonRun) => a?.elapsed_time - b?.elapsed_time)[0], + ?.sort((a: RawDungeonRun, b: RawDungeonRun) => a?.elapsed_time - b?.elapsed_time)[0], completions: data?.dungeonXp?.dungeon_types?.[type]?.tier_completions?.[floor] || 0 }; } -export function getDungeons(data: Record): SkyblockMemberDungeons { +export function getDungeons(data: Record): Dungeons { return { experience: getLevelByXp(data?.dungeons?.dungeon_types?.catacombs?.experience || 0, 'dungeons'), secrets: data?.dungeons?.secrets || 0, @@ -517,34 +308,23 @@ export function getDungeons(data: Record): SkyblockMemberDungeons { }; } -export function getJacobData(data: Record): SkyblockMemberJacobData { - if (!data.jacobs_contest) { - return { - medals: { bronze: 0, silver: 0, gold: 0 }, - perks: { doubleDrops: 0, farmingLevelCap: 0, personalBests: false }, - contests: {} - }; - } +export function getJacobData(data: Record): JacobData { return { - medals: data.jacobs_contest.medals_inv - ? { - bronze: data.jacobs_contest.medals_inv.bronze || 0, - silver: data.jacobs_contest.medals_inv.silver || 0, - gold: data.jacobs_contest.medals_inv.gold || 0 - } - : { bronze: 0, silver: 0, gold: 0 }, - perks: data.jacobs_contest.perks - ? { - doubleDrops: data.jacobs_contest.perks.double_drops || 0, - farmingLevelCap: data.jacobs_contest.perks.farming_level_cap || 0, - personalBests: data.jacobs_contest.perks.personal_bests || false - } - : { doubleDrops: 0, farmingLevelCap: 0, personalBests: false }, - contests: data.jacobs_contest.contests || {} + medals: { + bronze: data?.jacobs_contest?.medals_inv?.bronze || 0, + silver: data?.jacobs_contest?.medals_inv?.silver || 0, + gold: data?.jacobs_contest?.medals_inv?.gold || 0 + }, + perks: { + doubleDrops: data?.jacobs_contest?.perks?.double_drops || 0, + farmingLevelCap: data?.jacobs_contest?.perks?.farming_level_cap || 0, + personalBests: data?.jacobs_contest?.perks?.personal_bests || false + }, + contests: data?.jacobs_contestcontests || {} }; } -export function getChocolateFactory(data: Record): SkyblockMemberChocolateFactoryData { +export function getChocolateFactory(data: Record): ChocolateFactoryData { if (!data?.events?.easter) { return { employees: { bro: 0, cousin: 0, sis: 0, father: 0, grandma: 0, dog: 0, uncle: 0 }, @@ -619,7 +399,7 @@ export function getPetLevel(petExp: number, offsetRarity: number, maxLevel: numb return { level, xpCurrent, xpForNext, progress, xpMaxLevel }; } -export function parseRarity(str: string): SkyblockRarity { +export function parseRarity(str: string): Rarity { const rarityArray = [ 'COMMON', 'UNCOMMON', @@ -632,7 +412,7 @@ export function parseRarity(str: string): SkyblockRarity { 'VERY SPECIAL' ]; for (const rarity of rarityArray) { - if (str.includes(rarity)) return rarity as SkyblockRarity; + if (str.includes(rarity)) return rarity as Rarity; } return 'COMMON'; } @@ -644,58 +424,7 @@ export function parseGearScore(lore: any): number { return 0; } -export interface SkyblockMemberCrimsonKuudra { - none: number; - hot: number; - burning: number; - fiery: number; - highestWaveHot: number; - highestWaveFiery: number; - infernal: number; - highestWaveInfernal: number; - highestWaveBurning: number; -} -export interface SkyblockMemberCrimsonReputation { - mages: number; - barbarians: number; -} -export interface SkyblockMemberCrimsonTrophyFishCaught { - total: number; - bronze: number; - silver: number; - gold: number; - diamond: number; -} -export interface SkyblockMemberCrimsonTrophyFish { - rank: SkyblockMemberTrophyFishRank; - caught: SkyblockMemberCrimsonTrophyFishCaught; -} -export type CrimsonIsleDojoRank = 'S' | 'A' | 'B' | 'C' | 'D' | 'F'; -export type CrimsonIsleBelt = 'White' | 'Yellow' | 'Green' | 'Blue' | 'Brown' | 'Black'; - -export interface SkyblockMemberCrimsonDojoMinigame { - points: number; - rank: CrimsonIsleDojoRank; -} -export interface SkyblockMemberCrimsonDojo { - belt: CrimsonIsleBelt; - force: SkyblockMemberCrimsonDojoMinigame; - stamina: SkyblockMemberCrimsonDojoMinigame; - mastery: SkyblockMemberCrimsonDojoMinigame; - discipline: SkyblockMemberCrimsonDojoMinigame; - swiftness: SkyblockMemberCrimsonDojoMinigame; - control: SkyblockMemberCrimsonDojoMinigame; - tenacity: SkyblockMemberCrimsonDojoMinigame; -} -export interface SkyblockMemberCrimson { - faction: 'mages' | 'barbarians' | null; - reputation: SkyblockMemberCrimsonReputation; - trophyFish: SkyblockMemberCrimsonTrophyFish; - dojo: SkyblockMemberCrimsonDojo; - kuudra: SkyblockMemberCrimsonKuudra; -} - -function getScore(points: number) { +function getScore(points: number): CrimsonIsleDojoRank { if (1000 <= points) { return 'S'; } else if (800 <= points) { @@ -710,7 +439,7 @@ function getScore(points: number) { return 'F'; } -function getBelt(points: number) { +function getBelt(points: number): CrimsonIsleBelt { if (7000 <= points) { return 'Black'; } else if (6000 <= points) { @@ -725,7 +454,7 @@ function getBelt(points: number) { return 'White'; } -export function getCrimsonIsle(data: Record): SkyblockMemberCrimson { +export function getCrimsonIsle(data: Record): CrimsonIsle { return { faction: data?.nether_island_player_data?.selected_faction || null, reputation: { @@ -799,28 +528,10 @@ export function getCrimsonIsle(data: Record): SkyblockMemberCrimson }; } -export interface SkyblockMemberHOTMPowderData { - spent: number; - current: number; - total: number; -} - -export interface SkyblockMemberHOTMPowder { - mithril: SkyblockMemberHOTMPowderData; - gemstone: SkyblockMemberHOTMPowderData; - glacite: SkyblockMemberHOTMPowderData; -} - -export interface SkyblockMemberHOTM { - experience: SkyblockSkillLevel; - ability: string; - powder: SkyblockMemberHOTMPowder; -} - -export function getHOTM(data: Record): SkyblockMemberHOTM { +export function getHOTM(data: Record): HOTM { return { - experience: getLevelByXp(data.mining_core?.experience, 'hotm'), - ability: data.mining_core?.selected_pickaxe_ability || 'none', + experience: getLevelByXp(data?.mining_core?.experience || 0, 'hotm'), + ability: data?.mining_core?.selected_pickaxe_ability || 'none', powder: { mithril: { spent: data?.mining_core?.powder_spent_mithril || 0, diff --git a/src/utils/oscillation.test.ts b/src/utils/oscillation.test.ts new file mode 100644 index 00000000..113db1e7 --- /dev/null +++ b/src/utils/oscillation.test.ts @@ -0,0 +1,18 @@ +import { expect, test } from 'vitest'; +import { monthAB } from './oscillation'; + +test('oscillation', () => { + expect(monthAB(0)).toBe('b'); + expect(monthAB(1)).toBe('a'); + expect(monthAB(2)).toBe('b'); + expect(monthAB(3)).toBe('a'); + expect(monthAB(4)).toBe('b'); + expect(monthAB(5)).toBe('a'); + expect(monthAB(6)).toBe('b'); + expect(monthAB(7)).toBe('a'); + expect(monthAB(8)).toBe('b'); + expect(monthAB(9)).toBe('a'); + expect(monthAB(10)).toBe('b'); + expect(monthAB(11)).toBe('a'); + expect(monthAB(12)).toBe('b'); +}); diff --git a/src/utils/oscillation.ts b/src/utils/oscillation.ts index b6f4028f..d654ffb9 100644 --- a/src/utils/oscillation.ts +++ b/src/utils/oscillation.ts @@ -2,8 +2,11 @@ // Month oscillation started in December 2014, so every month that is pair ( odd in js!! ) is month A // Weekly oscillation started... just refer to the code in the docs const weeklyOscillationStart = 1417237200000; -export function monthAB() { - return new Date().getMonth() % 2 ? 'a' : 'b'; +export function monthAB(month?: number) { + if (month === undefined) { + month = new Date().getMonth(); + } + return month % 2 ? 'a' : 'b'; } export function weekAB() {