hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/API/getLeaderboards.test.js

@@ -0,0 +1,55 @@
+import Client from '../Client';
+import Leaderboard from '../structures/Leaderboard';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+test('getLeaderboards (raw)', 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.getLeaderboards({ raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getLeaderboards', 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.getLeaderboards();
+    Object.keys(data).forEach((key) => {
+        expect(data[key]).toBeDefined();
+        expectTypeOf(data[key]).toEqualTypeOf();
+        data[key].forEach((leaderboard) => {
+            expect(leaderboard).toBeDefined();
+            expect(leaderboard).instanceOf(Leaderboard);
+            expectTypeOf(leaderboard).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.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) => {
+                expect(leader).toBeDefined();
+                expectTypeOf(leader).toEqualTypeOf();
+            });
+        });
+    });
+    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();
+});

package/dist/src/API/getPlayer.js

@@ -0,0 +1,31 @@
+import Endpoint from '../Private/Endpoint';
+import Player from '../structures/Player';
+class getPlayer extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(query, options) {
+        if (!query)
+            throw new Error(this.client.errors.NO_NICKNAME_UUID);
+        query = await this.client.requests.toUUID(query);
+        const res = await this.client.requests.request(`/player?uuid=${query}`, options);
+        if (res.options.raw)
+            return res.data;
+        if (query && !res.data.player)
+            throw new Error(this.client.errors.PLAYER_HAS_NEVER_LOGGED);
+        return new Player(res.data.player, {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            guild: options?.guild ? await this.client.getGuild('player', query) : null,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            houses: options?.houses ? await this.client.getPlayerHouses(query) : null,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-expect-error
+            recentGames: options?.recentGames ? await this.client.getRecentGames(query) : null
+        });
+    }
+}
+export default getPlayer;

package/dist/src/API/getPlayer.test.js

