npm - hypixel-api-reborn - Versions diffs - 12.0.0-21 → 12.0.0-23 - Mend

hypixel-api-reborn 12.0.0-21 → 12.0.0-23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2210) hide show

package/dist/Structures/MiniGames/BuildBattle/BuildBattleVotes.test.js ADDED Viewed

@@ -0,0 +1,1869 @@
+import BuildBattleVotes from './BuildBattleVotes.js';
+import { expect, expectTypeOf, test } from 'vitest';
+test('BuildBattleVotes', () => {
+    const data = new BuildBattleVotes({ stats: 'meow' });
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(BuildBattleVotes);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.abandoned).toBeDefined();
+    expect(data.abandoned).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.abandoned).toEqualTypeOf();
+    expect(data.abandonedMansion).toBeDefined();
+    expect(data.abandonedMansion).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.abandonedMansion).toEqualTypeOf();
+    expect(data.adventCalendar).toBeDefined();
+    expect(data.adventCalendar).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.adventCalendar).toEqualTypeOf();
+    expect(data.airplane).toBeDefined();
+    expect(data.airplane).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.airplane).toEqualTypeOf();
+    expect(data.aladdin).toBeDefined();
+    expect(data.aladdin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.aladdin).toEqualTypeOf();
+    expect(data.alien).toBeDefined();
+    expect(data.alien).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.alien).toEqualTypeOf();
+    expect(data.alienInvasion).toBeDefined();
+    expect(data.alienInvasion).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.alienInvasion).toEqualTypeOf();
+    expect(data.anchor).toBeDefined();
+    expect(data.anchor).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.anchor).toEqualTypeOf();
+    expect(data.ancient).toBeDefined();
+    expect(data.ancient).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ancient).toEqualTypeOf();
+    expect(data.angel).toBeDefined();
+    expect(data.angel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.angel).toEqualTypeOf();
+    expect(data.angry).toBeDefined();
+    expect(data.angry).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.angry).toEqualTypeOf();
+    expect(data.animal).toBeDefined();
+    expect(data.animal).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.animal).toEqualTypeOf();
+    expect(data.ant).toBeDefined();
+    expect(data.ant).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ant).toEqualTypeOf();
+    expect(data.apocalyptic).toBeDefined();
+    expect(data.apocalyptic).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.apocalyptic).toEqualTypeOf();
+    expect(data.apple).toBeDefined();
+    expect(data.apple).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.apple).toEqualTypeOf();
+    expect(data.aquarium).toBeDefined();
+    expect(data.aquarium).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.aquarium).toEqualTypeOf();
+    expect(data.arcade).toBeDefined();
+    expect(data.arcade).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.arcade).toEqualTypeOf();
+    expect(data.arcadeMachine).toBeDefined();
+    expect(data.arcadeMachine).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.arcadeMachine).toEqualTypeOf();
+    expect(data.archer).toBeDefined();
+    expect(data.archer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.archer).toEqualTypeOf();
+    expect(data.arm).toBeDefined();
+    expect(data.arm).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.arm).toEqualTypeOf();
+    expect(data.astronaut).toBeDefined();
+    expect(data.astronaut).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.astronaut).toEqualTypeOf();
+    expect(data.awards).toBeDefined();
+    expect(data.awards).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.awards).toEqualTypeOf();
+    expect(data.axe).toBeDefined();
+    expect(data.axe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.axe).toEqualTypeOf();
+    expect(data.baby).toBeDefined();
+    expect(data.baby).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.baby).toEqualTypeOf();
+    expect(data.backpack).toBeDefined();
+    expect(data.backpack).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.backpack).toEqualTypeOf();
+    expect(data.bacon).toBeDefined();
+    expect(data.bacon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bacon).toEqualTypeOf();
+    expect(data.bakery).toBeDefined();
+    expect(data.bakery).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bakery).toEqualTypeOf();
+    expect(data.baking).toBeDefined();
+    expect(data.baking).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.baking).toEqualTypeOf();
+    expect(data.balloon).toBeDefined();
+    expect(data.balloon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.balloon).toEqualTypeOf();
+    expect(data.banana).toBeDefined();
+    expect(data.banana).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.banana).toEqualTypeOf();
+    expect(data.barbeque).toBeDefined();
+    expect(data.barbeque).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.barbeque).toEqualTypeOf();
+    expect(data.barn).toBeDefined();
+    expect(data.barn).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.barn).toEqualTypeOf();
+    expect(data.bat).toBeDefined();
+    expect(data.bat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bat).toEqualTypeOf();
+    expect(data.bath).toBeDefined();
+    expect(data.bath).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bath).toEqualTypeOf();
+    expect(data.bats).toBeDefined();
+    expect(data.bats).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bats).toEqualTypeOf();
+    expect(data.battle).toBeDefined();
+    expect(data.battle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.battle).toEqualTypeOf();
+    expect(data.baubles).toBeDefined();
+    expect(data.baubles).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.baubles).toEqualTypeOf();
+    expect(data.beach).toBeDefined();
+    expect(data.beach).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.beach).toEqualTypeOf();
+    expect(data.beanstalk).toBeDefined();
+    expect(data.beanstalk).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.beanstalk).toEqualTypeOf();
+    expect(data.bear).toBeDefined();
+    expect(data.bear).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bear).toEqualTypeOf();
+    expect(data.beard).toBeDefined();
+    expect(data.beard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.beard).toEqualTypeOf();
+    expect(data.bed).toBeDefined();
+    expect(data.bed).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bed).toEqualTypeOf();
+    expect(data.bee).toBeDefined();
+    expect(data.bee).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bee).toEqualTypeOf();
+    expect(data.bell).toBeDefined();
+    expect(data.bell).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bell).toEqualTypeOf();
+    expect(data.bike).toBeDefined();
+    expect(data.bike).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bike).toEqualTypeOf();
+    expect(data.bikeRiding).toBeDefined();
+    expect(data.bikeRiding).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bikeRiding).toEqualTypeOf();
+    expect(data.bird).toBeDefined();
+    expect(data.bird).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bird).toEqualTypeOf();
+    expect(data.birdHouse).toBeDefined();
+    expect(data.birdHouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.birdHouse).toEqualTypeOf();
+    expect(data.birthday).toBeDefined();
+    expect(data.birthday).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.birthday).toEqualTypeOf();
+    expect(data.birthdayParty).toBeDefined();
+    expect(data.birthdayParty).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.birthdayParty).toEqualTypeOf();
+    expect(data.blaze).toBeDefined();
+    expect(data.blaze).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.blaze).toEqualTypeOf();
+    expect(data.blizzard).toBeDefined();
+    expect(data.blizzard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.blizzard).toEqualTypeOf();
+    expect(data.block).toBeDefined();
+    expect(data.block).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.block).toEqualTypeOf();
+    expect(data.blocks).toBeDefined();
+    expect(data.blocks).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.blocks).toEqualTypeOf();
+    expect(data.boardGames).toBeDefined();
+    expect(data.boardGames).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boardGames).toEqualTypeOf();
+    expect(data.boardgames).toBeDefined();
+    expect(data.boardgames).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boardgames).toEqualTypeOf();
+    expect(data.boat).toBeDefined();
+    expect(data.boat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boat).toEqualTypeOf();
+    expect(data.bobsledding).toBeDefined();
+    expect(data.bobsledding).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bobsledding).toEqualTypeOf();
+    expect(data.bones).toBeDefined();
+    expect(data.bones).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bones).toEqualTypeOf();
+    expect(data.boogeyman).toBeDefined();
+    expect(data.boogeyman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boogeyman).toEqualTypeOf();
+    expect(data.book).toBeDefined();
+    expect(data.book).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.book).toEqualTypeOf();
+    expect(data.boot).toBeDefined();
+    expect(data.boot).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boot).toEqualTypeOf();
+    expect(data.bottle).toBeDefined();
+    expect(data.bottle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bottle).toEqualTypeOf();
+    expect(data.bouncyCastle).toBeDefined();
+    expect(data.bouncyCastle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bouncyCastle).toEqualTypeOf();
+    expect(data.bowlingAlley).toBeDefined();
+    expect(data.bowlingAlley).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bowlingAlley).toEqualTypeOf();
+    expect(data.box).toBeDefined();
+    expect(data.box).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.box).toEqualTypeOf();
+    expect(data.boxingRing).toBeDefined();
+    expect(data.boxingRing).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boxingRing).toEqualTypeOf();
+    expect(data.boy).toBeDefined();
+    expect(data.boy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.boy).toEqualTypeOf();
+    expect(data.brain).toBeDefined();
+    expect(data.brain).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.brain).toEqualTypeOf();
+    expect(data.branch).toBeDefined();
+    expect(data.branch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.branch).toEqualTypeOf();
+    expect(data.bread).toBeDefined();
+    expect(data.bread).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bread).toEqualTypeOf();
+    expect(data.breakfast).toBeDefined();
+    expect(data.breakfast).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.breakfast).toEqualTypeOf();
+    expect(data.brewingStand).toBeDefined();
+    expect(data.brewingStand).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.brewingStand).toEqualTypeOf();
+    expect(data.bridge).toBeDefined();
+    expect(data.bridge).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bridge).toEqualTypeOf();
+    expect(data.brokenBridge).toBeDefined();
+    expect(data.brokenBridge).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.brokenBridge).toEqualTypeOf();
+    expect(data.broomstick).toBeDefined();
+    expect(data.broomstick).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.broomstick).toEqualTypeOf();
+    expect(data.bucket).toBeDefined();
+    expect(data.bucket).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bucket).toEqualTypeOf();
+    expect(data.bug).toBeDefined();
+    expect(data.bug).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bug).toEqualTypeOf();
+    expect(data.builder).toBeDefined();
+    expect(data.builder).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.builder).toEqualTypeOf();
+    expect(data.bunny).toBeDefined();
+    expect(data.bunny).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.bunny).toEqualTypeOf();
+    expect(data.buried).toBeDefined();
+    expect(data.buried).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.buried).toEqualTypeOf();
+    expect(data.butterflies).toBeDefined();
+    expect(data.butterflies).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.butterflies).toEqualTypeOf();
+    expect(data.butterfly).toBeDefined();
+    expect(data.butterfly).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.butterfly).toEqualTypeOf();
+    expect(data.button).toBeDefined();
+    expect(data.button).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.button).toEqualTypeOf();
+    expect(data.cabin).toBeDefined();
+    expect(data.cabin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cabin).toEqualTypeOf();
+    expect(data.cake).toBeDefined();
+    expect(data.cake).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cake).toEqualTypeOf();
+    expect(data.camel).toBeDefined();
+    expect(data.camel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.camel).toEqualTypeOf();
+    expect(data.camera).toBeDefined();
+    expect(data.camera).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.camera).toEqualTypeOf();
+    expect(data.camp).toBeDefined();
+    expect(data.camp).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.camp).toEqualTypeOf();
+    expect(data.campfire).toBeDefined();
+    expect(data.campfire).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.campfire).toEqualTypeOf();
+    expect(data.camping).toBeDefined();
+    expect(data.camping).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.camping).toEqualTypeOf();
+    expect(data.campsite).toBeDefined();
+    expect(data.campsite).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.campsite).toEqualTypeOf();
+    expect(data.candle).toBeDefined();
+    expect(data.candle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.candle).toEqualTypeOf();
+    expect(data.candlelight).toBeDefined();
+    expect(data.candlelight).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.candlelight).toEqualTypeOf();
+    expect(data.candles).toBeDefined();
+    expect(data.candles).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.candles).toEqualTypeOf();
+    expect(data.candy).toBeDefined();
+    expect(data.candy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.candy).toEqualTypeOf();
+    expect(data.candyBuckets).toBeDefined();
+    expect(data.candyBuckets).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.candyBuckets).toEqualTypeOf();
+    expect(data.candyCane).toBeDefined();
+    expect(data.candyCane).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.candyCane).toEqualTypeOf();
+    expect(data.cannon).toBeDefined();
+    expect(data.cannon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cannon).toEqualTypeOf();
+    expect(data.car).toBeDefined();
+    expect(data.car).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.car).toEqualTypeOf();
+    expect(data.caribbean).toBeDefined();
+    expect(data.caribbean).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.caribbean).toEqualTypeOf();
+    expect(data.carnival).toBeDefined();
+    expect(data.carnival).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.carnival).toEqualTypeOf();
+    expect(data.carolling).toBeDefined();
+    expect(data.carolling).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.carolling).toEqualTypeOf();
+    expect(data.cart).toBeDefined();
+    expect(data.cart).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cart).toEqualTypeOf();
+    expect(data.cartoon).toBeDefined();
+    expect(data.cartoon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cartoon).toEqualTypeOf();
+    expect(data.castle).toBeDefined();
+    expect(data.castle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.castle).toEqualTypeOf();
+    expect(data.cat).toBeDefined();
+    expect(data.cat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cat).toEqualTypeOf();
+    expect(data.catapult).toBeDefined();
+    expect(data.catapult).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.catapult).toEqualTypeOf();
+    expect(data.caterpillar).toBeDefined();
+    expect(data.caterpillar).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.caterpillar).toEqualTypeOf();
+    expect(data.cauldron).toBeDefined();
+    expect(data.cauldron).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cauldron).toEqualTypeOf();
+    expect(data.cave).toBeDefined();
+    expect(data.cave).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cave).toEqualTypeOf();
+    expect(data.celebration).toBeDefined();
+    expect(data.celebration).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.celebration).toEqualTypeOf();
+    expect(data.cellar).toBeDefined();
+    expect(data.cellar).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cellar).toEqualTypeOf();
+    expect(data.cheese).toBeDefined();
+    expect(data.cheese).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cheese).toEqualTypeOf();
+    expect(data.chemistry).toBeDefined();
+    expect(data.chemistry).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chemistry).toEqualTypeOf();
+    expect(data.cherry).toBeDefined();
+    expect(data.cherry).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cherry).toEqualTypeOf();
+    expect(data.cherryBlossom).toBeDefined();
+    expect(data.cherryBlossom).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cherryBlossom).toEqualTypeOf();
+    expect(data.cherryBlossoms).toBeDefined();
+    expect(data.cherryBlossoms).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cherryBlossoms).toEqualTypeOf();
+    expect(data.chess).toBeDefined();
+    expect(data.chess).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chess).toEqualTypeOf();
+    expect(data.chest).toBeDefined();
+    expect(data.chest).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chest).toEqualTypeOf();
+    expect(data.chicken).toBeDefined();
+    expect(data.chicken).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chicken).toEqualTypeOf();
+    expect(data.chimney).toBeDefined();
+    expect(data.chimney).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chimney).toEqualTypeOf();
+    expect(data.chocolate).toBeDefined();
+    expect(data.chocolate).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chocolate).toEqualTypeOf();
+    expect(data.chocolateFactory).toBeDefined();
+    expect(data.chocolateFactory).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.chocolateFactory).toEqualTypeOf();
+    expect(data.choir).toBeDefined();
+    expect(data.choir).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.choir).toEqualTypeOf();
+    expect(data.christmasCard).toBeDefined();
+    expect(data.christmasCard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.christmasCard).toEqualTypeOf();
+    expect(data.christmasDinner).toBeDefined();
+    expect(data.christmasDinner).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.christmasDinner).toEqualTypeOf();
+    expect(data.christmasEve).toBeDefined();
+    expect(data.christmasEve).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.christmasEve).toEqualTypeOf();
+    expect(data.christmasGift).toBeDefined();
+    expect(data.christmasGift).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.christmasGift).toEqualTypeOf();
+    expect(data.christmasMorning).toBeDefined();
+    expect(data.christmasMorning).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.christmasMorning).toEqualTypeOf();
+    expect(data.christmasTree).toBeDefined();
+    expect(data.christmasTree).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.christmasTree).toEqualTypeOf();
+    expect(data.cinema).toBeDefined();
+    expect(data.cinema).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cinema).toEqualTypeOf();
+    expect(data.circus).toBeDefined();
+    expect(data.circus).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.circus).toEqualTypeOf();
+    expect(data.clock).toBeDefined();
+    expect(data.clock).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.clock).toEqualTypeOf();
+    expect(data.cloud).toBeDefined();
+    expect(data.cloud).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cloud).toEqualTypeOf();
+    expect(data.clown).toBeDefined();
+    expect(data.clown).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.clown).toEqualTypeOf();
+    expect(data.cobweb).toBeDefined();
+    expect(data.cobweb).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cobweb).toEqualTypeOf();
+    expect(data.coconut).toBeDefined();
+    expect(data.coconut).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.coconut).toEqualTypeOf();
+    expect(data.coffin).toBeDefined();
+    expect(data.coffin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.coffin).toEqualTypeOf();
+    expect(data.comet).toBeDefined();
+    expect(data.comet).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.comet).toEqualTypeOf();
+    expect(data.computer).toBeDefined();
+    expect(data.computer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.computer).toEqualTypeOf();
+    expect(data.cookieMountain).toBeDefined();
+    expect(data.cookieMountain).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cookieMountain).toEqualTypeOf();
+    expect(data.corpseBride).toBeDefined();
+    expect(data.corpseBride).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.corpseBride).toEqualTypeOf();
+    expect(data.costume).toBeDefined();
+    expect(data.costume).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.costume).toEqualTypeOf();
+    expect(data.cowboy).toBeDefined();
+    expect(data.cowboy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cowboy).toEqualTypeOf();
+    expect(data.crab).toBeDefined();
+    expect(data.crab).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.crab).toEqualTypeOf();
+    expect(data.craftingTable).toBeDefined();
+    expect(data.craftingTable).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.craftingTable).toEqualTypeOf();
+    expect(data.crane).toBeDefined();
+    expect(data.crane).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.crane).toEqualTypeOf();
+    expect(data.crayon).toBeDefined();
+    expect(data.crayon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.crayon).toEqualTypeOf();
+    expect(data.crayons).toBeDefined();
+    expect(data.crayons).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.crayons).toEqualTypeOf();
+    expect(data.creeper).toBeDefined();
+    expect(data.creeper).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.creeper).toEqualTypeOf();
+    expect(data.crocodile).toBeDefined();
+    expect(data.crocodile).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.crocodile).toEqualTypeOf();
+    expect(data.crystalBall).toBeDefined();
+    expect(data.crystalBall).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.crystalBall).toEqualTypeOf();
+    expect(data.cup).toBeDefined();
+    expect(data.cup).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cup).toEqualTypeOf();
+    expect(data.curtain).toBeDefined();
+    expect(data.curtain).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.curtain).toEqualTypeOf();
+    expect(data.cushion).toBeDefined();
+    expect(data.cushion).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.cushion).toEqualTypeOf();
+    expect(data.dancer).toBeDefined();
+    expect(data.dancer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dancer).toEqualTypeOf();
+    expect(data.darkWoods).toBeDefined();
+    expect(data.darkWoods).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.darkWoods).toEqualTypeOf();
+    expect(data.decoratedHouse).toBeDefined();
+    expect(data.decoratedHouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.decoratedHouse).toEqualTypeOf();
+    expect(data.demon).toBeDefined();
+    expect(data.demon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.demon).toEqualTypeOf();
+    expect(data.dice).toBeDefined();
+    expect(data.dice).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dice).toEqualTypeOf();
+    expect(data.dinosaur).toBeDefined();
+    expect(data.dinosaur).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dinosaur).toEqualTypeOf();
+    expect(data.disco).toBeDefined();
+    expect(data.disco).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.disco).toEqualTypeOf();
+    expect(data.disguise).toBeDefined();
+    expect(data.disguise).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.disguise).toEqualTypeOf();
+    expect(data.doll).toBeDefined();
+    expect(data.doll).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.doll).toEqualTypeOf();
+    expect(data.dollhouse).toBeDefined();
+    expect(data.dollhouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dollhouse).toEqualTypeOf();
+    expect(data.dolphin).toBeDefined();
+    expect(data.dolphin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dolphin).toEqualTypeOf();
+    expect(data.doorbell).toBeDefined();
+    expect(data.doorbell).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.doorbell).toEqualTypeOf();
+    expect(data.doughnut).toBeDefined();
+    expect(data.doughnut).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.doughnut).toEqualTypeOf();
+    expect(data.doughnuts).toBeDefined();
+    expect(data.doughnuts).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.doughnuts).toEqualTypeOf();
+    expect(data.dracula).toBeDefined();
+    expect(data.dracula).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dracula).toEqualTypeOf();
+    expect(data.dragon).toBeDefined();
+    expect(data.dragon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dragon).toEqualTypeOf();
+    expect(data.dress).toBeDefined();
+    expect(data.dress).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dress).toEqualTypeOf();
+    expect(data.drill).toBeDefined();
+    expect(data.drill).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.drill).toEqualTypeOf();
+    expect(data.drink).toBeDefined();
+    expect(data.drink).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.drink).toEqualTypeOf();
+    expect(data.droid).toBeDefined();
+    expect(data.droid).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.droid).toEqualTypeOf();
+    expect(data.drum).toBeDefined();
+    expect(data.drum).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.drum).toEqualTypeOf();
+    expect(data.dungeon).toBeDefined();
+    expect(data.dungeon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.dungeon).toEqualTypeOf();
+    expect(data.earmuffs).toBeDefined();
+    expect(data.earmuffs).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.earmuffs).toEqualTypeOf();
+    expect(data.earth).toBeDefined();
+    expect(data.earth).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.earth).toEqualTypeOf();
+    expect(data.easterEgg).toBeDefined();
+    expect(data.easterEgg).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.easterEgg).toEqualTypeOf();
+    expect(data.eatingCompetition).toBeDefined();
+    expect(data.eatingCompetition).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.eatingCompetition).toEqualTypeOf();
+    expect(data.eggBasket).toBeDefined();
+    expect(data.eggBasket).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.eggBasket).toEqualTypeOf();
+    expect(data.egyptain).toBeDefined();
+    expect(data.egyptain).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.egyptain).toEqualTypeOf();
+    expect(data.egyptian).toBeDefined();
+    expect(data.egyptian).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.egyptian).toEqualTypeOf();
+    expect(data.eiffelTower).toBeDefined();
+    expect(data.eiffelTower).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.eiffelTower).toEqualTypeOf();
+    expect(data.elephant).toBeDefined();
+    expect(data.elephant).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.elephant).toEqualTypeOf();
+    expect(data.elf).toBeDefined();
+    expect(data.elf).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.elf).toEqualTypeOf();
+    expect(data.enderman).toBeDefined();
+    expect(data.enderman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.enderman).toEqualTypeOf();
+    expect(data.engine).toBeDefined();
+    expect(data.engine).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.engine).toEqualTypeOf();
+    expect(data.ethereal).toBeDefined();
+    expect(data.ethereal).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ethereal).toEqualTypeOf();
+    expect(data.evergreenTree).toBeDefined();
+    expect(data.evergreenTree).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.evergreenTree).toEqualTypeOf();
+    expect(data.evilCat).toBeDefined();
+    expect(data.evilCat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.evilCat).toEqualTypeOf();
+    expect(data.evilClown).toBeDefined();
+    expect(data.evilClown).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.evilClown).toEqualTypeOf();
+    expect(data.extraterrestrial).toBeDefined();
+    expect(data.extraterrestrial).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.extraterrestrial).toEqualTypeOf();
+    expect(data.eye).toBeDefined();
+    expect(data.eye).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.eye).toEqualTypeOf();
+    expect(data.fairy).toBeDefined();
+    expect(data.fairy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fairy).toEqualTypeOf();
+    expect(data.family).toBeDefined();
+    expect(data.family).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.family).toEqualTypeOf();
+    expect(data.fancy).toBeDefined();
+    expect(data.fancy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fancy).toEqualTypeOf();
+    expect(data.fangs).toBeDefined();
+    expect(data.fangs).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fangs).toEqualTypeOf();
+    expect(data.fantasy).toBeDefined();
+    expect(data.fantasy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fantasy).toEqualTypeOf();
+    expect(data.farm).toBeDefined();
+    expect(data.farm).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.farm).toEqualTypeOf();
+    expect(data.farmersMarket).toBeDefined();
+    expect(data.farmersMarket).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.farmersMarket).toEqualTypeOf();
+    expect(data.feast).toBeDefined();
+    expect(data.feast).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.feast).toEqualTypeOf();
+    expect(data.feather).toBeDefined();
+    expect(data.feather).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.feather).toEqualTypeOf();
+    expect(data.fire).toBeDefined();
+    expect(data.fire).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fire).toEqualTypeOf();
+    expect(data.fireplace).toBeDefined();
+    expect(data.fireplace).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fireplace).toEqualTypeOf();
+    expect(data.firetruck).toBeDefined();
+    expect(data.firetruck).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.firetruck).toEqualTypeOf();
+    expect(data.firework).toBeDefined();
+    expect(data.firework).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.firework).toEqualTypeOf();
+    expect(data.fireworks).toBeDefined();
+    expect(data.fireworks).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fireworks).toEqualTypeOf();
+    expect(data.fishingRod).toBeDefined();
+    expect(data.fishingRod).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fishingRod).toEqualTypeOf();
+    expect(data.flag).toBeDefined();
+    expect(data.flag).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flag).toEqualTypeOf();
+    expect(data.flamingo).toBeDefined();
+    expect(data.flamingo).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flamingo).toEqualTypeOf();
+    expect(data.flashlight).toBeDefined();
+    expect(data.flashlight).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flashlight).toEqualTypeOf();
+    expect(data.floatingIsland).toBeDefined();
+    expect(data.floatingIsland).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.floatingIsland).toEqualTypeOf();
+    expect(data.flower).toBeDefined();
+    expect(data.flower).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flower).toEqualTypeOf();
+    expect(data.flowerPatch).toBeDefined();
+    expect(data.flowerPatch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flowerPatch).toEqualTypeOf();
+    expect(data.fly).toBeDefined();
+    expect(data.fly).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fly).toEqualTypeOf();
+    expect(data.flying).toBeDefined();
+    expect(data.flying).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flying).toEqualTypeOf();
+    expect(data.flyingPig).toBeDefined();
+    expect(data.flyingPig).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flyingPig).toEqualTypeOf();
+    expect(data.flyingSaucer).toBeDefined();
+    expect(data.flyingSaucer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.flyingSaucer).toEqualTypeOf();
+    expect(data.foot).toBeDefined();
+    expect(data.foot).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.foot).toEqualTypeOf();
+    expect(data.football).toBeDefined();
+    expect(data.football).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.football).toEqualTypeOf();
+    expect(data.forge).toBeDefined();
+    expect(data.forge).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.forge).toEqualTypeOf();
+    expect(data.fork).toBeDefined();
+    expect(data.fork).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fork).toEqualTypeOf();
+    expect(data.fortuneteller).toBeDefined();
+    expect(data.fortuneteller).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fortuneteller).toEqualTypeOf();
+    expect(data.fountain).toBeDefined();
+    expect(data.fountain).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fountain).toEqualTypeOf();
+    expect(data.frankenstein).toBeDefined();
+    expect(data.frankenstein).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.frankenstein).toEqualTypeOf();
+    expect(data.freezer).toBeDefined();
+    expect(data.freezer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.freezer).toEqualTypeOf();
+    expect(data.fridge).toBeDefined();
+    expect(data.fridge).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fridge).toEqualTypeOf();
+    expect(data.frostyTheSnowman).toBeDefined();
+    expect(data.frostyTheSnowman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.frostyTheSnowman).toEqualTypeOf();
+    expect(data.frozen).toBeDefined();
+    expect(data.frozen).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.frozen).toEqualTypeOf();
+    expect(data.fullMoon).toBeDefined();
+    expect(data.fullMoon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.fullMoon).toEqualTypeOf();
+    expect(data.futuristicHouse).toBeDefined();
+    expect(data.futuristicHouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.futuristicHouse).toEqualTypeOf();
+    expect(data.game).toBeDefined();
+    expect(data.game).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.game).toEqualTypeOf();
+    expect(data.garage).toBeDefined();
+    expect(data.garage).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.garage).toEqualTypeOf();
+    expect(data.garden).toBeDefined();
+    expect(data.garden).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.garden).toEqualTypeOf();
+    expect(data.ghast).toBeDefined();
+    expect(data.ghast).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ghast).toEqualTypeOf();
+    expect(data.ghost).toBeDefined();
+    expect(data.ghost).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ghost).toEqualTypeOf();
+    expect(data.ghostShip).toBeDefined();
+    expect(data.ghostShip).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ghostShip).toEqualTypeOf();
+    expect(data.ghoul).toBeDefined();
+    expect(data.ghoul).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ghoul).toEqualTypeOf();
+    expect(data.giantPresents).toBeDefined();
+    expect(data.giantPresents).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.giantPresents).toEqualTypeOf();
+    expect(data.gifts).toBeDefined();
+    expect(data.gifts).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gifts).toEqualTypeOf();
+    expect(data.gingerbread).toBeDefined();
+    expect(data.gingerbread).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gingerbread).toEqualTypeOf();
+    expect(data.gingerbreadHouse).toBeDefined();
+    expect(data.gingerbreadHouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gingerbreadHouse).toEqualTypeOf();
+    expect(data.gingerbreadMan).toBeDefined();
+    expect(data.gingerbreadMan).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gingerbreadMan).toEqualTypeOf();
+    expect(data.giraffe).toBeDefined();
+    expect(data.giraffe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.giraffe).toEqualTypeOf();
+    expect(data.girl).toBeDefined();
+    expect(data.girl).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.girl).toEqualTypeOf();
+    expect(data.glasses).toBeDefined();
+    expect(data.glasses).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.glasses).toEqualTypeOf();
+    expect(data.glove).toBeDefined();
+    expect(data.glove).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.glove).toEqualTypeOf();
+    expect(data.goat).toBeDefined();
+    expect(data.goat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.goat).toEqualTypeOf();
+    expect(data.goblin).toBeDefined();
+    expect(data.goblin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.goblin).toEqualTypeOf();
+    expect(data.golem).toBeDefined();
+    expect(data.golem).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.golem).toEqualTypeOf();
+    expect(data.goose).toBeDefined();
+    expect(data.goose).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.goose).toEqualTypeOf();
+    expect(data.gothic).toBeDefined();
+    expect(data.gothic).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gothic).toEqualTypeOf();
+    expect(data.gravestone).toBeDefined();
+    expect(data.gravestone).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gravestone).toEqualTypeOf();
+    expect(data.graveyard).toBeDefined();
+    expect(data.graveyard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.graveyard).toEqualTypeOf();
+    expect(data.greekTemple).toBeDefined();
+    expect(data.greekTemple).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.greekTemple).toEqualTypeOf();
+    expect(data.grimReaper).toBeDefined();
+    expect(data.grimReaper).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.grimReaper).toEqualTypeOf();
+    expect(data.grinch).toBeDefined();
+    expect(data.grinch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.grinch).toEqualTypeOf();
+    expect(data.guitar).toBeDefined();
+    expect(data.guitar).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.guitar).toEqualTypeOf();
+    expect(data.gym).toBeDefined();
+    expect(data.gym).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.gym).toEqualTypeOf();
+    expect(data.halloweenCostumes).toBeDefined();
+    expect(data.halloweenCostumes).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.halloweenCostumes).toEqualTypeOf();
+    expect(data.halloweenParty).toBeDefined();
+    expect(data.halloweenParty).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.halloweenParty).toEqualTypeOf();
+    expect(data.halloweenTreats).toBeDefined();
+    expect(data.halloweenTreats).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.halloweenTreats).toEqualTypeOf();
+    expect(data.hamburger).toBeDefined();
+    expect(data.hamburger).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hamburger).toEqualTypeOf();
+    expect(data.hammer).toBeDefined();
+    expect(data.hammer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hammer).toEqualTypeOf();
+    expect(data.hamster).toBeDefined();
+    expect(data.hamster).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hamster).toEqualTypeOf();
+    expect(data.hand).toBeDefined();
+    expect(data.hand).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hand).toEqualTypeOf();
+    expect(data.happy).toBeDefined();
+    expect(data.happy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.happy).toEqualTypeOf();
+    expect(data.harbor).toBeDefined();
+    expect(data.harbor).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.harbor).toEqualTypeOf();
+    expect(data.haunted).toBeDefined();
+    expect(data.haunted).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.haunted).toEqualTypeOf();
+    expect(data.hauntedForest).toBeDefined();
+    expect(data.hauntedForest).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hauntedForest).toEqualTypeOf();
+    expect(data.hauntedHouse).toBeDefined();
+    expect(data.hauntedHouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hauntedHouse).toEqualTypeOf();
+    expect(data.head).toBeDefined();
+    expect(data.head).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.head).toEqualTypeOf();
+    expect(data.headlessHorseman).toBeDefined();
+    expect(data.headlessHorseman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.headlessHorseman).toEqualTypeOf();
+    expect(data.heart).toBeDefined();
+    expect(data.heart).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.heart).toEqualTypeOf();
+    expect(data.helicopter).toBeDefined();
+    expect(data.helicopter).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.helicopter).toEqualTypeOf();
+    expect(data.hikingTrail).toBeDefined();
+    expect(data.hikingTrail).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hikingTrail).toEqualTypeOf();
+    expect(data.holiday).toBeDefined();
+    expect(data.holiday).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.holiday).toEqualTypeOf();
+    expect(data.holly).toBeDefined();
+    expect(data.holly).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.holly).toEqualTypeOf();
+    expect(data.hotAirBalloon).toBeDefined();
+    expect(data.hotAirBalloon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hotAirBalloon).toEqualTypeOf();
+    expect(data.hotChocolate).toBeDefined();
+    expect(data.hotChocolate).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hotChocolate).toEqualTypeOf();
+    expect(data.house).toBeDefined();
+    expect(data.house).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.house).toEqualTypeOf();
+    expect(data.howl).toBeDefined();
+    expect(data.howl).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.howl).toEqualTypeOf();
+    expect(data.hugeStocking).toBeDefined();
+    expect(data.hugeStocking).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hugeStocking).toEqualTypeOf();
+    expect(data.hurricane).toBeDefined();
+    expect(data.hurricane).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hurricane).toEqualTypeOf();
+    expect(data.hypixel).toBeDefined();
+    expect(data.hypixel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hypixel).toEqualTypeOf();
+    expect(data.hypixelSweater).toBeDefined();
+    expect(data.hypixelSweater).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.hypixelSweater).toEqualTypeOf();
+    expect(data.iceCream).toBeDefined();
+    expect(data.iceCream).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.iceCream).toEqualTypeOf();
+    expect(data.iceFishing).toBeDefined();
+    expect(data.iceFishing).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.iceFishing).toEqualTypeOf();
+    expect(data.iceSkating).toBeDefined();
+    expect(data.iceSkating).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.iceSkating).toEqualTypeOf();
+    expect(data.igloo).toBeDefined();
+    expect(data.igloo).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.igloo).toEqualTypeOf();
+    expect(data.illusion).toBeDefined();
+    expect(data.illusion).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.illusion).toEqualTypeOf();
+    expect(data.imp).toBeDefined();
+    expect(data.imp).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.imp).toEqualTypeOf();
+    expect(data.industrial).toBeDefined();
+    expect(data.industrial).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.industrial).toEqualTypeOf();
+    expect(data.insect).toBeDefined();
+    expect(data.insect).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.insect).toEqualTypeOf();
+    expect(data.ironman).toBeDefined();
+    expect(data.ironman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ironman).toEqualTypeOf();
+    expect(data.island).toBeDefined();
+    expect(data.island).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.island).toEqualTypeOf();
+    expect(data.jackolantern).toBeDefined();
+    expect(data.jackolantern).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.jackolantern).toEqualTypeOf();
+    expect(data.jellyfish).toBeDefined();
+    expect(data.jellyfish).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.jellyfish).toEqualTypeOf();
+    expect(data.jetski).toBeDefined();
+    expect(data.jetski).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.jetski).toEqualTypeOf();
+    expect(data.jewel).toBeDefined();
+    expect(data.jewel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.jewel).toEqualTypeOf();
+    expect(data.jingleBell).toBeDefined();
+    expect(data.jingleBell).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.jingleBell).toEqualTypeOf();
+    expect(data.jurassic).toBeDefined();
+    expect(data.jurassic).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.jurassic).toEqualTypeOf();
+    expect(data.keyboard).toBeDefined();
+    expect(data.keyboard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.keyboard).toEqualTypeOf();
+    expect(data.killerWhale).toBeDefined();
+    expect(data.killerWhale).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.killerWhale).toEqualTypeOf();
+    expect(data.king).toBeDefined();
+    expect(data.king).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.king).toEqualTypeOf();
+    expect(data.kite).toBeDefined();
+    expect(data.kite).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.kite).toEqualTypeOf();
+    expect(data.kitten).toBeDefined();
+    expect(data.kitten).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.kitten).toEqualTypeOf();
+    expect(data.knight).toBeDefined();
+    expect(data.knight).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.knight).toEqualTypeOf();
+    expect(data.laboratory).toBeDefined();
+    expect(data.laboratory).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.laboratory).toEqualTypeOf();
+    expect(data.ladyBug).toBeDefined();
+    expect(data.ladyBug).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ladyBug).toEqualTypeOf();
+    expect(data.lantern).toBeDefined();
+    expect(data.lantern).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.lantern).toEqualTypeOf();
+    expect(data.leaf).toBeDefined();
+    expect(data.leaf).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.leaf).toEqualTypeOf();
+    expect(data.leg).toBeDefined();
+    expect(data.leg).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.leg).toEqualTypeOf();
+    expect(data.library).toBeDefined();
+    expect(data.library).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.library).toEqualTypeOf();
+    expect(data.light).toBeDefined();
+    expect(data.light).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.light).toEqualTypeOf();
+    expect(data.lightbulb).toBeDefined();
+    expect(data.lightbulb).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.lightbulb).toEqualTypeOf();
+    expect(data.lighthouse).toBeDefined();
+    expect(data.lighthouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.lighthouse).toEqualTypeOf();
+    expect(data.lion).toBeDefined();
+    expect(data.lion).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.lion).toEqualTypeOf();
+    expect(data.livingDead).toBeDefined();
+    expect(data.livingDead).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.livingDead).toEqualTypeOf();
+    expect(data.llama).toBeDefined();
+    expect(data.llama).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.llama).toEqualTypeOf();
+    expect(data.lodge).toBeDefined();
+    expect(data.lodge).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.lodge).toEqualTypeOf();
+    expect(data.lunchbox).toBeDefined();
+    expect(data.lunchbox).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.lunchbox).toEqualTypeOf();
+    expect(data.madScientist).toBeDefined();
+    expect(data.madScientist).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.madScientist).toEqualTypeOf();
+    expect(data.magic).toBeDefined();
+    expect(data.magic).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.magic).toEqualTypeOf();
+    expect(data.magicWand).toBeDefined();
+    expect(data.magicWand).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.magicWand).toEqualTypeOf();
+    expect(data.magician).toBeDefined();
+    expect(data.magician).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.magician).toEqualTypeOf();
+    expect(data.magnet).toBeDefined();
+    expect(data.magnet).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.magnet).toEqualTypeOf();
+    expect(data.mailBox).toBeDefined();
+    expect(data.mailBox).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mailBox).toEqualTypeOf();
+    expect(data.map).toBeDefined();
+    expect(data.map).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.map).toEqualTypeOf();
+    expect(data.mars).toBeDefined();
+    expect(data.mars).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mars).toEqualTypeOf();
+    expect(data.marshmallow).toBeDefined();
+    expect(data.marshmallow).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.marshmallow).toEqualTypeOf();
+    expect(data.marshmallows).toBeDefined();
+    expect(data.marshmallows).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.marshmallows).toEqualTypeOf();
+    expect(data.martians).toBeDefined();
+    expect(data.martians).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.martians).toEqualTypeOf();
+    expect(data.mask).toBeDefined();
+    expect(data.mask).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mask).toEqualTypeOf();
+    expect(data.maze).toBeDefined();
+    expect(data.maze).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.maze).toEqualTypeOf();
+    expect(data.meadow).toBeDefined();
+    expect(data.meadow).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.meadow).toEqualTypeOf();
+    expect(data.medieval).toBeDefined();
+    expect(data.medieval).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.medieval).toEqualTypeOf();
+    expect(data.mermaid).toBeDefined();
+    expect(data.mermaid).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mermaid).toEqualTypeOf();
+    expect(data.meteorite).toBeDefined();
+    expect(data.meteorite).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.meteorite).toEqualTypeOf();
+    expect(data.mice).toBeDefined();
+    expect(data.mice).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mice).toEqualTypeOf();
+    expect(data.midnight).toBeDefined();
+    expect(data.midnight).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.midnight).toEqualTypeOf();
+    expect(data.milk).toBeDefined();
+    expect(data.milk).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.milk).toEqualTypeOf();
+    expect(data.milkAndCookies).toBeDefined();
+    expect(data.milkAndCookies).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.milkAndCookies).toEqualTypeOf();
+    expect(data.mincePie).toBeDefined();
+    expect(data.mincePie).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mincePie).toEqualTypeOf();
+    expect(data.mine).toBeDefined();
+    expect(data.mine).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mine).toEqualTypeOf();
+    expect(data.mistletoe).toBeDefined();
+    expect(data.mistletoe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mistletoe).toEqualTypeOf();
+    expect(data.modernHome).toBeDefined();
+    expect(data.modernHome).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.modernHome).toEqualTypeOf();
+    expect(data.money).toBeDefined();
+    expect(data.money).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.money).toEqualTypeOf();
+    expect(data.monkey).toBeDefined();
+    expect(data.monkey).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.monkey).toEqualTypeOf();
+    expect(data.monster).toBeDefined();
+    expect(data.monster).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.monster).toEqualTypeOf();
+    expect(data.monsterTruck).toBeDefined();
+    expect(data.monsterTruck).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.monsterTruck).toEqualTypeOf();
+    expect(data.monument).toBeDefined();
+    expect(data.monument).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.monument).toEqualTypeOf();
+    expect(data.moon).toBeDefined();
+    expect(data.moon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.moon).toEqualTypeOf();
+    expect(data.motorbike).toBeDefined();
+    expect(data.motorbike).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.motorbike).toEqualTypeOf();
+    expect(data.mouse).toBeDefined();
+    expect(data.mouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mouse).toEqualTypeOf();
+    expect(data.movie).toBeDefined();
+    expect(data.movie).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.movie).toEqualTypeOf();
+    expect(data.mummy).toBeDefined();
+    expect(data.mummy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mummy).toEqualTypeOf();
+    expect(data.museum).toBeDefined();
+    expect(data.museum).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.museum).toEqualTypeOf();
+    expect(data.mushroom).toBeDefined();
+    expect(data.mushroom).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mushroom).toEqualTypeOf();
+    expect(data.music).toBeDefined();
+    expect(data.music).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.music).toEqualTypeOf();
+    expect(data.mutant).toBeDefined();
+    expect(data.mutant).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mutant).toEqualTypeOf();
+    expect(data.mythical).toBeDefined();
+    expect(data.mythical).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.mythical).toEqualTypeOf();
+    expect(data.nail).toBeDefined();
+    expect(data.nail).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.nail).toEqualTypeOf();
+    expect(data.neon).toBeDefined();
+    expect(data.neon).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.neon).toEqualTypeOf();
+    expect(data.nightmare).toBeDefined();
+    expect(data.nightmare).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.nightmare).toEqualTypeOf();
+    expect(data.ninja).toBeDefined();
+    expect(data.ninja).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ninja).toEqualTypeOf();
+    expect(data.northPole).toBeDefined();
+    expect(data.northPole).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.northPole).toEqualTypeOf();
+    expect(data.nose).toBeDefined();
+    expect(data.nose).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.nose).toEqualTypeOf();
+    expect(data.nostalgia).toBeDefined();
+    expect(data.nostalgia).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.nostalgia).toEqualTypeOf();
+    expect(data.ocean).toBeDefined();
+    expect(data.ocean).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ocean).toEqualTypeOf();
+    expect(data.octopus).toBeDefined();
+    expect(data.octopus).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.octopus).toEqualTypeOf();
+    expect(data.ogre).toBeDefined();
+    expect(data.ogre).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ogre).toEqualTypeOf();
+    expect(data.olympics).toBeDefined();
+    expect(data.olympics).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.olympics).toEqualTypeOf();
+    expect(data.orange).toBeDefined();
+    expect(data.orange).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.orange).toEqualTypeOf();
+    expect(data.oven).toBeDefined();
+    expect(data.oven).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.oven).toEqualTypeOf();
+    expect(data.owl).toBeDefined();
+    expect(data.owl).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.owl).toEqualTypeOf();
+    expect(data.package).toBeDefined();
+    expect(data.package).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.package).toEqualTypeOf();
+    expect(data.paint).toBeDefined();
+    expect(data.paint).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.paint).toEqualTypeOf();
+    expect(data.painting).toBeDefined();
+    expect(data.painting).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.painting).toEqualTypeOf();
+    expect(data.palace).toBeDefined();
+    expect(data.palace).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.palace).toEqualTypeOf();
+    expect(data.palmTree).toBeDefined();
+    expect(data.palmTree).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.palmTree).toEqualTypeOf();
+    expect(data.panda).toBeDefined();
+    expect(data.panda).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.panda).toEqualTypeOf();
+    expect(data.parachute).toBeDefined();
+    expect(data.parachute).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.parachute).toEqualTypeOf();
+    expect(data.park).toBeDefined();
+    expect(data.park).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.park).toEqualTypeOf();
+    expect(data.pastel).toBeDefined();
+    expect(data.pastel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pastel).toEqualTypeOf();
+    expect(data.pen).toBeDefined();
+    expect(data.pen).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pen).toEqualTypeOf();
+    expect(data.pencil).toBeDefined();
+    expect(data.pencil).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pencil).toEqualTypeOf();
+    expect(data.penguin).toBeDefined();
+    expect(data.penguin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.penguin).toEqualTypeOf();
+    expect(data.phantom).toBeDefined();
+    expect(data.phantom).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.phantom).toEqualTypeOf();
+    expect(data.photograph).toBeDefined();
+    expect(data.photograph).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.photograph).toEqualTypeOf();
+    expect(data.piano).toBeDefined();
+    expect(data.piano).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.piano).toEqualTypeOf();
+    expect(data.picnic).toBeDefined();
+    expect(data.picnic).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.picnic).toEqualTypeOf();
+    expect(data.picture).toBeDefined();
+    expect(data.picture).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.picture).toEqualTypeOf();
+    expect(data.pie).toBeDefined();
+    expect(data.pie).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pie).toEqualTypeOf();
+    expect(data.piggyBank).toBeDefined();
+    expect(data.piggyBank).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.piggyBank).toEqualTypeOf();
+    expect(data.pineapple).toBeDefined();
+    expect(data.pineapple).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pineapple).toEqualTypeOf();
+    expect(data.pipe).toBeDefined();
+    expect(data.pipe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pipe).toEqualTypeOf();
+    expect(data.pirate).toBeDefined();
+    expect(data.pirate).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pirate).toEqualTypeOf();
+    expect(data.pirates).toBeDefined();
+    expect(data.pirates).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pirates).toEqualTypeOf();
+    expect(data.pitchfork).toBeDefined();
+    expect(data.pitchfork).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pitchfork).toEqualTypeOf();
+    expect(data.pixelArt).toBeDefined();
+    expect(data.pixelArt).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pixelArt).toEqualTypeOf();
+    expect(data.plane).toBeDefined();
+    expect(data.plane).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.plane).toEqualTypeOf();
+    expect(data.plantPot).toBeDefined();
+    expect(data.plantPot).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.plantPot).toEqualTypeOf();
+    expect(data.plate).toBeDefined();
+    expect(data.plate).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.plate).toEqualTypeOf();
+    expect(data.pogoStick).toBeDefined();
+    expect(data.pogoStick).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pogoStick).toEqualTypeOf();
+    expect(data.pogoSticks).toBeDefined();
+    expect(data.pogoSticks).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pogoSticks).toEqualTypeOf();
+    expect(data.pond).toBeDefined();
+    expect(data.pond).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pond).toEqualTypeOf();
+    expect(data.pool).toBeDefined();
+    expect(data.pool).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pool).toEqualTypeOf();
+    expect(data.poolParty).toBeDefined();
+    expect(data.poolParty).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.poolParty).toEqualTypeOf();
+    expect(data.poolTable).toBeDefined();
+    expect(data.poolTable).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.poolTable).toEqualTypeOf();
+    expect(data.popcorn).toBeDefined();
+    expect(data.popcorn).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.popcorn).toEqualTypeOf();
+    expect(data.popsicle).toBeDefined();
+    expect(data.popsicle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.popsicle).toEqualTypeOf();
+    expect(data.postOffice).toBeDefined();
+    expect(data.postOffice).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.postOffice).toEqualTypeOf();
+    expect(data.pot).toBeDefined();
+    expect(data.pot).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pot).toEqualTypeOf();
+    expect(data.potato).toBeDefined();
+    expect(data.potato).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.potato).toEqualTypeOf();
+    expect(data.potion).toBeDefined();
+    expect(data.potion).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.potion).toEqualTypeOf();
+    expect(data.pottedPlant).toBeDefined();
+    expect(data.pottedPlant).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pottedPlant).toEqualTypeOf();
+    expect(data.prehistoric).toBeDefined();
+    expect(data.prehistoric).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.prehistoric).toEqualTypeOf();
+    expect(data.presentsPile).toBeDefined();
+    expect(data.presentsPile).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.presentsPile).toEqualTypeOf();
+    expect(data.princess).toBeDefined();
+    expect(data.princess).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.princess).toEqualTypeOf();
+    expect(data.pumpkinCarving).toBeDefined();
+    expect(data.pumpkinCarving).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pumpkinCarving).toEqualTypeOf();
+    expect(data.pyramid).toBeDefined();
+    expect(data.pyramid).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.pyramid).toEqualTypeOf();
+    expect(data.racecar).toBeDefined();
+    expect(data.racecar).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.racecar).toEqualTypeOf();
+    expect(data.rainbow).toBeDefined();
+    expect(data.rainbow).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rainbow).toEqualTypeOf();
+    expect(data.rainforest).toBeDefined();
+    expect(data.rainforest).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rainforest).toEqualTypeOf();
+    expect(data.rat).toBeDefined();
+    expect(data.rat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rat).toEqualTypeOf();
+    expect(data.reindeer).toBeDefined();
+    expect(data.reindeer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.reindeer).toEqualTypeOf();
+    expect(data.rhino).toBeDefined();
+    expect(data.rhino).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rhino).toEqualTypeOf();
+    expect(data.ring).toBeDefined();
+    expect(data.ring).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ring).toEqualTypeOf();
+    expect(data.robot).toBeDefined();
+    expect(data.robot).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.robot).toEqualTypeOf();
+    expect(data.robots).toBeDefined();
+    expect(data.robots).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.robots).toEqualTypeOf();
+    expect(data.rockingChair).toBeDefined();
+    expect(data.rockingChair).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rockingChair).toEqualTypeOf();
+    expect(data.rollercoaster).toBeDefined();
+    expect(data.rollercoaster).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rollercoaster).toEqualTypeOf();
+    expect(data.roman).toBeDefined();
+    expect(data.roman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.roman).toEqualTypeOf();
+    expect(data.rubberDuck).toBeDefined();
+    expect(data.rubberDuck).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rubberDuck).toEqualTypeOf();
+    expect(data.rudolph).toBeDefined();
+    expect(data.rudolph).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rudolph).toEqualTypeOf();
+    expect(data.rustic).toBeDefined();
+    expect(data.rustic).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.rustic).toEqualTypeOf();
+    expect(data.sackOfPresents).toBeDefined();
+    expect(data.sackOfPresents).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sackOfPresents).toEqualTypeOf();
+    expect(data.sad).toBeDefined();
+    expect(data.sad).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sad).toEqualTypeOf();
+    expect(data.safari).toBeDefined();
+    expect(data.safari).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.safari).toEqualTypeOf();
+    expect(data.sailboat).toBeDefined();
+    expect(data.sailboat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sailboat).toEqualTypeOf();
+    expect(data.sandcastle).toBeDefined();
+    expect(data.sandcastle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sandcastle).toEqualTypeOf();
+    expect(data.sandwich).toBeDefined();
+    expect(data.sandwich).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sandwich).toEqualTypeOf();
+    expect(data.santa).toBeDefined();
+    expect(data.santa).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.santa).toEqualTypeOf();
+    expect(data.santaClaus).toBeDefined();
+    expect(data.santaClaus).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.santaClaus).toEqualTypeOf();
+    expect(data.santasSleigh).toBeDefined();
+    expect(data.santasSleigh).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.santasSleigh).toEqualTypeOf();
+    expect(data.santasWorkshop).toBeDefined();
+    expect(data.santasWorkshop).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.santasWorkshop).toEqualTypeOf();
+    expect(data.scarecrow).toBeDefined();
+    expect(data.scarecrow).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.scarecrow).toEqualTypeOf();
+    expect(data.scaryMovie).toBeDefined();
+    expect(data.scaryMovie).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.scaryMovie).toEqualTypeOf();
+    expect(data.school).toBeDefined();
+    expect(data.school).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.school).toEqualTypeOf();
+    expect(data.schoolBus).toBeDefined();
+    expect(data.schoolBus).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.schoolBus).toEqualTypeOf();
+    expect(data.scifi).toBeDefined();
+    expect(data.scifi).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.scifi).toEqualTypeOf();
+    expect(data.scientist).toBeDefined();
+    expect(data.scientist).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.scientist).toEqualTypeOf();
+    expect(data.scissors).toBeDefined();
+    expect(data.scissors).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.scissors).toEqualTypeOf();
+    expect(data.screw).toBeDefined();
+    expect(data.screw).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.screw).toEqualTypeOf();
+    expect(data.scythe).toBeDefined();
+    expect(data.scythe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.scythe).toEqualTypeOf();
+    expect(data.selfPortrait).toBeDefined();
+    expect(data.selfPortrait).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.selfPortrait).toEqualTypeOf();
+    expect(data.sewer).toBeDefined();
+    expect(data.sewer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sewer).toEqualTypeOf();
+    expect(data.shark).toBeDefined();
+    expect(data.shark).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shark).toEqualTypeOf();
+    expect(data.sheep).toBeDefined();
+    expect(data.sheep).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sheep).toEqualTypeOf();
+    expect(data.shell).toBeDefined();
+    expect(data.shell).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shell).toEqualTypeOf();
+    expect(data.shepherd).toBeDefined();
+    expect(data.shepherd).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shepherd).toEqualTypeOf();
+    expect(data.shipwreck).toBeDefined();
+    expect(data.shipwreck).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shipwreck).toEqualTypeOf();
+    expect(data.shoe).toBeDefined();
+    expect(data.shoe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shoe).toEqualTypeOf();
+    expect(data.shopping).toBeDefined();
+    expect(data.shopping).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shopping).toEqualTypeOf();
+    expect(data.shovel).toBeDefined();
+    expect(data.shovel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.shovel).toEqualTypeOf();
+    expect(data.skateboard).toBeDefined();
+    expect(data.skateboard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skateboard).toEqualTypeOf();
+    expect(data.skatepark).toBeDefined();
+    expect(data.skatepark).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skatepark).toEqualTypeOf();
+    expect(data.skatingRink).toBeDefined();
+    expect(data.skatingRink).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skatingRink).toEqualTypeOf();
+    expect(data.skeleton).toBeDefined();
+    expect(data.skeleton).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skeleton).toEqualTypeOf();
+    expect(data.skeletonJockey).toBeDefined();
+    expect(data.skeletonJockey).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skeletonJockey).toEqualTypeOf();
+    expect(data.skiCabin).toBeDefined();
+    expect(data.skiCabin).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skiCabin).toEqualTypeOf();
+    expect(data.skull).toBeDefined();
+    expect(data.skull).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skull).toEqualTypeOf();
+    expect(data.skydiver).toBeDefined();
+    expect(data.skydiver).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.skydiver).toEqualTypeOf();
+    expect(data.sled).toBeDefined();
+    expect(data.sled).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sled).toEqualTypeOf();
+    expect(data.slenderman).toBeDefined();
+    expect(data.slenderman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.slenderman).toEqualTypeOf();
+    expect(data.slime).toBeDefined();
+    expect(data.slime).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.slime).toEqualTypeOf();
+    expect(data.snail).toBeDefined();
+    expect(data.snail).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snail).toEqualTypeOf();
+    expect(data.snake).toBeDefined();
+    expect(data.snake).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snake).toEqualTypeOf();
+    expect(data.snowAngel).toBeDefined();
+    expect(data.snowAngel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowAngel).toEqualTypeOf();
+    expect(data.snowFort).toBeDefined();
+    expect(data.snowFort).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowFort).toEqualTypeOf();
+    expect(data.snowGlobe).toBeDefined();
+    expect(data.snowGlobe).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowGlobe).toEqualTypeOf();
+    expect(data.snowballFight).toBeDefined();
+    expect(data.snowballFight).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowballFight).toEqualTypeOf();
+    expect(data.snowflake).toBeDefined();
+    expect(data.snowflake).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowflake).toEqualTypeOf();
+    expect(data.snowman).toBeDefined();
+    expect(data.snowman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowman).toEqualTypeOf();
+    expect(data.snowyForest).toBeDefined();
+    expect(data.snowyForest).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.snowyForest).toEqualTypeOf();
+    expect(data.solarPanels).toBeDefined();
+    expect(data.solarPanels).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.solarPanels).toEqualTypeOf();
+    expect(data.solarSystem).toBeDefined();
+    expect(data.solarSystem).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.solarSystem).toEqualTypeOf();
+    expect(data.soldier).toBeDefined();
+    expect(data.soldier).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.soldier).toEqualTypeOf();
+    expect(data.sorcerer).toBeDefined();
+    expect(data.sorcerer).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sorcerer).toEqualTypeOf();
+    expect(data.soup).toBeDefined();
+    expect(data.soup).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.soup).toEqualTypeOf();
+    expect(data.space).toBeDefined();
+    expect(data.space).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.space).toEqualTypeOf();
+    expect(data.spaceship).toBeDefined();
+    expect(data.spaceship).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spaceship).toEqualTypeOf();
+    expect(data.spellbook).toBeDefined();
+    expect(data.spellbook).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spellbook).toEqualTypeOf();
+    expect(data.spider).toBeDefined();
+    expect(data.spider).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spider).toEqualTypeOf();
+    expect(data.spiderWeb).toBeDefined();
+    expect(data.spiderWeb).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spiderWeb).toEqualTypeOf();
+    expect(data.spirit).toBeDefined();
+    expect(data.spirit).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spirit).toEqualTypeOf();
+    expect(data.spirits).toBeDefined();
+    expect(data.spirits).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spirits).toEqualTypeOf();
+    expect(data.sponge).toBeDefined();
+    expect(data.sponge).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sponge).toEqualTypeOf();
+    expect(data.spookyTree).toBeDefined();
+    expect(data.spookyTree).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spookyTree).toEqualTypeOf();
+    expect(data.spring).toBeDefined();
+    expect(data.spring).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spring).toEqualTypeOf();
+    expect(data.spy).toBeDefined();
+    expect(data.spy).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.spy).toEqualTypeOf();
+    expect(data.stadium).toBeDefined();
+    expect(data.stadium).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.stadium).toEqualTypeOf();
+    expect(data.stamp).toBeDefined();
+    expect(data.stamp).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.stamp).toEqualTypeOf();
+    expect(data.star).toBeDefined();
+    expect(data.star).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.star).toEqualTypeOf();
+    expect(data.starryNight).toBeDefined();
+    expect(data.starryNight).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.starryNight).toEqualTypeOf();
+    expect(data.steamLocomotive).toBeDefined();
+    expect(data.steamLocomotive).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.steamLocomotive).toEqualTypeOf();
+    expect(data.steamPunk).toBeDefined();
+    expect(data.steamPunk).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.steamPunk).toEqualTypeOf();
+    expect(data.steampunk).toBeDefined();
+    expect(data.steampunk).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.steampunk).toEqualTypeOf();
+    expect(data.stick).toBeDefined();
+    expect(data.stick).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.stick).toEqualTypeOf();
+    expect(data.stocking).toBeDefined();
+    expect(data.stocking).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.stocking).toEqualTypeOf();
+    expect(data.sun).toBeDefined();
+    expect(data.sun).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sun).toEqualTypeOf();
+    expect(data.sunset).toBeDefined();
+    expect(data.sunset).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sunset).toEqualTypeOf();
+    expect(data.superHero).toBeDefined();
+    expect(data.superHero).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.superHero).toEqualTypeOf();
+    expect(data.superhero).toBeDefined();
+    expect(data.superhero).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.superhero).toEqualTypeOf();
+    expect(data.supernatural).toBeDefined();
+    expect(data.supernatural).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.supernatural).toEqualTypeOf();
+    expect(data.surfboard).toBeDefined();
+    expect(data.surfboard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.surfboard).toEqualTypeOf();
+    expect(data.surprise).toBeDefined();
+    expect(data.surprise).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.surprise).toEqualTypeOf();
+    expect(data.surreal).toBeDefined();
+    expect(data.surreal).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.surreal).toEqualTypeOf();
+    expect(data.sushi).toBeDefined();
+    expect(data.sushi).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sushi).toEqualTypeOf();
+    expect(data.swamp).toBeDefined();
+    expect(data.swamp).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.swamp).toEqualTypeOf();
+    expect(data.sweet).toBeDefined();
+    expect(data.sweet).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sweet).toEqualTypeOf();
+    expect(data.sweets).toBeDefined();
+    expect(data.sweets).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sweets).toEqualTypeOf();
+    expect(data.swing).toBeDefined();
+    expect(data.swing).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.swing).toEqualTypeOf();
+    expect(data.sword).toBeDefined();
+    expect(data.sword).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.sword).toEqualTypeOf();
+    expect(data.talentShow).toBeDefined();
+    expect(data.talentShow).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.talentShow).toEqualTypeOf();
+    expect(data.tank).toBeDefined();
+    expect(data.tank).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tank).toEqualTypeOf();
+    expect(data.tarantula).toBeDefined();
+    expect(data.tarantula).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tarantula).toEqualTypeOf();
+    expect(data.teddyBear).toBeDefined();
+    expect(data.teddyBear).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.teddyBear).toEqualTypeOf();
+    expect(data.temple).toBeDefined();
+    expect(data.temple).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.temple).toEqualTypeOf();
+    expect(data.tennis).toBeDefined();
+    expect(data.tennis).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tennis).toEqualTypeOf();
+    expect(data.tent).toBeDefined();
+    expect(data.tent).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tent).toEqualTypeOf();
+    expect(data.test).toBeDefined();
+    expect(data.test).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.test).toEqualTypeOf();
+    expect(data.tests).toBeDefined();
+    expect(data.tests).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tests).toEqualTypeOf();
+    expect(data.theBestToyEver).toBeDefined();
+    expect(data.theBestToyEver).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.theBestToyEver).toEqualTypeOf();
+    expect(data.theFuture).toBeDefined();
+    expect(data.theFuture).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.theFuture).toEqualTypeOf();
+    expect(data.theGrinch).toBeDefined();
+    expect(data.theGrinch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.theGrinch).toEqualTypeOf();
+    expect(data.theater).toBeDefined();
+    expect(data.theater).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.theater).toEqualTypeOf();
+    expect(data.themePark).toBeDefined();
+    expect(data.themePark).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.themePark).toEqualTypeOf();
+    expect(data.throne).toBeDefined();
+    expect(data.throne).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.throne).toEqualTypeOf();
+    expect(data.thunderAndLightning).toBeDefined();
+    expect(data.thunderAndLightning).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.thunderAndLightning).toEqualTypeOf();
+    expect(data.ticket).toBeDefined();
+    expect(data.ticket).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.ticket).toEqualTypeOf();
+    expect(data.tiger).toBeDefined();
+    expect(data.tiger).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tiger).toEqualTypeOf();
+    expect(data.tomb).toBeDefined();
+    expect(data.tomb).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tomb).toEqualTypeOf();
+    expect(data.tombstone).toBeDefined();
+    expect(data.tombstone).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tombstone).toEqualTypeOf();
+    expect(data.tooth).toBeDefined();
+    expect(data.tooth).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tooth).toEqualTypeOf();
+    expect(data.toothpaste).toBeDefined();
+    expect(data.toothpaste).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.toothpaste).toEqualTypeOf();
+    expect(data.topHat).toBeDefined();
+    expect(data.topHat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.topHat).toEqualTypeOf();
+    expect(data.torch).toBeDefined();
+    expect(data.torch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.torch).toEqualTypeOf();
+    expect(data.tornado).toBeDefined();
+    expect(data.tornado).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tornado).toEqualTypeOf();
+    expect(data.tower).toBeDefined();
+    expect(data.tower).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tower).toEqualTypeOf();
+    expect(data.towerOfPisa).toBeDefined();
+    expect(data.towerOfPisa).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.towerOfPisa).toEqualTypeOf();
+    expect(data.toyBox).toBeDefined();
+    expect(data.toyBox).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.toyBox).toEqualTypeOf();
+    expect(data.toyFactory).toBeDefined();
+    expect(data.toyFactory).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.toyFactory).toEqualTypeOf();
+    expect(data.toys).toBeDefined();
+    expect(data.toys).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.toys).toEqualTypeOf();
+    expect(data.tractor).toBeDefined();
+    expect(data.tractor).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.tractor).toEqualTypeOf();
+    expect(data.train).toBeDefined();
+    expect(data.train).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.train).toEqualTypeOf();
+    expect(data.trainStation).toBeDefined();
+    expect(data.trainStation).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.trainStation).toEqualTypeOf();
+    expect(data.trainstation).toBeDefined();
+    expect(data.trainstation).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.trainstation).toEqualTypeOf();
+    expect(data.trampoline).toBeDefined();
+    expect(data.trampoline).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.trampoline).toEqualTypeOf();
+    expect(data.treasure).toBeDefined();
+    expect(data.treasure).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.treasure).toEqualTypeOf();
+    expect(data.treasureChest).toBeDefined();
+    expect(data.treasureChest).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.treasureChest).toEqualTypeOf();
+    expect(data.treehouse).toBeDefined();
+    expect(data.treehouse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.treehouse).toEqualTypeOf();
+    expect(data.trickortreating).toBeDefined();
+    expect(data.trickortreating).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.trickortreating).toEqualTypeOf();
+    expect(data.troll).toBeDefined();
+    expect(data.troll).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.troll).toEqualTypeOf();
+    expect(data.truck).toBeDefined();
+    expect(data.truck).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.truck).toEqualTypeOf();
+    expect(data.turkey).toBeDefined();
+    expect(data.turkey).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.turkey).toEqualTypeOf();
+    expect(data.turtle).toBeDefined();
+    expect(data.turtle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.turtle).toEqualTypeOf();
+    expect(data.usa).toBeDefined();
+    expect(data.usa).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.usa).toEqualTypeOf();
+    expect(data.umbrella).toBeDefined();
+    expect(data.umbrella).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.umbrella).toEqualTypeOf();
+    expect(data.undead).toBeDefined();
+    expect(data.undead).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.undead).toEqualTypeOf();
+    expect(data.underTheSea).toBeDefined();
+    expect(data.underTheSea).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.underTheSea).toEqualTypeOf();
+    expect(data.underground).toBeDefined();
+    expect(data.underground).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.underground).toEqualTypeOf();
+    expect(data.unicorn).toBeDefined();
+    expect(data.unicorn).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.unicorn).toEqualTypeOf();
+    expect(data.vampire).toBeDefined();
+    expect(data.vampire).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.vampire).toEqualTypeOf();
+    expect(data.vegetableGarden).toBeDefined();
+    expect(data.vegetableGarden).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.vegetableGarden).toEqualTypeOf();
+    expect(data.vehicle).toBeDefined();
+    expect(data.vehicle).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.vehicle).toEqualTypeOf();
+    expect(data.vendingMachine).toBeDefined();
+    expect(data.vendingMachine).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.vendingMachine).toEqualTypeOf();
+    expect(data.videoGame).toBeDefined();
+    expect(data.videoGame).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.videoGame).toEqualTypeOf();
+    expect(data.viking).toBeDefined();
+    expect(data.viking).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.viking).toEqualTypeOf();
+    expect(data.volcano).toBeDefined();
+    expect(data.volcano).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.volcano).toEqualTypeOf();
+    expect(data.volcanoEruption).toBeDefined();
+    expect(data.volcanoEruption).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.volcanoEruption).toEqualTypeOf();
+    expect(data.volleyballCourt).toBeDefined();
+    expect(data.volleyballCourt).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.volleyballCourt).toEqualTypeOf();
+    expect(data.wallet).toBeDefined();
+    expect(data.wallet).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wallet).toEqualTypeOf();
+    expect(data.warlock).toBeDefined();
+    expect(data.warlock).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.warlock).toEqualTypeOf();
+    expect(data.watch).toBeDefined();
+    expect(data.watch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.watch).toEqualTypeOf();
+    expect(data.waterBucket).toBeDefined();
+    expect(data.waterBucket).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.waterBucket).toEqualTypeOf();
+    expect(data.waterfall).toBeDefined();
+    expect(data.waterfall).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.waterfall).toEqualTypeOf();
+    expect(data.web).toBeDefined();
+    expect(data.web).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.web).toEqualTypeOf();
+    expect(data.weightlifting).toBeDefined();
+    expect(data.weightlifting).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.weightlifting).toEqualTypeOf();
+    expect(data.werewolf).toBeDefined();
+    expect(data.werewolf).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.werewolf).toEqualTypeOf();
+    expect(data.western).toBeDefined();
+    expect(data.western).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.western).toEqualTypeOf();
+    expect(data.whale).toBeDefined();
+    expect(data.whale).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.whale).toEqualTypeOf();
+    expect(data.wheel).toBeDefined();
+    expect(data.wheel).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wheel).toEqualTypeOf();
+    expect(data.wickedWitch).toBeDefined();
+    expect(data.wickedWitch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wickedWitch).toEqualTypeOf();
+    expect(data.windmill).toBeDefined();
+    expect(data.windmill).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.windmill).toEqualTypeOf();
+    expect(data.winterSuit).toBeDefined();
+    expect(data.winterSuit).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.winterSuit).toEqualTypeOf();
+    expect(data.wisemen).toBeDefined();
+    expect(data.wisemen).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wisemen).toEqualTypeOf();
+    expect(data.wish).toBeDefined();
+    expect(data.wish).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wish).toEqualTypeOf();
+    expect(data.witch).toBeDefined();
+    expect(data.witch).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.witch).toEqualTypeOf();
+    expect(data.witchHut).toBeDefined();
+    expect(data.witchHut).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.witchHut).toEqualTypeOf();
+    expect(data.witchcraft).toBeDefined();
+    expect(data.witchcraft).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.witchcraft).toEqualTypeOf();
+    expect(data.witchesHat).toBeDefined();
+    expect(data.witchesHat).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.witchesHat).toEqualTypeOf();
+    expect(data.wizard).toBeDefined();
+    expect(data.wizard).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wizard).toEqualTypeOf();
+    expect(data.wolves).toBeDefined();
+    expect(data.wolves).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wolves).toEqualTypeOf();
+    expect(data.wonderland).toBeDefined();
+    expect(data.wonderland).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wonderland).toEqualTypeOf();
+    expect(data.world).toBeDefined();
+    expect(data.world).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.world).toEqualTypeOf();
+    expect(data.worm).toBeDefined();
+    expect(data.worm).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.worm).toEqualTypeOf();
+    expect(data.wreath).toBeDefined();
+    expect(data.wreath).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.wreath).toEqualTypeOf();
+    expect(data.yuleLog).toBeDefined();
+    expect(data.yuleLog).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.yuleLog).toEqualTypeOf();
+    expect(data.zebra).toBeDefined();
+    expect(data.zebra).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.zebra).toEqualTypeOf();
+    expect(data.zombie).toBeDefined();
+    expect(data.zombie).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.zombie).toEqualTypeOf();
+    expect(data.zombieApocalypse).toBeDefined();
+    expect(data.zombieApocalypse).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.zombieApocalypse).toEqualTypeOf();
+    expect(data.zombiePigman).toBeDefined();
+    expect(data.zombiePigman).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.zombiePigman).toEqualTypeOf();
+    expect(data.zombies).toBeDefined();
+    expect(data.zombies).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.zombies).toEqualTypeOf();
+    expect(data.zoo).toBeDefined();
+    expect(data.zoo).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.zoo).toEqualTypeOf();
+    expect(data.null).toBeDefined();
+    expect(data.null).toBeGreaterThanOrEqual(0);
+    expectTypeOf(data.null).toEqualTypeOf();
+});
+//# sourceMappingURL=BuildBattleVotes.test.js.map