hypixel-api-reborn 11.3.4 → 12.0.0-0

package/src/API/getSkyblockProfiles.test.ts

@@ -0,0 +1,164 @@
+import Client from '../Client';
+import SkyblockMember from '../structures/SkyBlock/SkyblockMember';
+import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getSkyblockProfiles (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e', { raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getSkyblockProfiles (no input)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  expect(() => client.getSkyblockProfiles()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+  client.destroy();
+});
+
+test('getSkyblockProfiles (no profiles)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  expect(() => client.getSkyblockProfiles('b45add7b081443909fb00aa9a3e15eb0')).rejects.toThrowError(
+    client.errors.NO_SKYBLOCK_PROFILES
+  );
+  client.destroy();
+});
+
+test('getSkyblockProfiles', 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.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e');
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[]>();
+
+  data.forEach((profile: SkyblockProfile) => {
+    expect(profile).toBeDefined();
+    expectTypeOf(profile).toEqualTypeOf<SkyblockProfile>();
+
+    expect(profile.profileId).toBeDefined();
+    expectTypeOf(profile.profileId).toEqualTypeOf<string>();
+
+    expect(profile.profileName).toBeDefined();
+    expectTypeOf(profile.profileName).toEqualTypeOf<string>();
+
+    expect(profile.gameMode).toBeDefined();
+    expectTypeOf(profile.gameMode).toEqualTypeOf<string | null>();
+
+    expect(profile.banking).toBeDefined();
+    expectTypeOf(profile.banking).toEqualTypeOf<object>();
+
+    expect(profile.communityUpgrades).toBeDefined();
+    expectTypeOf(profile.communityUpgrades).toEqualTypeOf<object>();
+
+    expect(profile.selected).toBeDefined();
+    expectTypeOf(profile.selected).toEqualTypeOf<boolean>();
+
+    expect(profile.members).toBeDefined();
+    expectTypeOf(profile.members).toEqualTypeOf<SkyblockMember[]>();
+
+    expect(profile.me).toBeDefined();
+    expectTypeOf(profile.me).toEqualTypeOf<SkyblockMember | undefined>();
+
+    expect(profile.toString()).toBeDefined();
+    expectTypeOf(profile.toString()).toEqualTypeOf<string>();
+    expect(profile.toString()).toBe(profile.profileName);
+  });
+
+  client.destroy();
+});
+
+test('getSkyblockProfiles (garden)', 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.getSkyblockProfiles('kathund', { garden: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[]>();
+
+  data.forEach((profile: SkyblockProfile) => {
+    expect(profile).toBeDefined();
+    expectTypeOf(profile).toEqualTypeOf<SkyblockProfile>();
+
+    expect(profile.profileId).toBeDefined();
+    expectTypeOf(profile.profileId).toEqualTypeOf<string>();
+
+    expect(profile.profileName).toBeDefined();
+    expectTypeOf(profile.profileName).toEqualTypeOf<string>();
+
+    expect(profile.gameMode).toBeDefined();
+    expectTypeOf(profile.gameMode).toEqualTypeOf<string | null>();
+
+    expect(profile.banking).toBeDefined();
+    expectTypeOf(profile.banking).toEqualTypeOf<object>();
+
+    expect(profile.communityUpgrades).toBeDefined();
+    expectTypeOf(profile.communityUpgrades).toEqualTypeOf<object>();
+
+    expect(profile.selected).toBeDefined();
+    expectTypeOf(profile.selected).toEqualTypeOf<boolean>();
+
+    expect(profile.members).toBeDefined();
+    expectTypeOf(profile.members).toEqualTypeOf<SkyblockMember[]>();
+
+    expect(profile.me).toBeDefined();
+    expectTypeOf(profile.me).toEqualTypeOf<SkyblockMember | undefined>();
+
+    expect(profile.toString()).toBeDefined();
+    expectTypeOf(profile.toString()).toEqualTypeOf<string>();
+    expect(profile.toString()).toBe(profile.profileName);
+  });
+
+  client.destroy();
+});
+
+test('getSkyblockProfiles (museum)', 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.getSkyblockProfiles('14727faefbdc4aff848cd2713eb9939e', { museum: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<SkyblockProfile[]>();
+
+  data.forEach((profile: SkyblockProfile) => {
+    expect(profile).toBeDefined();
+    expectTypeOf(profile).toEqualTypeOf<SkyblockProfile>();
+
+    expect(profile.profileId).toBeDefined();
+    expectTypeOf(profile.profileId).toEqualTypeOf<string>();
+
+    expect(profile.profileName).toBeDefined();
+    expectTypeOf(profile.profileName).toEqualTypeOf<string>();
+
+    expect(profile.gameMode).toBeDefined();
+    expectTypeOf(profile.gameMode).toEqualTypeOf<string | null>();
+
+    expect(profile.banking).toBeDefined();
+    expectTypeOf(profile.banking).toEqualTypeOf<object>();
+
+    expect(profile.communityUpgrades).toBeDefined();
+    expectTypeOf(profile.communityUpgrades).toEqualTypeOf<object>();
+
+    expect(profile.selected).toBeDefined();
+    expectTypeOf(profile.selected).toEqualTypeOf<boolean>();
+
+    expect(profile.members).toBeDefined();
+    expectTypeOf(profile.members).toEqualTypeOf<SkyblockMember[]>();
+
+    expect(profile.me).toBeDefined();
+    expectTypeOf(profile.me).toEqualTypeOf<SkyblockMember | undefined>();
+
+    expect(profile.toString()).toBeDefined();
+    expectTypeOf(profile.toString()).toEqualTypeOf<string>();
+    expect(profile.toString()).toBe(profile.profileName);
+  });
+
+  client.destroy();
+});

package/src/API/getSkyblockProfiles.ts

@@ -0,0 +1,43 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import SkyblockProfile from '../structures/SkyBlock/SkyblockProfile';
+import { SkyblockRequestOptions } from './API';
+
+class getSkyblockProfiles extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(query: string, options?: SkyblockRequestOptions): Promise<SkyblockProfile[]> {
+    if (!query) throw new Error(this.client.errors.NO_NICKNAME_UUID);
+    query = await this.client.requests.toUUID(query);
+    const res = await this.client.requests.request(`/skyblock/profiles?uuid=${query}`, options);
+    if (res.options.raw) return res.data;
+    if (!res.data.profiles || !res.data.profiles.length) throw new Error(this.client.errors.NO_SKYBLOCK_PROFILES);
+    const profiles = [];
+    for (let i = 0; i < res.data.profiles.length; i++) {
+      profiles.push({
+        uuid: query,
+        profileId: res.data.profiles[i].profile_id,
+        profileName: res.data.profiles[i].cute_name,
+        gameMode: res.data.profiles[i].game_mode || null,
+        m: res.data.profiles[i].members[query],
+        banking: res.data.profiles[i].banking,
+        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
+      });
+    }
+    return profiles.map((p) => new SkyblockProfile(p));
+  }
+}
+
+export default getSkyblockProfiles;

package/src/API/getStatus.test.ts

@@ -0,0 +1,42 @@
+import Client from '../Client';
+import Game from '../structures/Game';
+import Status from '../structures/Status';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getStatus (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getStatus('14727faefbdc4aff848cd2713eb9939e', { raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getStatus', 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.getStatus('14727faefbdc4aff848cd2713eb9939e');
+  expect(data).toBeDefined();
+  expect(data).toBeInstanceOf(Status);
+  expectTypeOf(data).toEqualTypeOf<Status>();
+
+  expect(data.online).toBeDefined();
+  expectTypeOf(data.online).toEqualTypeOf<boolean>();
+
+  expect(data.game).toBeDefined();
+  expectTypeOf(data.game).toEqualTypeOf<Game | null>();
+
+  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();
+});

package/src/API/getStatus.ts

@@ -0,0 +1,21 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import Status from '../structures/Status';
+import { RequestOptions } from '../Private/Requests';
+
+class getStatus extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(query: string, options?: RequestOptions): Promise<Status> {
+    query = await this.client.requests.toUUID(query);
+    const res = await this.client.requests.request(`/status?uuid=${query}`, options);
+    if (res.options.raw) return res.data;
+    return new Status(res.data.session);
+  }
+}
+
+export default getStatus;

package/src/API/getWatchdogStats.test.ts

@@ -0,0 +1,44 @@
+import Client from '../Client';
+import WatchdogStats from '../structures/Watchdog/Stats';
+import { expect, expectTypeOf, test } from 'vitest';
+
+test('getWatchdogStats (raw)', async () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', { cache: false, checkForUpdates: false });
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-expect-error
+  const data = await client.getWatchdogStats({ raw: true });
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<object>();
+  client.destroy();
+});
+
+test('getWatchdogStats', 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.getWatchdogStats();
+  expect(data).toBeDefined();
+  expectTypeOf(data).toEqualTypeOf<WatchdogStats>();
+  expect(data).toBeInstanceOf(WatchdogStats);
+
+  expect(data.byWatchdogTotal).toBeDefined();
+  expectTypeOf(data.byWatchdogTotal).toEqualTypeOf<number>();
+  expect(data.byWatchdogTotal).toBeGreaterThanOrEqual(0);
+
+  expect(data.byWatchdogLastMinute).toBeDefined();
+  expectTypeOf(data.byWatchdogLastMinute).toEqualTypeOf<number>();
+  expect(data.byWatchdogLastMinute).toBeGreaterThanOrEqual(0);
+
+  expect(data.byWatchdogRollingDay).toBeDefined();
+  expectTypeOf(data.byWatchdogRollingDay).toEqualTypeOf<number>();
+  expect(data.byWatchdogRollingDay).toBeGreaterThanOrEqual(0);
+
+  expect(data.byStaffTotal).toBeDefined();
+  expectTypeOf(data.byStaffTotal).toEqualTypeOf<number>();
+  expect(data.byStaffTotal).toBeGreaterThanOrEqual(0);
+
+  expect(data.byStaffRollingDay).toBeDefined();
+  expectTypeOf(data.byStaffRollingDay).toEqualTypeOf<number>();
+  expect(data.byStaffRollingDay).toBeGreaterThanOrEqual(0);
+  client.destroy();
+});

