hypixel-api-reborn 11.3.4 → 12.0.0-0

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

@@ -0,0 +1,508 @@
+import Client from '../Client';
+import Game from '../structures/Game';
+import Guild from '../structures/Guild/Guild';
+import GuildMember from '../structures/Guild/GuildMember';
+import GuildRank from '../structures/Guild/GuildRank';
+import { expect, expectTypeOf, test } from 'vitest';
+test('Invalid Guild Type', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.getGuild('invalid', 'invalid')).rejects.toThrowError(client.errors.INVALID_GUILD_SEARCH_PARAMETER);
+    client.destroy();
+});
+test('Invalid Guild', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.getGuild('name', 'this guild dose not exist')).rejects.toThrowError(client.errors.GUILD_DOES_NOT_EXIST);
+    client.destroy();
+});
+test('Invalid Guild ID', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.getGuild('id', 'invalid guild id')).rejects.toThrowError(client.errors.INVALID_GUILD_ID);
+    client.destroy();
+});
+test('No Guild Query', () => {
+    const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(() => client.getGuild('id')).rejects.toThrowError(client.errors.NO_GUILD_QUERY);
+    client.destroy();
+});
+test('User not in a 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.getGuild('player', '37501e7512b845ab8796e2baf9e9677a');
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getGuild (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.getGuild('name', 'Pixelic', { raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getGuild (Name)', 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.getGuild('name', 'Pixelic');
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Guild);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.id).toBeDefined();
+    expectTypeOf(data.id).toEqualTypeOf();
+    expect(data.name).toBeDefined();
+    expectTypeOf(data.name).toEqualTypeOf();
+    expect(data.description).toBeDefined();
+    expectTypeOf(data.description).toEqualTypeOf();
+    expect(data.experience).toBeDefined();
+    expectTypeOf(data.experience).toEqualTypeOf();
+    expect(data.experience).toBeGreaterThanOrEqual(0);
+    expect(data.level).toBeDefined();
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.members).toBeDefined();
+    expectTypeOf(data.members).toEqualTypeOf();
+    data.members.forEach((member) => {
+        expect(member).toBeDefined();
+        expectTypeOf(member).toEqualTypeOf();
+        expect(member.uuid).toBeDefined();
+        expectTypeOf(member.uuid).toEqualTypeOf();
+        expect(member.joinedAtTimestamp).toBeDefined();
+        expectTypeOf(member.joinedAtTimestamp).toEqualTypeOf();
+        expect(member.joinedAt).toBeDefined();
+        expectTypeOf(member.joinedAt).toEqualTypeOf();
+        expect(member.questParticipation).toBeDefined();
+        expectTypeOf(member.questParticipation).toEqualTypeOf();
+        expect(member.rank).toBeDefined();
+        expectTypeOf(member.rank).toEqualTypeOf();
+        expect(member.mutedUntilTimestamp).toBeDefined();
+        expectTypeOf(member.mutedUntilTimestamp).toEqualTypeOf();
+        expect(member.mutedUntil).toBeDefined();
+        expectTypeOf(member.mutedUntil).toEqualTypeOf();
+        expect(member.expHistory).toBeDefined();
+        expectTypeOf(member.expHistory).toEqualTypeOf();
+        expect(member.weeklyExperience).toBeDefined();
+        expectTypeOf(member.weeklyExperience).toEqualTypeOf();
+        expect(member.weeklyExperience).toBeGreaterThanOrEqual(0);
+        expect(member.toString()).toBeDefined();
+        expectTypeOf(member.toString()).toEqualTypeOf();
+        expect(member.toString()).toEqual(member.uuid);
+    });
+    expect(data.me).toBeDefined();
+    expectTypeOf(data.me).toEqualTypeOf();
+    if (null !== data.me) {
+        expect(data.me).toBeDefined();
+        expectTypeOf(data.me).toEqualTypeOf();
+        expect(data.me.uuid).toBeDefined();
+        expectTypeOf(data.me.uuid).toEqualTypeOf();
+        expect(data.me.joinedAtTimestamp).toBeDefined();
+        expectTypeOf(data.me.joinedAtTimestamp).toEqualTypeOf();
+        expect(data.me.joinedAt).toBeDefined();
+        expectTypeOf(data.me.joinedAt).toEqualTypeOf();
+        expect(data.me.questParticipation).toBeDefined();
+        expectTypeOf(data.me.questParticipation).toEqualTypeOf();
+        expect(data.me.rank).toBeDefined();
+        expectTypeOf(data.me.rank).toEqualTypeOf();
+        expect(data.me.mutedUntilTimestamp).toBeDefined();
+        expectTypeOf(data.me.mutedUntilTimestamp).toEqualTypeOf();
+        expect(data.me.mutedUntil).toBeDefined();
+        expectTypeOf(data.me.mutedUntil).toEqualTypeOf();
+        expect(data.me.expHistory).toBeDefined();
+        expectTypeOf(data.me.expHistory).toEqualTypeOf();
+        expect(data.me.weeklyExperience).toBeDefined();
+        expectTypeOf(data.me.weeklyExperience).toEqualTypeOf();
+        expect(data.me.weeklyExperience).toBeGreaterThanOrEqual(0);
+        expect(data.me.toString()).toBeDefined();
+        expectTypeOf(data.me.toString()).toEqualTypeOf();
+        expect(data.me.toString()).toEqual(data.me.uuid);
+    }
+    expect(data.ranks).toBeDefined();
+    expectTypeOf(data.ranks).toEqualTypeOf();
+    data.ranks.forEach((rank) => {
+        expect(rank).toBeDefined();
+        expect(rank).toBeInstanceOf(GuildRank);
+        expectTypeOf(rank).toEqualTypeOf();
+        expect(rank.name).toBeDefined();
+        expectTypeOf(rank.name).toEqualTypeOf();
+        expect(rank.default).toBeDefined();
+        expectTypeOf(rank.default).toEqualTypeOf();
+        expect(rank.tag).toBeDefined();
+        expectTypeOf(rank.tag).toEqualTypeOf();
+        expect(rank.createdAtTimestamp).toBeDefined();
+        expectTypeOf(rank.createdAtTimestamp).toEqualTypeOf();
+        expect(rank.createdAt).toBeDefined();
+        expectTypeOf(rank.createdAt).toEqualTypeOf();
+        expect(rank.priority).toBeDefined();
+        expectTypeOf(rank.priority).toEqualTypeOf();
+        expect(rank.toString()).toBeDefined();
+        expectTypeOf(rank.toString()).toEqualTypeOf();
+        expect(rank.toString()).toEqual(rank.name);
+    });
+    expect(data.totalWeeklyGexp).toBeDefined();
+    expectTypeOf(data.totalWeeklyGexp).toEqualTypeOf();
+    expect(data.createdAtTimestamp).toBeDefined();
+    expectTypeOf(data.createdAtTimestamp).toEqualTypeOf();
+    expect(data.createdAt).toBeDefined();
+    expectTypeOf(data.createdAt).toEqualTypeOf();
+    expect(data.joinable).toBeDefined();
+    expectTypeOf(data.joinable).toEqualTypeOf();
+    expect(data.publiclyListed).toBeDefined();
+    expectTypeOf(data.publiclyListed).toEqualTypeOf();
+    expect(data.chatMuteUntilTimestamp).toBeDefined();
+    expectTypeOf(data.chatMuteUntilTimestamp).toEqualTypeOf();
+    expect(data.chatMuteUntil).toBeDefined();
+    expectTypeOf(data.chatMuteUntil).toEqualTypeOf();
+    expect(data.banner).toBeDefined();
+    expectTypeOf(data.banner).toEqualTypeOf();
+    expect(data.tag).toBeDefined();
+    expectTypeOf(data.tag).toEqualTypeOf();
+    expect(data.tagColor).toBeDefined();
+    expectTypeOf(data.tagColor).toEqualTypeOf();
+    if (data.tagColor) {
+        expect(data.tagColor).toBeDefined();
+        expectTypeOf(data.tagColor).toEqualTypeOf();
+        expect(data.tagColor.color).toBeDefined();
+        expectTypeOf(data.tagColor.color).toEqualTypeOf();
+        expect(data.tagColor.toString).toBeDefined();
+        expectTypeOf(data.tagColor.toString).toEqualTypeOf();
+        expect(data.tagColor.toString()).toBeDefined();
+        expectTypeOf(data.tagColor.toString()).toEqualTypeOf();
+        expect(data.tagColor.toHex).toBeDefined();
+        expectTypeOf(data.tagColor.toHex).toEqualTypeOf();
+        expect(data.tagColor.toHex()).toBeDefined();
+        expectTypeOf(data.tagColor.toHex()).toEqualTypeOf();
+        expect(data.tagColor.toCode).toBeDefined();
+        expectTypeOf(data.tagColor.toCode).toEqualTypeOf();
+        expect(data.tagColor.toCode()).toBeDefined();
+        expectTypeOf(data.tagColor.toCode()).toEqualTypeOf();
+        expect(data.tagColor.toInGameCode).toBeDefined();
+        expectTypeOf(data.tagColor.toInGameCode).toEqualTypeOf();
+        expect(data.tagColor.toInGameCode()).toBeDefined();
+        expectTypeOf(data.tagColor.toInGameCode()).toEqualTypeOf();
+    }
+    expect(data.expHistory).toBeDefined();
+    expectTypeOf(data.expHistory).toEqualTypeOf();
+    expect(data.achievements).toBeDefined();
+    expectTypeOf(data.achievements).toEqualTypeOf();
+    expect(data.achievements.winners).toBeDefined();
+    expectTypeOf(data.achievements.winners).toEqualTypeOf();
+    expect(data.achievements.winners).toBeGreaterThanOrEqual(0);
+    expect(data.achievements.experienceKings).toBeDefined();
+    expectTypeOf(data.achievements.experienceKings).toEqualTypeOf();
+    expect(data.achievements.experienceKings).toBeGreaterThanOrEqual(0);
+    expect(data.preferredGames).toBeDefined();
+    expectTypeOf(data.preferredGames).toEqualTypeOf();
+    data.preferredGames.forEach((game) => {
+        expect(game).toBeDefined();
+        expectTypeOf(game).toEqualTypeOf();
+        expect(game.game).toBeDefined();
+        expectTypeOf(game.game).toEqualTypeOf();
+        expect(game.id).toBeDefined();
+        expectTypeOf(game.id).toEqualTypeOf();
+        expect(game.code).toBeDefined();
+        expectTypeOf(game.code).toEqualTypeOf();
+        expect(game.name).toBeDefined();
+        expectTypeOf(game.name).toEqualTypeOf();
+        expect(game.found).toBeDefined();
+        expectTypeOf(game.found).toEqualTypeOf();
+        expect(game.toString()).toBeDefined();
+        expect(game.toString()).toBe(game.name);
+        expectTypeOf(game.toString()).toEqualTypeOf();
+        expect(Game.IDS).toBeDefined();
+        expectTypeOf(Game.IDS).toEqualTypeOf();
+        expect(Game.CODES).toBeDefined();
+        expectTypeOf(Game.CODES).toEqualTypeOf();
+        expect(Game.NAMES).toBeDefined();
+        expectTypeOf(Game.NAMES).toEqualTypeOf();
+    });
+    expect(data.toString()).toBeDefined();
+    expectTypeOf(data.toString()).toEqualTypeOf();
+    expect(data.guildMaster()).toBeDefined();
+    expect(data.guildMaster()).toBeInstanceOf(GuildMember);
+    expect(['Guild Master', 'GUILDMASTER']).toContain(data.guildMaster().rank);
+    expectTypeOf(data.guildMaster()).toEqualTypeOf();
+    client.destroy();
+});
+test('getGuild (Id)', 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.getGuild('id', '64b54f9d8ea8c96aaedafe84');
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Guild);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.id).toBeDefined();
+    expectTypeOf(data.id).toEqualTypeOf();
+    expect(data.name).toBeDefined();
+    expectTypeOf(data.name).toEqualTypeOf();
+    expect(data.description).toBeDefined();
+    expectTypeOf(data.description).toEqualTypeOf();
+    expect(data.experience).toBeDefined();
+    expectTypeOf(data.experience).toEqualTypeOf();
+    expect(data.experience).toBeGreaterThanOrEqual(0);
+    expect(data.level).toBeDefined();
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.members).toBeDefined();
+    expectTypeOf(data.members).toEqualTypeOf();
+    data.members.forEach((member) => {
+        expect(member).toBeDefined();
+        expectTypeOf(member).toEqualTypeOf();
+        expect(member.uuid).toBeDefined();
+        expectTypeOf(member.uuid).toEqualTypeOf();
+        expect(member.joinedAtTimestamp).toBeDefined();
+        expectTypeOf(member.joinedAtTimestamp).toEqualTypeOf();
+        expect(member.joinedAt).toBeDefined();
+        expectTypeOf(member.joinedAt).toEqualTypeOf();
+        expect(member.questParticipation).toBeDefined();
+        expectTypeOf(member.questParticipation).toEqualTypeOf();
+        expect(member.rank).toBeDefined();
+        expectTypeOf(member.rank).toEqualTypeOf();
+        expect(member.mutedUntilTimestamp).toBeDefined();
+        expectTypeOf(member.mutedUntilTimestamp).toEqualTypeOf();
+        expect(member.mutedUntil).toBeDefined();
+        expectTypeOf(member.mutedUntil).toEqualTypeOf();
+        expect(member.expHistory).toBeDefined();
+        expectTypeOf(member.expHistory).toEqualTypeOf();
+        expect(member.weeklyExperience).toBeDefined();
+        expectTypeOf(member.weeklyExperience).toEqualTypeOf();
+        expect(member.weeklyExperience).toBeGreaterThanOrEqual(0);
+        expect(member.toString()).toBeDefined();
+        expectTypeOf(member.toString()).toEqualTypeOf();
+        expect(member.toString()).toEqual(member.uuid);
+    });
+    expect(data.me).toBeDefined();
+    expectTypeOf(data.me).toEqualTypeOf();
+    if (null !== data.me) {
+        expect(data.me).toBeDefined();
+        expectTypeOf(data.me).toEqualTypeOf();
+        expect(data.me.uuid).toBeDefined();
+        expectTypeOf(data.me.uuid).toEqualTypeOf();
+        expect(data.me.joinedAtTimestamp).toBeDefined();
+        expectTypeOf(data.me.joinedAtTimestamp).toEqualTypeOf();
+        expect(data.me.joinedAt).toBeDefined();
+        expectTypeOf(data.me.joinedAt).toEqualTypeOf();
+        expect(data.me.questParticipation).toBeDefined();
+        expectTypeOf(data.me.questParticipation).toEqualTypeOf();
+        expect(data.me.rank).toBeDefined();
+        expectTypeOf(data.me.rank).toEqualTypeOf();
+        expect(data.me.mutedUntilTimestamp).toBeDefined();
+        expectTypeOf(data.me.mutedUntilTimestamp).toEqualTypeOf();
+        expect(data.me.mutedUntil).toBeDefined();
+        expectTypeOf(data.me.mutedUntil).toEqualTypeOf();
+        expect(data.me.expHistory).toBeDefined();
+        expectTypeOf(data.me.expHistory).toEqualTypeOf();
+        expect(data.me.weeklyExperience).toBeDefined();
+        expectTypeOf(data.me.weeklyExperience).toEqualTypeOf();
+        expect(data.me.weeklyExperience).toBeGreaterThanOrEqual(0);
+        expect(data.me.toString()).toBeDefined();
+        expectTypeOf(data.me.toString()).toEqualTypeOf();
+        expect(data.me.toString()).toEqual(data.me.uuid);
+    }
+    expect(data.ranks).toBeDefined();
+    expectTypeOf(data.ranks).toEqualTypeOf();
+    data.ranks.forEach((rank) => {
+        expect(rank).toBeDefined();
+        expect(rank).toBeInstanceOf(GuildRank);
+        expectTypeOf(rank).toEqualTypeOf();
+        expect(rank.name).toBeDefined();
+        expectTypeOf(rank.name).toEqualTypeOf();
+        expect(rank.default).toBeDefined();
+        expectTypeOf(rank.default).toEqualTypeOf();
+        expect(rank.tag).toBeDefined();
+        expectTypeOf(rank.tag).toEqualTypeOf();
+        expect(rank.createdAtTimestamp).toBeDefined();
+        expectTypeOf(rank.createdAtTimestamp).toEqualTypeOf();
+        expect(rank.createdAt).toBeDefined();
+        expectTypeOf(rank.createdAt).toEqualTypeOf();
+        expect(rank.priority).toBeDefined();
+        expectTypeOf(rank.priority).toEqualTypeOf();
+        expect(rank.toString()).toBeDefined();
+        expectTypeOf(rank.toString()).toEqualTypeOf();
+        expect(rank.toString()).toEqual(rank.name);
+    });
+    expect(data.totalWeeklyGexp).toBeDefined();
+    expectTypeOf(data.totalWeeklyGexp).toEqualTypeOf();
+    expect(data.createdAtTimestamp).toBeDefined();
+    expectTypeOf(data.createdAtTimestamp).toEqualTypeOf();
+    expect(data.createdAt).toBeDefined();
+    expectTypeOf(data.createdAt).toEqualTypeOf();
+    expect(data.joinable).toBeDefined();
+    expectTypeOf(data.joinable).toEqualTypeOf();
+    expect(data.publiclyListed).toBeDefined();
+    expectTypeOf(data.publiclyListed).toEqualTypeOf();
+    expect(data.chatMuteUntilTimestamp).toBeDefined();
+    expectTypeOf(data.chatMuteUntilTimestamp).toEqualTypeOf();
+    expect(data.chatMuteUntil).toBeDefined();
+    expectTypeOf(data.chatMuteUntil).toEqualTypeOf();
+    expect(data.banner).toBeDefined();
+    expectTypeOf(data.banner).toEqualTypeOf();
+    expect(data.tag).toBeDefined();
+    expectTypeOf(data.tag).toEqualTypeOf();
+    expect(data.tagColor).toBeDefined();
+    expectTypeOf(data.tagColor).toEqualTypeOf();
+    expect(data.expHistory).toBeDefined();
+    expectTypeOf(data.expHistory).toEqualTypeOf();
+    expect(data.achievements).toBeDefined();
+    expectTypeOf(data.achievements).toEqualTypeOf();
+    expect(data.achievements.winners).toBeDefined();
+    expectTypeOf(data.achievements.winners).toEqualTypeOf();
+    expect(data.achievements.winners).toBeGreaterThanOrEqual(0);
+    expect(data.achievements.experienceKings).toBeDefined();
+    expectTypeOf(data.achievements.experienceKings).toEqualTypeOf();
+    expect(data.achievements.experienceKings).toBeGreaterThanOrEqual(0);
+    expect(data.preferredGames).toBeDefined();
+    expectTypeOf(data.preferredGames).toEqualTypeOf();
+    expect(data.toString()).toBeDefined();
+    expectTypeOf(data.toString()).toEqualTypeOf();
+    expect(data.guildMaster()).toBeDefined();
+    expect(data.guildMaster()).toBeInstanceOf(GuildMember);
+    expect(['Guild Master', 'GUILDMASTER']).toContain(data.guildMaster().rank);
+    expectTypeOf(data.guildMaster()).toEqualTypeOf();
+    client.destroy();
+});
+test('getGuild (Player)', 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.getGuild('player', '14727faefbdc4aff848cd2713eb9939e');
+    expect(data).toBeDefined();
+    expect(data).toBeInstanceOf(Guild);
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.id).toBeDefined();
+    expectTypeOf(data.id).toEqualTypeOf();
+    expect(data.name).toBeDefined();
+    expectTypeOf(data.name).toEqualTypeOf();
+    expect(data.description).toBeDefined();
+    expectTypeOf(data.description).toEqualTypeOf();
+    expect(data.experience).toBeDefined();
+    expectTypeOf(data.experience).toEqualTypeOf();
+    expect(data.experience).toBeGreaterThanOrEqual(0);
+    expect(data.level).toBeDefined();
+    expectTypeOf(data.level).toEqualTypeOf();
+    expect(data.members).toBeDefined();
+    expectTypeOf(data.members).toEqualTypeOf();
+    data.members.forEach((member) => {
+        expect(member).toBeDefined();
+        expectTypeOf(member).toEqualTypeOf();
+        expect(member.uuid).toBeDefined();
+        expectTypeOf(member.uuid).toEqualTypeOf();
+        expect(member.joinedAtTimestamp).toBeDefined();
+        expectTypeOf(member.joinedAtTimestamp).toEqualTypeOf();
+        expect(member.joinedAt).toBeDefined();
+        expectTypeOf(member.joinedAt).toEqualTypeOf();
+        expect(member.questParticipation).toBeDefined();
+        expectTypeOf(member.questParticipation).toEqualTypeOf();
+        expect(member.rank).toBeDefined();
+        expectTypeOf(member.rank).toEqualTypeOf();
+        expect(member.mutedUntilTimestamp).toBeDefined();
+        expectTypeOf(member.mutedUntilTimestamp).toEqualTypeOf();
+        expect(member.mutedUntil).toBeDefined();
+        expectTypeOf(member.mutedUntil).toEqualTypeOf();
+        expect(member.expHistory).toBeDefined();
+        expectTypeOf(member.expHistory).toEqualTypeOf();
+        expect(member.weeklyExperience).toBeDefined();
+        expectTypeOf(member.weeklyExperience).toEqualTypeOf();
+        expect(member.weeklyExperience).toBeGreaterThanOrEqual(0);
+        expect(member.toString()).toBeDefined();
+        expectTypeOf(member.toString()).toEqualTypeOf();
+        expect(member.toString()).toEqual(member.uuid);
+    });
+    expect(data.me).toBeDefined();
+    expectTypeOf(data.me).toEqualTypeOf();
+    if (null !== data.me) {
+        expect(data.me).toBeDefined();
+        expectTypeOf(data.me).toEqualTypeOf();
+        expect(data.me.uuid).toBeDefined();
+        expectTypeOf(data.me.uuid).toEqualTypeOf();
+        expect(data.me.joinedAtTimestamp).toBeDefined();
+        expectTypeOf(data.me.joinedAtTimestamp).toEqualTypeOf();
+        expect(data.me.joinedAt).toBeDefined();
+        expectTypeOf(data.me.joinedAt).toEqualTypeOf();
+        expect(data.me.questParticipation).toBeDefined();
+        expectTypeOf(data.me.questParticipation).toEqualTypeOf();
+        expect(data.me.rank).toBeDefined();
+        expectTypeOf(data.me.rank).toEqualTypeOf();
+        expect(data.me.mutedUntilTimestamp).toBeDefined();
+        expectTypeOf(data.me.mutedUntilTimestamp).toEqualTypeOf();
+        expect(data.me.mutedUntil).toBeDefined();
+        expectTypeOf(data.me.mutedUntil).toEqualTypeOf();
+        expect(data.me.expHistory).toBeDefined();
+        expectTypeOf(data.me.expHistory).toEqualTypeOf();
+        expect(data.me.weeklyExperience).toBeDefined();
+        expectTypeOf(data.me.weeklyExperience).toEqualTypeOf();
+        expect(data.me.weeklyExperience).toBeGreaterThanOrEqual(0);
+        expect(data.me.toString()).toBeDefined();
+        expectTypeOf(data.me.toString()).toEqualTypeOf();
+        expect(data.me.toString()).toEqual(data.me.uuid);
+    }
+    expect(data.ranks).toBeDefined();
+    expectTypeOf(data.ranks).toEqualTypeOf();
+    data.ranks.forEach((rank) => {
+        expect(rank).toBeDefined();
+        expect(rank).toBeInstanceOf(GuildRank);
+        expectTypeOf(rank).toEqualTypeOf();
+        expect(rank.name).toBeDefined();
+        expectTypeOf(rank.name).toEqualTypeOf();
+        expect(rank.default).toBeDefined();
+        expectTypeOf(rank.default).toEqualTypeOf();
+        expect(rank.tag).toBeDefined();
+        expectTypeOf(rank.tag).toEqualTypeOf();
+        expect(rank.createdAtTimestamp).toBeDefined();
+        expectTypeOf(rank.createdAtTimestamp).toEqualTypeOf();
+        expect(rank.createdAt).toBeDefined();
+        expectTypeOf(rank.createdAt).toEqualTypeOf();
+        expect(rank.priority).toBeDefined();
+        expectTypeOf(rank.priority).toEqualTypeOf();
+        expect(rank.toString()).toBeDefined();
+        expectTypeOf(rank.toString()).toEqualTypeOf();
+        expect(rank.toString()).toEqual(rank.name);
+    });
+    expect(data.totalWeeklyGexp).toBeDefined();
+    expectTypeOf(data.totalWeeklyGexp).toEqualTypeOf();
+    expect(data.createdAtTimestamp).toBeDefined();
+    expectTypeOf(data.createdAtTimestamp).toEqualTypeOf();
+    expect(data.createdAt).toBeDefined();
+    expectTypeOf(data.createdAt).toEqualTypeOf();
+    expect(data.joinable).toBeDefined();
+    expectTypeOf(data.joinable).toEqualTypeOf();
+    expect(data.publiclyListed).toBeDefined();
+    expectTypeOf(data.publiclyListed).toEqualTypeOf();
+    expect(data.chatMuteUntilTimestamp).toBeDefined();
+    expectTypeOf(data.chatMuteUntilTimestamp).toEqualTypeOf();
+    expect(data.chatMuteUntil).toBeDefined();
+    expectTypeOf(data.chatMuteUntil).toEqualTypeOf();
+    expect(data.banner).toBeDefined();
+    expectTypeOf(data.banner).toEqualTypeOf();
+    expect(data.tag).toBeDefined();
+    expectTypeOf(data.tag).toEqualTypeOf();
+    expect(data.tagColor).toBeDefined();
+    expectTypeOf(data.tagColor).toEqualTypeOf();
+    expect(data.expHistory).toBeDefined();
+    expectTypeOf(data.expHistory).toEqualTypeOf();
+    expect(data.achievements).toBeDefined();
+    expectTypeOf(data.achievements).toEqualTypeOf();
+    expect(data.achievements.winners).toBeDefined();
+    expectTypeOf(data.achievements.winners).toEqualTypeOf();
+    expect(data.achievements.winners).toBeGreaterThanOrEqual(0);
+    expect(data.achievements.experienceKings).toBeDefined();
+    expectTypeOf(data.achievements.experienceKings).toEqualTypeOf();
+    expect(data.achievements.experienceKings).toBeGreaterThanOrEqual(0);
+    expect(data.preferredGames).toBeDefined();
+    expectTypeOf(data.preferredGames).toEqualTypeOf();
+    expect(data.toString()).toBeDefined();
+    expectTypeOf(data.toString()).toEqualTypeOf();
+    expect(data.guildMaster()).toBeDefined();
+    expect(data.guildMaster()).toBeInstanceOf(GuildMember);
+    expect(['Guild Master', 'GUILDMASTER']).toContain(data.guildMaster().rank);
+    expectTypeOf(data.guildMaster()).toEqualTypeOf();
+    client.destroy();
+});

