diff --git a/src/API/API.d.ts b/src/API/API.d.ts
index 8221f663..81e0d584 100644
--- a/src/API/API.d.ts
+++ b/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';
diff --git a/src/API/getAchievements.test.ts b/src/API/getAchievements.test.ts
index 68e06cb2..08f92d63 100644
--- a/src/API/getAchievements.test.ts
+++ b/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();
diff --git a/src/API/getAchievements.ts b/src/API/getAchievements.ts
index 308faf3a..3cf07831 100644
--- a/src/API/getAchievements.ts
+++ b/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);
   }
 }
diff --git a/src/API/getActiveHouses.test.ts b/src/API/getActiveHouses.test.ts
index 70f78600..bfb31b13 100644
--- a/src/API/getActiveHouses.test.ts
+++ b/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);
diff --git a/src/API/getActiveHouses.ts b/src/API/getActiveHouses.ts
index 8552e349..0af0c566 100644
--- a/src/API/getActiveHouses.ts
+++ b/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));
   }
 }
diff --git a/src/API/getBoosters.test.ts b/src/API/getBoosters.test.ts
index e62a7524..00a3cfae 100644
--- a/src/API/getBoosters.test.ts
+++ 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);
diff --git a/src/API/getBoosters.ts b/src/API/getBoosters.ts
index 385a50d2..3858055f 100644
--- a/src/API/getBoosters.ts
+++ b/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();
   }
 }
diff --git a/src/API/getChallenges.test.ts b/src/API/getChallenges.test.ts
index ab582109..80813ff0 100644
--- a/src/API/getChallenges.test.ts
+++ b/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();
diff --git a/src/API/getChallenges.ts b/src/API/getChallenges.ts
index a1677fb6..1672e73e 100644
--- a/src/API/getChallenges.ts
+++ b/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);
   }
 }