@@ -0,0 +1,290 @@
+import Arcade from '../structures/MiniGames/Arcade';
+import ArenaBrawl from '../structures/MiniGames/ArenaBrawl';
+import BedWars from '../structures/MiniGames/BedWars';
+import BlitzSurvivalGames from '../structures/MiniGames/BlitzSurvivalGames';
+import BuildBattle from '../structures/MiniGames/BuildBattle';
+import Client from '../Client';
+import CopsAndCrims from '../structures/MiniGames/CopsAndCrims';
+import Duels from '../structures/MiniGames/Duels';
+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 from '../structures/MiniGames/Pit';
+import Player from '../structures/Player';
+import Quakecraft from '../structures/MiniGames/Quakecraft';
+import RecentGame from '../structures/RecentGame';
+import SkyWars from '../structures/MiniGames/SkyWars';
+import SmashHeroes from '../structures/MiniGames/SmashHeroes';
+import SpeedUHC from '../structures/MiniGames/SpeedUHC';
+import TNTGames from '../structures/MiniGames/TNTGames';
+import TurboKartRacers from '../structures/MiniGames/TurboKartRacers';
+import UHC from '../structures/MiniGames/UHC';
+import VampireZ from '../structures/MiniGames/VampireZ';
+import Walls from '../structures/MiniGames/Walls';
+import Warlords from '../structures/MiniGames/Warlords';
+import WoolWars from '../structures/MiniGames/WoolWars';
+import axios from 'axios';
+import { expect, expectTypeOf, test, vi } from 'vitest';
+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);
+    client.destroy();
+});
+test('getPLayer (raw)', 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('14727faefbdc4aff848cd2713eb9939e', { 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, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const data = await client.getPlayer('14727faefbdc4aff848cd2713eb9939e', { guild: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.guild).toBeDefined();
+    expectTypeOf(data.guild).toEqualTypeOf();
+    expect(data.guild).toBeInstanceOf(Guild);
+    client.destroy();
+});
+test('getPlayer (houses)', 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('14727faefbdc4aff848cd2713eb9939e', { houses: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.houses).toBeDefined();
+    expectTypeOf(data.houses).toEqualTypeOf();
+    data.houses.forEach((house) => {
+        expect(house).toBeDefined();
+        expect(house).toBeInstanceOf(House);
+        expectTypeOf(house).toEqualTypeOf();
+    });
+    client.destroy();
+});
+test('getPlayer (recent games)', 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('14727faefbdc4aff848cd2713eb9939e', { recentGames: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.recentGames).toBeDefined();
+    expectTypeOf(data.recentGames).toEqualTypeOf();
+    data.recentGames.forEach((game) => {
+        expect(game).toBeDefined();
+        expect(game).toBeInstanceOf(RecentGame);
+        expectTypeOf(game).toEqualTypeOf();
+    });
+    client.destroy();
+});
+test('getPlayer', 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('14727faefbdc4aff848cd2713eb9939e');
+    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.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();
+    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();
+        expect(data.plusColor.toString()).toBeDefined();
+        expectTypeOf(data.plusColor.toString()).toEqualTypeOf();
+        expect(data.plusColor.toHex).toBeDefined();
+        expectTypeOf(data.plusColor.toHex).toEqualTypeOf();
+        expect(data.plusColor.toHex()).toBeDefined();
+        expectTypeOf(data.plusColor.toHex()).toEqualTypeOf();
+        expect(data.plusColor.toCode).toBeDefined();
+        expectTypeOf(data.plusColor.toCode).toEqualTypeOf();
+        expect(data.plusColor.toCode()).toBeDefined();
+        expectTypeOf(data.plusColor.toCode()).toEqualTypeOf();
+        expect(data.plusColor.toInGameCode).toBeDefined();
+        expectTypeOf(data.plusColor.toInGameCode).toEqualTypeOf();
+        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();
+        expect(data.prefixColor.toString()).toBeDefined();
+        expectTypeOf(data.prefixColor.toString()).toEqualTypeOf();
+        expect(data.prefixColor.toHex).toBeDefined();
+        expectTypeOf(data.prefixColor.toHex).toEqualTypeOf();
+        expect(data.prefixColor.toHex()).toBeDefined();
+        expectTypeOf(data.prefixColor.toHex()).toEqualTypeOf();
+        expect(data.prefixColor.toCode).toBeDefined();
+        expectTypeOf(data.prefixColor.toCode).toEqualTypeOf();
+        expect(data.prefixColor.toCode()).toBeDefined();
+        expectTypeOf(data.prefixColor.toCode()).toEqualTypeOf();
+        expect(data.prefixColor.toInGameCode).toBeDefined();
+        expectTypeOf(data.prefixColor.toInGameCode).toEqualTypeOf();
+        expect(data.prefixColor.toInGameCode()).toBeDefined();
+        expectTypeOf(data.prefixColor.toInGameCode()).toEqualTypeOf();
+    }
+    expect(data.karma).toBeDefined();
+    expectTypeOf(data.karma).toEqualTypeOf();
+    expect(data.achievements).toBeDefined();
+    expectTypeOf(data.achievements).toEqualTypeOf();
+    expect(data.achievementPoints).toBeDefined();
+    expectTypeOf(data.achievementPoints).toEqualTypeOf();
+    expect(data.totalExperience).toBeDefined();
+    expectTypeOf(data.totalExperience).toEqualTypeOf();
+    expect(data.level).toBeDefined();
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.socialMedia).toBeDefined();
+    expectTypeOf(data.socialMedia).toEqualTypeOf();
+    expect(data.giftBundlesSent).toBeDefined();
+    expectTypeOf(data.giftBundlesSent).toEqualTypeOf();
+    expect(data.giftBundlesReceived).toBeDefined();
+    expectTypeOf(data.giftBundlesReceived).toEqualTypeOf();
+    expect(data.giftsSent).toBeDefined();
+    expectTypeOf(data.giftsSent).toEqualTypeOf();
+    expect(data.isOnline).toBeDefined();
+    expectTypeOf(data.isOnline).toEqualTypeOf();
+    expect(data.lastDailyReward).toBeDefined();
+    expectTypeOf(data.lastDailyReward).toEqualTypeOf();
+    expect(data.lastDailyRewardTimestamp).toBeDefined();
+    expectTypeOf(data.lastDailyRewardTimestamp).toEqualTypeOf();
+    expect(data.totalRewards).toBeDefined();
+    expectTypeOf(data.totalRewards).toEqualTypeOf();
+    expect(data.totalDailyRewards).toBeDefined();
+    expectTypeOf(data.totalDailyRewards).toEqualTypeOf();
+    expect(data.rewardStreak).toBeDefined();
+    expectTypeOf(data.rewardStreak).toEqualTypeOf();
+    expect(data.rewardScore).toBeDefined();
+    expectTypeOf(data.rewardScore).toEqualTypeOf();
+    expect(data.rewardHighScore).toBeDefined();
+    expectTypeOf(data.rewardHighScore).toEqualTypeOf();
+    expect(data.levelProgress).toBeDefined();
+    expectTypeOf(data.levelProgress).toEqualTypeOf();
+    expect(data.stats).toBeDefined();
+    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.woolwars).toBeDefined();
+    expect(data.stats.woolwars).instanceOf(WoolWars);
+    expectTypeOf(data.stats.woolwars).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();
+    client.destroy();
+});