package/src/API/getWatchdogStats.ts

@@ -0,0 +1,20 @@
+import Client from '../Client';
+import Endpoint from '../Private/Endpoint';
+import WatchdogStats from '../structures/Watchdog/Stats';
+import { RequestOptions } from '../Private/Requests';
+
+class getWatchdogStats extends Endpoint {
+  readonly client: Client;
+  constructor(client: Client) {
+    super(client);
+    this.client = client;
+  }
+
+  async execute(options?: RequestOptions): Promise<WatchdogStats> {
+    const res = await this.client.requests.request('/punishmentstats', options);
+    if (res.options.raw) return res.data;
+    return new WatchdogStats(res.data);
+  }
+}
+
+export default getWatchdogStats;

package/src/API/index.ts

@@ -0,0 +1,56 @@
+import getAchievements from './getAchievements';
+import getActiveHouses from './getActiveHouses';
+import getBoosters from './getBoosters';
+import getChallenges from './getChallenges';
+import getGameCounts from './getGameCounts';
+import getGuild from './getGuild';
+import getGuildAchievements from './getGuildAchievements';
+import getHouse from './getHouse';
+import getLeaderboards from './getLeaderboards';
+import getPlayer from './getPlayer';
+import getPlayerHouses from './getPlayerHouses';
+import getQuests from './getQuests';
+import getRecentGames from './getRecentGames';
+import getSkyblockAuction from './getSkyblockAuction';
+import getSkyblockAuctions from './getSkyblockAuctions';
+import getSkyblockAuctionsByPlayer from './getSkyblockAuctionsByPlayer';
+import getSkyblockBazaar from './getSkyblockBazaar';
+import getSkyblockBingo from './getSkyblockBingo';
+import getSkyblockFireSales from './getSkyblockFireSales';
+import getSkyblockGarden from './getSkyblockGarden';
+import getSkyblockGovernment from './getSkyblockGovernment';
+import getSkyblockMember from './getSkyblockMember';
+import getSkyblockMuseum from './getSkyblockMuseum';
+import getSkyblockNews from './getSkyblockNews';
+import getSkyblockProfiles from './getSkyblockProfiles';
+import getStatus from './getStatus';
+import getWatchdogStats from './getWatchdogStats';
+export default {
+  getAchievements,
+  getActiveHouses,
+  getBoosters,
+  getChallenges,
+  getGameCounts,
+  getGuild,
+  getGuildAchievements,
+  getHouse,
+  getLeaderboards,
+  getPlayer,
+  getPlayerHouses,
+  getQuests,
+  getRecentGames,
+  getSkyblockAuction,
+  getSkyblockAuctions,
+  getSkyblockAuctionsByPlayer,
+  getSkyblockBazaar,
+  getSkyblockBingo,
+  getSkyblockFireSales,
+  getSkyblockGarden,
+  getSkyblockGovernment,
+  getSkyblockMember,
+  getSkyblockMuseum,
+  getSkyblockNews,
+  getSkyblockProfiles,
+  getStatus,
+  getWatchdogStats
+};

