hypixel-api-reborn 11.3.4 → 12.0.0-0

package/src/API/getSkyblockMember.test.ts

@@ -0,0 +1,308 @@
+import Client from '../Client';
+import SkyblockGarden from '../structures/SkyBlock/SkyblockGarden';
+import SkyblockInventoryItem, { SkyblockGemstone } from '../structures/SkyBlock/SkyblockInventoryItem';
+import SkyblockMember, { SkyblockMemberArmor, SkyblockMemberEquipment } from '../structures/SkyBlock/SkyblockMember';
+import SkyblockMuseum from '../structures/SkyBlock/SkyblockMuseum';
+import SkyblockPet from '../structures/SkyBlock/SkyblockPet';
+import { NetworthResult } from 'skyhelper-networth';
+import {
+  SkyblockMemberChocolateFactoryData,
+  SkyblockMemberDungeons,
+  SkyblockMemberJacobData,
+  SkyblockMemberSkills,
+  SkyblockMemberSlayer,
+  SkyblockMemberStats,
+  SkyblockMemberTrophyFishRank,
+  SkyblockRarity,
+  SkyblockSkillLevel
+} from '../utils/SkyblockUtils';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getSkyblockMember (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e', { raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getSkyblockMember (no input)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  expect(() => client.getSkyblockMember()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+  client.destroy();
+});
+
+test('getSkyblockMember (no profiles)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  expect(() => client.getSkyblockMember('b45add7b081443909fb00aa9a3e15eb0')).rejects.toThrowError(
+    client.errors.NO_SKYBLOCK_PROFILES
+  );
+  client.destroy();
+});
+
+test('getSkyblockMember', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e');
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<SkyblockMember[]>();
+
+  data.forEach(async (member: SkyblockMember) => {
+    expect(member).toBeDefined();
+    expect(member).toBeInstanceOf(SkyblockMember);
+    expectTypeOf(member).toEqualTypeOf<SkyblockMember>();
+
+    expect(member.uuid).toBeDefined();
+    expectTypeOf(member.uuid).toEqualTypeOf<string>();
+
+    expect(member.gameMode).toBeDefined();
+    expectTypeOf(member.gameMode).toEqualTypeOf<string | null>();
+
+    expect(member.selected).toBeDefined();
+    expectTypeOf(member.selected).toEqualTypeOf<boolean>();
+
+    expect(member.garden).toBeDefined();
+    expect(member.garden).toBeNull();
+    expectTypeOf(member.garden).toEqualTypeOf<SkyblockGarden | null>();
+
+    expect(member.museum).toBeDefined();
+    expectTypeOf(member.museum).toEqualTypeOf<SkyblockMuseum | null>();
+
+    expect(member.profileName).toBeDefined();
+    expectTypeOf(member.profileName).toEqualTypeOf<string>();
+
+    expect(member.profileId).toBeDefined();
+    expectTypeOf(member.profileId).toEqualTypeOf<string>();
+
+    expect(member.firstJoinTimestamp).toBeDefined();
+    expectTypeOf(member.firstJoinTimestamp).toEqualTypeOf<number>();
+
+    expect(member.firstJoinAt).toBeDefined();
+    expectTypeOf(member.firstJoinAt).toEqualTypeOf<Date>();
+
+    expect(member.experience).toBeDefined();
+    expectTypeOf(member.experience).toEqualTypeOf<number>();
+
+    expect(member.level).toBeDefined();
+    expectTypeOf(member.level).toEqualTypeOf<number>();
+
+    expect(member.hotm).toBeDefined();
+    expectTypeOf(member.hotm).toEqualTypeOf<SkyblockSkillLevel>();
+
+    expect(member.trophyFish).toBeDefined();
+    expectTypeOf(member.trophyFish).toEqualTypeOf<SkyblockMemberTrophyFishRank>();
+
+    expect(member.highestMagicalPower).toBeDefined();
+    expectTypeOf(member.highestMagicalPower).toEqualTypeOf<number>();
+
+    expect(member.fairySouls).toBeDefined();
+    expectTypeOf(member.fairySouls).toEqualTypeOf<number>();
+
+    expect(member.fairyExchanges).toBeDefined();
+    expectTypeOf(member.fairyExchanges).toEqualTypeOf<number>();
+
+    expect(member.skills).toBeDefined();
+    expectTypeOf(member.skills).toEqualTypeOf<SkyblockMemberSkills>();
+
+    expect(member.bestiary).toBeDefined();
+    expectTypeOf(member.bestiary).toEqualTypeOf<number>();
+
+    expect(member.slayer).toBeDefined();
+    expectTypeOf(member.slayer).toEqualTypeOf<SkyblockMemberSlayer | null>();
+
+    expect(member.dungeons).toBeDefined();
+    expectTypeOf(member.dungeons).toEqualTypeOf<SkyblockMemberDungeons | null>();
+
+    expect(member.collections).toBeDefined();
+    expectTypeOf(member.collections).toEqualTypeOf<Record<string, number>>();
+
+    expect(member.purse).toBeDefined();
+    expectTypeOf(member.purse).toEqualTypeOf<number>();
+
+    expect(member.stats).toBeDefined();
+    expectTypeOf(member.stats).toEqualTypeOf<SkyblockMemberStats | null>();
+
+    expect(member.pets).toBeDefined();
+    expectTypeOf(member.pets).toEqualTypeOf<SkyblockPet[]>();
+    member.pets.forEach((pet: SkyblockPet) => {
+      expect(pet).toBeDefined();
+      expect(pet).toBeInstanceOf(SkyblockPet);
+      expectTypeOf(pet).toEqualTypeOf<SkyblockPet>();
+
+      expect(pet.uuid).toBeDefined();
+      expectTypeOf(pet.uuid).toEqualTypeOf<string>();
+
+      expect(pet.name).toBeDefined();
+      expectTypeOf(pet.name).toEqualTypeOf<string>();
+
+      expect(pet.xp).toBeDefined();
+      expectTypeOf(pet.xp).toEqualTypeOf<number>();
+
+      expect(pet.active).toBeDefined();
+      expectTypeOf(pet.active).toEqualTypeOf<boolean>();
+
+      expect(pet.rarity).toBeDefined();
+      expectTypeOf(pet.rarity).toEqualTypeOf<SkyblockRarity>();
+
+      expect(pet.petScore).toBeDefined();
+      expectTypeOf(pet.petScore).toEqualTypeOf<number>();
+
+      expect(pet.heldItem).toBeDefined();
+      expectTypeOf(pet.heldItem).toEqualTypeOf<string | null>();
+
+      expect(pet.candyUsed).toBeDefined();
+      expectTypeOf(pet.candyUsed).toEqualTypeOf<number>();
+
+      expect(pet.skin).toBeDefined();
+      expectTypeOf(pet.skin).toEqualTypeOf<string | null>();
+
+      expect(pet.toString()).toBeDefined();
+      expect(pet.toString()).toBe(pet.name);
+      expectTypeOf(pet.toString()).toEqualTypeOf<string>();
+    });
+
+    expect(member.jacob).toBeDefined();
+    expectTypeOf(member.jacob).toEqualTypeOf<SkyblockMemberJacobData>();
+
+    expect(member.chocolate).toBeDefined();
+    expectTypeOf(member.chocolate).toEqualTypeOf<SkyblockMemberChocolateFactoryData>();
+
+    expect(member.getArmor()).toBeDefined();
+    expectTypeOf(member.getArmor).toEqualTypeOf<() => Promise<SkyblockMemberArmor>>();
+    expectTypeOf(member.getArmor()).toEqualTypeOf<Promise<SkyblockMemberArmor>>();
+
+    expect(member.getWardrobe()).toBeDefined();
+    expectTypeOf(member.getWardrobe).toEqualTypeOf<() => Promise<SkyblockInventoryItem[]>>();
+    expectTypeOf(member.getWardrobe()).toEqualTypeOf<Promise<SkyblockInventoryItem[]>>();
+
+    expect(member.getEnderChest()).toBeDefined();
+    expectTypeOf(member.getEnderChest).toEqualTypeOf<() => Promise<SkyblockInventoryItem[]>>();
+    expectTypeOf(member.getEnderChest()).toEqualTypeOf<Promise<SkyblockInventoryItem[]>>();
+
+    expect(member.getInventory()).toBeDefined();
+    expectTypeOf(member.getInventory).toEqualTypeOf<() => Promise<SkyblockInventoryItem[]>>();
+    expectTypeOf(member.getInventory()).toEqualTypeOf<Promise<SkyblockInventoryItem[]>>();
+
+    const inv = await member.getInventory();
+    inv.forEach((item: SkyblockInventoryItem) => {
+      expect(item.itemId).toBeDefined();
+      expectTypeOf(item.itemId).toEqualTypeOf<number>();
+
+      expect(item.count).toBeDefined();
+      expectTypeOf(item.count).toEqualTypeOf<number>();
+
+      expect(item.name).toBeDefined();
+      expectTypeOf(item.name).toEqualTypeOf<string>();
+
+      expect(item.lore).toBeDefined();
+      expectTypeOf(item.lore).toEqualTypeOf<string>();
+
+      expect(item.loreArray).toBeDefined();
+      expectTypeOf(item.loreArray).toEqualTypeOf<string[]>();
+
+      expect(item.loreForEmbed).toBeDefined();
+      expectTypeOf(item.loreForEmbed).toEqualTypeOf<string>();
+
+      expect(item.color).toBeDefined();
+      expectTypeOf(item.color).toEqualTypeOf<string | null>();
+
+      expect(item.enchantments).toBeDefined();
+      expectTypeOf(item.enchantments).toEqualTypeOf<Record<string, number>>();
+
+      expect(item.reforge).toBeDefined();
+      expectTypeOf(item.reforge).toEqualTypeOf<string>();
+
+      expect(item.gemstones).toBeDefined();
+      expectTypeOf(item.gemstones).toEqualTypeOf<SkyblockGemstone[] | []>();
+
+      expect(item.damage).toBeDefined();
+      expectTypeOf(item.damage).toEqualTypeOf<number>();
+
+      expect(item.rarity).toBeDefined();
+      expectTypeOf(item.rarity).toEqualTypeOf<string>();
+
+      expect(item.dungeonStars).toBeDefined();
+      expectTypeOf(item.dungeonStars).toEqualTypeOf<number>();
+
+      expect(item.gearScore).toBeDefined();
+      expectTypeOf(item.gearScore).toEqualTypeOf<number>();
+
+      expect(item.uuid).toBeDefined();
+      expectTypeOf(item.uuid).toEqualTypeOf<string>();
+
+      expect(item.soulbound).toBeDefined();
+      expectTypeOf(item.soulbound).toEqualTypeOf<boolean>();
+
+      expect(item.artOfWar).toBeDefined();
+      expectTypeOf(item.artOfWar).toEqualTypeOf<number>();
+
+      expect(item.rune).toBeDefined();
+      expectTypeOf(item.rune).toEqualTypeOf<object>();
+
+      expect(item.hotPotatoBooks).toBeDefined();
+      expectTypeOf(item.hotPotatoBooks).toEqualTypeOf<number>();
+
+      expect(item.recombobulated).toBeDefined();
+      expectTypeOf(item.recombobulated).toEqualTypeOf<boolean>();
+
+      expect(item.attributes).toBeDefined();
+      expectTypeOf(item.attributes).toEqualTypeOf<object>();
+
+      expect(item.hecatomb).toBeDefined();
+      expectTypeOf(item.hecatomb).toEqualTypeOf<number>();
+
+      expect(item.champion).toBeDefined();
+      expectTypeOf(item.champion).toEqualTypeOf<number>();
+
+      expect(item.cultivating).toBeDefined();
+      expectTypeOf(item.cultivating).toEqualTypeOf<number>();
+
+      expect(item.expertise).toBeDefined();
+      expectTypeOf(item.expertise).toEqualTypeOf<number>();
+
+      expect(item.compact).toBeDefined();
+      expectTypeOf(item.compact).toEqualTypeOf<number>();
+
+      expect(item.blocksWalked).toBeDefined();
+      expectTypeOf(item.blocksWalked).toEqualTypeOf<number>();
+
+      expect(item.toString()).toBeDefined();
+      expect(item.toString()).toBe(item.name);
+      expectTypeOf(item.toString()).toEqualTypeOf<string>();
+    });
+
+    expect(member.getPetScore()).toBeDefined();
+    expectTypeOf(member.getPetScore).toEqualTypeOf<() => number>();
+    expectTypeOf(member.getPetScore()).toEqualTypeOf<number>();
+
+    expect(member.getEquipment()).toBeDefined();
+    expectTypeOf(member.getEquipment).toEqualTypeOf<() => Promise<SkyblockMemberEquipment>>();
+    expectTypeOf(member.getEquipment()).toEqualTypeOf<Promise<SkyblockMemberEquipment>>();
+
+    expect(member.getPersonalVault()).toBeDefined();
+    expectTypeOf(member.getPersonalVault).toEqualTypeOf<() => Promise<SkyblockInventoryItem[]>>();
+    expectTypeOf(member.getPersonalVault()).toEqualTypeOf<Promise<SkyblockInventoryItem[]>>();
+
+    expect(member.getNetworth()).toBeDefined();
+    expectTypeOf(member.getNetworth).toEqualTypeOf<() => Promise<NetworthResult | null>>();
+    expectTypeOf(member.getNetworth()).toEqualTypeOf<Promise<NetworthResult | null>>();
+
+    expect(member.getFarmingWeight()).toBeDefined();
+    expectTypeOf(member.getFarmingWeight).toEqualTypeOf<() => number>();
+    expectTypeOf(member.getFarmingWeight()).toEqualTypeOf<number>();
+    expect(member.getFarmingWeight()).greaterThanOrEqual(0);
+
+    expect(member.toString()).toBeDefined();
+    expect(member.toString()).toBe(member.uuid);
+    expectTypeOf(member.toString()).toEqualTypeOf<string>();
+  });
+
+  client.destroy();
+});