package/dist/src/API/getPlayerHouses.js

@@ -0,0 +1,19 @@
+import Endpoint from '../Private/Endpoint';
+import House from '../structures/House';
+class getPlayerHouses extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(query, options) {
+        if (!query)
+            throw new Error(this.client.errors.NO_NICKNAME_UUID);
+        query = await this.client.requests.toUUID(query);
+        const res = await this.client.requests.request(`/housing/houses?player=${query}`, options);
+        if (res.options.raw)
+            return res.data;
+        return res.data.map((h) => new House(h));
+    }
+}
+export default getPlayerHouses;

package/dist/src/API/getPlayerHouses.test.js

@@ -0,0 +1,50 @@
+import Client from '../Client';
+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, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.getPlayerHouses()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+    client.destroy();
+});
+test('getPlayerHouses (raw)', 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.getPlayerHouses('69e04609da2a4e7dabb83546a971969e', { raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getPlayerHouses', 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.getPlayerHouses('69e04609da2a4e7dabb83546a971969e');
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    data.forEach((house) => {
+        expect(house).toBeDefined();
+        expect(house).toBeInstanceOf(House);
+        expectTypeOf(house).toEqualTypeOf();
+        expect(house.name).toBeDefined();
+        expectTypeOf(house.name).toEqualTypeOf();
+        expect(house.uuid).toBeDefined();
+        expectTypeOf(house.uuid).toEqualTypeOf();
+        expect(house.owner).toBeDefined();
+        expectTypeOf(house.owner).toEqualTypeOf();
+        expect(house.createdAtTimestamp).toBeDefined();
+        expectTypeOf(house.createdAtTimestamp).toEqualTypeOf();
+        expect(house.createdAt).toBeDefined();
+        expectTypeOf(house.createdAt).toEqualTypeOf();
+        expect(house.players).toBeDefined();
+        expectTypeOf(house.players).toEqualTypeOf();
+        expect(house.cookies).toBeDefined();
+        expectTypeOf(house.cookies).toEqualTypeOf();
+        expect(house.toString()).toBeDefined();
+        expectTypeOf(house.toString()).toEqualTypeOf();
+        expect(house.toString()).toBe(house.name);
+    });
+    client.destroy();
+});

package/dist/src/API/getQuests.js

@@ -0,0 +1,16 @@
+import Endpoint from '../Private/Endpoint';
+import Quests from '../structures/Static/Quests';
+class getQuests extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(options) {
+        const res = await this.client.requests.request('/resources/quests', options);
+        if (res.options.raw)
+            return res.data;
+        return new Quests(res.data);
+    }
+}
+export default getQuests;

package/dist/src/API/getQuests.test.js