package/dist/src/API/getGuildAchievements.js

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

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

@@ -0,0 +1,51 @@
+import Client from '../Client';
+import { expect, expectTypeOf, test } from 'vitest';
+test('getGuildAchievements (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.getGuildAchievements({ raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getGuildAchievements', 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.getGuildAchievements();
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.lastUpdatedTimestamp).toBeDefined();
+    expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf();
+    expect(data.lastUpdatedAt).toBeDefined();
+    expectTypeOf(data.lastUpdatedAt).toEqualTypeOf();
+    expect(data.achievements).toBeDefined();
+    expectTypeOf(data.achievements).toEqualTypeOf();
+    Object.keys(data.achievements).forEach((achievement) => {
+        expect(data.achievements[achievement]).toBeDefined();
+        expectTypeOf(data.achievements[achievement]).toEqualTypeOf();
+        expect(data.achievements[achievement].name).toBeDefined();
+        expectTypeOf(data.achievements[achievement].name).toEqualTypeOf();
+        expect(data.achievements[achievement].codeName).toBeDefined();
+        expectTypeOf(data.achievements[achievement].codeName).toEqualTypeOf();
+        expect(data.achievements[achievement].description).toBeDefined();
+        expectTypeOf(data.achievements[achievement].description).toEqualTypeOf();
+        expect(data.achievements[achievement].type).toBeDefined();
+        expectTypeOf(data.achievements[achievement].type).toEqualTypeOf();
+        expect(['ONE_TIME', 'TIERED']).toContain(data.achievements[achievement].type);
+        expect(data.achievements[achievement].rarity).toBeDefined();
+        expectTypeOf(data.achievements[achievement].rarity).toEqualTypeOf();
+        expect(data.achievements[achievement].tierInformation).toBeDefined();
+        expectTypeOf(data.achievements[achievement].tierInformation).toEqualTypeOf();
+        expect(data.achievements[achievement].points).toBeDefined();
+        expectTypeOf(data.achievements[achievement].points).toEqualTypeOf();
+        if ('TIERED' === data.achievements[achievement].type) {
+            expect(data.achievements[achievement].totalAmountRequired).toBeDefined();
+            expectTypeOf(data.achievements[achievement].totalAmountRequired).toEqualTypeOf();
+        }
+        expect(data.achievements[achievement].toString()).toBeDefined();
+        expectTypeOf(data.achievements[achievement].toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});

package/dist/src/API/getHouse.js

@@ -0,0 +1,18 @@
+import Endpoint from '../Private/Endpoint';
+import House from '../structures/House';
+class getHouse extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(query, options) {
+        if (!query)
+            throw new Error(this.client.errors.NO_UUID);
+        const res = await this.client.requests.request(`/housing/house?house=${query}`, options);
+        if (res.options.raw)
+            return res.data;
+        return new House(res.data);
+    }
+}
+export default getHouse;

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