package/src/API/getSkyblockMember.ts

@@ -0,0 +1,45 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import SkyblockMember from '../structures/SkyBlock/SkyblockMember';
+import { SkyblockRequestOptions } from './API';
+
+class getSkyblockMember extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(query: string, options?: SkyblockRequestOptions): Promise<Map<string, SkyblockMember>> {
+    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(`/skyblock/profiles?uuid=${query}`, options);
+    if (res.options.raw) return res.data;
+    if (!res.data.profiles || !res.data.profiles.length) throw new Error(this.client.errors.NO_SKYBLOCK_PROFILES);
+    const memberByProfileName = new Map();
+    for (const profile of res.data.profiles) {
+      memberByProfileName.set(
+        profile.cute_name,
+        new SkyblockMember({
+          uuid: query,
+          profileId: profile.profile_id,
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-expect-error
+          garden: options?.garden ? await this.client.getSkyblockGarden(profile.profile_id) : null,
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-expect-error
+          museum: options?.garden ? await this.client.getSkyblockMuseum(query, profile.profile_id) : null,
+          profileName: profile.cute_name,
+          gameMode: profile.game_mode || null,
+          m: profile.members[query],
+          banking: profile.banking,
+          communityUpgrades: profile.community_upgrades,
+          selected: profile.selected
+        })
+      );
+    }
+    return memberByProfileName;
+  }
+}
+
+export default getSkyblockMember;