@@ -0,0 +1,48 @@
+import Client from '../Client';
+import GameQuests from '../structures/Static/GameQuests';
+import Quest from '../structures/Static/Quest';
+import Quests from '../structures/Static/Quests';
+import { expect, expectTypeOf, test } from 'vitest';
+test('getQuests (raw)', 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.getQuests({ raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getQuests', 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.getQuests();
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Quests);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.lastUpdatedTimestamp).toBeDefined();
+    expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf();
+    expect(data.lastUpdatedTimestamp).toBeGreaterThanOrEqual(0);
+    expect(data.lastUpdatedAt).toBeDefined();
+    expectTypeOf(data.lastUpdatedAt).toEqualTypeOf();
+    expect(data.questsPerGame).toBeDefined();
+    expectTypeOf(data.questsPerGame).toEqualTypeOf();
+    Object.keys(data.questsPerGame).forEach((game) => {
+        expect(data.questsPerGame[game]).toBeDefined();
+        expect(data.questsPerGame[game]).toBeInstanceOf(GameQuests);
+        expectTypeOf(data.questsPerGame[game]).toEqualTypeOf();
+        expect(data.questsPerGame[game].game).toBeDefined();
+        expect(data.questsPerGame[game].game).toBe(game);
+        expectTypeOf(data.questsPerGame[game].game).toEqualTypeOf();
+        expect(data.questsPerGame[game].quests).toBeDefined();
+        expectTypeOf(data.questsPerGame[game].quests).toEqualTypeOf();
+        data.questsPerGame[game].quests.forEach((quest) => {
+            expect(quest).toBeDefined();
+            expect(quest).toBeInstanceOf(Quest);
+            expectTypeOf(quest).toEqualTypeOf();
+            expect(quest.toString()).toBeDefined();
+            expectTypeOf(quest.toString()).toEqualTypeOf();
+        });
+    });
+    client.destroy();
+});

package/dist/src/API/getRecentGames.js

@@ -0,0 +1,19 @@
+import Endpoint from '../Private/Endpoint';
+import RecentGame from '../structures/RecentGame';
+class getRecentGames extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(query, options) {
+        if (!query)
+            throw new Error(this.client.errors.NO_NICKNAME_UUID);
+        query = await this.client.requests.toUUID(query);
+        const res = await this.client.requests.request(`/recentgames?uuid=${query}`, options);
+        if (res.options.raw)
+            return res.data;
+        return res.data.games.map((x) => new RecentGame(x));
+    }
+}
+export default getRecentGames;

package/dist/src/API/getRecentGames.test.js

@@ -0,0 +1,52 @@
+import Client from '../Client';
+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, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.getRecentGames()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+    client.destroy();
+});
+test('getRecentGames (raw)', 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.getRecentGames('add71246c46e455c8345c129ea6f146c', { raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getRecentGames', 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.getRecentGames('add71246c46e455c8345c129ea6f146c');
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    data.forEach((game) => {
+        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.date).toBeDefined();
+        expectTypeOf(game.date).toEqualTypeOf();
+        expect(game.mode).toBeDefined();
+        expectTypeOf(game.mode).toEqualTypeOf();
+        expect(game.map).toBeDefined();
+        expectTypeOf(game.map).toEqualTypeOf();
+        expect(game.ongoing).toBeDefined();
+        expectTypeOf(game.ongoing).toEqualTypeOf();
+        expect(game.endedAt).toBeDefined();
+        expectTypeOf(game.endedAt).toEqualTypeOf();
+        expect(game.endedTimestamp).toBeDefined();
+        expectTypeOf(game.endedTimestamp).toEqualTypeOf();
+        expect(game.toString()).toBeDefined();
+        expect(game.toString()).toEqual(game.mode);
+        expectTypeOf(game.toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});

package/dist/src/API/getSkyblockAuction.js

@@ -0,0 +1,32 @@
+import Auction from '../structures/SkyBlock/Auctions/Auction';
+import Endpoint from '../Private/Endpoint';
+class getSkyblockAction extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(type, query, options) {
+        let filter;
+        if ('profile' === type) {
+            filter = 'profile';
+        }
+        else if ('player' === type && query) {
+            query = await this.client.requests.toUUID(query);
+            filter = 'player';
+        }
+        else if ('auction' === type) {
+            filter = 'uuid';
+        }
+        else {
+            throw new Error(this.client.errors.BAD_AUCTION_FILTER);
+        }
+        if (!query)
+            throw new Error(this.client.errors.NO_NICKNAME_UUID);
+        const res = await this.client.requests.request(`/skyblock/auction?${filter}=${query}`, options);
+        if (res.options.raw)
+            return res.data;
+        return res.data.auctions.map((a) => new Auction(a, options?.includeItemBytes ?? false));
+    }
+}
+export default getSkyblockAction;