package/src/Client.test.ts

@@ -0,0 +1,148 @@
+import CacheHandler from './Private/CacheHandler';
+import Client, { ClientOptions } from './Client';
+import Errors from './Errors';
+import Requests from './Private/Requests';
+import Updater from './Private/Updater';
+import { expect, expectTypeOf, test } from 'vitest';
+const errors = new Errors();
+
+test('Client (No Key)', () => {
+  expect(() => new Client('')).toThrowError(errors.NO_API_KEY);
+});
+
+test('Client (No Options)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '');
+  expect(client).toBeDefined();
+  expect(client).toBeInstanceOf(Client);
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.key).toBe(process.env.HYPIXEL_KEY ?? '');
+  expectTypeOf(client.key).toBeString();
+
+  expect(client.options).toBeDefined();
+  expectTypeOf(client.options).toEqualTypeOf<ClientOptions>();
+
+  expect(client.options.cache).toBeDefined();
+  expect(client.options.cache).toBe(true);
+  expect(client.options.cache).toBeTruthy();
+
+  expect(client.options.cacheTime).toBeDefined();
+  expectTypeOf(client.options.cacheTime).toEqualTypeOf<number | undefined>();
+  expect(client.options.cacheTime).toBe(300);
+
+  expect(client.options.cacheMaxKeys).toBeDefined();
+  expectTypeOf(client.options.cacheMaxKeys).toEqualTypeOf<number | undefined>();
+  expect(client.options.cacheMaxKeys).toBe(-1);
+
+  expect(client.options.cacheCheckPeriod).toBeDefined();
+  expectTypeOf(client.options.cacheCheckPeriod).toEqualTypeOf<number | undefined>();
+  expect(client.options.cacheCheckPeriod).toBe(180);
+
+  expect(client.options.rateLimit).toBeDefined();
+  expectTypeOf(client.options.rateLimit).toEqualTypeOf<'AUTO' | 'NONE' | undefined>();
+  expect(client.options.rateLimit).toBe('AUTO');
+
+  expect(client.options.silent).toBeDefined();
+  expectTypeOf(client.options.silent).toEqualTypeOf<boolean | undefined>();
+  expect(client.options.silent).toBe(false);
+  expect(client.options.silent).toBeFalsy();
+
+  expect(client.options.checkForUpdates).toBeDefined();
+  expect(client.options.checkForUpdates).toBeTruthy();
+  expect(client.options.checkForUpdates).toBe(true);
+
+  expect(client.options.checkForUpdatesInterval).toBeDefined();
+  expectTypeOf(client.options.checkForUpdatesInterval).toEqualTypeOf<number | undefined>();
+  expect(client.options.checkForUpdatesInterval).toBe(60);
+
+  expect(client.requests).toBeDefined();
+  expect(client.requests).toBeInstanceOf(Requests);
+  expectTypeOf(client.requests).toEqualTypeOf<Requests>();
+
+  expect(client.cacheHandler).toBeDefined();
+  expect(client.cacheHandler).toBeInstanceOf(CacheHandler);
+  expectTypeOf(client.cacheHandler).toEqualTypeOf<CacheHandler>();
+
+  expect(client.updater).toBeDefined();
+  expect(client.updater).toBeInstanceOf(Updater);
+  expectTypeOf(client.updater).toEqualTypeOf<Updater>();
+
+  expect(client.errors).toBeDefined();
+  expect(client.errors).toBeInstanceOf(Errors);
+  expectTypeOf(client.errors).toEqualTypeOf<Errors>();
+
+  client.destroy();
+});
+
+test('Client (Options)', () => {
+  const client = new Client(process.env.HYPIXEL_KEY ?? '', {
+    cache: false,
+    cacheTime: 600,
+    cacheMaxKeys: 100,
+    cacheCheckPeriod: 300,
+    rateLimit: 'NONE',
+    silent: true,
+    checkForUpdates: false,
+    checkForUpdatesInterval: 120
+  });
+  expect(client).toBeDefined();
+  expect(client).toBeInstanceOf(Client);
+  expectTypeOf(client).toEqualTypeOf<Client>();
+
+  expect(client.key).toBe(process.env.HYPIXEL_KEY ?? '');
+  expectTypeOf(client.key).toBeString();
+
+  expect(client.options).toBeDefined();
+  expectTypeOf(client.options).toEqualTypeOf<ClientOptions>();
+
+  expect(client.options.cache).toBeDefined();
+  expect(client.options.cache).toBe(false);
+  expect(client.options.cache).toBeFalsy();
+
+  expect(client.options.cacheTime).toBeDefined();
+  expectTypeOf(client.options.cacheTime).toEqualTypeOf<number | undefined>();
+  expect(client.options.cacheTime).toBe(600);
+
+  expect(client.options.cacheMaxKeys).toBeDefined();
+  expectTypeOf(client.options.cacheMaxKeys).toEqualTypeOf<number | undefined>();
+  expect(client.options.cacheMaxKeys).toBe(100);
+
+  expect(client.options.cacheCheckPeriod).toBeDefined();
+  expectTypeOf(client.options.cacheCheckPeriod).toEqualTypeOf<number | undefined>();
+  expect(client.options.cacheCheckPeriod).toBe(300);
+
+  expect(client.options.rateLimit).toBeDefined();
+  expectTypeOf(client.options.rateLimit).toEqualTypeOf<'AUTO' | 'NONE' | undefined>();
+  expect(client.options.rateLimit).toBe('NONE');
+
+  expect(client.options.silent).toBeDefined();
+  expectTypeOf(client.options.silent).toEqualTypeOf<boolean | undefined>();
+  expect(client.options.silent).toBe(true);
+  expect(client.options.silent).toBeTruthy();
+
+  expect(client.options.checkForUpdates).toBeDefined();
+  expect(client.options.checkForUpdates).toBeFalsy();
+  expect(client.options.checkForUpdates).toBe(false);
+
+  expect(client.options.checkForUpdatesInterval).toBeDefined();
+  expectTypeOf(client.options.checkForUpdatesInterval).toEqualTypeOf<number | undefined>();
+  expect(client.options.checkForUpdatesInterval).toBe(120);
+
+  expect(client.requests).toBeDefined();
+  expect(client.requests).toBeInstanceOf(Requests);
+  expectTypeOf(client.requests).toEqualTypeOf<Requests>();
+
+  expect(client.cacheHandler).toBeDefined();
+  expect(client.cacheHandler).toBeInstanceOf(CacheHandler);
+  expectTypeOf(client.cacheHandler).toEqualTypeOf<CacheHandler>();
+
+  expect(client.updater).toBeDefined();
+  expect(client.updater).toBeInstanceOf(Updater);
+  expectTypeOf(client.updater).toEqualTypeOf<Updater>();
+
+  expect(client.errors).toBeDefined();
+  expect(client.errors).toBeInstanceOf(Errors);
+  expectTypeOf(client.errors).toEqualTypeOf<Errors>();
+
+  client.destroy();
+});