package/src/API/getSkyblockMuseum.test.ts

@@ -0,0 +1,91 @@
+import Client from '../Client';
+import SkyblockInventoryItem from '../structures/SkyBlock/SkyblockInventoryItem';
+import SkyblockMuseum from '../structures/SkyBlock/SkyblockMuseum';
+import SkyblockMuseumItem from '../structures/SkyBlock/SkyblockMuseumItem';
+import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getSkyblockMuseum (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const profiles = await client.getSkyblockProfiles('Skreewy');
+  const profile = profiles.find((profile: SkyblockProfile) => true === profile.selected);
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockMuseum('Skreewy', profile.profileId, { raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getSkyblockMuseum', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const profiles = await client.getSkyblockProfiles('Skreewy');
+  const profile = profiles.find((profile: SkyblockProfile) => true === profile.selected);
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockMuseum('Skreewy', profile.profileId);
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<SkyblockMuseum>();
+
+  expect(data.getItems()).toBeDefined();
+  expectTypeOf(data.getItems).toEqualTypeOf<() => Promise<SkyblockMuseumItem[]>>();
+  expectTypeOf(data.getItems()).toEqualTypeOf<Promise<SkyblockMuseumItem[]>>();
+
+  const items = await data.getItems();
+  expect(items).toBeDefined();
+  expectTypeOf(items).toEqualTypeOf<SkyblockMuseumItem[]>();
+  items.forEach((item: SkyblockMuseumItem) => {
+    expect(item).toBeDefined();
+    expect(item).toBeInstanceOf(SkyblockMuseumItem);
+    expectTypeOf(item).toEqualTypeOf<SkyblockMuseumItem>();
+
+    expect(item.name).toBeDefined();
+    expectTypeOf(item.name).toEqualTypeOf<string>();
+
+    expect(item.donated).toBeDefined();
+    expectTypeOf(item.donated).toEqualTypeOf<number>();
+
+    expect(item.featuredSlot).toBeDefined();
+    expectTypeOf(item.featuredSlot).toEqualTypeOf<string | null>();
+
+    expect(item.borrowing).toBeDefined();
+    expectTypeOf(item.borrowing).toEqualTypeOf<boolean>();
+
+    expect(item.items).toBeDefined();
+    expectTypeOf(item.items).toEqualTypeOf<SkyblockInventoryItem[]>();
+  });
+
+  expect(data.getSpecial()).toBeDefined();
+  expectTypeOf(data.getSpecial).toEqualTypeOf<() => Promise<SkyblockMuseumItem[]>>();
+  expectTypeOf(data.getSpecial()).toEqualTypeOf<Promise<SkyblockMuseumItem[]>>();
+
+  const special = await data.getSpecial();
+  expect(special).toBeDefined();
+  expectTypeOf(special).toEqualTypeOf<SkyblockMuseumItem[]>();
+  special.forEach((item: SkyblockMuseumItem) => {
+    expect(item).toBeDefined();
+    expect(item).toBeInstanceOf(SkyblockMuseumItem);
+    expectTypeOf(item).toEqualTypeOf<SkyblockMuseumItem>();
+
+    expect(item.name).toBeDefined();
+    expectTypeOf(item.name).toEqualTypeOf<string>();
+
+    expect(item.donated).toBeDefined();
+    expectTypeOf(item.donated).toEqualTypeOf<number>();
+
+    expect(item.featuredSlot).toBeDefined();
+    expectTypeOf(item.featuredSlot).toEqualTypeOf<string | null>();
+
+    expect(item.borrowing).toBeDefined();
+    expectTypeOf(item.borrowing).toEqualTypeOf<boolean>();
+
+    expect(item.items).toBeDefined();
+    expectTypeOf(item.items).toEqualTypeOf<SkyblockInventoryItem[]>();
+  });
+
+  client.destroy();
+});

package/src/API/getSkyblockMuseum.ts

@@ -0,0 +1,22 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import SkyblockMuseum from '../structures/SkyBlock/SkyblockMuseum';
+import { RequestOptions } from '../Private/Requests';
+
+class getSkyblockMuseum extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(query: string, profileId: string, options?: RequestOptions): Promise<SkyblockMuseum> {
+    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(`/skyblock/museum?uuid=${query}&profile=${profileId}`, options);
+    if (res.options.raw) return res.data;
+    return new SkyblockMuseum({ uuid: query, m: res.data, profileId: profileId });
+  }
+}
+
+export default getSkyblockMuseum;