@@ -0,0 +1,51 @@
+import Client from '../Client';
+import { expect, expectTypeOf, test } from 'vitest';
+test('getHouse (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 houses = await client.getActiveHouses();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const data = await client.getHouse(houses[0].uuid, { raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getHouse (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.getHouse()).rejects.toThrowError(client.errors.NO_UUID);
+    client.destroy();
+});
+test('getHouse', 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 houses = await client.getActiveHouses();
+    expect(houses).toBeDefined();
+    expectTypeOf(houses).toEqualTypeOf();
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    const data = await client.getHouse(houses[0].uuid);
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.name).toBeDefined();
+    expectTypeOf(data.name).toEqualTypeOf();
+    expect(data.uuid).toBeDefined();
+    expectTypeOf(data.uuid).toEqualTypeOf();
+    expect(data.owner).toBeDefined();
+    expectTypeOf(data.owner).toEqualTypeOf();
+    expect(data.createdAtTimestamp).toBeDefined();
+    expectTypeOf(data.createdAtTimestamp).toEqualTypeOf();
+    expect(data.createdAt).toBeDefined();
+    expectTypeOf(data.createdAt).toEqualTypeOf();
+    expect(data.players).toBeDefined();
+    expectTypeOf(data.players).toEqualTypeOf();
+    expect(data.cookies).toBeDefined();
+    expectTypeOf(data.cookies).toEqualTypeOf();
+    expect(data.toString()).toBeDefined();
+    expectTypeOf(data.toString()).toEqualTypeOf();
+    client.destroy();
+});

package/dist/src/API/getLeaderboards.js

@@ -0,0 +1,23 @@
+import Endpoint from '../Private/Endpoint';
+import Leaderboard from '../structures/Leaderboard';
+class getLeaderboards extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(options) {
+        const res = await this.client.requests.request('/leaderboards', options);
+        if (res.options.raw)
+            return res.data;
+        if (!res.data.leaderboards) {
+            throw new Error(this.client.errors.SOMETHING_WENT_WRONG.replace(/{cause}/, 'Try again.'));
+        }
+        const leaderboards = {};
+        Object.keys(res.data.leaderboards).forEach((key) => {
+            leaderboards[key] = res.data.leaderboards[key].map((l) => new Leaderboard(l));
+        });
+        return leaderboards;
+    }
+}
+export default getLeaderboards;