Define endpoints

src/API/API.d.ts

@@ -1,3 +1,5 @@
+import Auction from '../structures/SkyBlock/Auctions/Auction';
+import AuctionInfo from '../structures/SkyBlock/Auctions/AuctionInfo';
 import { RequestOptions } from '../Private/RequestHandler';
 
 export interface PlayerRequestOptions extends RequestOptions {
@@ -15,4 +17,10 @@ export interface SkyblockRequestOptions extends RequestOptions {
   museum?: boolean;
 }
 
+export interface SkyblockAuctionsResult {
+  info: AuctionInfo;
+  auctions: Auction[];
+}
+
 export type GuildFetchOptions = 'id' | 'name' | 'player';
+export type AuctionFetchOptions = 'profile' | 'player' | 'auction';

src/API/getAchievements.test.ts

@@ -1,80 +1,101 @@
-import Achievement from '../structures/Static/Achievement';
-import AchievementTier from '../structures/Static/AchievementTier';
-import Achievements from '../structures/Static/Achievements';
+import Achievements from '../structures/Static/Achievements/Achievements';
 import Client from '../Client';
-import GameAchievements from '../structures/Static/GameAchievements';
-import { StaticGameNames } from '../typings';
+import GameAchievements from '../structures/Static/Achievements/Game';
+import OneTimeAchivement from '../structures/Static/Achievements/OneTime';
+import TieredAchivement, { AchivementTier } from '../structures/Static/Achievements/Tired';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getAchievements (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.getAchievements({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Achievements | RequestData>();
   client.destroy();
 });
 
 test('getAchievements', 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.getAchievements();
+  let data = await client.getAchievements();
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Achievements);
-  expectTypeOf(data).toEqualTypeOf<Achievements>();
+  expectTypeOf(data).toEqualTypeOf<Achievements | RequestData>();
+  data = data as Achievements;
   expect(data.lastUpdatedTimestamp).toBeDefined();
+  expect(data.lastUpdatedTimestamp).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
-  expect(data.lastUpdatedTimestamp).toBeGreaterThan(0);
   expect(data.lastUpdatedAt).toBeDefined();
   expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
   expect(data.achievementsPerGame).toBeDefined();
-  expectTypeOf(data.achievementsPerGame).toEqualTypeOf<Record<StaticGameNames, GameAchievements>>();
+  expectTypeOf(data.achievementsPerGame).toEqualTypeOf<Record<string, GameAchievements>>();
   Object.keys(data.achievementsPerGame).forEach((game) => {
-    expect(data.achievementsPerGame[game]).toBeDefined();
-    expect(data.achievementsPerGame[game]).toBeInstanceOf(GameAchievements);
-    expectTypeOf(data.achievementsPerGame[game]).toEqualTypeOf<GameAchievements>();
-    expect(data.achievementsPerGame[game].category).toBeDefined();
-    expect(data.achievementsPerGame[game].category).toBe(game);
-    expectTypeOf(data.achievementsPerGame[game].totalPoints).toEqualTypeOf<string>();
-    expect(data.achievementsPerGame[game].totalPoints).toBeDefined();
-    expect(data.achievementsPerGame[game].totalPoints).toBeGreaterThanOrEqual(0);
-    expectTypeOf(data.achievementsPerGame[game].totalPoints).toEqualTypeOf<number>();
-    expect(data.achievementsPerGame[game].totalLegacyPoints).toBeDefined();
-    expect(data.achievementsPerGame[game].totalLegacyPoints).toBeGreaterThanOrEqual(0);
-    expect(data.achievementsPerGame[game].totalLegacyPoints).toBeDefined();
-    expectTypeOf(data.achievementsPerGame[game].totalLegacyPoints).toEqualTypeOf<number>();
-    expect(data.achievementsPerGame[game].achievements).toBeDefined();
-    expectTypeOf(data.achievementsPerGame[game].achievements).toEqualTypeOf<Achievement[]>();
-    data.achievementsPerGame[game].achievements.forEach((gameAchievement: Achievement) => {
-      expect(gameAchievement).toBeDefined();
-      expect(gameAchievement).toBeInstanceOf(Achievement);
-      expectTypeOf(gameAchievement).toEqualTypeOf<Achievement>();
-      expect(gameAchievement.name).toBeDefined();
-      expectTypeOf(gameAchievement.name).toEqualTypeOf<string>();
-      expect(gameAchievement.codeName).toBeDefined();
-      expectTypeOf(gameAchievement.codeName).toEqualTypeOf<string>();
-      expect(gameAchievement.description).toBeDefined();
-      expectTypeOf(gameAchievement.description).toEqualTypeOf<string>();
-      expect(gameAchievement.type).toBeDefined();
-      expectTypeOf(gameAchievement.type).toEqualTypeOf<'ONE_TIME' | 'TIERED'>();
-      expect(['ONE_TIME', 'TIERED']).toContain(gameAchievement.type);
-      expect(gameAchievement.rarity).toBeDefined();
-      expectTypeOf(gameAchievement.rarity).toEqualTypeOf<Record<
-        'local' | 'localPercentage' | 'global' | 'globalPercentage',
-        number
-      > | null>();
-      expect(gameAchievement.tierInformation).toBeDefined();
-      expectTypeOf(gameAchievement.tierInformation).toEqualTypeOf<AchievementTier | null>();
-      expect(gameAchievement.points).toBeDefined();
-      expectTypeOf(gameAchievement.points).toEqualTypeOf<number>();
-      if ('TIERED' === gameAchievement.type) {
-        expect(gameAchievement.totalAmountRequired).toBeDefined();
-        expectTypeOf(gameAchievement.totalAmountRequired).toEqualTypeOf<number | null>();
-      }
-      expect(gameAchievement.toString()).toBeDefined();
-      expectTypeOf(gameAchievement.toString()).toEqualTypeOf<string>();
+    const gameData = data.achievementsPerGame[game];
+    expect(gameData).toBeDefined();
+    expect(gameData).toBeInstanceOf(GameAchievements);
+    expectTypeOf(gameData).toEqualTypeOf<GameAchievements>();
+    expect(gameData.game).toBeDefined();
+    expectTypeOf(gameData.game).toEqualTypeOf<string>();
+    expect(gameData.points).toBeDefined();
+    expect(gameData.points).toBeGreaterThanOrEqual(0);
+    expectTypeOf(gameData.points).toEqualTypeOf<number>();
+    expect(gameData.legacyPoints).toBeDefined();
+    expect(gameData.legacyPoints).toBeGreaterThanOrEqual(0);
+    expectTypeOf(gameData.legacyPoints).toEqualTypeOf<number>();
+    expect(gameData.oneTimeAchievements).toBeDefined();
+    expectTypeOf(gameData.oneTimeAchievements).toEqualTypeOf<OneTimeAchivement[]>();
+    gameData.oneTimeAchievements.forEach((achievement) => {
+      expect(achievement.codeName).toBeDefined();
+      expectTypeOf(achievement.codeName).toEqualTypeOf<string>();
+      expect(achievement.name).toBeDefined();
+      expectTypeOf(achievement.name).toEqualTypeOf<string>();
+      expect(achievement.description).toBeDefined();
+      expectTypeOf(achievement.description).toEqualTypeOf<string>();
+      expect(achievement.secret).toBeDefined();
+      expectTypeOf(achievement.secret).toEqualTypeOf<boolean>();
+      expect(achievement.legacy).toBeDefined();
+      expectTypeOf(achievement.legacy).toEqualTypeOf<boolean>();
+      expect(achievement.points).toBeDefined();
+      expectTypeOf(achievement.points).toEqualTypeOf<number>();
+      expect(achievement.gamePercentUnlocked).toBeDefined();
+      expectTypeOf(achievement.gamePercentUnlocked).toEqualTypeOf<number>();
+      expect(achievement.globalPercentUnlocked).toBeDefined();
+      expectTypeOf(achievement.globalPercentUnlocked).toEqualTypeOf<number>();
+      expect(achievement.toString()).toBeDefined();
+      expect(achievement.toString()).toBe(achievement.codeName);
+      expectTypeOf(achievement.toString()).toEqualTypeOf<string>();
+    });
+    expect(gameData.tieredAchievements).toBeDefined();
+    expectTypeOf(gameData.tieredAchievements).toEqualTypeOf<TieredAchivement[]>();
+    gameData.tieredAchievements.forEach((achievement) => {
+      expect(achievement.codeName).toBeDefined();
+      expectTypeOf(achievement.codeName).toEqualTypeOf<string>();
+      expect(achievement.name).toBeDefined();
+      expectTypeOf(achievement.name).toEqualTypeOf<string>();
+      expect(achievement.description).toBeDefined();
+      expectTypeOf(achievement.description).toEqualTypeOf<string>();
+      expect(achievement.secret).toBeDefined();
+      expectTypeOf(achievement.secret).toEqualTypeOf<boolean>();
+      expect(achievement.legacy).toBeDefined();
+      expectTypeOf(achievement.legacy).toEqualTypeOf<boolean>();
+      expect(achievement.tiers).toBeDefined();
+      expectTypeOf(achievement.tiers).toEqualTypeOf<AchivementTier[]>();
+      achievement.tiers.forEach((tier) => {
+        expect(tier).toBeDefined();
+        expectTypeOf(tier).toEqualTypeOf<AchivementTier>();
+        expect(tier.tier).toBeDefined();
+        expect(tier.tier).toBeGreaterThanOrEqual(0);
+        expectTypeOf(tier.tier).toEqualTypeOf<number>();
+        expect(tier.points).toBeDefined();
+        expect(tier.points).toBeGreaterThanOrEqual(0);
+        expectTypeOf(tier.points).toEqualTypeOf<number>();
+        expect(tier.amount).toBeDefined();
+        expect(tier.amount).toBeGreaterThanOrEqual(0);
+        expectTypeOf(tier.amount).toEqualTypeOf<number>();
+      });
+      expect(achievement.toString()).toBeDefined();
+      expect(achievement.toString()).toBe(achievement.codeName);
+      expectTypeOf(achievement.toString()).toEqualTypeOf<string>();
     });
   });
   client.destroy();

src/API/getAchievements.ts

@@ -1,7 +1,7 @@
-import Achievements from '../structures/Static/Achievements';
+import Achievements from '../structures/Static/Achievements/Achievements';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getAchievements extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getAchievements extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Achievements> {
+  async execute(options?: RequestOptions): Promise<Achievements | RequestData> {
     const res = await this.client.requestHandler.request('/resources/achievements', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new Achievements(res.data);
   }
 }

src/API/getActiveHouses.test.ts

@@ -1,24 +1,23 @@
 import Client from '../Client';
 import House from '../structures/House';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getActiveHouses (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.getActiveHouses({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<House[] | RequestData>();
   client.destroy();
 });
 
 test('getActiveHouses', 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.getActiveHouses();
+  let data = await client.getActiveHouses();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<House[]>();
+  expectTypeOf(data).toEqualTypeOf<House[] | RequestData>();
+  data = data as House[];
   data.forEach((house: House) => {
     expect(house).toBeDefined();
     expect(house).toBeInstanceOf(House);

src/API/getActiveHouses.ts

@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import House from '../structures/House';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getActiveHouses extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getActiveHouses extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<House[]> {
+  async execute(options?: RequestOptions): Promise<House[] | RequestData> {
     const res = await this.client.requestHandler.request('/housing/active', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.map((b: any) => new House(b));
   }
 }

src/API/getBoosters.test.ts

@@ -1,25 +1,24 @@
 import Booster from '../structures/Boosters/Booster';
 import Client from '../Client';
 import Game, { GameCode, GameID, GameString } from '../structures/Game';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getBoosters (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.getBoosters({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Booster[] | RequestData>();
   client.destroy();
 });
 
 test('getBoosters', 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.getBoosters();
+  let data = await client.getBoosters();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Booster[]>();
+  expectTypeOf(data).toEqualTypeOf<Booster[] | RequestData>();
+  data = data as Booster[];
   data.forEach((booster: Booster) => {
     expect(booster).toBeDefined();
     expect(booster).toBeInstanceOf(Booster);

src/API/getBoosters.ts

@@ -1,7 +1,7 @@
 import Booster from '../structures/Boosters/Booster';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getBoosters extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getBoosters extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Booster[]> {
+  async execute(options?: RequestOptions): Promise<Booster[] | RequestData> {
     const res = await this.client.requestHandler.request('/boosters', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.boosters.map((b: any) => new Booster(b)).reverse();
   }
 }

src/API/getChallenges.test.ts

@@ -1,53 +1,47 @@
 import Challenges from '../structures/Static/Challenges';
 import Client from '../Client';
-import GameChallenges, { ChallengeData } from '../structures/Static/GameChallenges';
-import { StaticGameNames } from '../typings';
+import GameChallenges, { Challenge, ChallengeReward } from '../structures/Static/GameChallenges';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getChallenges (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.getChallenges({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Challenges | RequestData>();
   client.destroy();
 });
 
 test('getChallenges', 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.getChallenges();
+  let data = await client.getChallenges();
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Challenges);
-  expectTypeOf(data).toEqualTypeOf<Challenges>();
+  expectTypeOf(data).toEqualTypeOf<Challenges | RequestData>();
+  data = data as Challenges;
   expect(data.lastUpdatedTimestamp).toBeDefined();
   expect(data.lastUpdatedTimestamp).toBeGreaterThan(0);
   expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
   expect(data.lastUpdatedAt).toBeDefined();
   expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
   expect(data.challengesPerGame).toBeDefined();
-  expectTypeOf(data.challengesPerGame).toEqualTypeOf<Record<StaticGameNames, GameChallenges>>();
-  Object.keys(data.challengesPerGame).forEach((game) => {
-    expect(data.challengesPerGame[game]).toBeDefined();
-    expect(data.challengesPerGame[game]).toBeInstanceOf(GameChallenges);
-    expectTypeOf(data.challengesPerGame[game]).toEqualTypeOf<GameChallenges>();
-    expect(data.challengesPerGame[game].category).toBeDefined();
-    expect(data.challengesPerGame[game].category).toEqual(game);
-    expect(data.challengesPerGame[game].challenges).toBeDefined();
-    expectTypeOf(data.challengesPerGame[game].challenges).toEqualTypeOf<Map<string, ChallengeData>>();
-    data.challengesPerGame[game].challenges.forEach((challenge: ChallengeData) => {
-      expect(challenge).toBeDefined();
-      expectTypeOf(challenge).toEqualTypeOf<ChallengeData>();
+  expectTypeOf(data.challengesPerGame).toEqualTypeOf<Record<string, GameChallenges>>();
+  Object.keys(data.challengesPerGame).forEach((gameName) => {
+    expect(data.challengesPerGame[gameName]).toBeDefined();
+    expect(data.challengesPerGame[gameName]).toBeInstanceOf(GameChallenges);
+    expectTypeOf(data.challengesPerGame[gameName]).toEqualTypeOf<GameChallenges>();
+    expect(data.challengesPerGame[gameName].category).toBeDefined();
+    expect(data.challengesPerGame[gameName].category).toEqual(gameName);
+    expect(data.challengesPerGame[gameName].challenges).toBeDefined();
+    expectTypeOf(data.challengesPerGame[gameName].challenges).toEqualTypeOf<Challenge[]>();
+    data.challengesPerGame[gameName].challenges.forEach((challenge: Challenge) => {
       expect(challenge.id).toBeDefined();
       expectTypeOf(challenge.id).toEqualTypeOf<string>();
       expect(challenge.name).toBeDefined();
       expectTypeOf(challenge.name).toEqualTypeOf<string>();
-      expect(challenge.reward).toBeDefined();
-      expectTypeOf(challenge.reward).toEqualTypeOf<number>();
-      expect(challenge.rewardType).toBeDefined();
-      expectTypeOf(challenge.rewardType).toEqualTypeOf<string>();
+      expect(challenge.rewards).toBeDefined();
+      expectTypeOf(challenge.rewards).toEqualTypeOf<ChallengeReward[]>();
     });
   });
   client.destroy();

src/API/getChallenges.ts

@@ -1,7 +1,7 @@
 import Challenges from '../structures/Static/Challenges';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getChallenges extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getChallenges extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Challenges> {
+  async execute(options?: RequestOptions): Promise<Challenges | RequestData> {
     const res = await this.client.requestHandler.request('/resources/challenges', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new Challenges(res.data);
   }
 }