diff --git a/src/API/getGameCounts.test.ts b/src/API/getGameCounts.test.ts
index 1971e274..55af4024 100644
--- a/src/API/getGameCounts.test.ts
+++ b/src/API/getGameCounts.test.ts
@@ -1,25 +1,24 @@
 import Client from '../Client';
 import GameCounts from '../structures/GameCounts';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getGameCounts (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.getGameCounts({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<GameCounts | RequestData>();
   client.destroy();
 });
 
 test('getGameCounts', 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.getGameCounts();
+  let data = await client.getGameCounts();
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(GameCounts);
-  expectTypeOf(data).toEqualTypeOf<GameCounts>();
+  expectTypeOf(data).toEqualTypeOf<GameCounts | RequestData>();
+  data = data as GameCounts;
   expect(data.playerCount).toBeDefined();
   expectTypeOf(data.playerCount).toEqualTypeOf<number>();
   expect(data.toString()).toBeDefined();
diff --git a/src/API/getGameCounts.ts b/src/API/getGameCounts.ts
index 682b0741..8295c228 100644
--- a/src/API/getGameCounts.ts
+++ b/src/API/getGameCounts.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import GameCounts from '../structures/GameCounts';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getGameCounts extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getGameCounts extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<GameCounts> {
+  async execute(options?: RequestOptions): Promise<GameCounts | RequestData> {
     const res = await this.client.requestHandler.request('/counts', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new GameCounts(res.data);
   }
 }
diff --git a/src/API/getGuild.test.ts b/src/API/getGuild.test.ts
index db5b5086..93fafb03 100644
--- a/src/API/getGuild.test.ts
+++ b/src/API/getGuild.test.ts
@@ -5,6 +5,7 @@ import Guild from '../structures/Guild/Guild';
 import GuildMember from '../structures/Guild/GuildMember';
 import GuildRank from '../structures/Guild/GuildRank';
 import { ExpHistory } from '../utils/Guild';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('Invalid Guild Type', () => {
@@ -19,8 +20,6 @@ test('Invalid Guild Type', () => {
 
 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
   );
@@ -29,8 +28,6 @@ test('Invalid Guild', () => {
 
 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();
 });
@@ -45,32 +42,28 @@ test('No Guild Query', () => {
 
 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<null>();
+  expectTypeOf(data).toEqualTypeOf<Guild | null | RequestData>();
   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<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Guild | null | RequestData>();
   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');
+  let data = await client.getGuild('name', 'Pixelic');
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Guild);
-  expectTypeOf(data).toEqualTypeOf<Guild>();
+  expectTypeOf(data).toEqualTypeOf<Guild | null | RequestData>();
+  data = data as Guild;
   expect(data.id).toBeDefined();
   expectTypeOf(data.id).toEqualTypeOf<string>();
   expect(data.name).toBeDefined();
@@ -248,12 +241,11 @@ test('getGuild (Name)', async () => {
 
 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');
+  let data = await client.getGuild('id', '64b54f9d8ea8c96aaedafe84');
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Guild);
-  expectTypeOf(data).toEqualTypeOf<Guild>();
+  expectTypeOf(data).toEqualTypeOf<Guild | null | RequestData>();
+  data = data as Guild;
   expect(data.id).toBeDefined();
   expectTypeOf(data.id).toEqualTypeOf<string>();
   expect(data.name).toBeDefined();
@@ -386,12 +378,11 @@ test('getGuild (Id)', async () => {
 
 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');
+  let data = await client.getGuild('player', '14727faefbdc4aff848cd2713eb9939e');
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Guild);
-  expectTypeOf(data).toEqualTypeOf<Guild>();
+  expectTypeOf(data).toEqualTypeOf<Guild | null | RequestData>();
+  data = data as Guild;
   expect(data.id).toBeDefined();
   expectTypeOf(data.id).toEqualTypeOf<string>();
   expect(data.name).toBeDefined();
diff --git a/src/API/getGuild.ts b/src/API/getGuild.ts
index fef22a12..5569fc66 100644
--- a/src/API/getGuild.ts
+++ b/src/API/getGuild.ts
@@ -3,7 +3,7 @@ import Endpoint from '../Private/Endpoint';
 import Guild from '../structures/Guild/Guild';
 import isGuildID from '../utils/isGuildID';
 import { GuildFetchOptions } from './API';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getGuild extends Endpoint {
   readonly client: Client;
@@ -12,7 +12,11 @@ class getGuild extends Endpoint {
     this.client = client;
   }
 
-  async execute(searchParameter: GuildFetchOptions, query: string, options?: RequestOptions): Promise<Guild | null> {
+  async execute(
+    searchParameter: GuildFetchOptions,
+    query: string,
+    options?: RequestOptions
+  ): Promise<Guild | null | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_GUILD_QUERY);
     if ('id' === searchParameter && !isGuildID(query)) throw new Error(this.client.errors.INVALID_GUILD_ID);
     const isPlayerQuery = 'player' === searchParameter;
@@ -21,7 +25,7 @@ class getGuild extends Endpoint {
       throw new Error(this.client.errors.INVALID_GUILD_SEARCH_PARAMETER);
     }
     const res = await this.client.requestHandler.request(`/guild?${searchParameter}=${encodeURI(query)}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     if (!res.data.guild && 'player' !== searchParameter) {
       throw new Error(this.client.errors.GUILD_DOES_NOT_EXIST);
     }
diff --git a/src/API/getGuildAchievements.test.ts b/src/API/getGuildAchievements.test.ts
index a36e4a2f..af533308 100644
--- a/src/API/getGuildAchievements.test.ts
+++ b/src/API/getGuildAchievements.test.ts
@@ -1,59 +1,82 @@
-import Achievement from '../structures/Static/Achievement';
-import AchievementTier from '../structures/Static/AchievementTier';
 import Client from '../Client';
-import GuildAchievements from '../structures/Static/GuildAchievements';
+import GuildAchievements from '../structures/Static/Achievements/Guild';
+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('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<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<GuildAchievements | RequestData>();
   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();
+  let data = await client.getGuildAchievements();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<GuildAchievements>();
+  expectTypeOf(data).toEqualTypeOf<GuildAchievements | RequestData>();
+  data = data as GuildAchievements;
   expect(data.lastUpdatedTimestamp).toBeDefined();
   expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
   expect(data.lastUpdatedAt).toBeDefined();
-  expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date | null>();
-  expect(data.achievements).toBeDefined();
-  expectTypeOf(data.achievements).toEqualTypeOf<Record<string, Achievement>>();
-  Object.keys(data.achievements).forEach((achievement) => {
-    expect(data.achievements[achievement]).toBeDefined();
-    expectTypeOf(data.achievements[achievement]).toEqualTypeOf<Achievement>();
-    expect(data.achievements[achievement].name).toBeDefined();
-    expectTypeOf(data.achievements[achievement].name).toEqualTypeOf<string>();
-    expect(data.achievements[achievement].codeName).toBeDefined();
-    expectTypeOf(data.achievements[achievement].codeName).toEqualTypeOf<string>();
-    expect(data.achievements[achievement].description).toBeDefined();
-    expectTypeOf(data.achievements[achievement].description).toEqualTypeOf<string>();
-    expect(data.achievements[achievement].type).toBeDefined();
-    expectTypeOf(data.achievements[achievement].type).toEqualTypeOf<'ONE_TIME' | 'TIERED'>();
-    expect(['ONE_TIME', 'TIERED']).toContain(data.achievements[achievement].type);
-    expect(data.achievements[achievement].rarity).toBeDefined();
-    expectTypeOf(data.achievements[achievement].rarity).toEqualTypeOf<Record<
-      'local' | 'localPercentage' | 'global' | 'globalPercentage',
-      number
-    > | null>();
-    expect(data.achievements[achievement].tierInformation).toBeDefined();
-    expectTypeOf(data.achievements[achievement].tierInformation).toEqualTypeOf<AchievementTier | null>();
-    expect(data.achievements[achievement].points).toBeDefined();
-    expectTypeOf(data.achievements[achievement].points).toEqualTypeOf<number>();
-    if ('TIERED' === data.achievements[achievement].type) {
-      expect(data.achievements[achievement].totalAmountRequired).toBeDefined();
-      expectTypeOf(data.achievements[achievement].totalAmountRequired).toEqualTypeOf<number | null>();
-    }
-    expect(data.achievements[achievement].toString()).toBeDefined();
-    expectTypeOf(data.achievements[achievement].toString()).toEqualTypeOf<string>();
+  expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
+  expect(data.oneTimeAchievements).toBeDefined();
+  expectTypeOf(data.oneTimeAchievements).toEqualTypeOf<OneTimeAchivement[]>();
+  data.oneTimeAchievements.forEach((achievement: OneTimeAchivement) => {
+    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(data.tieredAchievements).toBeDefined();
+  expectTypeOf(data.tieredAchievements).toEqualTypeOf<TieredAchivement[]>();
+  data.tieredAchievements.forEach((achievement: TieredAchivement) => {
+    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).toBeUndefined();
+      expectTypeOf(tier.points).toEqualTypeOf<number | undefined>();
+      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();
 });
diff --git a/src/API/getGuildAchievements.ts b/src/API/getGuildAchievements.ts
index 8beaf29a..31f18a69 100644
--- a/src/API/getGuildAchievements.ts
+++ b/src/API/getGuildAchievements.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import GuildAchievements from '../structures/Static/GuildAchievements';
-import { RequestOptions } from '../Private/RequestHandler';
+import GuildAchievements from '../structures/Static/Achievements/Guild';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getGuildAchievements extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getGuildAchievements extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<GuildAchievements> {
+  async execute(options?: RequestOptions): Promise<GuildAchievements | RequestData> {
     const res = await this.client.requestHandler.request('/resources/guilds/achievements', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new GuildAchievements(res.data);
   }
 }
diff --git a/src/API/getHouse.test.ts b/src/API/getHouse.test.ts
index 98af8d16..6819a192 100644
--- a/src/API/getHouse.test.ts
+++ b/src/API/getHouse.test.ts
@@ -1,17 +1,15 @@
 import Client from '../Client';
 import House from '../structures/House';
+import { RequestData } from '../Private/RequestHandler';
 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 houses = (await client.getActiveHouses()) as House[];
+
   const data = await client.getHouse(houses[0].uuid, { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expectTypeOf(data).toEqualTypeOf<House | RequestData>();
   client.destroy();
 });
 
@@ -25,16 +23,13 @@ test('getHouse (no input)', () => {
 
 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();
+  const houses = (await client.getActiveHouses()) as House[];
   expect(houses).toBeDefined();
   expectTypeOf(houses).toEqualTypeOf<House[]>();
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getHouse(houses[0].uuid);
+  let data = await client.getHouse(houses[0].uuid);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<House>();
+  expectTypeOf(data).toEqualTypeOf<House | RequestData>();
+  data = data as House;
   expect(data.name).toBeDefined();
   expectTypeOf(data.name).toEqualTypeOf<string>();
   expect(data.uuid).toBeDefined();
@@ -42,9 +37,9 @@ test('getHouse', async () => {
   expect(data.owner).toBeDefined();
   expectTypeOf(data.owner).toEqualTypeOf<string>();
   expect(data.createdAtTimestamp).toBeDefined();
-  expectTypeOf(data.createdAtTimestamp).toEqualTypeOf<number>();
+  expectTypeOf(data.createdAtTimestamp).toEqualTypeOf<number | null>();
   expect(data.createdAt).toBeDefined();
-  expectTypeOf(data.createdAt).toEqualTypeOf<Date>();
+  expectTypeOf(data.createdAt).toEqualTypeOf<Date | null>();
   expect(data.players).toBeDefined();
   expectTypeOf(data.players).toEqualTypeOf<number>();
   expect(data.cookies).toBeDefined();
diff --git a/src/API/getHouse.ts b/src/API/getHouse.ts
index 227cb0d0..e637d1c1 100644
--- a/src/API/getHouse.ts
+++ b/src/API/getHouse.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 getHouse extends Endpoint {
   readonly client: Client;
@@ -10,10 +10,10 @@ class getHouse extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<House> {
+  async execute(query: string, options?: RequestOptions): Promise<House | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_UUID);
     const res = await this.client.requestHandler.request(`/housing/house?house=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new House(res.data);
   }
 }
diff --git a/src/API/getLeaderboards.test.ts b/src/API/getLeaderboards.test.ts
index 17844d36..7c9a4f59 100644
--- a/src/API/getLeaderboards.test.ts
+++ b/src/API/getLeaderboards.test.ts
@@ -1,23 +1,24 @@
 import Client from '../Client';
 import Leaderboard from '../structures/Leaderboard';
+import { RequestData } from '../Private/RequestHandler';
 import { defaultRequestData } from '../../vitest.setup';
 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<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Record<string, Leaderboard[]> | RequestData>();
   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();
+  let data = await client.getLeaderboards();
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<Record<string, Leaderboard[]> | RequestData>();
+  data = data as Record<string, Leaderboard[]>;
   Object.keys(data).forEach((key) => {
     expect(data[key]).toBeDefined();
     expectTypeOf(data[key]).toEqualTypeOf<Leaderboard[]>();
@@ -54,8 +55,7 @@ test('getLeaderboards (Missing Data)', () => {
     ...defaultRequestData,
     json: () => Promise.resolve({ success: true })
   } as any);
-  // 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.')
   );
diff --git a/src/API/getLeaderboards.ts b/src/API/getLeaderboards.ts
index ab822816..9d1e4f87 100644
--- a/src/API/getLeaderboards.ts
+++ b/src/API/getLeaderboards.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import Leaderboard from '../structures/Leaderboard';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getLeaderboards extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getLeaderboards extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Record<string, Leaderboard[]>> {
+  async execute(options?: RequestOptions): Promise<Record<string, Leaderboard[]> | RequestData> {
     const res = await this.client.requestHandler.request('/leaderboards', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     if (!res.data.leaderboards) {
       throw new Error(this.client.errors.SOMETHING_WENT_WRONG.replace(/{cause}/, 'Try again.'));
     }
diff --git a/src/API/getPlayer.test.ts b/src/API/getPlayer.test.ts
index 92e736bc..01d989cb 100644
--- a/src/API/getPlayer.test.ts
+++ b/src/API/getPlayer.test.ts
@@ -33,6 +33,7 @@ import VampireZ from '../structures/MiniGames/VampireZ';
 import Walls from '../structures/MiniGames/Walls';
 import Warlords from '../structures/MiniGames/Warlords';
 import WoolGames from '../structures/MiniGames/WoolGames';
+import { RequestData } from '../Private/RequestHandler';
 import { defaultRequestData } from '../../vitest.setup';
 import { expect, expectTypeOf, test, vi } from 'vitest';
 
@@ -42,8 +43,7 @@ test('getPlayer (never joinned hypixel)', async () => {
     ...defaultRequestData,
     json: () => Promise.resolve({ success: true })
   } as any);
-  // 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
   );
@@ -61,21 +61,19 @@ test('getPlayer (no input)', () => {
 
 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('4855c53ee4fb4100997600a92fc50984', { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Player | RequestData>();
   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('28667672039044989b0019b14a2c34d6', { guild: true });
+  let data = await client.getPlayer('28667672039044989b0019b14a2c34d6', { guild: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Player>();
+  expectTypeOf(data).toEqualTypeOf<Player | RequestData>();
+  data = data as Player;
   expect(data.guild).toBeDefined();
   expectTypeOf(data.guild).toEqualTypeOf<Guild | null>();
   expect(data.guild).toBeInstanceOf(Guild);
@@ -84,46 +82,47 @@ test('getPlayer (guild)', async () => {
 
 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('618a96fec8b0493fa89427891049550b', { houses: true });
+  let data = await client.getPlayer('618a96fec8b0493fa89427891049550b', { houses: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Player>();
+  expectTypeOf(data).toEqualTypeOf<Player | RequestData>();
+  data = data as Player;
   expect(data.houses).toBeDefined();
   expectTypeOf(data.houses).toEqualTypeOf<House[] | null>();
-  data.houses.forEach((house: House) => {
-    expect(house).toBeDefined();
-    expect(house).toBeInstanceOf(House);
-    expectTypeOf(house).toEqualTypeOf<House>();
-  });
+  if (data.houses) {
+    data.houses.forEach((house: House) => {
+      expect(house).toBeDefined();
+      expect(house).toBeInstanceOf(House);
+      expectTypeOf(house).toEqualTypeOf<House>();
+    });
+  }
   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('37501e7512b845ab8796e2baf9e9677a', { recentGames: true });
+  let data = await client.getPlayer('37501e7512b845ab8796e2baf9e9677a', { recentGames: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Player>();
+  expectTypeOf(data).toEqualTypeOf<Player | RequestData>();
+  data = data as Player;
   expect(data.recentGames).toBeDefined();
   expectTypeOf(data.recentGames).toEqualTypeOf<RecentGame[] | null>();
-  data.recentGames.forEach((game: RecentGame) => {
-    expect(game).toBeDefined();
-    expect(game).toBeInstanceOf(RecentGame);
-    expectTypeOf(game).toEqualTypeOf<RecentGame>();
-  });
+  if (data.recentGames) {
+    data.recentGames.forEach((game: RecentGame) => {
+      expect(game).toBeDefined();
+      expect(game).toBeInstanceOf(RecentGame);
+      expectTypeOf(game).toEqualTypeOf<RecentGame>();
+    });
+  }
   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');
+  let data = await client.getPlayer('14727faefbdc4aff848cd2713eb9939e');
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Player);
-  expectTypeOf(data).toEqualTypeOf<Player>();
+  expectTypeOf(data).toEqualTypeOf<Player | RequestData>();
+  data = data as Player;
   expect(data.nickname).toBeDefined();
   expectTypeOf(data.nickname).toEqualTypeOf<string>();
   expect(data.uuid).toBeDefined();
@@ -133,7 +132,7 @@ test('getPlayer', async () => {
   expect(data.guild).toBeDefined();
   expectTypeOf(data.guild).toEqualTypeOf<Guild | null>();
   expect(data.channel).toBeDefined();
-  expectTypeOf(data.channel).toEqualTypeOf<string | null>();
+  expectTypeOf(data.channel).toEqualTypeOf<string>();
   expect(data.firstLoginTimestamp).toBeDefined();
   expectTypeOf(data.firstLoginTimestamp).toEqualTypeOf<number | null>();
   expect(data.firstLogin).toBeDefined();
diff --git a/src/API/getPlayer.ts b/src/API/getPlayer.ts
index c54cd973..71827128 100644
--- a/src/API/getPlayer.ts
+++ b/src/API/getPlayer.ts
@@ -1,7 +1,11 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
+import Guild from '../structures/Guild/Guild';
+import House from '../structures/House';
 import Player from '../structures/Player';
+import RecentGame from '../structures/RecentGame';
 import { PlayerRequestOptions } from './API';
+import { RequestData } from '../Private/RequestHandler';
 
 class getPlayer extends Endpoint {
   readonly client: Client;
@@ -10,22 +14,16 @@ class getPlayer extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: PlayerRequestOptions): Promise<Player> {
+  async execute(query: string, options?: PlayerRequestOptions): Promise<Player | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/player?uuid=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     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
+      guild: options?.guild ? ((await this.client.getGuild('player', query)) as Guild) : null,
+      houses: options?.houses ? ((await this.client.getPlayerHouses(query)) as House[]) : null,
+      recentGames: options?.recentGames ? ((await this.client.getRecentGames(query)) as RecentGame[]) : null
     });
   }
 }
diff --git a/src/API/getPlayerHouses.test.ts b/src/API/getPlayerHouses.test.ts
index 5c6d237a..4f1a1741 100644
--- a/src/API/getPlayerHouses.test.ts
+++ b/src/API/getPlayerHouses.test.ts
@@ -1,5 +1,6 @@
 import Client from '../Client';
 import House from '../structures/House';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getPlayerHouses (No input)', () => {
@@ -12,21 +13,19 @@ test('getPlayerHouses (No input)', () => {
 
 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<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<House[] | RequestData>();
   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');
+  let data = await client.getPlayerHouses('69e04609da2a4e7dabb83546a971969e');
   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);
diff --git a/src/API/getPlayerHouses.ts b/src/API/getPlayerHouses.ts
index 1d31fd24..de73be06 100644
--- a/src/API/getPlayerHouses.ts
+++ b/src/API/getPlayerHouses.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 getPlayerHouses extends Endpoint {
   readonly client: Client;
@@ -10,11 +10,11 @@ class getPlayerHouses extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<House[]> {
+  async execute(query: string, options?: RequestOptions): Promise<House[] | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/housing/houses?player=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.map((h: any) => new House(h));
   }
 }
diff --git a/src/API/getQuests.test.ts b/src/API/getQuests.test.ts
index 83f0f07b..d051bec9 100644
--- a/src/API/getQuests.test.ts
+++ b/src/API/getQuests.test.ts
@@ -1,35 +1,33 @@
 import Client from '../Client';
 import GameQuests from '../structures/Static/GameQuests';
-import Quest from '../structures/Static/Quest';
+import Quest, { QuestObjective, QuestReward, QuestType } from '../structures/Static/Quest';
 import Quests from '../structures/Static/Quests';
-import { StaticGameNames } from '../typings';
+import { RequestData } from '../Private/RequestHandler';
 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<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Quests | RequestData>();
   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();
+  let data = await client.getQuests();
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Quests);
-  expectTypeOf(data).toEqualTypeOf<Quests>();
+  expectTypeOf(data).toEqualTypeOf<Quests | RequestData>();
+  data = data as Quests;
   expect(data.lastUpdatedTimestamp).toBeDefined();
   expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
   expect(data.lastUpdatedTimestamp).toBeGreaterThanOrEqual(0);
   expect(data.lastUpdatedAt).toBeDefined();
   expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
   expect(data.questsPerGame).toBeDefined();
-  expectTypeOf(data.questsPerGame).toEqualTypeOf<Record<StaticGameNames, GameQuests>>();
+  expectTypeOf(data.questsPerGame).toEqualTypeOf<Record<string, GameQuests>>();
   Object.keys(data.questsPerGame).forEach((game) => {
     expect(data.questsPerGame[game]).toBeDefined();
     expect(data.questsPerGame[game]).toBeInstanceOf(GameQuests);
@@ -43,8 +41,18 @@ test('getQuests', async () => {
       expect(quest).toBeDefined();
       expect(quest).toBeInstanceOf(Quest);
       expectTypeOf(quest).toEqualTypeOf<Quest>();
-      expect(quest.toString()).toBeDefined();
-      expectTypeOf(quest.toString()).toEqualTypeOf<string>();
+      expect(quest.id).toBeDefined();
+      expectTypeOf(quest.id).toEqualTypeOf<string>();
+      expect(quest.name).toBeDefined();
+      expectTypeOf(quest.name).toEqualTypeOf<string>();
+      expect(quest.description).toBeDefined();
+      expectTypeOf(quest.description).toEqualTypeOf<string>();
+      expect(quest.rewards).toBeDefined();
+      expectTypeOf(quest.rewards).toEqualTypeOf<QuestReward[]>();
+      expect(quest.type).toBeDefined();
+      expectTypeOf(quest.type).toEqualTypeOf<QuestType>();
+      expect(quest.objectives).toBeDefined();
+      expectTypeOf(quest.objectives).toEqualTypeOf<QuestObjective[]>();
     });
   });
   client.destroy();
diff --git a/src/API/getQuests.ts b/src/API/getQuests.ts
index 2ffdca11..a6cb70bf 100644
--- a/src/API/getQuests.ts
+++ b/src/API/getQuests.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import Quests from '../structures/Static/Quests';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getQuests extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getQuests extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Quests> {
+  async execute(options?: RequestOptions): Promise<Quests | RequestData> {
     const res = await this.client.requestHandler.request('/resources/quests', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new Quests(res.data);
   }
 }
diff --git a/src/API/getRecentGames.test.ts b/src/API/getRecentGames.test.ts
index 09afe66a..258c32c4 100644
--- a/src/API/getRecentGames.test.ts
+++ b/src/API/getRecentGames.test.ts
@@ -1,6 +1,7 @@
 import Client from '../Client';
 import Game from '../structures/Game';
 import RecentGame from '../structures/RecentGame';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getRecentGames (no input)', () => {
@@ -13,21 +14,19 @@ test('getRecentGames (no input)', () => {
 
 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('3b76b69ae5134296a730ed49171ad6f8', { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<RecentGame[] | RequestData>();
   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('ea805d40e8284d8d8e64e9fc8ac301ca');
+  let data = await client.getRecentGames('ea805d40e8284d8d8e64e9fc8ac301ca');
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<RecentGame[]>();
+  expectTypeOf(data).toEqualTypeOf<RecentGame[] | RequestData>();
+  data = data as RecentGame[];
   data.forEach((game: RecentGame) => {
     expect(game).toBeDefined();
     expectTypeOf(game).toEqualTypeOf<RecentGame>();
diff --git a/src/API/getRecentGames.ts b/src/API/getRecentGames.ts
index 54ce2820..8dad9ebb 100644
--- a/src/API/getRecentGames.ts
+++ b/src/API/getRecentGames.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import RecentGame from '../structures/RecentGame';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getRecentGames extends Endpoint {
   readonly client: Client;
@@ -10,11 +10,11 @@ class getRecentGames extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<RecentGame[]> {
+  async execute(query: string, options?: RequestOptions): Promise<RecentGame[] | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/recentgames?uuid=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.games.map((x: any) => new RecentGame(x));
   }
 }
diff --git a/src/API/getSkyblockAuction.test.ts b/src/API/getSkyblockAuction.test.ts
index 21dc40e6..02194594 100644
--- a/src/API/getSkyblockAuction.test.ts
+++ b/src/API/getSkyblockAuction.test.ts
@@ -3,25 +3,22 @@ import Bid from '../structures/SkyBlock/Auctions/Bid';
 import Client from '../Client';
 import ItemBytes from '../structures/ItemBytes';
 import { Rarity } from '../structures/SkyBlock/SkyblockMemberTypes';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockAuction (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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
+  if (!auctions.auctions[0].auctioneerUuid) throw new Error("Something wen't wrong while fetching auctions");
   const data = await client.getSkyblockAuction('player', auctions.auctions[0].auctioneerUuid, { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
   client.destroy();
 });
 
 test('getSkyblockAuction (No 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.getSkyblockAuction('auction', '')).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
   client.destroy();
 });
@@ -36,17 +33,12 @@ test('getSkyblockAuction (Bad Filter)', () => {
 
 test('getSkyblockAuction (Auction)', 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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockAuction('auction', auctions.auctions[0].auctioneerUuid);
-  expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
-
+  if (!auctions.auctions[0].auctioneerUuid) throw new Error("Something wen't wrong while fetching auctions");
+  let data = await client.getSkyblockAuction('auction', auctions.auctions[0].auctioneerUuid);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Auction[]>();
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
+  data = data as Auction[];
   expect(data.length).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.length).toEqualTypeOf<number>();
   data.forEach((auction: Auction) => {
@@ -123,17 +115,12 @@ test('getSkyblockAuction (Auction)', async () => {
 
 test('getSkyblockAuction (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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockAuction('player', auctions.auctions[0].auctioneerUuid);
-  expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
-
+  if (!auctions.auctions[0].auctioneerUuid) throw new Error("Something wen't wrong while fetching auctions");
+  let data = await client.getSkyblockAuction('player', auctions.auctions[0].auctioneerUuid);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Auction[]>();
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
+  data = data as Auction[];
   expect(data.length).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.length).toEqualTypeOf<number>();
   data.forEach((auction: Auction) => {
@@ -210,17 +197,12 @@ test('getSkyblockAuction (Player)', async () => {
 
 test('getSkyblockAuction (Profile)', 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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockAuction('profile', auctions.auctions[0].auctioneerProfile);
+  if (!auctions.auctions[0].auctioneerProfile) throw new Error("Something wen't wrong while fetching auctions");
+  let data = await client.getSkyblockAuction('profile', auctions.auctions[0].auctioneerProfile);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
-
-  expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Auction[]>();
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
+  data = data as Auction[];
   expect(data.length).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.length).toEqualTypeOf<number>();
   data.forEach((auction: Auction) => {
@@ -297,19 +279,14 @@ test('getSkyblockAuction (Profile)', async () => {
 
 test('getSkyblockAuction (Include Item Bytes)', 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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockAuction('profile', auctions.auctions[0].auctioneerProfile, {
+  if (!auctions.auctions[0].auctioneerProfile) throw new Error("Something wen't wrong while fetching auctions");
+  let data = await client.getSkyblockAuction('profile', auctions.auctions[0].auctioneerProfile, {
     includeItemBytes: true
   });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
-
-  expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Auction[]>();
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
+  data = data as Auction[];
   expect(data.length).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.length).toEqualTypeOf<number>();
   data.forEach((auction: Auction) => {
diff --git a/src/API/getSkyblockAuction.ts b/src/API/getSkyblockAuction.ts
index d5da391e..c3386a07 100644
--- a/src/API/getSkyblockAuction.ts
+++ b/src/API/getSkyblockAuction.ts
@@ -1,7 +1,8 @@
 import Auction from '../structures/SkyBlock/Auctions/Auction';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import { AuctionRequestOptions } from './API';
+import { AuctionFetchOptions, AuctionRequestOptions } from './API';
+import { RequestData } from '../Private/RequestHandler';
 
 class getSkyblockAction extends Endpoint {
   readonly client: Client;
@@ -11,10 +12,10 @@ class getSkyblockAction extends Endpoint {
   }
 
   async execute(
-    type: 'profile' | 'player' | 'auction',
+    type: AuctionFetchOptions,
     query: string,
     options?: AuctionRequestOptions
-  ): Promise<Auction[]> {
+  ): Promise<Auction[] | RequestData> {
     let filter;
     if ('profile' === type) {
       filter = 'profile';
@@ -28,7 +29,7 @@ class getSkyblockAction extends Endpoint {
     }
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     const res = await this.client.requestHandler.request(`/skyblock/auction?${filter}=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.auctions.map((a: any) => new Auction(a, options?.includeItemBytes ?? false));
   }
 }
diff --git a/src/API/getSkyblockAuctions.test.ts b/src/API/getSkyblockAuctions.test.ts
index a1a0002b..243f28b6 100644
--- a/src/API/getSkyblockAuctions.test.ts
+++ b/src/API/getSkyblockAuctions.test.ts
@@ -4,18 +4,9 @@ import Bid from '../structures/SkyBlock/Auctions/Bid';
 import Client from '../Client';
 import ItemBytes from '../structures/ItemBytes';
 import { Rarity } from '../structures/SkyBlock/SkyblockMemberTypes';
+import { SkyblockAuctionsResult } from './API';
 import { expect, expectTypeOf, test } from 'vitest';
 
-test('getSkyblockAuctions (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.getSkyblockAuctions(1, { raw: true });
-  expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
-  client.destroy();
-});
-
 test('getSkyblockAuctions (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
@@ -26,16 +17,12 @@ test('getSkyblockAuctions (No input)', () => {
 
 test('getSkyblockAuctions (Negative 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.getSkyblockAuctions(-1)).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE);
   client.destroy();
 });
 
 test('getSkyblockAuctions (Page 0)', () => {
   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.getSkyblockAuctions(0)).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE);
   client.destroy();
 });
@@ -50,11 +37,9 @@ test('getSkyblockAuctions (String Input)', () => {
 
 test('getSkyblockAuctions (One Page)', 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.getSkyblockAuctions(1);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<{ info: AuctionInfo; auctions: Auction[] }>();
+  expectTypeOf(data).toEqualTypeOf<SkyblockAuctionsResult>();
   expect(data.info).toBeDefined();
   expect(data.info).toBeInstanceOf(AuctionInfo);
   expectTypeOf(data.info).toEqualTypeOf<AuctionInfo>();
@@ -159,8 +144,6 @@ test('getSkyblockAuctions (One Page)', async () => {
 
 test('getSkyblockAuctions (One Page Include Item Bytes)', 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.getSkyblockAuctions(1, { includeItemBytes: true });
   expect(data).toBeDefined();
   expectTypeOf(data).toEqualTypeOf<{ info: AuctionInfo; auctions: Auction[] }>();
@@ -266,10 +249,9 @@ test('getSkyblockAuctions (One Page Include Item Bytes)', async () => {
   client.destroy();
 });
 
-test.skip('getSkyblockAuctions (All Pages)', async () => {
+test('getSkyblockAuctions (All Pages)', 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.getSkyblockAuctions('*');
   expect(data).toBeDefined();
   expectTypeOf(data).toEqualTypeOf<{ info: AuctionInfo; auctions: Auction[] }>();
diff --git a/src/API/getSkyblockAuctions.ts b/src/API/getSkyblockAuctions.ts
index 846ad825..353c30b2 100644
--- a/src/API/getSkyblockAuctions.ts
+++ b/src/API/getSkyblockAuctions.ts
@@ -2,7 +2,7 @@ import Auction from '../structures/SkyBlock/Auctions/Auction';
 import AuctionInfo from '../structures/SkyBlock/Auctions/AuctionInfo';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import { AuctionRequestOptions } from './API';
+import { AuctionRequestOptions, SkyblockAuctionsResult } from './API';
 
 class getSkyblockAuctions extends Endpoint {
   readonly client: Client;
@@ -12,10 +12,7 @@ class getSkyblockAuctions extends Endpoint {
     this.client = client;
   }
 
-  async execute(
-    query: number | '*',
-    options?: AuctionRequestOptions
-  ): Promise<{ info: AuctionInfo; auctions: Auction[] }> {
+  async execute(query: number | '*', options?: AuctionRequestOptions): Promise<SkyblockAuctionsResult> {
     if (!query) throw new Error(this.client.errors.INVALID_OPTION_VALUE);
     if ('number' === typeof query && 0 >= query) throw new Error(this.client.errors.INVALID_OPTION_VALUE);
     if ('number' !== typeof query && '*' !== query) throw new Error(this.client.errors.INVALID_OPTION_VALUE);
@@ -24,7 +21,7 @@ class getSkyblockAuctions extends Endpoint {
     return await this.getPage(query);
   }
 
-  async getAllPages(): Promise<{ info: AuctionInfo; auctions: Auction[] }> {
+  async getAllPages(): Promise<SkyblockAuctionsResult> {
     const page = 0;
     const { info, auctions } = await this.getPage(page);
     const pages = info.totalPages;
@@ -39,7 +36,7 @@ class getSkyblockAuctions extends Endpoint {
     return { info, auctions };
   }
 
-  async getPage(page: number): Promise<{ info: AuctionInfo; auctions: Auction[] }> {
+  async getPage(page: number): Promise<SkyblockAuctionsResult> {
     const res = await this.client.requestHandler.request(`/skyblock/auctions?page=${page}`, this.options);
     return {
       info: new AuctionInfo(res.data),
@@ -50,8 +47,7 @@ class getSkyblockAuctions extends Endpoint {
   private parseOptions(options: any): AuctionRequestOptions {
     return {
       includeItemBytes: options?.includeItemBytes ?? false,
-      noCache: options?.noCache ?? false,
-      raw: options?.raw ?? false
+      noCache: options?.noCache ?? false
     };
   }
 }
diff --git a/src/API/getSkyblockAuctionsByPlayer.test.ts b/src/API/getSkyblockAuctionsByPlayer.test.ts
index 025a8abb..f326f95f 100644
--- a/src/API/getSkyblockAuctionsByPlayer.test.ts
+++ b/src/API/getSkyblockAuctionsByPlayer.test.ts
@@ -3,18 +3,17 @@ import Bid from '../structures/SkyBlock/Auctions/Bid';
 import Client from '../Client';
 import ItemBytes from '../structures/ItemBytes';
 import { Rarity } from '../structures/SkyBlock/SkyblockMemberTypes';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockAuctionsByPlayer (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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
+  if (!auctions.auctions[0].auctioneerUuid) throw new Error("Something wen't wrong while fetching auctions");
   const data = await client.getSkyblockAuctionsByPlayer(auctions.auctions[0].auctioneerUuid, { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
   client.destroy();
 });
 
@@ -28,15 +27,12 @@ test('getSkyblockAuctionsByPlayer (No Input)', () => {
 
 test('getSkyblockAuctionsByPlayer', 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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockAuctionsByPlayer(auctions.auctions[0].auctioneerUuid);
+  if (!auctions.auctions[0].auctioneerUuid) throw new Error("Something wen't wrong while fetching auctions");
+  let data = await client.getSkyblockAuctionsByPlayer(auctions.auctions[0].auctioneerUuid);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Auction[]>();
-
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
+  data = data as Auction[];
   data.forEach((auction: Auction) => {
     expect(auction).toBeDefined();
     expect(auction).toBeInstanceOf(Auction);
@@ -142,17 +138,12 @@ test('getSkyblockAuctionsByPlayer', async () => {
 
 test('getSkyblockAuctionsByPlayer (Item Bytes)', 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 auctions = await client.getSkyblockAuctions(1);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockAuctionsByPlayer(auctions.auctions[0].auctioneerUuid, {
-    includeItemBytes: true
-  });
+  if (!auctions.auctions[0].auctioneerUuid) throw new Error("Something wen't wrong while fetching auctions");
+  let data = await client.getSkyblockAuctionsByPlayer(auctions.auctions[0].auctioneerUuid, { includeItemBytes: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Auction[]>();
-
+  expectTypeOf(data).toEqualTypeOf<Auction[] | RequestData>();
+  data = data as Auction[];
   data.forEach((auction: Auction) => {
     expect(auction).toBeDefined();
     expect(auction).toBeInstanceOf(Auction);
diff --git a/src/API/getSkyblockAuctionsByPlayer.ts b/src/API/getSkyblockAuctionsByPlayer.ts
index dcfa4f2c..f7ad921c 100644
--- a/src/API/getSkyblockAuctionsByPlayer.ts
+++ b/src/API/getSkyblockAuctionsByPlayer.ts
@@ -2,6 +2,7 @@ import Auction from '../structures/SkyBlock/Auctions/Auction';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import { AuctionRequestOptions } from './API';
+import { RequestData } from '../Private/RequestHandler';
 
 class getSkyblockActionsByPlayer extends Endpoint {
   readonly client: Client;
@@ -10,11 +11,11 @@ class getSkyblockActionsByPlayer extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: AuctionRequestOptions): Promise<Auction[]> {
+  async execute(query: string, options?: AuctionRequestOptions): Promise<Auction[] | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/skyblock/auction?player=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.auctions.map((a: any) => new Auction(a, options?.includeItemBytes ?? false));
   }
 }
diff --git a/src/API/getSkyblockBazaar.test.ts b/src/API/getSkyblockBazaar.test.ts
index 70e23111..269524e8 100644
--- a/src/API/getSkyblockBazaar.test.ts
+++ b/src/API/getSkyblockBazaar.test.ts
@@ -1,24 +1,23 @@
 import Client from '../Client';
 import Order from '../structures/SkyBlock/Bazaar/Order';
 import Product from '../structures/SkyBlock/Bazaar/Product';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockBazarr (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.getSkyblockBazaar({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Product[] | RequestData>();
   client.destroy();
 });
 test('getSkyblockBazarr', 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.getSkyblockBazaar();
+  let data = await client.getSkyblockBazaar();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<Product[]>();
+  expectTypeOf(data).toEqualTypeOf<Product[] | RequestData>();
+  data = data as Product[];
   data.forEach((product: Product) => {
     expect(product).toBeDefined();
     expect(product).toBeInstanceOf(Product);
diff --git a/src/API/getSkyblockBazaar.ts b/src/API/getSkyblockBazaar.ts
index c22cf0d4..53660eb2 100644
--- a/src/API/getSkyblockBazaar.ts
+++ b/src/API/getSkyblockBazaar.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import Product from '../structures/SkyBlock/Bazaar/Product';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getSkyblockBazaar extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getSkyblockBazaar extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Product[]> {
+  async execute(options?: RequestOptions): Promise<Product[] | RequestData> {
     const res = await this.client.requestHandler.request('/skyblock/bazaar', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return Object.keys(res.data.products).map((x) => new Product(res.data.products[x]));
   }
 }
diff --git a/src/API/getSkyblockBingo.test.ts b/src/API/getSkyblockBingo.test.ts
index f86ec670..ccd2da90 100644
--- a/src/API/getSkyblockBingo.test.ts
+++ b/src/API/getSkyblockBingo.test.ts
@@ -1,42 +1,43 @@
 import Bingo from '../structures/SkyBlock/Static/Bingo';
 import BingoData from '../structures/SkyBlock/Static/BingoData';
 import Client from '../Client';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockBingo (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.getSkyblockBingo({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<BingoData | RequestData>();
   client.destroy();
 });
 
 test('getSkyblockBingo', 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.getSkyblockBingo();
+  let data = await client.getSkyblockBingo();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf(BingoData);
+  expectTypeOf(data).toEqualTypeOf<BingoData | RequestData>();
+  data = data as BingoData;
   expect(data.lastUpdatedTimestamp).toBeDefined();
   expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
   expect(data.lastUpdatedAt).toBeDefined();
-  expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
+  expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date | null>();
   expect(data.id).toBeDefined();
-  expectTypeOf(data.id).toEqualTypeOf<number>();
+  expectTypeOf(data.id).toEqualTypeOf<number | null>();
   expect(data.goals).toBeDefined();
   expectTypeOf(data.goals).toEqualTypeOf<Bingo[] | null>();
-  data.goals.forEach((goal: Bingo) => {
-    expect(goal).toBeDefined();
-    expectTypeOf(goal).toEqualTypeOf<Bingo>();
-    expect(goal).toBeInstanceOf(Bingo);
-    expect(goal.toString()).toBeDefined();
-    expect(goal.toString()).toBe(goal.id);
-    expectTypeOf(goal.toString()).toEqualTypeOf<string>();
-  });
+  if (data.goals) {
+    data.goals.forEach((goal: Bingo) => {
+      expect(goal).toBeDefined();
+      expectTypeOf(goal).toEqualTypeOf<Bingo>();
+      expect(goal).toBeInstanceOf(Bingo);
+      expect(goal.toString()).toBeDefined();
+      expect(goal.toString()).toBe(goal.id);
+      expectTypeOf(goal.toString()).toEqualTypeOf<string>();
+    });
+  }
   expect(data.getGoal(1, 1)).toBeDefined();
-  expectTypeOf(data.getGoal(1, 1)).toEqualTypeOf<Bingo>();
+  expectTypeOf(data.getGoal(1, 1)).toEqualTypeOf<Bingo | undefined>();
   client.destroy();
 });
diff --git a/src/API/getSkyblockBingo.ts b/src/API/getSkyblockBingo.ts
index 60317674..95ba6751 100644
--- a/src/API/getSkyblockBingo.ts
+++ b/src/API/getSkyblockBingo.ts
@@ -1,7 +1,7 @@
 import BingoData from '../structures/SkyBlock/Static/BingoData';
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getSkyblockBingo extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getSkyblockBingo extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<BingoData> {
+  async execute(options?: RequestOptions): Promise<BingoData | RequestData> {
     const res = await this.client.requestHandler.request('/resources/skyblock/bingo', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new BingoData(res.data);
   }
 }
diff --git a/src/API/getSkyblockFireSales.test.ts b/src/API/getSkyblockFireSales.test.ts
index ab98987e..44a76cf8 100644
--- a/src/API/getSkyblockFireSales.test.ts
+++ b/src/API/getSkyblockFireSales.test.ts
@@ -1,15 +1,15 @@
 import Client from '../Client';
 import FireSale from '../structures/SkyBlock/Static/FireSale';
+import { RequestData } from '../Private/RequestHandler';
 import { defaultRequestData } from '../../vitest.setup';
 import { expect, expectTypeOf, test, vi } from 'vitest';
 
 test('getSkyblockFireSales (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.getSkyblockFireSales({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<FireSale[] | RequestData>();
   client.destroy();
 });
 
@@ -18,6 +18,7 @@ test('getSkyblockFireSales', async () => {
   vi.spyOn(global, 'fetch').mockResolvedValue({
     ...defaultRequestData,
     json: () =>
+      /* eslint-disable camelcase */
       Promise.resolve({
         success: true,
         sales: [
@@ -25,12 +26,13 @@ test('getSkyblockFireSales', async () => {
           { item_id: 'PET_SKIN_LION_BLACK', start: 1725120000000, end: 1725552000000, amount: 6500, price: 650 }
         ]
       })
+    /* eslint-enable camelcase */
   } as any);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
-  const data = await client.getSkyblockFireSales();
+
+  let data = await client.getSkyblockFireSales();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<FireSale[]>();
+  expectTypeOf(data).toEqualTypeOf<FireSale[] | RequestData>();
+  data = data as FireSale[];
   data.forEach((firesale: FireSale) => {
     expect(firesale).toBeDefined();
     expect(firesale).toBeInstanceOf(FireSale);
diff --git a/src/API/getSkyblockFireSales.ts b/src/API/getSkyblockFireSales.ts
index 788e8ae0..617e2846 100644
--- a/src/API/getSkyblockFireSales.ts
+++ b/src/API/getSkyblockFireSales.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import FireSale from '../structures/SkyBlock/Static/FireSale';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getSkyblockFireSales extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getSkyblockFireSales extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<FireSale[]> {
+  async execute(options?: RequestOptions): Promise<FireSale[] | RequestData> {
     const res = await this.client.requestHandler.request('/skyblock/firesales', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.sales.map((a: any) => new FireSale(a));
   }
 }
diff --git a/src/API/getSkyblockGarden.test.ts b/src/API/getSkyblockGarden.test.ts
index b5bbf03e..637025bd 100644
--- a/src/API/getSkyblockGarden.test.ts
+++ b/src/API/getSkyblockGarden.test.ts
@@ -5,6 +5,7 @@ import SkyblockGarden, {
   SkyblockGardenVisitor,
   SkyblockGarenCrops
 } from '../structures/SkyBlock/SkyblockGarden';
+import { RequestData } from '../Private/RequestHandler';
 import { SkillLevel } from '../structures/SkyBlock/SkyblockMemberTypes';
 import { expect, expectTypeOf, test } from 'vitest';
 
@@ -18,22 +19,20 @@ test('getSkyblockGarden (no input)', () => {
 
 test('getSkyblockGarden (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.getSkyblockGarden('805c9751-0ff1-4cb6-8e9c-1067bf3bc601', { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<SkyblockGarden | RequestData>();
   client.destroy();
 });
 
 test('getSkyblockGarden', 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.getSkyblockGarden('805c9751-0ff1-4cb6-8e9c-1067bf3bc601');
+  let data = await client.getSkyblockGarden('805c9751-0ff1-4cb6-8e9c-1067bf3bc601');
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(SkyblockGarden);
-  expectTypeOf(data).toEqualTypeOf<SkyblockGarden>();
+  expectTypeOf(data).toEqualTypeOf<SkyblockGarden | RequestData>();
+  data = data as SkyblockGarden;
 
   expect(data.level).toBeDefined();
   expectTypeOf(data.level).toEqualTypeOf<SkillLevel>();
diff --git a/src/API/getSkyblockGarden.ts b/src/API/getSkyblockGarden.ts
index 0a32f60b..71c9e0c4 100644
--- a/src/API/getSkyblockGarden.ts
+++ b/src/API/getSkyblockGarden.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import SkyblockGarden from '../structures/SkyBlock/SkyblockGarden';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getSkyblockGarden extends Endpoint {
   readonly client: Client;
@@ -10,10 +10,10 @@ class getSkyblockGarden extends Endpoint {
     this.client = client;
   }
 
-  async execute(profileId: string, options?: RequestOptions): Promise<SkyblockGarden> {
+  async execute(profileId: string, options?: RequestOptions): Promise<SkyblockGarden | RequestData> {
     if (!profileId) throw new Error(this.client.errors.NO_UUID);
     const res = await this.client.requestHandler.request(`/skyblock/garden?profile=${profileId}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new SkyblockGarden(res.data);
   }
 }
diff --git a/src/API/getSkyblockGovernment.test.ts b/src/API/getSkyblockGovernment.test.ts
index 9f91fa76..4913c8b0 100644
--- a/src/API/getSkyblockGovernment.test.ts
+++ b/src/API/getSkyblockGovernment.test.ts
@@ -2,34 +2,30 @@ import Candidate from '../structures/SkyBlock/Static/Candidate';
 import Client from '../Client';
 import GovernmentData from '../structures/SkyBlock/Static/Government';
 import Perk from '../structures/SkyBlock/Static/Perk';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockGovernment (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.getSkyblockGovernment({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<GovernmentData | RequestData>();
   client.destroy();
 });
 
 test('getSkyblockGovernment', 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.getSkyblockGovernment();
+  let data = await client.getSkyblockGovernment();
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(GovernmentData);
-  expectTypeOf(data).toEqualTypeOf<GovernmentData>();
-
+  expectTypeOf(data).toEqualTypeOf<GovernmentData | RequestData>();
+  data = data as GovernmentData;
   expect(data.lastUpdatedTimestamp).toBeDefined();
   expect(data.lastUpdatedTimestamp).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.lastUpdatedTimestamp).toEqualTypeOf<number>();
-
   expect(data.lastUpdatedAt).toBeDefined();
   expectTypeOf(data.lastUpdatedAt).toEqualTypeOf<Date>();
-
   expect(data.lastElectionResults).toBeDefined();
   expectTypeOf(data.lastElectionResults).toEqualTypeOf<Map<string, Candidate>>();
   data.lastElectionResults.forEach((candidate: Candidate) => {
@@ -37,42 +33,30 @@ test('getSkyblockGovernment', async () => {
     expect(candidate).toBeInstanceOf(Candidate);
     expectTypeOf(candidate).toEqualTypeOf<Candidate>();
     expect(candidate.name).toBeDefined();
-
     expectTypeOf(candidate.name).toEqualTypeOf<string>();
-
     expect(candidate.keyBenefit).toBeDefined();
     expectTypeOf(candidate.keyBenefit).toEqualTypeOf<string>();
-
     expect(candidate.perks).toBeDefined();
     expectTypeOf(candidate.perks).toEqualTypeOf<Perk[] | null>();
-
     expect(candidate.isMayor).toBeDefined();
     expectTypeOf(candidate.isMayor).toEqualTypeOf<boolean>();
-
     expect(candidate.votesReceived).toBeDefined();
     expectTypeOf(candidate.votesReceived).toEqualTypeOf<number>();
-
     expect(candidate.toString()).toBeDefined();
     expect(candidate.toString()).toBe(candidate.name);
     expectTypeOf(candidate.toString()).toEqualTypeOf<string>();
   });
-
   expect(data.mayor).toBeDefined();
   expectTypeOf(data.mayor).toEqualTypeOf<Candidate | undefined>();
-
   expect(data.runningYear).toBeDefined();
   expect(data.runningYear).toBeGreaterThanOrEqual(0);
   expectTypeOf(data.runningYear).toEqualTypeOf<number>();
-
   expect(data.currentElectionResults).toBeDefined();
   expectTypeOf(data.currentElectionResults).toEqualTypeOf<Map<string, Candidate> | null>();
-
   expect(data.currentElectionFor).toBeDefined();
   expectTypeOf(data.currentElectionFor).toEqualTypeOf<number | null>();
-
   expect(data.toString()).toBeDefined();
   expect(data.toString()).toBe(data.mayor?.name || '');
   expectTypeOf(data.toString()).toEqualTypeOf<string>();
-
   client.destroy();
 });
diff --git a/src/API/getSkyblockGovernment.ts b/src/API/getSkyblockGovernment.ts
index 8f89caf7..66eae556 100644
--- a/src/API/getSkyblockGovernment.ts
+++ b/src/API/getSkyblockGovernment.ts
@@ -1,7 +1,7 @@
 import Client from '../Client.js';
 import Endpoint from '../Private/Endpoint.js';
 import GovernmentData from '../structures/SkyBlock/Static/Government.js';
-import { RequestOptions } from '../Private/RequestHandler.js';
+import { RequestData, RequestOptions } from '../Private/RequestHandler.js';
 
 class getSkyblockGovernment extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getSkyblockGovernment extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<GovernmentData> {
+  async execute(options?: RequestOptions): Promise<GovernmentData | RequestData> {
     const res = await this.client.requestHandler.request('/resources/skyblock/election', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new GovernmentData(res.data);
   }
 }
diff --git a/src/API/getSkyblockMember.test.ts b/src/API/getSkyblockMember.test.ts
index db9d102d..56c46730 100644
--- a/src/API/getSkyblockMember.test.ts
+++ b/src/API/getSkyblockMember.test.ts
@@ -17,15 +17,15 @@ import {
   Slayer
 } from '../structures/SkyBlock/SkyblockMemberTypes';
 import { NetworthResult } from 'skyhelper-networth';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockMember (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.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e', { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Map<string, SkyblockMember> | RequestData>();
   client.destroy();
 });
 
@@ -39,8 +39,6 @@ test('getSkyblockMember (no input)', () => {
 
 test('getSkyblockMember (no profiles)', () => {
   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.getSkyblockMember('b45add7b081443909fb00aa9a3e15eb0')).rejects.toThrowError(
     client.errors.NO_SKYBLOCK_PROFILES
   );
@@ -49,11 +47,10 @@ test('getSkyblockMember (no profiles)', () => {
 
 test('getSkyblockMember (museum)', 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.getSkyblockMember('add71246c46e455c8345c129ea6f146c', { museum: true });
+  let data = await client.getSkyblockMember('add71246c46e455c8345c129ea6f146c', { museum: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockMember[]>();
+  expectTypeOf(data).toEqualTypeOf<Map<string, SkyblockMember> | RequestData>();
+  data = data as Map<string, SkyblockMember>;
   data.forEach(async (member: SkyblockMember) => {
     expect(member).toBeDefined();
     expect(member).toBeInstanceOf(SkyblockMember);
@@ -253,11 +250,10 @@ test('getSkyblockMember (museum)', async () => {
 
 test('getSkyblockMember (garden)', 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.getSkyblockMember('add71246c46e455c8345c129ea6f146c', { garden: true });
+  let data = await client.getSkyblockMember('add71246c46e455c8345c129ea6f146c', { garden: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockMember[]>();
+  expectTypeOf(data).toEqualTypeOf<Map<string, SkyblockMember> | RequestData>();
+  data = data as Map<string, SkyblockMember>;
   data.forEach(async (member: SkyblockMember) => {
     expect(member).toBeDefined();
     expect(member).toBeInstanceOf(SkyblockMember);
@@ -456,11 +452,10 @@ test('getSkyblockMember (garden)', async () => {
 });
 test('getSkyblockMember', 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.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e');
+  let data = await client.getSkyblockMember('14727faefbdc4aff848cd2713eb9939e');
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockMember[]>();
+  expectTypeOf(data).toEqualTypeOf<Map<string, SkyblockMember> | RequestData>();
+  data = data as Map<string, SkyblockMember>;
   data.forEach(async (member: SkyblockMember) => {
     expect(member).toBeDefined();
     expect(member).toBeInstanceOf(SkyblockMember);
diff --git a/src/API/getSkyblockMember.ts b/src/API/getSkyblockMember.ts
index d9c64ebe..ed2cacc7 100644
--- a/src/API/getSkyblockMember.ts
+++ b/src/API/getSkyblockMember.ts
@@ -1,6 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import SkyblockMember from '../structures/SkyBlock/SkyblockMember';
+import { RequestData } from '../Private/RequestHandler';
 import { SkyblockRequestOptions } from './API';
 
 class getSkyblockMember extends Endpoint {
@@ -10,11 +11,11 @@ class getSkyblockMember extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: SkyblockRequestOptions): Promise<Map<string, SkyblockMember>> {
+  async execute(query: string, options?: SkyblockRequestOptions): Promise<Map<string, SkyblockMember> | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/skyblock/profiles?uuid=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     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) {
@@ -23,11 +24,7 @@ class getSkyblockMember extends Endpoint {
         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?.museum ? await this.client.getSkyblockMuseum(query, profile.profile_id) : null,
           profileName: profile.cute_name,
           gameMode: profile.game_mode || null,
diff --git a/src/API/getSkyblockMuseum.test.ts b/src/API/getSkyblockMuseum.test.ts
index d198ec91..317ba782 100644
--- a/src/API/getSkyblockMuseum.test.ts
+++ b/src/API/getSkyblockMuseum.test.ts
@@ -3,6 +3,7 @@ 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 { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockMuseum (no input)', () => {
@@ -15,29 +16,25 @@ test('getSkyblockMuseum (no input)', () => {
 
 test('getSkyblockMuseum (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 profiles = await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41');
-  const profile = profiles.find((profile: SkyblockProfile) => true === profile.selected);
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-expect-error
+  const profiles = (await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41')) as SkyblockProfile[];
+  const profile = profiles.find((profile: SkyblockProfile) => true === profile.selected) || null;
+  if (null === profile) throw new Error("Something wen't wrong while fetching profiles");
   const data = await client.getSkyblockMuseum('63fe6f4c4b0643b2abd02d15dc303e41', profile.profileId, { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<SkyblockMuseum | RequestData>();
   client.destroy();
 });
 
 test('getSkyblockMuseum', 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 profiles = await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41');
-  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('63fe6f4c4b0643b2abd02d15dc303e41', profile.profileId);
+  const profiles = (await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41')) as SkyblockProfile[];
+  const profile = profiles.find((profile: SkyblockProfile) => true === profile.selected) || null;
+  if (null === profile) throw new Error("Something wen't wrong while fetching profiles");
+  let data = await client.getSkyblockMuseum('63fe6f4c4b0643b2abd02d15dc303e41', profile.profileId);
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockMuseum>();
+  expectTypeOf(data).toEqualTypeOf<SkyblockMuseum | RequestData>();
+  data = data as SkyblockMuseum;
 
   expect(data.getItems()).toBeDefined();
   expectTypeOf(data.getItems).toEqualTypeOf<() => Promise<SkyblockMuseumItem[]>>();
diff --git a/src/API/getSkyblockMuseum.ts b/src/API/getSkyblockMuseum.ts
index 58d8bfc1..659d6135 100644
--- a/src/API/getSkyblockMuseum.ts
+++ b/src/API/getSkyblockMuseum.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import SkyblockMuseum from '../structures/SkyBlock/SkyblockMuseum';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getSkyblockMuseum extends Endpoint {
   readonly client: Client;
@@ -10,14 +10,14 @@ class getSkyblockMuseum extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, profileId: string, options?: RequestOptions): Promise<SkyblockMuseum> {
+  async execute(query: string, profileId: string, options?: RequestOptions): Promise<SkyblockMuseum | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(
       `/skyblock/museum?uuid=${query}&profile=${profileId}`,
       options
     );
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new SkyblockMuseum({ uuid: query, m: res.data, profileId: profileId });
   }
 }
diff --git a/src/API/getSkyblockNews.test.ts b/src/API/getSkyblockNews.test.ts
index 424dbc71..36c01a44 100644
--- a/src/API/getSkyblockNews.test.ts
+++ b/src/API/getSkyblockNews.test.ts
@@ -1,41 +1,34 @@
 import Client from '../Client';
 import SkyblockNews from '../structures/SkyBlock/News/SkyblockNews';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockNews (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.getSkyblockNews({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<SkyblockNews[] | RequestData>();
   client.destroy();
 });
 
 test('getSkyblockNews', 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.getSkyblockNews();
+  let data = await client.getSkyblockNews();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockNews[]>();
-
+  expectTypeOf(data).toEqualTypeOf<SkyblockNews[] | RequestData>();
+  data = data as 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>();
diff --git a/src/API/getSkyblockNews.ts b/src/API/getSkyblockNews.ts
index 5aa298f7..f42fce6b 100644
--- a/src/API/getSkyblockNews.ts
+++ b/src/API/getSkyblockNews.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import SkyblockNews from '../structures/SkyBlock/News/SkyblockNews';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getSkyblockNews extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getSkyblockNews extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<SkyblockNews[]> {
+  async execute(options?: RequestOptions): Promise<SkyblockNews[] | RequestData> {
     const res = await this.client.requestHandler.request('/skyblock/news', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return res.data.items.map((i: any) => new SkyblockNews(i));
   }
 }
diff --git a/src/API/getSkyblockProfiles.test.ts b/src/API/getSkyblockProfiles.test.ts
index 9a77dd6f..9dfec999 100644
--- a/src/API/getSkyblockProfiles.test.ts
+++ b/src/API/getSkyblockProfiles.test.ts
@@ -1,15 +1,15 @@
 import Client from '../Client';
 import SkyblockMember from '../structures/SkyBlock/SkyblockMember';
 import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getSkyblockProfiles (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.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e', { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[] | RequestData>();
   client.destroy();
 });
 
@@ -23,8 +23,6 @@ test('getSkyblockProfiles (no input)', () => {
 
 test('getSkyblockProfiles (no profiles)', () => {
   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.getSkyblockProfiles('b45add7b081443909fb00aa9a3e15eb0')).rejects.toThrowError(
     client.errors.NO_SKYBLOCK_PROFILES
   );
@@ -33,11 +31,10 @@ test('getSkyblockProfiles (no profiles)', () => {
 
 test('getSkyblockProfiles', 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.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e');
+  let data = await client.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e');
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[]>();
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[] | RequestData>();
+  data = data as SkyblockProfile[];
 
   data.forEach((profile: SkyblockProfile) => {
     expect(profile).toBeDefined();
@@ -77,11 +74,10 @@ test('getSkyblockProfiles', async () => {
 
 test('getSkyblockProfiles (garden)', 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.getSkyblockProfiles('add71246c46e455c8345c129ea6f146c', { garden: true });
+  let data = await client.getSkyblockProfiles('add71246c46e455c8345c129ea6f146c', { garden: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[]>();
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[] | RequestData>();
+  data = data as SkyblockProfile[];
 
   data.forEach((profile: SkyblockProfile) => {
     expect(profile).toBeDefined();
@@ -121,11 +117,10 @@ test('getSkyblockProfiles (garden)', async () => {
 
 test('getSkyblockProfiles (museum)', 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.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41', { museum: true });
+  let data = await client.getSkyblockProfiles('63fe6f4c4b0643b2abd02d15dc303e41', { museum: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[]>();
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[] | RequestData>();
+  data = data as SkyblockProfile[];
 
   data.forEach((profile: SkyblockProfile) => {
     expect(profile).toBeDefined();
diff --git a/src/API/getSkyblockProfiles.ts b/src/API/getSkyblockProfiles.ts
index e10d384f..d588b546 100644
--- a/src/API/getSkyblockProfiles.ts
+++ b/src/API/getSkyblockProfiles.ts
@@ -1,6 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile';
+import { RequestData } from '../Private/RequestHandler';
 import { SkyblockRequestOptions } from './API';
 
 class getSkyblockProfiles extends Endpoint {
@@ -10,11 +11,11 @@ class getSkyblockProfiles extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: SkyblockRequestOptions): Promise<SkyblockProfile[]> {
+  async execute(query: string, options?: SkyblockRequestOptions): Promise<SkyblockProfile[] | RequestData> {
     if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/skyblock/profiles?uuid=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     if (!res.data.profiles || !res.data.profiles.length) throw new Error(this.client.errors.NO_SKYBLOCK_PROFILES);
     const profiles = [];
     for (let i = 0; i < res.data.profiles.length; i++) {
@@ -28,11 +29,7 @@ class getSkyblockProfiles extends Endpoint {
         communityUpgrades: res.data.profiles[i].community_upgrades,
         selected: res.data.profiles[i].selected,
         members: res.data.profiles[i].members,
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
         garden: options?.garden ? await this.client.getSkyblockGarden(res.data.profiles[i].profile_id) : null,
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-expect-error
         museum: options?.garden ? await this.client.getSkyblockMuseum(query, res.data.profiles[i].profile_id) : null
       });
     }
diff --git a/src/API/getStatus.test.ts b/src/API/getStatus.test.ts
index bf6e3573..8f13784f 100644
--- a/src/API/getStatus.test.ts
+++ b/src/API/getStatus.test.ts
@@ -1,30 +1,27 @@
 import Client from '../Client';
 import Game, { GameCode, GameID, GameString } from '../structures/Game';
 import Status from '../structures/Status';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getStatus (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.getStatus('4982eac19ae7422891b61a17a74c87a2', { raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<Status | RequestData>();
   client.destroy();
 });
 
 test('getStatus', 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.getStatus('370d6421b761456fadf28c43fe5c4bcf');
+  let data = await client.getStatus('370d6421b761456fadf28c43fe5c4bcf');
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Status);
-  expectTypeOf(data).toEqualTypeOf<Status>();
-
+  expectTypeOf(data).toEqualTypeOf<Status | RequestData>();
+  data = data as Status;
   expect(data.online).toBeDefined();
   expectTypeOf(data.online).toEqualTypeOf<boolean>();
-
   expect(data.game).toBeDefined();
   expectTypeOf(data.game).toEqualTypeOf<Game | null>();
   if (data.game) {
@@ -50,16 +47,12 @@ test('getStatus', async () => {
     expect(Game.NAMES).toBeDefined();
     expectTypeOf(Game.NAMES).toEqualTypeOf<GameString[]>();
   }
-
   expect(data.mode).toBeDefined();
   expectTypeOf(data.mode).toEqualTypeOf<string | null>();
-
   expect(data.map).toBeDefined();
   expectTypeOf(data.map).toEqualTypeOf<string | null>();
-
   expect(data.toString()).toBeDefined();
   expectTypeOf(data.toString()).toEqualTypeOf<'Online' | 'Offline'>();
   expect(data.toString()).toBe(data.online ? 'Online' : 'Offline');
-
   client.destroy();
 });
diff --git a/src/API/getStatus.ts b/src/API/getStatus.ts
index 12d179d9..fe47cebe 100644
--- a/src/API/getStatus.ts
+++ b/src/API/getStatus.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import Status from '../structures/Status';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getStatus extends Endpoint {
   readonly client: Client;
@@ -10,10 +10,10 @@ class getStatus extends Endpoint {
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<Status> {
+  async execute(query: string, options?: RequestOptions): Promise<Status | RequestData> {
     query = await this.client.requestHandler.toUUID(query);
     const res = await this.client.requestHandler.request(`/status?uuid=${query}`, options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new Status(res.data.session);
   }
 }
diff --git a/src/API/getWatchdogStats.test.ts b/src/API/getWatchdogStats.test.ts
index 886244ba..f60b6aad 100644
--- a/src/API/getWatchdogStats.test.ts
+++ b/src/API/getWatchdogStats.test.ts
@@ -1,44 +1,38 @@
 import Client from '../Client';
 import WatchdogStats from '../structures/WatchdogStats';
+import { RequestData } from '../Private/RequestHandler';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('getWatchdogStats (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.getWatchdogStats({ raw: true });
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<object>();
+  expect(data).toBeInstanceOf(RequestData);
+  expectTypeOf(data).toEqualTypeOf<WatchdogStats | RequestData>();
   client.destroy();
 });
 
 test('getWatchdogStats', 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.getWatchdogStats();
+  let data = await client.getWatchdogStats();
   expect(data).toBeDefined();
-  expectTypeOf(data).toEqualTypeOf<WatchdogStats>();
   expect(data).toBeInstanceOf(WatchdogStats);
-
+  expectTypeOf(data).toEqualTypeOf<WatchdogStats | RequestData>();
+  data = data as WatchdogStats;
   expect(data.byWatchdogTotal).toBeDefined();
-  expectTypeOf(data.byWatchdogTotal).toEqualTypeOf<number>();
   expect(data.byWatchdogTotal).toBeGreaterThanOrEqual(0);
-
+  expectTypeOf(data.byWatchdogTotal).toEqualTypeOf<number>();
   expect(data.byWatchdogLastMinute).toBeDefined();
-  expectTypeOf(data.byWatchdogLastMinute).toEqualTypeOf<number>();
   expect(data.byWatchdogLastMinute).toBeGreaterThanOrEqual(0);
-
+  expectTypeOf(data.byWatchdogLastMinute).toEqualTypeOf<number>();
   expect(data.byWatchdogRollingDay).toBeDefined();
-  expectTypeOf(data.byWatchdogRollingDay).toEqualTypeOf<number>();
   expect(data.byWatchdogRollingDay).toBeGreaterThanOrEqual(0);
-
+  expectTypeOf(data.byWatchdogRollingDay).toEqualTypeOf<number>();
   expect(data.byStaffTotal).toBeDefined();
-  expectTypeOf(data.byStaffTotal).toEqualTypeOf<number>();
   expect(data.byStaffTotal).toBeGreaterThanOrEqual(0);
-
+  expectTypeOf(data.byStaffTotal).toEqualTypeOf<number>();
   expect(data.byStaffRollingDay).toBeDefined();
-  expectTypeOf(data.byStaffRollingDay).toEqualTypeOf<number>();
   expect(data.byStaffRollingDay).toBeGreaterThanOrEqual(0);
+  expectTypeOf(data.byStaffRollingDay).toEqualTypeOf<number>();
   client.destroy();
 });
diff --git a/src/API/getWatchdogStats.ts b/src/API/getWatchdogStats.ts
index 718491e6..fbc9e926 100644
--- a/src/API/getWatchdogStats.ts
+++ b/src/API/getWatchdogStats.ts
@@ -1,7 +1,7 @@
 import Client from '../Client';
 import Endpoint from '../Private/Endpoint';
 import WatchdogStats from '../structures/WatchdogStats';
-import { RequestOptions } from '../Private/RequestHandler';
+import { RequestData, RequestOptions } from '../Private/RequestHandler';
 
 class getWatchdogStats extends Endpoint {
   readonly client: Client;
@@ -10,9 +10,9 @@ class getWatchdogStats extends Endpoint {
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<WatchdogStats> {
+  async execute(options?: RequestOptions): Promise<WatchdogStats | RequestData> {
     const res = await this.client.requestHandler.request('/punishmentstats', options);
-    if (res.options.raw) return res.data;
+    if (res.options.raw) return res;
     return new WatchdogStats(res.data);
   }
 }
diff --git a/src/Client.ts b/src/Client.ts
index feefa58d..ea0f11e6 100644
--- a/src/Client.ts
+++ b/src/Client.ts
@@ -1,9 +1,40 @@
 import API from './API';
+import Achievements from './structures/Static/Achievements/Achievements';
+import Auction from './structures/SkyBlock/Auctions/Auction';
+import BingoData from './structures/SkyBlock/Static/BingoData';
+import Booster from './structures/Boosters/Booster';
 import CacheHandler from './Private/CacheHandler';
+import Challenges from './structures/Static/Challenges';
 import Errors from './Errors';
+import FireSale from './structures/SkyBlock/Static/FireSale';
+import GameCounts from './structures/GameCounts';
+import GovernmentData from './structures/SkyBlock/Static/Government';
+import Guild from './structures/Guild/Guild';
+import GuildAchievements from './structures/Static/Achievements/Guild';
+import House from './structures/House';
+import Leaderboard from './structures/Leaderboard';
+import Player from './structures/Player';
+import Product from './structures/SkyBlock/Bazaar/Product';
+import Quests from './structures/Static/Quests';
 import RateLimit from './Private/RateLimit';
-import RequestHandler from './Private/RequestHandler';
+import RecentGame from './structures/RecentGame';
+import RequestHandler, { RequestData, RequestOptions } from './Private/RequestHandler';
+import SkyblockGarden from './structures/SkyBlock/SkyblockGarden';
+import SkyblockMember from './structures/SkyBlock/SkyblockMember';
+import SkyblockMuseum from './structures/SkyBlock/SkyblockMuseum';
+import SkyblockNews from './structures/SkyBlock/News/SkyblockNews';
+import SkyblockProfile from './structures/SkyBlock/SkyblockProfile';
+import Status from './structures/Status';
 import Updater from './Private/Updater';
+import WatchdogStats from './structures/WatchdogStats';
+import {
+  AuctionFetchOptions,
+  AuctionRequestOptions,
+  GuildFetchOptions,
+  PlayerRequestOptions,
+  SkyblockAuctionsResult,
+  SkyblockRequestOptions
+} from './API/API';
 
 export interface ClientOptions {
   cache?: boolean;
@@ -85,6 +116,132 @@ class Client {
       checkForUpdatesInterval: options?.checkForUpdatesInterval ?? 60
     };
   }
+
+  public getAchievements(options?: RequestOptions): Promise<Achievements | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getActiveHouses(options?: RequestOptions): Promise<House[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getBoosters(options?: RequestOptions): Promise<Booster[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getChallenges(options?: RequestOptions): Promise<Challenges | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getGameCounts(options?: RequestOptions): Promise<GameCounts | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getGuild(
+    searchParameter: GuildFetchOptions,
+    query: string,
+    options?: RequestOptions
+  ): Promise<Guild | null | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getGuildAchievements(options?: RequestOptions): Promise<GuildAchievements | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getHouse(query: string, options?: RequestOptions): Promise<House | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getLeaderboards(options?: RequestOptions): Promise<Record<string, Leaderboard[]> | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getPlayer(query: string, options?: PlayerRequestOptions): Promise<Player | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getPlayerHouses(query: string, options?: RequestOptions): Promise<House[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getQuests(options?: RequestOptions): Promise<Quests | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getRecentGames(query: string, options?: RequestOptions): Promise<RecentGame[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockAuction(
+    type: AuctionFetchOptions,
+    query: string,
+    options?: AuctionRequestOptions
+  ): Promise<Auction[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockAuctions(query: number | '*', options?: AuctionRequestOptions): Promise<SkyblockAuctionsResult> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockAuctionsByPlayer(query: string, options?: AuctionRequestOptions): Promise<Auction[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockBazaar(options?: RequestOptions): Promise<Product[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockBingo(options?: RequestOptions): Promise<BingoData | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockFireSales(options?: RequestOptions): Promise<FireSale[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockGarden(profileId: string, options?: RequestOptions): Promise<SkyblockGarden | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockGovernment(options?: RequestOptions): Promise<GovernmentData | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockMember(
+    query: string,
+    options?: SkyblockRequestOptions
+  ): Promise<Map<string, SkyblockMember> | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockMuseum(
+    query: string,
+    profileId: string,
+    options?: RequestOptions
+  ): Promise<SkyblockMuseum | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockNews(options?: RequestOptions): Promise<SkyblockNews[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getSkyblockProfiles(
+    query: string,
+    options?: SkyblockRequestOptions
+  ): Promise<SkyblockProfile[] | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getStatus(query: string, options?: RequestOptions): Promise<Status | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
+
+  public getWatchdogStats(options?: RequestOptions): Promise<WatchdogStats | RequestData> {
+    throw new Error(this.errors.ENDPOINT_NOT_LOADED);
+  }
 }
 
 export default Client;
diff --git a/src/Errors.ts b/src/Errors.ts
index d6bd0e68..f8d99927 100644
--- a/src/Errors.ts
+++ b/src/Errors.ts
@@ -39,6 +39,7 @@ class Errors {
     '[Hypixel-API-Reborn] Endpoint execute method is not implemented yet! Please report this https://discord.gg/NSEBNMM';
   RATE_LIMIT_INIT_ERROR: string =
     '[hypixel-api-reborn] An error happened whilst initializing rate limit. We strongly recommend restarting the code as this can lead to desynchronization.';
+  ENDPOINT_NOT_LOADED: string = '[hypixel-api-reborn] This endpoint has not been loaded yet. Please restart your code';
 }
 
 export default Errors;
diff --git a/src/Private/RequestHandler.ts b/src/Private/RequestHandler.ts
index b300ab2e..96d1b0ca 100644
--- a/src/Private/RequestHandler.ts
+++ b/src/Private/RequestHandler.ts
@@ -7,7 +7,7 @@ export interface RequestOptions {
   noCache?: boolean;
 }
 
-class RequestData {
+export class RequestData {
   readonly data: any;
   readonly headers: Record<string, any>;
   readonly statusCode: number;
diff --git a/src/index.ts b/src/index.ts
index ea30c8c0..925e2e29 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -91,14 +91,15 @@ export * from './structures/SkyBlock/Static/Candidate';
 export * from './structures/SkyBlock/Static/FireSale';
 export * from './structures/SkyBlock/Static/Government';
 export * from './structures/SkyBlock/Static/Perk';
-export * from './structures/Static/Achievement';
-export * from './structures/Static/AchievementTier';
-export * from './structures/Static/Achievements';
+export * from './structures/Static/Achievements/Achievements';
+export * from './structures/Static/Achievements/Base';
+export * from './structures/Static/Achievements/Game';
+export * from './structures/Static/Achievements/Guild';
+export * from './structures/Static/Achievements/OneTime';
+export * from './structures/Static/Achievements/Tired';
 export * from './structures/Static/Challenges';
-export * from './structures/Static/GameAchievements';
 export * from './structures/Static/GameChallenges';
 export * from './structures/Static/GameQuests';
-export * from './structures/Static/GuildAchievements';
 export * from './structures/Static/Quest';
 export * from './structures/Static/Quests';
 export * from './structures/Status';
diff --git a/src/structures/MiniGames/Pit.test.ts b/src/structures/MiniGames/Pit.test.ts
index a6201151..47fc9ab4 100644
--- a/src/structures/MiniGames/Pit.test.ts
+++ b/src/structures/MiniGames/Pit.test.ts
@@ -1,6 +1,7 @@
 import Client from '../../Client';
 import Pit, { PitArmor } from './Pit';
 import PitInventoryItem from './PitInventoryItem';
+import Player from '../Player';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('Pit', () => {
@@ -88,9 +89,8 @@ test('Pit', () => {
 
 test('Pit Inventory', 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('3457688aa57c4d71ab9d22b04f9160db');
+  let data = await client.getPlayer('3457688aa57c4d71ab9d22b04f9160db');
+  data = data as Player;
   expect(data.stats.pit.getInventory).toBeDefined();
   expectTypeOf(data.stats.pit.getInventory).toEqualTypeOf<() => Promise<PitInventoryItem[]>>();
   expect(data.stats.pit.getInventory).toBeInstanceOf(Function);
diff --git a/src/structures/SkyBlock/Bazaar/Product.test.ts b/src/structures/SkyBlock/Bazaar/Product.test.ts
index 4288df57..92e8b23e 100644
--- a/src/structures/SkyBlock/Bazaar/Product.test.ts
+++ b/src/structures/SkyBlock/Bazaar/Product.test.ts
@@ -2,6 +2,7 @@ import Product from './Product';
 import { expect, expectTypeOf, test } from 'vitest';
 
 test('Product', () => {
+  /* eslint-disable camelcase */
   const data = new Product({
     product_id: 'INK_SACK:3',
     sell_summary: [
@@ -41,6 +42,7 @@ test('Product', () => {
       buyOrders: 152
     }
   });
+  /* eslint-enable camelcase */
   expect(data).toBeDefined();
   expect(data).toBeInstanceOf(Product);
   expectTypeOf(data).toEqualTypeOf<Product>();
diff --git a/src/structures/Static/Achievement.ts b/src/structures/Static/Achievement.ts
deleted file mode 100644
index 94f1bd34..00000000
--- a/src/structures/Static/Achievement.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-import AchievementTier from './AchievementTier';
-
-function collectAll(data: AchievementTier | null) {
-  if (null === data) {
-    return { totalPoints: 0, totalAmount: 0 };
-  }
-  const mTier = data.maxTier;
-  let totalPoints = 0;
-  let totalAmount = 0;
-  for (let i = 1; i <= mTier; i++) {
-    totalPoints += data.getTier(i).pointsRewarded;
-    totalAmount += data.getTier(i).amountRequired;
-  }
-  return { totalPoints, totalAmount };
-}
-
-class Achievement {
-  name: string;
-  codeName: string;
-  description: string;
-  type: 'ONE_TIME' | 'TIERED';
-  rarity: Record<'local' | 'localPercentage' | 'global' | 'globalPercentage', number> | null;
-  tierInformation: AchievementTier | null;
-  points: number;
-  totalAmountRequired: number | null;
-  constructor(achievementName: string, data: Record<string, any>) {
-    this.name = data.name.trim();
-    this.codeName = achievementName;
-    this.description = data.description.trim();
-    this.type = data.tiers ? 'TIERED' : 'ONE_TIME';
-    this.rarity = {
-      local: parseFloat(data.gamePercentUnlocked) || 0,
-      localPercentage: parseFloat(data.gamePercentUnlocked) * 100 || 0,
-      global: data.globalPercentUnlocked,
-      globalPercentage: parseFloat(data.globalPercentUnlocked) * 100 || 0
-    };
-    this.tierInformation = 'TIERED' === this.type ? new AchievementTier(data.tiers) : null;
-    const { totalPoints = 0, totalAmount = 0 }: { totalPoints: number; totalAmount: number } =
-      'TIERED' === this.type ? collectAll(this.tierInformation) : { totalPoints: 0, totalAmount: 0 };
-    this.points = 'ONE_TIME' === this.type ? parseInt(data.points, 10) : totalPoints;
-    this.totalAmountRequired = 'TIERED' === this.type ? totalAmount : null;
-  }
-
-  toString(): string {
-    return this.codeName;
-  }
-}
-
-export default Achievement;
diff --git a/src/structures/Static/AchievementTier.ts b/src/structures/Static/AchievementTier.ts
deleted file mode 100644
index 3f9fef2b..00000000
--- a/src/structures/Static/AchievementTier.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-class AchievementTier {
-  maxTier: number;
-  tierInfo: any;
-  constructor(data: Record<string, any>) {
-    this.maxTier = data.length;
-    this.tierInfo = data.sort(
-      ({ tier: tierA }: { tier: number }, { tier: tierB }: { tier: number }) => Number(tierA) - Number(tierB)
-    );
-  }
-
-  getTier(tier: number): Record<'pointsRewarded' | 'amountRequired', number> {
-    const index = tier - 1;
-    const info = this.tierInfo[index];
-    return { pointsRewarded: parseInt(info.points, 10) || 0, amountRequired: parseInt(info.amount, 10) || 0 };
-  }
-}
-
-export default AchievementTier;
diff --git a/src/structures/Static/Achievements.ts b/src/structures/Static/Achievements.ts
deleted file mode 100644
index f473183b..00000000
--- a/src/structures/Static/Achievements.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-import GameAchievements from './GameAchievements';
-import { StaticGameNames } from '../../typings';
-
-class Achievements {
-  lastUpdatedTimestamp: number;
-  lastUpdatedAt: Date | null;
-  achievementsPerGame: Record<StaticGameNames, GameAchievements>;
-  constructor(data: Record<string, any>) {
-    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
-    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
-    this.achievementsPerGame = Object.fromEntries(
-      Object.entries(data.achievements).map(([game, data]) => [
-        game,
-        new GameAchievements(game as StaticGameNames, data as Record<string, any>)
-      ])
-    ) as Record<StaticGameNames, GameAchievements>;
-  }
-}
-
-export default Achievements;
diff --git a/src/structures/Static/Achievements/Achievements.ts b/src/structures/Static/Achievements/Achievements.ts
new file mode 100644
index 00000000..6c06573c
--- /dev/null
+++ b/src/structures/Static/Achievements/Achievements.ts
@@ -0,0 +1,17 @@
+import GameAchievements from './Game';
+
+class Achievements {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date;
+  achievementsPerGame: Record<string, GameAchievements>;
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = data.lastUpdated;
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.achievementsPerGame = {};
+    Object.keys(data.achievements).forEach((game) => {
+      this.achievementsPerGame.game = new GameAchievements(game, data.achievements[game]);
+    });
+  }
+}
+
+export default Achievements;
diff --git a/src/structures/Static/Achievements/Base.ts b/src/structures/Static/Achievements/Base.ts
new file mode 100644
index 00000000..93a32984
--- /dev/null
+++ b/src/structures/Static/Achievements/Base.ts
@@ -0,0 +1,20 @@
+class BaseAchievement {
+  codeName: string;
+  name: string;
+  description: string;
+  secret: boolean;
+  legacy: boolean;
+  constructor(achievementName: string, data: Record<string, any>) {
+    this.codeName = achievementName;
+    this.name = data.name;
+    this.description = data.description;
+    this.secret = data.secret || false;
+    this.legacy = data.legacy || false;
+  }
+
+  toString(): string {
+    return this.codeName;
+  }
+}
+
+export default BaseAchievement;
diff --git a/src/structures/Static/Achievements/Game.ts b/src/structures/Static/Achievements/Game.ts
new file mode 100644
index 00000000..e0078b14
--- /dev/null
+++ b/src/structures/Static/Achievements/Game.ts
@@ -0,0 +1,23 @@
+import OneTimeAchivement from './OneTime';
+import TieredAchivement from './Tired';
+
+class GameAchievements {
+  game: string;
+  points: number;
+  legacyPoints: number;
+  oneTimeAchievements: OneTimeAchivement[];
+  tieredAchievements: TieredAchivement[];
+  constructor(game: string, data: Record<string, any>) {
+    this.game = game;
+    this.points = data.total_points || 0;
+    this.legacyPoints = data.total_legacy_points || 0;
+    this.oneTimeAchievements = Object.keys(data.one_time).map(
+      (achivementKey) => new OneTimeAchivement(achivementKey, data.one_time[achivementKey])
+    );
+    this.tieredAchievements = Object.keys(data.tiered).map(
+      (achivementKey) => new TieredAchivement(achivementKey, data.tiered[achivementKey])
+    );
+  }
+}
+
+export default GameAchievements;
diff --git a/src/structures/Static/Achievements/Guild.ts b/src/structures/Static/Achievements/Guild.ts
new file mode 100644
index 00000000..acf86359
--- /dev/null
+++ b/src/structures/Static/Achievements/Guild.ts
@@ -0,0 +1,21 @@
+import OneTimeAchivement from './OneTime';
+import TieredAchivement from './Tired';
+
+class GuildAchievements {
+  lastUpdatedTimestamp: number;
+  lastUpdatedAt: Date;
+  oneTimeAchievements: OneTimeAchivement[];
+  tieredAchievements: TieredAchivement[];
+  constructor(data: Record<string, any>) {
+    this.lastUpdatedTimestamp = data.lastUpdated;
+    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
+    this.oneTimeAchievements = Object.keys(data.one_time).map(
+      (achivementKey) => new OneTimeAchivement(achivementKey, data.one_time[achivementKey])
+    );
+    this.tieredAchievements = Object.keys(data.tiered).map(
+      (achivementKey) => new TieredAchivement(achivementKey, data.tiered[achivementKey])
+    );
+  }
+}
+
+export default GuildAchievements;
diff --git a/src/structures/Static/Achievements/OneTime.ts b/src/structures/Static/Achievements/OneTime.ts
new file mode 100644
index 00000000..dd7cbc6f
--- /dev/null
+++ b/src/structures/Static/Achievements/OneTime.ts
@@ -0,0 +1,15 @@
+import BaseAchievement from './Base';
+
+class OneTimeAchivement extends BaseAchievement {
+  points: number;
+  gamePercentUnlocked: number;
+  globalPercentUnlocked: number;
+  constructor(achivementName: string, data: Record<string, any>) {
+    super(achivementName, data);
+    this.points = data.points;
+    this.gamePercentUnlocked = data.gamePercentUnlocked || 0;
+    this.globalPercentUnlocked = data.globalPercentUnlocked || 0;
+  }
+}
+
+export default OneTimeAchivement;
diff --git a/src/structures/Static/Achievements/Tired.ts b/src/structures/Static/Achievements/Tired.ts
new file mode 100644
index 00000000..ddf4371a
--- /dev/null
+++ b/src/structures/Static/Achievements/Tired.ts
@@ -0,0 +1,17 @@
+import BaseAchievement from './Base';
+
+export interface AchivementTier {
+  tier: number;
+  points?: number;
+  amount: number;
+}
+
+class TieredAchivement extends BaseAchievement {
+  tiers: AchivementTier[];
+  constructor(achivementName: string, data: Record<string, any>) {
+    super(achivementName, data);
+    this.tiers = data.tiers;
+  }
+}
+
+export default TieredAchivement;
diff --git a/src/structures/Static/Challenges.ts b/src/structures/Static/Challenges.ts
index 8d861657..245acc62 100644
--- a/src/structures/Static/Challenges.ts
+++ b/src/structures/Static/Challenges.ts
@@ -1,19 +1,16 @@
 import GameChallenges from './GameChallenges';
-import { StaticGameNames } from '../../typings';
 
 class Challenges {
   lastUpdatedTimestamp: number;
-  lastUpdatedAt: Date | null;
-  challengesPerGame: Record<StaticGameNames, GameChallenges>;
+  lastUpdatedAt: Date;
+  challengesPerGame: Record<string, GameChallenges>;
   constructor(data: Record<string, any>) {
-    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedTimestamp = data.lastUpdated;
     this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
-    this.challengesPerGame = Object.fromEntries(
-      Object.entries(data.challenges).map(([game, data]) => [
-        game,
-        new GameChallenges(game as StaticGameNames, data as Record<string, any>)
-      ])
-    ) as Record<StaticGameNames, GameChallenges>;
+    this.challengesPerGame = {};
+    Object.keys(data.challenges).forEach((game) => {
+      this.challengesPerGame[game] = new GameChallenges(game, data.challenges[game]);
+    });
   }
 }
 
diff --git a/src/structures/Static/GameAchievements.ts b/src/structures/Static/GameAchievements.ts
deleted file mode 100644
index 9cfbb293..00000000
--- a/src/structures/Static/GameAchievements.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import Achievement from './Achievement';
-import { StaticGameNames } from '../../typings';
-
-class GameAchievements {
-  category: StaticGameNames;
-  totalPoints: number;
-  totalLegacyPoints: number;
-  achievements: Achievement[];
-  constructor(name: StaticGameNames, data: Record<string, any>) {
-    this.category = name;
-    this.totalPoints = parseInt(data.total_points, 10) || 0;
-    this.totalLegacyPoints = parseInt(data.total_legacy_points, 10) || 0;
-    this.achievements = Object.entries({ ...(data.one_time || {}), ...(data.tiered || {}) }).map(
-      ([name, data]) => new Achievement(name, data as Record<string, any>)
-    );
-  }
-}
-
-export default GameAchievements;
diff --git a/src/structures/Static/GameChallenges.ts b/src/structures/Static/GameChallenges.ts
index 0a512af1..468f641c 100644
--- a/src/structures/Static/GameChallenges.ts
+++ b/src/structures/Static/GameChallenges.ts
@@ -1,27 +1,25 @@
-import { StaticGameNames } from '../../typings';
+export interface ChallengeReward {
+  type: 'MultipliedExperienceReward';
+  amount: number;
+}
 
-export interface ChallengeData {
+export class Challenge {
   id: string;
   name: string;
-  reward: number;
-  rewardType: string;
+  rewards: ChallengeReward[];
+  constructor(data: Record<string, any>) {
+    this.id = data.id;
+    this.name = data.name;
+    this.rewards = data.rewards;
+  }
 }
 
 class GameChallenges {
-  category: StaticGameNames;
-  challenges: Map<string, ChallengeData>;
-  constructor(name: StaticGameNames, data: Record<string, any>) {
+  category: string;
+  challenges: Challenge[];
+  constructor(name: string, data: { id: string; name: string; rewards: { type: string; amount: number }[] }[]) {
     this.category = name;
-    this.challenges = new Map();
-    data.forEach((challenge: any) => {
-      const content = {
-        id: challenge.id,
-        name: challenge.name,
-        reward: parseInt(challenge.rewards[0].amount, 10) || 0,
-        rewardType: challenge.rewards[0].type
-      };
-      this.challenges.set(challenge.id, content);
-    });
+    this.challenges = data.map((challenge) => new Challenge(challenge));
   }
 }
 
diff --git a/src/structures/Static/GameQuests.ts b/src/structures/Static/GameQuests.ts
index 3c74e2c0..fc037a52 100644
--- a/src/structures/Static/GameQuests.ts
+++ b/src/structures/Static/GameQuests.ts
@@ -1,10 +1,9 @@
 import Quest from './Quest';
-import { StaticGameNames } from '../../typings';
 
 class GameQuests {
-  game: StaticGameNames;
+  game: string;
   quests: Quest[];
-  constructor(name: StaticGameNames, data: Record<string, any>) {
+  constructor(name: string, data: Record<string, any>) {
     this.game = name;
     this.quests = data.map((x: any) => new Quest(x));
   }
diff --git a/src/structures/Static/GuildAchievements.ts b/src/structures/Static/GuildAchievements.ts
deleted file mode 100644
index 272d7478..00000000
--- a/src/structures/Static/GuildAchievements.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import Achievement from './Achievement';
-
-class GuildAchievements {
-  lastUpdatedTimestamp: number;
-  lastUpdatedAt: Date | null;
-  achievements: Record<string, Achievement>;
-  constructor(data: Record<string, any>) {
-    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
-    this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
-    this.achievements = Object.fromEntries(
-      Object.entries({ ...(data.tiered || {}), ...(data.one_time || {}) }).map(([name, value]) => [
-        name,
-        new Achievement(name, value as Record<string, any>)
-      ])
-    );
-  }
-}
-
-export default GuildAchievements;
diff --git a/src/structures/Static/Quest.ts b/src/structures/Static/Quest.ts
index ce229ac0..ec1f3a84 100644
--- a/src/structures/Static/Quest.ts
+++ b/src/structures/Static/Quest.ts
@@ -1,36 +1,40 @@
-export interface QuestObjective {
-  id: string;
-  type: 'Integer' | 'Boolean';
-  amountNeeded: number;
-}
+export type QuestType = 'Daily' | 'Weekly';
+export type QuestObjectiveType = 'Integer' | 'Boolean';
 
 export interface QuestReward {
   type: string;
   amount: number;
 }
 
+export class QuestObjective {
+  id: string;
+  type: QuestObjectiveType;
+  amountNeeded: number;
+  constructor(objective: Record<string, any>) {
+    this.id = objective.id;
+    this.type = 'IntegerObjective' === objective.type ? 'Integer' : 'Boolean';
+    this.amountNeeded = parseInt(objective.integer || '1', 10);
+  }
+}
+
 class Quest {
-  questName: string;
-  questID: string;
+  id: string;
+  name: string;
   description: string;
-  type: 'DAILY' | 'WEEKLY';
-  objectives: QuestObjective[];
   rewards: QuestReward[];
+  type: QuestType;
+  objectives: QuestObjective[];
   constructor(data: Record<string, any>) {
-    this.questName = data.name.trim();
-    this.questID = data.id;
+    this.id = data.id.trim();
+    this.name = data.name.trim();
     this.description = data.description.trim();
-    this.type = 'DailyResetQuestRequirement' === data.requirements?.[0].type ? 'DAILY' : 'WEEKLY';
-    this.objectives = data.objectives.map((objective: any) => ({
-      id: objective.id,
-      type: 'IntegerObjective' === objective.type ? 'Integer' : 'Boolean',
-      amountNeeded: parseInt(objective.integer || '1', 10)
-    }));
     this.rewards = data.rewards || [];
+    this.type = 'DailyResetQuestRequirement' === data.requirements?.[0].type ? 'Daily' : 'Weekly';
+    this.objectives = data.objectives.map((objective: any) => new QuestObjective(objective));
   }
 
   toString(): string {
-    return this.questName;
+    return this.name;
   }
 }
 
diff --git a/src/structures/Static/Quests.ts b/src/structures/Static/Quests.ts
index ff7aaa64..1c220467 100644
--- a/src/structures/Static/Quests.ts
+++ b/src/structures/Static/Quests.ts
@@ -1,19 +1,16 @@
 import GameQuests from './GameQuests';
-import { StaticGameNames } from '../../typings';
 
 class Quests {
   lastUpdatedTimestamp: number;
-  lastUpdatedAt: Date | null;
-  questsPerGame: Record<StaticGameNames, GameQuests>;
+  lastUpdatedAt: Date;
+  questsPerGame: Record<string, GameQuests>;
   constructor(data: Record<string, any>) {
-    this.lastUpdatedTimestamp = parseInt(data.lastUpdated, 10);
+    this.lastUpdatedTimestamp = data.lastUpdated;
     this.lastUpdatedAt = new Date(this.lastUpdatedTimestamp);
-    this.questsPerGame = Object.fromEntries(
-      Object.entries(data.quests).map(([game, data]) => [
-        game,
-        new GameQuests(game as StaticGameNames, data as Record<string, any>)
-      ])
-    ) as Record<StaticGameNames, GameQuests>;
+    this.questsPerGame = {};
+    Object.keys(data.quests).forEach((game) => {
+      this.questsPerGame[game] = new GameQuests(game, data.quests[game]);
+    });
   }
 }
 
diff --git a/src/typings/index.d.ts b/src/typings/index.d.ts
deleted file mode 100644
index 86e537e3..00000000
--- a/src/typings/index.d.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-export type StaticGameNames =
-  | 'arcade'
-  | 'arena'
-  | 'bedwars'
-  | 'hungergames'
-  | 'buildbattle'
-  | 'truecombat'
-  | 'duels'
-  | 'mcgo'
-  | 'murdermystery'
-  | 'paintball'
-  | 'quake'
-  | 'skyclash'
-  | 'skywars'
-  | 'supersmash'
-  | 'speeduhc'
-  | 'gingerbread'
-  | 'tntgames'
-  | 'uhc'
-  | 'vampirez'
-  | 'walls3'
-  | 'walls'
-  | 'battleground'
-  | 'woolgames';