package/src/Client.ts

@@ -0,0 +1,91 @@
+import API from './API';
+import CacheHandler from './Private/CacheHandler';
+import Errors from './Errors';
+import RateLimit from './Private/RateLimit';
+import Requests from './Private/Requests';
+import Updater from './Private/Updater';
+
+export interface ClientOptions {
+  cache?: boolean;
+  cacheTime?: number;
+  cacheMaxKeys?: number;
+  cacheCheckPeriod?: number;
+  rateLimit?: 'AUTO' | 'NONE';
+  silent?: boolean;
+  checkForUpdates?: boolean;
+  checkForUpdatesInterval?: number;
+}
+
+const clients: Client[] = [];
+
+class Client {
+  declare options: ClientOptions;
+  declare requests: Requests;
+  declare cacheHandler: CacheHandler;
+  declare updater: Updater;
+  declare errors: Errors;
+  declare rateLimit: RateLimit;
+  readonly key: string;
+  declare interval: NodeJS.Timeout;
+  constructor(key: string, options?: ClientOptions) {
+    this.key = key;
+    this.errors = new Errors();
+    if (!this.key.length) throw new Error(this.errors.NO_API_KEY);
+    this.options = this.parasOptions(options);
+    this.requests = new Requests(this);
+    this.cacheHandler = new CacheHandler(this);
+    this.updater = new Updater(this);
+    this.rateLimit = new RateLimit(this);
+    if ('NONE' !== this.options.rateLimit) this.rateLimit.initialize();
+    for (const func in API) {
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      const endpoint = new API[func](this);
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-expect-error
+      this[func] = endpoint.execute.bind(endpoint);
+    }
+    if (clients.find((x) => x.key === key)) {
+      // eslint-disable-next-line no-console
+      console.warn(this.errors.MULTIPLE_INSTANCES);
+      const found = clients.find((x) => x.key === key);
+      if (found) {
+        this.destroy();
+        Object.assign(this, found);
+        return;
+      }
+      return;
+    }
+    if (this.options.checkForUpdates) {
+      this.interval = setInterval(
+        () => {
+          this.updater.checkForUpdates();
+        },
+        1000 * 60 * (this.options.checkForUpdatesInterval ?? 60)
+      );
+    }
+    clients.push(this);
+  }
+
+  destroy() {
+    const clientIndex = clients.findIndex((client) => client.key === this.key);
+    if (-1 !== clientIndex) clients.splice(clientIndex, 1);
+    if (this.interval) clearInterval(this.interval);
+    if (this.rateLimit.interval) clearInterval(this.rateLimit.interval);
+  }
+
+  private parasOptions(options?: ClientOptions): ClientOptions {
+    return {
+      cache: options?.cache ?? true,
+      cacheTime: options?.cacheTime ?? 300,
+      cacheMaxKeys: options?.cacheMaxKeys ?? -1,
+      cacheCheckPeriod: options?.cacheCheckPeriod ?? 180,
+      rateLimit: options?.rateLimit ?? 'AUTO',
+      silent: options?.silent ?? false,
+      checkForUpdates: options?.checkForUpdates ?? true,
+      checkForUpdatesInterval: options?.checkForUpdatesInterval ?? 60
+    };
+  }
+}
+
+export default Client;