package/src/API/getSkyblockNews.test.ts

@@ -0,0 +1,45 @@
+import Client from '../Client';
+import SkyblockNews from '../structures/SkyBlock/News/SkyblockNews';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getSkyblockNews (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockNews({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getSkyblockNews', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockNews();
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<SkyblockNews[]>();
+
+  data.forEach((news: SkyblockNews) => {
+    expect(news.title).toBeDefined();
+    expectTypeOf(news.title).toEqualTypeOf<string>();
+
+    expect(news.link).toBeDefined();
+    expectTypeOf(news.link).toEqualTypeOf<string>();
+
+    expect(news.rawDate).toBeDefined();
+    expectTypeOf(news.rawDate).toEqualTypeOf<string>();
+
+    expect(news.date).toBeDefined();
+    expectTypeOf(news.date).toEqualTypeOf<Date | null>();
+
+    expect(news.version).toBeDefined();
+    expectTypeOf(news.version).toEqualTypeOf<string | null>();
+
+    expect(news.toString()).toBeDefined();
+    expect(news.toString()).toBe(news.title);
+    expectTypeOf(news.toString()).toEqualTypeOf<string>();
+  });
+
+  client.destroy();
+});

package/src/API/getSkyblockNews.ts

@@ -0,0 +1,20 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import SkyblockNews from '../structures/SkyBlock/News/SkyblockNews';
+import { RequestOptions } from '../Private/Requests';
+
+class getSkyblockNews extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<SkyblockNews[]> {
+    const res = await this.client.requests.request('/skyblock/news', options);
+    if (res.options.raw) return res.data;
+    return res.data.items.map((i: any) => new SkyblockNews(i));
+  }
+}
+
+export default getSkyblockNews;