hypixel-api-reborn 11.3.4 → 12.0.0-0

package/dist/src/API/getSkyblockAuctions.test.js

@@ -0,0 +1,366 @@
+import Auction from '../structures/SkyBlock/Auctions/Auction';
+import AuctionInfo from '../structures/SkyBlock/Auctions/AuctionInfo';
+import Bid from '../structures/SkyBlock/Auctions/Bid';
+import Client from '../Client';
+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();
+    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
+    // @ts-expect-error
+    expect(() => client.getSkyblockAuctions()).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE);
+    client.destroy();
+});
+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();
+});
+test('getSkyblockAuctions (String 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('hi')).rejects.toThrowError(client.errors.INVALID_OPTION_VALUE);
+    client.destroy();
+});
+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();
+    expect(data.info).toBeDefined();
+    expect(data.info).toBeInstanceOf(AuctionInfo);
+    expectTypeOf(data.info).toEqualTypeOf();
+    expect(data.info.page).toBeDefined();
+    expect(data.info.page).greaterThanOrEqual(0);
+    expectTypeOf(data.info.page).toEqualTypeOf();
+    expect(data.info.totalPages).toBeDefined();
+    expect(data.info.totalPages).greaterThanOrEqual(0);
+    expectTypeOf(data.info.totalPages).toEqualTypeOf();
+    expect(data.info.totalAuctions).toBeDefined();
+    expect(data.info.totalAuctions).greaterThanOrEqual(0);
+    expectTypeOf(data.info.totalAuctions).toEqualTypeOf();
+    expect(data.info.lastUpdatedTimestamp).toBeDefined();
+    expect(data.info.lastUpdatedTimestamp).greaterThanOrEqual(0);
+    expectTypeOf(data.info.lastUpdatedTimestamp).toEqualTypeOf();
+    expect(data.info.lastUpdatedAt).toBeDefined();
+    expectTypeOf(data.info.lastUpdatedAt).toEqualTypeOf();
+    expect(data.auctions).toBeDefined();
+    expectTypeOf(data.auctions).toEqualTypeOf();
+    expect(data.auctions.length).greaterThanOrEqual(0);
+    expectTypeOf(data.auctions.length).toEqualTypeOf();
+    data.auctions.forEach((auction) => {
+        expect(auction).toBeDefined();
+        expect(auction).toBeInstanceOf(Auction);
+        expectTypeOf(auction).toEqualTypeOf();
+        expect(auction.auctionId).toBeDefined();
+        expectTypeOf(auction.auctionId).toEqualTypeOf();
+        expect(auction.auctioneerUuid).toBeDefined();
+        expectTypeOf(auction.auctioneerUuid).toEqualTypeOf();
+        expect(auction.auctioneerProfile).toBeDefined();
+        expectTypeOf(auction.auctioneerProfile).toEqualTypeOf();
+        expect(auction.bin).toBeDefined();
+        expectTypeOf(auction.bin).toEqualTypeOf();
+        expect(auction.itemBytes).toBeDefined();
+        expectTypeOf(auction.itemBytes).toEqualTypeOf();
+        if (auction.itemBytes) {
+            expect(auction.itemBytes).toBeDefined();
+            expectTypeOf(auction.itemBytes).toEqualTypeOf();
+            expect(auction.itemBytes.bytesBuffer).toBeDefined();
+            expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf();
+            expect(auction.itemBytes.base64).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64).toEqualTypeOf();
+            expect(auction.itemBytes.base64()).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf();
+        }
+        expect(auction.coop).toBeDefined();
+        expectTypeOf(auction.coop).toEqualTypeOf();
+        expect(auction.auctionStartTimestamp).toBeDefined();
+        expect(auction.auctionStartTimestamp).greaterThanOrEqual(0);
+        expectTypeOf(auction.auctionStartTimestamp).toEqualTypeOf();
+        expect(auction.auctionStart).toBeDefined();
+        expectTypeOf(auction.auctionStart).toEqualTypeOf();
+        expect(auction.auctionEndTimestamp).toBeDefined();
+        expectTypeOf(auction.auctionEndTimestamp).toEqualTypeOf();
+        expect(auction.auctionEnd).toBeDefined();
+        expectTypeOf(auction.auctionEnd).toEqualTypeOf();
+        expect(auction.item).toBeDefined();
+        expectTypeOf(auction.item).toEqualTypeOf();
+        expect(auction.itemLore).toBeDefined();
+        expectTypeOf(auction.itemLore).toEqualTypeOf();
+        expect(auction.itemLoreRaw).toBeDefined();
+        expectTypeOf(auction.itemLoreRaw).toEqualTypeOf();
+        expect(auction.rarity).toBeDefined();
+        expectTypeOf(auction.rarity).toEqualTypeOf();
+        expect(auction.startingBid).toBeDefined();
+        expectTypeOf(auction.startingBid).toEqualTypeOf();
+        expect(auction.highestBid).toBeDefined();
+        expectTypeOf(auction.highestBid).toEqualTypeOf();
+        expect(auction.bids).toBeDefined();
+        expectTypeOf(auction.bids).toEqualTypeOf();
+        auction.bids.forEach((bid) => {
+            expect(bid).toBeDefined();
+            expect(bid).toBeInstanceOf(Bid);
+            expectTypeOf(bid).toEqualTypeOf();
+            expect(bid.auctionId).toBeDefined();
+            expectTypeOf(bid.auctionId).toEqualTypeOf();
+            expect(bid.profileId).toBeDefined();
+            expectTypeOf(bid.profileId).toEqualTypeOf();
+            expect(bid.amount).toBeDefined();
+            expect(bid.amount).greaterThanOrEqual(0);
+            expectTypeOf(bid.amount).toEqualTypeOf();
+            expect(bid.timestamp).toBeDefined();
+            expectTypeOf(bid.timestamp).toEqualTypeOf();
+            expect(bid.at).toBeDefined();
+            expectTypeOf(bid.at).toEqualTypeOf();
+            expect(bid.bidder).toBeDefined();
+            expectTypeOf(bid.bidder).toEqualTypeOf();
+            expect(bid.toString()).toBeDefined();
+            expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`);
+            expectTypeOf(bid.toString()).toEqualTypeOf();
+        });
+        expect(auction.claimed).toBeDefined();
+        expectTypeOf(auction.claimed).toEqualTypeOf();
+        expect(auction.claimedBidders).toBeDefined();
+        expectTypeOf(auction.claimedBidders).toEqualTypeOf();
+        expect(auction.toString()).toBeDefined();
+        expect(auction.toString()).toEqual(auction.item);
+        expectTypeOf(auction.toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});
+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();
+    expect(data.info).toBeDefined();
+    expect(data.info).toBeInstanceOf(AuctionInfo);
+    expectTypeOf(data.info).toEqualTypeOf();
+    expect(data.info.page).toBeDefined();
+    expect(data.info.page).greaterThanOrEqual(0);
+    expectTypeOf(data.info.page).toEqualTypeOf();
+    expect(data.info.totalPages).toBeDefined();
+    expect(data.info.totalPages).greaterThanOrEqual(0);
+    expectTypeOf(data.info.totalPages).toEqualTypeOf();
+    expect(data.info.totalAuctions).toBeDefined();
+    expect(data.info.totalAuctions).greaterThanOrEqual(0);
+    expectTypeOf(data.info.totalAuctions).toEqualTypeOf();
+    expect(data.info.lastUpdatedTimestamp).toBeDefined();
+    expect(data.info.lastUpdatedTimestamp).greaterThanOrEqual(0);
+    expectTypeOf(data.info.lastUpdatedTimestamp).toEqualTypeOf();
+    expect(data.info.lastUpdatedAt).toBeDefined();
+    expectTypeOf(data.info.lastUpdatedAt).toEqualTypeOf();
+    expect(data.auctions).toBeDefined();
+    expectTypeOf(data.auctions).toEqualTypeOf();
+    expect(data.auctions.length).greaterThanOrEqual(0);
+    expectTypeOf(data.auctions.length).toEqualTypeOf();
+    data.auctions.forEach((auction) => {
+        expect(auction).toBeDefined();
+        expect(auction).toBeInstanceOf(Auction);
+        expectTypeOf(auction).toEqualTypeOf();
+        expect(auction.auctionId).toBeDefined();
+        expectTypeOf(auction.auctionId).toEqualTypeOf();
+        expect(auction.auctioneerUuid).toBeDefined();
+        expectTypeOf(auction.auctioneerUuid).toEqualTypeOf();
+        expect(auction.auctioneerProfile).toBeDefined();
+        expectTypeOf(auction.auctioneerProfile).toEqualTypeOf();
+        expect(auction.bin).toBeDefined();
+        expectTypeOf(auction.bin).toEqualTypeOf();
+        expect(auction.itemBytes).toBeDefined();
+        expectTypeOf(auction.itemBytes).toEqualTypeOf();
+        if (auction.itemBytes) {
+            expect(auction.itemBytes).toBeDefined();
+            expectTypeOf(auction.itemBytes).toEqualTypeOf();
+            expect(auction.itemBytes.bytesBuffer).toBeDefined();
+            expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf();
+            expect(auction.itemBytes.base64).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64).toEqualTypeOf();
+            expect(auction.itemBytes.base64()).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf();
+        }
+        expect(auction.coop).toBeDefined();
+        expectTypeOf(auction.coop).toEqualTypeOf();
+        expect(auction.auctionStartTimestamp).toBeDefined();
+        expect(auction.auctionStartTimestamp).greaterThanOrEqual(0);
+        expectTypeOf(auction.auctionStartTimestamp).toEqualTypeOf();
+        expect(auction.auctionStart).toBeDefined();
+        expectTypeOf(auction.auctionStart).toEqualTypeOf();
+        expect(auction.auctionEndTimestamp).toBeDefined();
+        expectTypeOf(auction.auctionEndTimestamp).toEqualTypeOf();
+        expect(auction.auctionEnd).toBeDefined();
+        expectTypeOf(auction.auctionEnd).toEqualTypeOf();
+        expect(auction.item).toBeDefined();
+        expectTypeOf(auction.item).toEqualTypeOf();
+        expect(auction.itemLore).toBeDefined();
+        expectTypeOf(auction.itemLore).toEqualTypeOf();
+        expect(auction.itemLoreRaw).toBeDefined();
+        expectTypeOf(auction.itemLoreRaw).toEqualTypeOf();
+        expect(auction.rarity).toBeDefined();
+        expectTypeOf(auction.rarity).toEqualTypeOf();
+        expect(auction.startingBid).toBeDefined();
+        expectTypeOf(auction.startingBid).toEqualTypeOf();
+        expect(auction.highestBid).toBeDefined();
+        expectTypeOf(auction.highestBid).toEqualTypeOf();
+        expect(auction.bids).toBeDefined();
+        expectTypeOf(auction.bids).toEqualTypeOf();
+        auction.bids.forEach((bid) => {
+            expect(bid).toBeDefined();
+            expect(bid).toBeInstanceOf(Bid);
+            expectTypeOf(bid).toEqualTypeOf();
+            expect(bid.auctionId).toBeDefined();
+            expectTypeOf(bid.auctionId).toEqualTypeOf();
+            expect(bid.profileId).toBeDefined();
+            expectTypeOf(bid.profileId).toEqualTypeOf();
+            expect(bid.amount).toBeDefined();
+            expect(bid.amount).greaterThanOrEqual(0);
+            expectTypeOf(bid.amount).toEqualTypeOf();
+            expect(bid.timestamp).toBeDefined();
+            expectTypeOf(bid.timestamp).toEqualTypeOf();
+            expect(bid.at).toBeDefined();
+            expectTypeOf(bid.at).toEqualTypeOf();
+            expect(bid.bidder).toBeDefined();
+            expectTypeOf(bid.bidder).toEqualTypeOf();
+            expect(bid.toString()).toBeDefined();
+            expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`);
+            expectTypeOf(bid.toString()).toEqualTypeOf();
+        });
+        expect(auction.claimed).toBeDefined();
+        expectTypeOf(auction.claimed).toEqualTypeOf();
+        expect(auction.claimedBidders).toBeDefined();
+        expectTypeOf(auction.claimedBidders).toEqualTypeOf();
+        expect(auction.toString()).toBeDefined();
+        expect(auction.toString()).toEqual(auction.item);
+        expectTypeOf(auction.toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});
+test.skip('getSkyblockAuctions (All Pages)', 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('*');
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    expect(data.info).toBeDefined();
+    expect(data.info).toBeInstanceOf(AuctionInfo);
+    expectTypeOf(data.info).toEqualTypeOf();
+    expect(data.info.page).toBeDefined();
+    expect(data.info.page).greaterThanOrEqual(0);
+    expectTypeOf(data.info.page).toEqualTypeOf();
+    expect(data.info.totalPages).toBeDefined();
+    expect(data.info.totalPages).greaterThanOrEqual(0);
+    expectTypeOf(data.info.totalPages).toEqualTypeOf();
+    expect(data.info.totalAuctions).toBeDefined();
+    expect(data.info.totalAuctions).greaterThanOrEqual(0);
+    expectTypeOf(data.info.totalAuctions).toEqualTypeOf();
+    expect(data.info.lastUpdatedTimestamp).toBeDefined();
+    expect(data.info.lastUpdatedTimestamp).greaterThanOrEqual(0);
+    expectTypeOf(data.info.lastUpdatedTimestamp).toEqualTypeOf();
+    expect(data.info.lastUpdatedAt).toBeDefined();
+    expectTypeOf(data.info.lastUpdatedAt).toEqualTypeOf();
+    expect(data.auctions).toBeDefined();
+    expectTypeOf(data.auctions).toEqualTypeOf();
+    expect(data.auctions.length).greaterThanOrEqual(0);
+    expectTypeOf(data.auctions.length).toEqualTypeOf();
+    data.auctions.forEach((auction) => {
+        expect(auction).toBeDefined();
+        expect(auction).toBeInstanceOf(Auction);
+        expectTypeOf(auction).toEqualTypeOf();
+        expect(auction.auctionId).toBeDefined();
+        expectTypeOf(auction.auctionId).toEqualTypeOf();
+        expect(auction.auctioneerUuid).toBeDefined();
+        expectTypeOf(auction.auctioneerUuid).toEqualTypeOf();
+        expect(auction.auctioneerProfile).toBeDefined();
+        expectTypeOf(auction.auctioneerProfile).toEqualTypeOf();
+        expect(auction.bin).toBeDefined();
+        expectTypeOf(auction.bin).toEqualTypeOf();
+        expect(auction.itemBytes).toBeDefined();
+        expectTypeOf(auction.itemBytes).toEqualTypeOf();
+        if (auction.itemBytes) {
+            expect(auction.itemBytes).toBeDefined();
+            expectTypeOf(auction.itemBytes).toEqualTypeOf();
+            expect(auction.itemBytes.bytesBuffer).toBeDefined();
+            expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf();
+            expect(auction.itemBytes.base64).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64).toEqualTypeOf();
+            expect(auction.itemBytes.base64()).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf();
+        }
+        expect(auction.coop).toBeDefined();
+        expectTypeOf(auction.coop).toEqualTypeOf();
+        expect(auction.auctionStartTimestamp).toBeDefined();
+        expect(auction.auctionStartTimestamp).greaterThanOrEqual(0);
+        expectTypeOf(auction.auctionStartTimestamp).toEqualTypeOf();
+        expect(auction.auctionStart).toBeDefined();
+        expectTypeOf(auction.auctionStart).toEqualTypeOf();
+        expect(auction.auctionEndTimestamp).toBeDefined();
+        expectTypeOf(auction.auctionEndTimestamp).toEqualTypeOf();
+        expect(auction.auctionEnd).toBeDefined();
+        expectTypeOf(auction.auctionEnd).toEqualTypeOf();
+        expect(auction.item).toBeDefined();
+        expectTypeOf(auction.item).toEqualTypeOf();
+        expect(auction.itemLore).toBeDefined();
+        expectTypeOf(auction.itemLore).toEqualTypeOf();
+        expect(auction.itemLoreRaw).toBeDefined();
+        expectTypeOf(auction.itemLoreRaw).toEqualTypeOf();
+        expect(auction.rarity).toBeDefined();
+        expectTypeOf(auction.rarity).toEqualTypeOf();
+        expect(auction.startingBid).toBeDefined();
+        expectTypeOf(auction.startingBid).toEqualTypeOf();
+        expect(auction.highestBid).toBeDefined();
+        expectTypeOf(auction.highestBid).toEqualTypeOf();
+        expect(auction.bids).toBeDefined();
+        expectTypeOf(auction.bids).toEqualTypeOf();
+        auction.bids.forEach((bid) => {
+            expect(bid).toBeDefined();
+            expect(bid).toBeInstanceOf(Bid);
+            expectTypeOf(bid).toEqualTypeOf();
+            expect(bid.auctionId).toBeDefined();
+            expectTypeOf(bid.auctionId).toEqualTypeOf();
+            expect(bid.profileId).toBeDefined();
+            expectTypeOf(bid.profileId).toEqualTypeOf();
+            expect(bid.amount).toBeDefined();
+            expect(bid.amount).greaterThanOrEqual(0);
+            expectTypeOf(bid.amount).toEqualTypeOf();
+            expect(bid.timestamp).toBeDefined();
+            expectTypeOf(bid.timestamp).toEqualTypeOf();
+            expect(bid.at).toBeDefined();
+            expectTypeOf(bid.at).toEqualTypeOf();
+            expect(bid.bidder).toBeDefined();
+            expectTypeOf(bid.bidder).toEqualTypeOf();
+            expect(bid.toString()).toBeDefined();
+            expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`);
+            expectTypeOf(bid.toString()).toEqualTypeOf();
+        });
+        expect(auction.claimed).toBeDefined();
+        expectTypeOf(auction.claimed).toEqualTypeOf();
+        expect(auction.claimedBidders).toBeDefined();
+        expectTypeOf(auction.claimedBidders).toEqualTypeOf();
+        expect(auction.toString()).toBeDefined();
+        expect(auction.toString()).toEqual(auction.item);
+        expectTypeOf(auction.toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});

package/dist/src/API/getSkyblockAuctionsByPlayer.js

@@ -0,0 +1,19 @@
+import Auction from '../structures/SkyBlock/Auctions/Auction';
+import Endpoint from '../Private/Endpoint';
+class getSkyblockActionsByPlayer extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(query, options) {
+        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/auction?player=${query}`, options);
+        if (res.options.raw)
+            return res.data;
+        return res.data.auctions.map((a) => new Auction(a, options?.includeItemBytes ?? false));
+    }
+}
+export default getSkyblockActionsByPlayer;

package/dist/src/API/getSkyblockAuctionsByPlayer.test.js

@@ -0,0 +1,207 @@
+import Auction from '../structures/SkyBlock/Auctions/Auction';
+import Bid from '../structures/SkyBlock/Auctions/Bid';
+import Client from '../Client';
+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
+    const data = await client.getSkyblockAuctionsByPlayer(auctions.auctions[0].auctioneerUuid, { raw: true });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    client.destroy();
+});
+test('getSkyblockAuctionsByPlayer (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
+    // @ts-expect-error
+    expect(() => client.getSkyblockAuctionsByPlayer()).rejects.toThrowError(client.errors.NO_NICKNAME_UUID);
+    client.destroy();
+});
+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);
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    data.forEach((auction) => {
+        expect(auction).toBeDefined();
+        expect(auction).toBeInstanceOf(Auction);
+        expectTypeOf(auction).toEqualTypeOf();
+        expect(auction.auctionId).toBeDefined();
+        expectTypeOf(auction.auctionId).toEqualTypeOf();
+        expect(auction.auctioneerUuid).toBeDefined();
+        expectTypeOf(auction.auctioneerUuid).toEqualTypeOf();
+        expect(auction.auctioneerProfile).toBeDefined();
+        expectTypeOf(auction.auctioneerProfile).toEqualTypeOf();
+        expect(auction.bin).toBeDefined();
+        expectTypeOf(auction.bin).toEqualTypeOf();
+        expect(auction.itemBytes).toBeDefined();
+        expectTypeOf(auction.itemBytes).toEqualTypeOf();
+        expect(auction.itemBytes).toBeDefined();
+        expectTypeOf(auction.itemBytes).toEqualTypeOf();
+        if (auction.itemBytes) {
+            expect(auction.itemBytes).toBeDefined();
+            expectTypeOf(auction.itemBytes).toEqualTypeOf();
+            expect(auction.itemBytes.bytesBuffer).toBeDefined();
+            expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf();
+            expect(auction.itemBytes.base64).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64).toEqualTypeOf();
+            expect(auction.itemBytes.base64()).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf();
+        }
+        expect(auction.coop).toBeDefined();
+        expectTypeOf(auction.coop).toEqualTypeOf();
+        expect(auction.auctionStartTimestamp).toBeDefined();
+        expect(auction.auctionStartTimestamp).greaterThanOrEqual(0);
+        expectTypeOf(auction.auctionStartTimestamp).toEqualTypeOf();
+        expect(auction.auctionStart).toBeDefined();
+        expectTypeOf(auction.auctionStart).toEqualTypeOf();
+        expect(auction.auctionEndTimestamp).toBeDefined();
+        expectTypeOf(auction.auctionEndTimestamp).toEqualTypeOf();
+        expect(auction.auctionEnd).toBeDefined();
+        expectTypeOf(auction.auctionEnd).toEqualTypeOf();
+        expect(auction.item).toBeDefined();
+        expectTypeOf(auction.item).toEqualTypeOf();
+        expect(auction.itemLore).toBeDefined();
+        expectTypeOf(auction.itemLore).toEqualTypeOf();
+        expect(auction.itemLoreRaw).toBeDefined();
+        expectTypeOf(auction.itemLoreRaw).toEqualTypeOf();
+        expect(auction.rarity).toBeDefined();
+        expectTypeOf(auction.rarity).toEqualTypeOf();
+        expect(auction.startingBid).toBeDefined();
+        expectTypeOf(auction.startingBid).toEqualTypeOf();
+        expect(auction.highestBid).toBeDefined();
+        expectTypeOf(auction.highestBid).toEqualTypeOf();
+        expect(auction.bids).toBeDefined();
+        expectTypeOf(auction.bids).toEqualTypeOf();
+        auction.bids.forEach((bid) => {
+            expect(bid).toBeDefined();
+            expect(bid).toBeInstanceOf(Bid);
+            expectTypeOf(bid).toEqualTypeOf();
+            expect(bid.auctionId).toBeDefined();
+            expectTypeOf(bid.auctionId).toEqualTypeOf();
+            expect(bid.profileId).toBeDefined();
+            expectTypeOf(bid.profileId).toEqualTypeOf();
+            expect(bid.amount).toBeDefined();
+            expect(bid.amount).greaterThanOrEqual(0);
+            expectTypeOf(bid.amount).toEqualTypeOf();
+            expect(bid.timestamp).toBeDefined();
+            expectTypeOf(bid.timestamp).toEqualTypeOf();
+            expect(bid.at).toBeDefined();
+            expectTypeOf(bid.at).toEqualTypeOf();
+            expect(bid.bidder).toBeDefined();
+            expectTypeOf(bid.bidder).toEqualTypeOf();
+            expect(bid.toString()).toBeDefined();
+            expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`);
+            expectTypeOf(bid.toString()).toEqualTypeOf();
+        });
+        expect(auction.claimed).toBeDefined();
+        expectTypeOf(auction.claimed).toEqualTypeOf();
+        expect(auction.claimedBidders).toBeDefined();
+        expectTypeOf(auction.claimedBidders).toEqualTypeOf();
+        expect(auction.toString()).toBeDefined();
+        expect(auction.toString()).toEqual(auction.item);
+        expectTypeOf(auction.toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});
+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
+    });
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    data.forEach((auction) => {
+        expect(auction).toBeDefined();
+        expect(auction).toBeInstanceOf(Auction);
+        expectTypeOf(auction).toEqualTypeOf();
+        expect(auction.auctionId).toBeDefined();
+        expectTypeOf(auction.auctionId).toEqualTypeOf();
+        expect(auction.auctioneerUuid).toBeDefined();
+        expectTypeOf(auction.auctioneerUuid).toEqualTypeOf();
+        expect(auction.auctioneerProfile).toBeDefined();
+        expectTypeOf(auction.auctioneerProfile).toEqualTypeOf();
+        expect(auction.bin).toBeDefined();
+        expectTypeOf(auction.bin).toEqualTypeOf();
+        expect(auction.itemBytes).toBeDefined();
+        expectTypeOf(auction.itemBytes).toEqualTypeOf();
+        if (auction.itemBytes) {
+            expect(auction.itemBytes).toBeDefined();
+            expectTypeOf(auction.itemBytes).toEqualTypeOf();
+            expect(auction.itemBytes.bytesBuffer).toBeDefined();
+            expectTypeOf(auction.itemBytes.bytesBuffer).toEqualTypeOf();
+            expect(auction.itemBytes.base64).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64).toEqualTypeOf();
+            expect(auction.itemBytes.base64()).toBeDefined();
+            expectTypeOf(auction.itemBytes.base64()).toEqualTypeOf();
+        }
+        expect(auction.coop).toBeDefined();
+        expectTypeOf(auction.coop).toEqualTypeOf();
+        expect(auction.auctionStartTimestamp).toBeDefined();
+        expect(auction.auctionStartTimestamp).greaterThanOrEqual(0);
+        expectTypeOf(auction.auctionStartTimestamp).toEqualTypeOf();
+        expect(auction.auctionStart).toBeDefined();
+        expectTypeOf(auction.auctionStart).toEqualTypeOf();
+        expect(auction.auctionEndTimestamp).toBeDefined();
+        expectTypeOf(auction.auctionEndTimestamp).toEqualTypeOf();
+        expect(auction.auctionEnd).toBeDefined();
+        expectTypeOf(auction.auctionEnd).toEqualTypeOf();
+        expect(auction.item).toBeDefined();
+        expectTypeOf(auction.item).toEqualTypeOf();
+        expect(auction.itemLore).toBeDefined();
+        expectTypeOf(auction.itemLore).toEqualTypeOf();
+        expect(auction.itemLoreRaw).toBeDefined();
+        expectTypeOf(auction.itemLoreRaw).toEqualTypeOf();
+        expect(auction.rarity).toBeDefined();
+        expectTypeOf(auction.rarity).toEqualTypeOf();
+        expect(auction.startingBid).toBeDefined();
+        expectTypeOf(auction.startingBid).toEqualTypeOf();
+        expect(auction.highestBid).toBeDefined();
+        expectTypeOf(auction.highestBid).toEqualTypeOf();
+        expect(auction.bids).toBeDefined();
+        expectTypeOf(auction.bids).toEqualTypeOf();
+        auction.bids.forEach((bid) => {
+            expect(bid).toBeDefined();
+            expect(bid).toBeInstanceOf(Bid);
+            expectTypeOf(bid).toEqualTypeOf();
+            expect(bid.auctionId).toBeDefined();
+            expectTypeOf(bid.auctionId).toEqualTypeOf();
+            expect(bid.profileId).toBeDefined();
+            expectTypeOf(bid.profileId).toEqualTypeOf();
+            expect(bid.amount).toBeDefined();
+            expect(bid.amount).greaterThanOrEqual(0);
+            expectTypeOf(bid.amount).toEqualTypeOf();
+            expect(bid.timestamp).toBeDefined();
+            expectTypeOf(bid.timestamp).toEqualTypeOf();
+            expect(bid.at).toBeDefined();
+            expectTypeOf(bid.at).toEqualTypeOf();
+            expect(bid.bidder).toBeDefined();
+            expectTypeOf(bid.bidder).toEqualTypeOf();
+            expect(bid.toString()).toBeDefined();
+            expect(bid.toString()).toBe(`${bid.bidder} bid ${bid.amount} coins`);
+            expectTypeOf(bid.toString()).toEqualTypeOf();
+        });
+        expect(auction.claimed).toBeDefined();
+        expectTypeOf(auction.claimed).toEqualTypeOf();
+        expect(auction.claimedBidders).toBeDefined();
+        expectTypeOf(auction.claimedBidders).toEqualTypeOf();
+        expect(auction.toString()).toBeDefined();
+        expect(auction.toString()).toEqual(auction.item);
+        expectTypeOf(auction.toString()).toEqualTypeOf();
+    });
+    client.destroy();
+});

package/dist/src/API/getSkyblockBazaar.js

@@ -0,0 +1,16 @@
+import Endpoint from '../Private/Endpoint';
+import Product from '../structures/SkyBlock/Bazaar/Product';
+class getSkyblockBazaar extends Endpoint {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
+    async execute(options) {
+        const res = await this.client.requests.request('/skyblock/bazaar', options);
+        if (res.options.raw)
+            return res.data;
+        return Object.keys(res.data.products).map((x) => new Product(res.data.products[x]));
+    }
+}
+export default getSkyblockBazaar;

package/dist/src/API/getSkyblockBazaar.test.js

@@ -0,0 +1,51 @@
+import Client from '../Client';
+import Order from '../structures/SkyBlock/Bazaar/Order';
+import Product from '../structures/SkyBlock/Bazaar/Product';
+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();
+    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();
+    expect(data).toBeDefined();
+    expectTypeOf(data).toEqualTypeOf();
+    data.forEach((product) => {
+        expect(product).toBeDefined();
+        expect(product).toBeInstanceOf(Product);
+        expectTypeOf(product).toEqualTypeOf();
+        expect(product.productId).toBeDefined();
+        expectTypeOf(product.productId).toEqualTypeOf();
+        expect(product.sellSummary).toBeDefined();
+        expectTypeOf(product.sellSummary).toEqualTypeOf();
+        product.sellSummary.forEach((sell) => {
+            expect(sell).toBeDefined();
+            expect(sell).toBeInstanceOf(Order);
+            expectTypeOf(sell).toEqualTypeOf();
+            expect(sell.amount).toBeDefined();
+            expectTypeOf(sell.amount).toEqualTypeOf();
+            expect(sell.amount).toBeGreaterThanOrEqual(0);
+            expect(sell.pricePerUnit).toBeDefined();
+            expectTypeOf(sell.pricePerUnit).toEqualTypeOf();
+            expect(sell.pricePerUnit).toBeGreaterThanOrEqual(0);
+            expect(sell.totalPrice).toBeDefined();
+            expectTypeOf(sell.totalPrice).toEqualTypeOf();
+            expect(sell.totalPrice).toBeGreaterThanOrEqual(0);
+            expect(sell.orders).toBeDefined();
+            expectTypeOf(sell.orders).toEqualTypeOf();
+            expect(sell.orders).toBeGreaterThanOrEqual(0);
+            expect(sell.toString()).toBeDefined();
+            expect(sell.toString()).toEqual(sell.totalPrice);
+            expectTypeOf(sell.toString()).toEqualTypeOf();
+        });
+    });
+    client.destroy();
+});