Update tsconfig

.vscode/settings.json

@@ -3,5 +3,14 @@
   "prettier.useTabs": false,
   "files.insertFinalNewline": true,
   "files.trimTrailingWhitespace": true,
-  "editor.trimAutoWhitespace": true
+  "editor.trimAutoWhitespace": true,
+  "editor.formatOnSave": true,
+  "editor.codeActionsOnSave": {
+    "source.fixAll.eslint": "explicit"
+  },
+  "[typescript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "typescript.format.semicolons": "insert",
+  "typescript.preferences.quoteStyle": "single"
 }

package.json

@@ -21,7 +21,7 @@
     "lint": "npx eslint src/ --fix",
     "prettier:check": "npx prettier --check .",
     "prettier": "npx prettier --write .",
-    "build": "npx tsc && cp -r ./src/Types dist/",
+    "build": "npx tsc",
     "test": "npx vitest run",
     "test:coverage": "npx vitest run --coverage",
     "test:ui": "npx vitest --ui --coverage",

src/API/getAchievements.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getAchievements extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Achievements | RequestData> {
+  override async execute(options?: RequestOptions): Promise<Achievements | RequestData> {
     const res = await this.client.requestHandler.request('/resources/achievements', options);
     if (res.options.raw) return res;
     return new Achievements(res.data);

src/API/getActiveHouses.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getActiveHouses extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<House[] | RequestData> {
+  override async execute(options?: RequestOptions): Promise<House[] | RequestData> {
     const res = await this.client.requestHandler.request('/housing/active', options);
     if (res.options.raw) return res;
     return res.data.map((b: any) => new House(b));

src/API/getBoosters.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getBoosters extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Booster[] | RequestData> {
+  override async execute(options?: RequestOptions): Promise<Booster[] | RequestData> {
     const res = await this.client.requestHandler.request('/boosters', options);
     if (res.options.raw) return res;
     return res.data.boosters.map((b: any) => new Booster(b)).reverse();

src/API/getChallenges.test.ts

@@ -3,8 +3,8 @@ import Challenges from '../Structures/Static/Challenges.js';
 import Client from '../Client.js';
 import GameChallenges from '../Structures/Static/GameChallenges.js';
 import RequestData from '../Private/RequestData.js';
-import { ChallengeReward } from '../Types/Static.js';
 import { expect, expectTypeOf, test } from 'vitest';
+import type { ChallengeReward } from '../Types/Static.js';
 
 test('getChallenges (raw)', async () => {
   const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });

src/API/getChallenges.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getChallenges extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Challenges | RequestData> {
+  override async execute(options?: RequestOptions): Promise<Challenges | RequestData> {
     const res = await this.client.requestHandler.request('/resources/challenges', options);
     if (res.options.raw) return res;
     return new Challenges(res.data);

src/API/getGameCounts.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getGameCounts extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<GameCounts | RequestData> {
+  override async execute(options?: RequestOptions): Promise<GameCounts | RequestData> {
     const res = await this.client.requestHandler.request('/counts', options);
     if (res.options.raw) return res;
     return new GameCounts(res.data);

src/API/getGuild.ts

@@ -2,17 +2,17 @@ import Client from '../Client.js';
 import Endpoint from '../Private/Endpoint.js';
 import Guild from '../Structures/Guild/Guild.js';
 import RequestData from '../Private/RequestData.js';
-import { GuildFetchOptions } from '../Types/API.js';
+import type { GuildFetchOptions } from '../Types/API.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getGuild extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(
+  override async execute(
     searchParameter: GuildFetchOptions,
     query: string,
     options?: RequestOptions

src/API/getGuildAchievements.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getGuildAchievements extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<GuildAchievements | RequestData> {
+  override async execute(options?: RequestOptions): Promise<GuildAchievements | RequestData> {
     const res = await this.client.requestHandler.request('/resources/guilds/achievements', options);
     if (res.options.raw) return res;
     return new GuildAchievements(res.data);

src/API/getHouse.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getHouse extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<House | RequestData> {
+  override 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;

src/API/getLeaderboards.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getLeaderboards extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Record<string, Leaderboard[]> | RequestData> {
+  override async execute(options?: RequestOptions): Promise<Record<string, Leaderboard[]> | RequestData> {
     const res = await this.client.requestHandler.request('/leaderboards', options);
     if (res.options.raw) return res;
     if (!res.data.leaderboards) {

src/API/getPlayer.test.ts

@@ -37,9 +37,9 @@ import VampireZ from '../Structures/MiniGames/VampireZ/VampireZ.js';
 import Walls from '../Structures/MiniGames/Walls.js';
 import Warlords from '../Structures/MiniGames/Warlords/Warlords.js';
 import WoolGames from '../Structures/MiniGames/WoolGames/WoolGames.js';
-import { ChatChannel, Language, LevelProgress, PlayerRank, PlayerStats, ScorpiusBribe } from '../Types/Player.js';
 import { defaultRequestData } from '../../vitest.setup.js';
 import { expect, expectTypeOf, test, vi } from 'vitest';
+import type { ChatChannel, Language, LevelProgress, PlayerRank, PlayerStats, ScorpiusBribe } from '../Types/Player.js';
 
 test('getPlayer (never joinned hypixel)', async () => {
   const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });

src/API/getPlayer.ts

@@ -5,16 +5,16 @@ import House from '../Structures/House.js';
 import Player from '../Structures/Player/Player.js';
 import RecentGame from '../Structures/RecentGame.js';
 import RequestData from '../Private/RequestData.js';
-import { PlayerRequestOptions } from '../Types/API.js';
+import type { PlayerRequestOptions } from '../Types/API.js';
 
 class getPlayer extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(query: string, options?: PlayerRequestOptions): Promise<Player | RequestData> {
+  override 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);

src/API/getPlayerHouses.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getPlayerHouses extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<House[] | RequestData> {
+  override 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);

src/API/getQuests.test.ts

@@ -4,8 +4,8 @@ import Quest from '../Structures/Static/Quest.js';
 import QuestObjective from '../Structures/Static/QuestObjective.js';
 import Quests from '../Structures/Static/Quests.js';
 import RequestData from '../Private/RequestData.js';
-import { QuestReward, QuestType } from '../Types/Static.js';
 import { expect, expectTypeOf, test } from 'vitest';
+import type { QuestReward, QuestType } from '../Types/Static.js';
 
 test('getQuests (raw)', async () => {
   const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });

src/API/getQuests.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getQuests extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Quests | RequestData> {
+  override async execute(options?: RequestOptions): Promise<Quests | RequestData> {
     const res = await this.client.requestHandler.request('/resources/quests', options);
     if (res.options.raw) return res;
     return new Quests(res.data);

src/API/getRecentGames.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getRecentGames extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(query: string, options?: RequestOptions): Promise<RecentGame[] | RequestData> {
+  override 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);

src/API/getSkyblockAuction.test.ts

@@ -3,8 +3,8 @@ import Bid from '../Structures/SkyBlock/Auctions/Bid.js';
 import Client from '../Client.js';
 import ItemBytes from '../Structures/ItemBytes.js';
 import RequestData from '../Private/RequestData.js';
-import { Rarity } from '../Types/Skyblock.js';
 import { expect, expectTypeOf, test } from 'vitest';
+import type { Rarity } from '../Types/Skyblock.js';
 
 test('getSkyblockAuction (raw)', async () => {
   const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });

src/API/getSkyblockAuction.ts

@@ -2,16 +2,16 @@ import Auction from '../Structures/SkyBlock/Auctions/Auction.js';
 import Client from '../Client.js';
 import Endpoint from '../Private/Endpoint.js';
 import RequestData from '../Private/RequestData.js';
-import { AuctionFetchOptions, AuctionRequestOptions } from '../Types/API.js';
+import type { AuctionFetchOptions, AuctionRequestOptions } from '../Types/API.js';
 
 class getSkyblockAction extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(
+  override async execute(
     type: AuctionFetchOptions,
     query: string,
     options?: AuctionRequestOptions

src/API/getSkyblockAuctions.test.ts

@@ -3,9 +3,9 @@ import AuctionInfo from '../Structures/SkyBlock/Auctions/AuctionInfo.js';
 import Bid from '../Structures/SkyBlock/Auctions/Bid.js';
 import Client from '../Client.js';
 import ItemBytes from '../Structures/ItemBytes.js';
-import { Rarity } from '../Types/Skyblock.js';
-import { SkyblockAuctionsResult } from '../Types/API.js';
 import { expect, expectTypeOf, test } from 'vitest';
+import type { Rarity } from '../Types/Skyblock.js';
+import type { SkyblockAuctionsResult } from '../Types/API.js';
 
 test('getSkyblockAuctions (No input)', () => {
   const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });

src/API/getSkyblockAuctions.ts

@@ -2,17 +2,17 @@ import Auction from '../Structures/SkyBlock/Auctions/Auction.js';
 import AuctionInfo from '../Structures/SkyBlock/Auctions/AuctionInfo.js';
 import Client from '../Client.js';
 import Endpoint from '../Private/Endpoint.js';
-import { AuctionRequestOptions, SkyblockAuctionsResult } from '../Types/API.js';
+import type { AuctionRequestOptions, SkyblockAuctionsResult } from '../Types/API.js';
 
 class getSkyblockAuctions extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   declare options: AuctionRequestOptions;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(query: number | '*', options?: AuctionRequestOptions): Promise<SkyblockAuctionsResult> {
+  override 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);

src/API/getSkyblockAuctionsByPlayer.test.ts

@@ -3,8 +3,8 @@ import Bid from '../Structures/SkyBlock/Auctions/Bid.js';
 import Client from '../Client.js';
 import ItemBytes from '../Structures/ItemBytes.js';
 import RequestData from '../Private/RequestData.js';
-import { Rarity } from '../Types/Skyblock.js';
 import { expect, expectTypeOf, test } from 'vitest';
+import type { Rarity } from '../Types/Skyblock.js';
 
 test('getSkyblockAuctionsByPlayer (raw)', async () => {
   const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false, rateLimit: 'NONE' });

src/API/getSkyblockAuctionsByPlayer.ts

@@ -2,16 +2,16 @@ import Auction from '../Structures/SkyBlock/Auctions/Auction.js';
 import Client from '../Client.js';
 import Endpoint from '../Private/Endpoint.js';
 import RequestData from '../Private/RequestData.js';
-import { AuctionRequestOptions } from '../Types/API.js';
+import type { AuctionRequestOptions } from '../Types/API.js';
 
 class getSkyblockActionsByPlayer extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(query: string, options?: AuctionRequestOptions): Promise<Auction[] | RequestData> {
+  override 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);

src/API/getSkyblockBazaar.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getSkyblockBazaar extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<Product[] | RequestData> {
+  override async execute(options?: RequestOptions): Promise<Product[] | RequestData> {
     const res = await this.client.requestHandler.request('/skyblock/bazaar', options);
     if (res.options.raw) return res;
     return Object.keys(res.data.products).map((x) => new Product(res.data.products[x]));

src/API/getSkyblockBingo.ts

@@ -5,13 +5,13 @@ import RequestData from '../Private/RequestData.js';
 import type { RequestOptions } from '../Types/Requests.js';
 
 class getSkyblockBingo extends Endpoint {
-  readonly client: Client;
+  override readonly client: Client;
   constructor(client: Client) {
     super(client);
     this.client = client;
   }
 
-  async execute(options?: RequestOptions): Promise<BingoData | RequestData> {
+  override async execute(options?: RequestOptions): Promise<BingoData | RequestData> {
     const res = await this.client.requestHandler.request('/resources/skyblock/bingo', options);
     if (res.options.raw) return res;
     return new BingoData(res.data);