package/src/Errors.ts

@@ -0,0 +1,42 @@
+/* eslint-disable max-len */
+class Errors {
+  INVALID_API_KEY: string =
+    '[Hypixel-API-Reborn] Invalid API Key! For help join our Discord Server https://discord.gg/NSEBNMM';
+  NO_API_KEY: string =
+    '[Hypixel-API-Reborn] No API Key specified! For help join our Discord Server https://discord.gg/NSEBNMM';
+  ERROR_CODE_CAUSE: string =
+    '[Hypixel-API-Reborn] Code: {code} - {cause}! For help join our Discord Server https://discord.gg/NSEBNMM';
+  ERROR_STATUSTEXT: string =
+    '[Hypixel-API-Reborn] {statustext}! For help join our Discord Server https://discord.gg/NSEBNMM';
+  NO_NICKNAME_UUID: string = '[Hypixel-API-Reborn] No nickname or uuid specified.';
+  NO_UUID: string = '[Hypixel-API-Reborn] No uuid specified.';
+  UUID_NICKNAME_MUST_BE_A_STRING: string = '[Hypixel-API-Reborn] Nickname or uuid must be a string.';
+  MALFORMED_UUID: string = '[Hypixel-API-Reborn] Malformed UUID!';
+  PLAYER_HAS_NEVER_LOGGED: string = '[Hypixel-API-Reborn] Player has never logged into Hypixel.';
+  NO_GUILD_QUERY: string = '[Hypixel-API-Reborn] No guild search query specified.';
+  INVALID_GUILD_ID: string = '[Hypixel-API-Reborn] Specified Guild ID is invalid.';
+  INVALID_GUILD_SEARCH_PARAMETER: string =
+    "[Hypixel-API-Reborn] getGuild() searchParameter must be 'id'; 'guild' or 'player'.";
+  SOMETHING_WENT_WRONG: string = '[Hypixel-API-Reborn] Something went wrong. {cause}';
+  GUILD_DOES_NOT_EXIST: string = '[Hypixel-API-Reborn] Guild does not exist.';
+  PAGE_INDEX_ERROR: string =
+    '[Hypixel-API-Reborn] Invalid page index. Must be an integer, an array of 2 integers, or a keyword. For help join our Discord Server https://discord.gg/NSEBNMM';
+  INVALID_OPTION_VALUE: string =
+    '[Hypixel-API-Reborn] Invalid option value! For help join our Discord Server https://discord.gg/NSEBNMM';
+  UPDATER_REQUEST_NOT_OK: string = '[Hypixel-API-Reborn] Something went wrong while checking for updates.';
+  MULTIPLE_INSTANCES: string =
+    '[Hypixel-API-Reborn] Multiple instances of hypixel-api-reborn are found so we merged them for you. Please refrain from spawning multiple instances in the future. For more information, join our Discord Server https://discord.gg/NSEBNMM.';
+  UNEXPECTED_ERROR: string =
+    "[Hypixel-API-Reborn] The data provided to hypixel API is malformed and thus not recognized by hypixel, but this shouldn't be your fault. Please report this error in our Discord Server https://discord.gg/NSEBNMM or GitHub. ";
+  RATE_LIMIT_EXCEEDED: string =
+    "[Hypixel-API-Reborn] The rate limitations on your API Key has been exceeded. There might be an outage (Check Hypixel's status page), or you simply did too many requests in a short time. Hint: Enable rate limit options! They can help you avoid this error! For help join our Discord Server https://discord.gg/NSEBNMM";
+  NO_SKYBLOCK_PROFILES: string = '[Hypixel-API-Reborn] The player has no skyblock profiles.';
+  BAD_AUCTION_FILTER: string =
+    '[Hypixel-API-Reborn] Unexpected filter for Client#getSkyblockAuction. Expected one of "PLAYER", "AUCTION", "PROFILE", but got something else.';
+  NOT_IMPLEMENTED: string =
+    '[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.';
+}
+
+export default Errors;