seyfert 1.2.1 → 1.2.3

package/lib/structures/Message.d.ts

@@ -44,7 +44,7 @@ export declare class Message extends BaseMessage {
     reply(body: Omit<MessageCreateBodyRequest, 'message_reference'>, fail?: boolean): Promise<Message>;
     edit(body: MessageUpdateBodyRequest): Promise<Message>;
     write(body: MessageCreateBodyRequest): Promise<Message>;
-    delete(reason?: string): Promise<void | undefined>;
+    delete(reason?: string): Promise<void>;
     crosspost(reason?: string): Promise<Message>;
 }
 export type EditMessageWebhook = Omit<MessageWebhookMethodEditParams, 'messageId'>;

package/lib/structures/User.d.ts

@@ -17,11 +17,10 @@ export declare class User extends DiscordBase<APIUser> {
     dm(force?: boolean): Promise<import("./channels").DMChannel>;
     write(body: MessageCreateBodyRequest): Promise<import("./Message").Message>;
     avatarURL(options?: ImageOptions): string;
+    avatarDecorationURL(options?: ImageOptions): string | undefined;
     bannerURL(options?: ImageOptions): string | undefined;
     presence(): import("..").ReturnCache<(Omit<import("discord-api-types/v10").GatewayPresenceUpdate, "user"> & {
-        id: string; /**
-         * Fetch user
-         */
+        id: string;
     } & {
         guild_id: string;
     }) | undefined>;

package/lib/structures/User.js

@@ -27,17 +27,22 @@ class User extends DiscordBase_1.DiscordBase {
     avatarURL(options) {
         if (!this.avatar) {
             const avatarIndex = this.discriminator === '0' ? Number(BigInt(this.id) >> 22n) % 6 : Number.parseInt(this.discriminator) % 5;
-            return this.rest.cdn.defaultAvatar(avatarIndex);
+            return this.rest.cdn.embed.avatars.get(avatarIndex);
         }
-        return this.rest.cdn.avatar(this.id, this.avatar, options);
+        return this.rest.cdn.avatars(this.id).get(this.avatar, options);
+    }
+    avatarDecorationURL(options) {
+        if (!this.avatarDecoration)
+            return;
+        return this.rest.cdn['avatar-decorations'](this.id).get(this.avatarDecoration, options);
     }
     bannerURL(options) {
         if (!this.banner)
             return;
-        return this.rest.cdn.banner(this.id, this.banner, options);
+        return this.rest.cdn.banners(this.id).get(this.banner, options);
     }
     presence() {
-        return this.cache.presences?.get(this.id);
+        return this.client.members.presence(this.id);
     }
     toString() {
         return `<@${this.id}>`;

package/lib/structures/VoiceState.d.ts

@@ -0,0 +1,18 @@
+import type { GuildMember, UsingClient } from '../';
+import type { VoiceStateResource } from '../cache/resources/voice-states';
+import type { ObjectToLower } from '../common';
+import { Base } from './extra/Base';
+export interface VoiceState extends Base, ObjectToLower<VoiceStateResource> {
+}
+export declare class VoiceState extends Base {
+    private withMember?;
+    constructor(client: UsingClient, data: VoiceStateResource, withMember?: GuildMember | undefined);
+    isMuted(): boolean;
+    member(force?: boolean): Promise<GuildMember>;
+    user(force?: boolean): Promise<import("./User").User>;
+    channel(force?: boolean): Promise<import("./channels").BaseChannel<import("discord-api-types/v10").ChannelType> | import("./channels").DMChannel | import("./channels").CategoryChannel | undefined>;
+    setMute(mute?: boolean, reason?: string): Promise<GuildMember>;
+    setDeaf(deaf?: boolean, reason?: string): Promise<GuildMember>;
+    disconnect(reason?: string): Promise<GuildMember>;
+    setChannel(channel_id: null | string, reason?: string): Promise<GuildMember>;
+}

package/lib/structures/VoiceState.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceState = void 0;
+const Base_1 = require("./extra/Base");
+class VoiceState extends Base_1.Base {
+    withMember;
+    constructor(client, data, withMember) {
+        super(client);
+        this.withMember = withMember;
+        this.__patchThis(data);
+    }
+    isMuted() {
+        return this.mute || this.selfMute;
+    }
+    async member(force) {
+        return (this.withMember ??= await this.client.members.fetch(this.guildId, this.userId, force));
+    }
+    async user(force) {
+        return this.client.users.fetch(this.userId, force);
+    }
+    async channel(force) {
+        if (!this.channelId)
+            return;
+        return this.client.channels.fetch(this.channelId, force);
+    }
+    async setMute(mute = !this.mute, reason) {
+        return this.client.members.edit(this.guildId, this.userId, { mute }, reason).then(member => {
+            this.mute = mute;
+            return member;
+        });
+    }
+    async setDeaf(deaf = !this.deaf, reason) {
+        return this.client.members.edit(this.guildId, this.userId, { deaf }, reason).then(member => {
+            this.deaf = deaf;
+            return member;
+        });
+    }
+    async disconnect(reason) {
+        return this.setChannel(null, reason);
+    }
+    async setChannel(channel_id, reason) {
+        return this.client.members.edit(this.guildId, this.userId, { channel_id }, reason).then(member => {
+            this.channelId = channel_id;
+            return member;
+        });
+    }
+}
+exports.VoiceState = VoiceState;

package/lib/structures/Webhook.js

@@ -60,7 +60,7 @@ class Webhook extends DiscordBase_1.DiscordBase {
         if (!this.avatar) {
             return null;
         }
-        return this.rest.cdn.avatar(this.id, this.avatar, options);
+        return this.rest.cdn.avatars(this.id).get(this.avatar, options);
     }
     /**
      * Fetches the webhook data from the Discord API.

package/lib/structures/channels.d.ts

@@ -1,4 +1,4 @@
-import { type APIChannelBase, type APIGuildChannel, type APIGuildForumDefaultReactionEmoji, type APIGuildForumTag, ChannelType, type RESTGetAPIChannelMessageReactionUsersQuery, type RESTPatchAPIChannelJSONBody, type RESTPatchAPIGuildChannelPositionsJSONBody, type RESTPostAPIChannelWebhookJSONBody, type RESTPostAPIGuildChannelJSONBody, type SortOrderType, VideoQualityMode, type APIDMChannel, type APIGuildCategoryChannel, type APIGuildForumChannel, type APIGuildMediaChannel, type APIGuildStageVoiceChannel, type APIGuildVoiceChannel, type APINewsChannel, type APITextChannel, type APIThreadChannel, type ThreadAutoArchiveDuration } from 'discord-api-types/v10';
+import { ChannelType, VideoQualityMode, type APIChannelBase, type APIDMChannel, type APIGuildCategoryChannel, type APIGuildChannel, type APIGuildForumChannel, type APIGuildForumDefaultReactionEmoji, type APIGuildForumTag, type APIGuildMediaChannel, type APIGuildStageVoiceChannel, type APIGuildVoiceChannel, type APINewsChannel, type APITextChannel, type APIThreadChannel, type RESTGetAPIChannelMessageReactionUsersQuery, type RESTPatchAPIChannelJSONBody, type RESTPatchAPIGuildChannelPositionsJSONBody, type RESTPostAPIChannelWebhookJSONBody, type RESTPostAPIGuildChannelJSONBody, type RESTPostAPIGuildForumThreadsJSONBody, type SortOrderType, type ThreadAutoArchiveDuration } from 'discord-api-types/v10';
 import type { UsingClient } from '../commands';
 import type { EmojiResolvable, MessageCreateBodyRequest, MessageUpdateBodyRequest, MethodContext, ObjectToLower, StringToNumber, ToClass } from '../common';
 import type { GuildMember } from './GuildMember';
@@ -64,12 +64,14 @@ export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
             id: string;
             deny: import("./extra/Permissions").PermissionsBitField;
             allow: import("./extra/Permissions").PermissionsBitField;
+            guildId: string;
         }[] | undefined>;
         values: () => {
             type: number;
             id: string;
             deny: import("./extra/Permissions").PermissionsBitField;
             allow: import("./extra/Permissions").PermissionsBitField;
+            guildId: string;
         }[][];
     };
     memberPermissions(member: GuildMember, checkAdmin?: boolean): Promise<import("./extra/Permissions").PermissionsBitField>;
@@ -80,18 +82,21 @@ export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
             id: string;
             deny: import("./extra/Permissions").PermissionsBitField;
             allow: import("./extra/Permissions").PermissionsBitField;
+            guildId: string;
         } | undefined;
         roles: {
             type: number;
             id: string;
             deny: import("./extra/Permissions").PermissionsBitField;
             allow: import("./extra/Permissions").PermissionsBitField;
+            guildId: string;
         }[];
         member: {
             type: number;
             id: string;
             deny: import("./extra/Permissions").PermissionsBitField;
             allow: import("./extra/Permissions").PermissionsBitField;
+            guildId: string;
         } | undefined;
     }>;
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">>;
@@ -108,7 +113,7 @@ export declare class MessagesMethods extends DiscordBase {
         write: (body: MessageCreateBodyRequest) => Promise<import("./Message").Message>;
         edit: (messageId: string, body: MessageUpdateBodyRequest) => Promise<import("./Message").Message>;
         crosspost: (messageId: string, reason?: string) => Promise<import("./Message").Message>;
-        delete: (messageId: string, reason?: string) => Promise<void | undefined>;
+        delete: (messageId: string, reason?: string) => Promise<void>;
         fetch: (messageId: string) => Promise<import("./Message").Message>;
         purge: (messages: string[], reason?: string) => Promise<never>;
     };
@@ -129,7 +134,7 @@ export declare class MessagesMethods extends DiscordBase {
         write: (body: MessageCreateBodyRequest) => Promise<import("./Message").Message>;
         edit: (messageId: string, body: MessageUpdateBodyRequest) => Promise<import("./Message").Message>;
         crosspost: (messageId: string, reason?: string) => Promise<import("./Message").Message>;
-        delete: (messageId: string, reason?: string) => Promise<void | undefined>;
+        delete: (messageId: string, reason?: string) => Promise<void>;
         fetch: (messageId: string) => Promise<import("./Message").Message>;
         purge: (messages: string[], reason?: string) => Promise<never>;
     };
@@ -168,14 +173,17 @@ export declare class ThreadOnlyMethods extends DiscordBase {
     setReactionEmoji(emoji: APIGuildForumDefaultReactionEmoji, reason?: string): Promise<AllChannels>;
     setSortOrder(sort: SortOrderType, reason?: string): Promise<AllChannels>;
     setThreadRateLimit(rate: number, reason?: string): Promise<AllChannels>;
+    thread(body: RESTPostAPIGuildForumThreadsJSONBody, reason?: string): Promise<ThreadChannel>;
 }
 export interface VoiceChannelMethods extends BaseChannel<ChannelType> {
 }
 export declare class VoiceChannelMethods extends DiscordBase {
+    guildId?: string;
     setBitrate(bitrate: number | null, reason?: string): Promise<AllChannels>;
     setUserLimit(user_limit: number | null, reason?: string): Promise<AllChannels>;
     setRTC(rtc_region: string | null, reason?: string): Promise<AllChannels>;
     setVideoQuality(quality: keyof typeof VideoQualityMode, reason?: string): Promise<AllChannels>;
+    states(): Promise<import("./VoiceState").VoiceState[]>;
 }
 export declare class WebhookGuildMethods extends DiscordBase {
     webhooks: {

package/lib/structures/channels.js

@@ -229,12 +229,16 @@ let ThreadOnlyMethods = class ThreadOnlyMethods extends DiscordBase_1.DiscordBas
     setThreadRateLimit(rate, reason) {
         return this.edit({ default_thread_rate_limit_per_user: rate }, reason);
     }
+    async thread(body, reason) {
+        return this.client.channels.thread(this.id, body, reason);
+    }
 };
 exports.ThreadOnlyMethods = ThreadOnlyMethods;
 exports.ThreadOnlyMethods = ThreadOnlyMethods = __decorate([
     (0, ts_mixer_1.mix)(TopicableGuildChannel)
 ], ThreadOnlyMethods);
 class VoiceChannelMethods extends DiscordBase_1.DiscordBase {
+    guildId;
     setBitrate(bitrate, reason) {
         return this.edit({ bitrate }, reason);
     }
@@ -247,13 +251,22 @@ class VoiceChannelMethods extends DiscordBase_1.DiscordBase {
     setVideoQuality(quality, reason) {
         return this.edit({ video_quality_mode: v10_1.VideoQualityMode[quality] }, reason);
     }
+    async states() {
+        if (!this.guildId)
+            return [];
+        const states = await this.cache.voiceStates?.values(this.guildId);
+        if (!states?.length)
+            return [];
+        const filter = states.filter(state => state.channelId === this.id);
+        return filter;
+    }
 }
 exports.VoiceChannelMethods = VoiceChannelMethods;
 class WebhookGuildMethods extends DiscordBase_1.DiscordBase {
     webhooks = WebhookGuildMethods.guild({ client: this.client, guildId: this.id });
     static guild(ctx) {
         return {
-            list: () => ctx.client.webhooks.listFromChannel(ctx.guildId),
+            list: () => ctx.client.webhooks.listFromGuild(ctx.guildId),
         };
     }
 }

package/lib/structures/extra/BaseGuild.js

@@ -38,7 +38,7 @@ class BaseGuild extends DiscordBase_1.DiscordBase {
         if (!this.icon) {
             return;
         }
-        return this.rest.cdn.icon(this.id, this.icon, options);
+        return this.rest.cdn.icons(this.id).get(this.icon, options);
     }
     /**
      * splashURL gets the current guild splash as a string.
@@ -50,7 +50,7 @@ class BaseGuild extends DiscordBase_1.DiscordBase {
         if (!this.splash) {
             return;
         }
-        return this.rest.cdn.discoverySplash(this.id, this.splash, options);
+        return this.rest.cdn['discovery-splashes'](this.id).get(this.splash, options);
     }
     /**
      * bannerURL gets the current guild banner as a string.
@@ -62,7 +62,7 @@ class BaseGuild extends DiscordBase_1.DiscordBase {
         if (!this.banner) {
             return;
         }
-        return this.rest.cdn.banner(this.id, this.banner, options);
+        return this.rest.cdn.banners(this.id).get(this.banner, options);
     }
     toString() {
         return this.name;

package/lib/structures/extra/Permissions.d.ts

@@ -53,7 +53,7 @@ export declare class PermissionsBitField extends BitField<typeof PermissionFlags
         readonly SendVoiceMessages: bigint;
     };
     static All: bigint;
-    keys: (bits: BitFieldResolvable<typeof PermissionFlagsBits>[]) => PermissionStrings;
+    keys: (bits?: BitFieldResolvable<typeof PermissionFlagsBits>[]) => PermissionStrings;
     has(...bits: BitFieldResolvable<typeof PermissionFlagsBits>[]): boolean;
     strictHas(...bits: BitFieldResolvable<typeof PermissionFlagsBits>[]): boolean;
 }

package/lib/structures/index.d.ts

@@ -11,5 +11,6 @@ export * from './Interaction';
 export * from './Message';
 export * from './Sticker';
 export * from './User';
+export * from './VoiceState';
 export * from './Webhook';
 export * from './channels';

package/lib/structures/index.js

@@ -27,5 +27,6 @@ __exportStar(require("./Interaction"), exports);
 __exportStar(require("./Message"), exports);
 __exportStar(require("./Sticker"), exports);
 __exportStar(require("./User"), exports);
+__exportStar(require("./VoiceState"), exports);
 __exportStar(require("./Webhook"), exports);
 __exportStar(require("./channels"), exports);

package/lib/websocket/discord/shard.d.ts

@@ -3,7 +3,7 @@ import type { GatewayReceivePayload, GatewaySendPayload } from 'discord-api-type
 import type WS from 'ws';
 import { type CloseEvent } from 'ws';
 import type { Logger } from '../../common';
-import { DynamicBucket, PriorityQueue } from '../structures';
+import { DynamicBucket } from '../structures';
 import { ConnectTimeout } from '../structures/timeout';
 import { BaseSocket } from './basesocket';
 import type { ShardData, ShardOptions } from './shared';
@@ -23,7 +23,7 @@ export declare class Shard {
     connectTimeout: ConnectTimeout;
     heart: ShardHeart;
     bucket: DynamicBucket;
-    offlineSendQueue: PriorityQueue<(_?: unknown) => void>;
+    offlineSendQueue: ((_?: unknown) => void)[];
     constructor(id: number, options: ShardOptions);
     get latency(): number;
     get isOpen(): boolean;
@@ -31,7 +31,7 @@ export declare class Shard {
     get resumeGatewayURL(): string | undefined;
     get currentGatewayURL(): string;
     connect(): Promise<void>;
-    send<T extends GatewaySendPayload = GatewaySendPayload>(priority: number, message: T): Promise<void>;
+    send<T extends GatewaySendPayload = GatewaySendPayload>(force: boolean, message: T): Promise<void>;
     identify(): Promise<void>;
     get resumable(): boolean;
     resume(): Promise<void>;
@@ -42,6 +42,6 @@ export declare class Shard {
     protected handleClosed(close: CloseEvent): Promise<void>;
     close(code: number, reason: string): Promise<void>;
     protected handleMessage({ data }: WS.MessageEvent): Promise<void>;
-    checkOffline(priority: number): Promise<unknown>;
+    checkOffline(force: boolean): Promise<unknown>;
     calculateSafeRequests(): number;
 }

package/lib/websocket/discord/shard.js

@@ -23,7 +23,7 @@ class Shard {
         ack: true,
     };
     bucket;
-    offlineSendQueue = new structures_1.PriorityQueue();
+    offlineSendQueue = [];
     constructor(id, options) {
         this.id = id;
         this.options = options;
@@ -34,12 +34,7 @@ class Shard {
         if (options.debugger)
             this.debugger = options.debugger;
         const safe = this.calculateSafeRequests();
-        this.bucket = new structures_1.DynamicBucket({
-            limit: safe,
-            refillAmount: safe,
-            refillInterval: 6e4,
-            debugger: this.debugger,
-        });
+        this.bucket = new structures_1.DynamicBucket({ refillInterval: 6e4, limit: safe, debugger: options.debugger });
     }
     get latency() {
         return this.heart.lastAck && this.heart.lastBeat
@@ -76,7 +71,7 @@ class Shard {
             this.heart.ack = true;
         };
     }
-    async send(priority, message) {
+    async send(force, message) {
         this.debugger?.info(`[Shard #${this.id}] Sending: ${v10_1.GatewayOpcodes[message.op]} ${JSON.stringify(message.d, (_, value) => {
             if (typeof value === 'string')
                 return value.replace(this.options.token, v => {
@@ -85,13 +80,13 @@ class Shard {
                 });
             return value;
         }, 1)}`);
-        await this.checkOffline(priority);
-        await this.bucket.acquire(priority);
-        await this.checkOffline(priority);
+        await this.checkOffline(force);
+        await this.bucket.acquire(force);
+        await this.checkOffline(force);
         this.websocket?.send(JSON.stringify(message));
     }
     async identify() {
-        await this.send(0, {
+        await this.send(true, {
             op: v10_1.GatewayOpcodes.Identify,
             d: {
                 token: `Bot ${this.options.token}`,
@@ -107,7 +102,7 @@ class Shard {
         return !!(this.data.resume_gateway_url && this.data.session_id && this.data.resumeSeq !== null);
     }
     async resume() {
-        await this.send(0, {
+        await this.send(true, {
             op: v10_1.GatewayOpcodes.Resume,
             d: {
                 seq: this.data.resumeSeq,
@@ -185,13 +180,13 @@ class Shard {
                 {
                     switch (packet.t) {
                         case v10_1.GatewayDispatchEvents.Resumed:
-                            this.offlineSendQueue.toArray().map((resolve) => resolve());
+                            this.offlineSendQueue.map((resolve) => resolve());
                             this.options.handlePayload(this.id, packet);
                             break;
                         case v10_1.GatewayDispatchEvents.Ready: {
                             this.data.resume_gateway_url = packet.d.resume_gateway_url;
                             this.data.session_id = packet.d.session_id;
-                            this.offlineSendQueue.toArray().map((resolve) => resolve());
+                            this.offlineSendQueue.map((resolve) => resolve());
                             this.options.handlePayload(this.id, packet);
                             break;
                         }
@@ -251,9 +246,9 @@ class Shard {
         }
         return this.onpacket(JSON.parse(data));
     }
-    checkOffline(priority) {
+    checkOffline(force) {
         if (!this.isOpen) {
-            return new Promise(resolve => this.offlineSendQueue.push(resolve, priority));
+            return new Promise(resolve => this.offlineSendQueue[force ? 'unshift' : 'push'](resolve));
         }
         return Promise.resolve();
     }

package/lib/websocket/discord/sharder.d.ts

@@ -22,7 +22,7 @@ export declare class ShardManager extends Map<number, Shard> {
     disconnect(shardId: number): Promise<void> | undefined;
     disconnectAll(): Promise<unknown>;
     setShardPresence(shardId: number, payload: GatewayUpdatePresence['d']): void;
-    setPresence(payload: GatewayUpdatePresence['d']): Promise<void> | undefined;
+    setPresence(payload: GatewayUpdatePresence['d']): Promise<void>;
     joinVoice(guild_id: string, channel_id: string, options: ObjectToLower<Pick<GatewayVoiceStateUpdate['d'], 'self_deaf' | 'self_mute'>>): void;
     leaveVoice(guild_id: string): void;
     send<T extends GatewaySendPayload>(shardId: number, payload: T): void;

package/lib/websocket/discord/sharder.js

@@ -82,7 +82,7 @@ class ShardManager extends Map {
      */
     spawnBuckets() {
         this.debugger?.info('#0 Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.concurrency);
+        const chunks = structures_1.DynamicBucket.chunk(new Array(this.shardEnd - this.shardStart), this.concurrency);
         chunks.forEach((arr, index) => {
             for (let i = 0; i < arr.length; i++) {
                 const id = i + (index > 0 ? index * this.concurrency : 0) + this.shardStart;
@@ -155,7 +155,7 @@ class ShardManager extends Map {
                 payload,
             });
         }
-        this.get(shardId)?.send(1, payload);
+        this.get(shardId)?.send(false, payload);
     }
 }
 exports.ShardManager = ShardManager;

package/lib/websocket/discord/worker.d.ts

@@ -25,7 +25,7 @@ export type WorkerSendResultPayload = CreateWorkerMessage<'RESULT_PAYLOAD', {
 }>;
 export type WorkerSendCacheRequest = CreateWorkerMessage<'CACHE_REQUEST', {
     nonce: string;
-    method: 'scan' | 'get' | 'set' | 'patch' | 'values' | 'keys' | 'count' | 'remove' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
+    method: 'scan' | 'get' | 'set' | 'patch' | 'values' | 'keys' | 'count' | 'remove' | 'flush' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
     args: any[];
 }>;
 export type WorkerSendShardInfo = CreateWorkerMessage<'SHARD_INFO', WorkerShardInfo & {

package/lib/websocket/discord/workermanager.js

@@ -83,7 +83,7 @@ class WorkerManager extends Map {
     }
     prepareSpaces() {
         this.debugger?.info('Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.shardEnd - this.shardStart), this.options.shardsPerWorker);
+        const chunks = structures_1.DynamicBucket.chunk(new Array(this.shardEnd - this.shardStart), this.options.shardsPerWorker);
         chunks.forEach((shards, index) => {
             for (let i = 0; i < shards.length; i++) {
                 const id = i + (index > 0 ? index * this.options.shardsPerWorker : 0) + this.shardStart;
@@ -310,19 +310,13 @@ class WorkerManager extends Map {
         return nonce;
     }
     generateSendPromise(nonce, message = 'Timeout') {
-        let resolve = (_) => {
-            /**/
-        };
-        let timeout = -1;
-        const promise = new Promise((res, rej) => {
-            resolve = res;
-            timeout = setTimeout(() => {
+        return new Promise((res, rej) => {
+            const timeout = setTimeout(() => {
                 this.promises.delete(nonce);
                 rej(new Error(message));
             }, 60e3);
+            this.promises.set(nonce, { resolve: res, timeout });
         });
-        this.promises.set(nonce, { resolve, timeout });
-        return promise;
     }
     async send(data, shardId) {
         const workerId = this.calculateWorkerId(shardId);

package/lib/websocket/structures/index.d.ts

@@ -1,117 +1,24 @@
 /// <reference types="node" />
-import type { Logger } from '../../common';
-/**
- * just any kind of request to queue and resolve later
- */
-export type QueuedRequest = (value: void | Promise<void>) => Promise<unknown> | any;
+import { type Logger } from '../../common';
 /**
  * options of the dynamic bucket
  */
 export interface DynamicBucketOptions {
     limit: number;
     refillInterval: number;
-    refillAmount: number;
     debugger?: Logger;
 }
-/**
- * generally useless for interaction based bots
- * ideally this would only be triggered on certain paths
- * example: a huge amount of messages being spammed
- *
- * a dynamic bucket is just a priority queue implemented using linked lists
- * we create an empty bucket for every path
- * dynamically allocating memory improves the final memory footprint
- */
 export declare class DynamicBucket {
-    limit: number;
-    refillInterval: number;
-    refillAmount: number;
-    /** The queue of requests to acquire an available request. Mapped by <shardId, resolve()> */
-    queue: PriorityQueue<QueuedRequest>;
-    /** The amount of requests that have been used up already. */
+    options: DynamicBucketOptions;
+    queue: ((value?: unknown) => any)[];
     used: number;
-    /** Whether or not the queue is already processing. */
-    processing: boolean;
-    /** The timeout id for the timer to reduce the used amount by the refill amount.  */
-    timeoutId?: NodeJS.Timeout;
-    /** The timestamp in milliseconds when the next refill is scheduled. */
+    processing?: boolean;
     refillsAt?: number;
-    debugger?: Logger;
+    timeoutId?: NodeJS.Timeout;
     constructor(options: DynamicBucketOptions);
     get remaining(): number;
     refill(): void;
-    /** Begin processing the queue. */
     processQueue(): Promise<void>;
-    /** Pauses the execution until the request is available to be made. */
-    acquire(priority: number): Promise<void>;
-    toString(): string;
-}
-/**
- * abstract node lol
- */
-export interface AbstractNode<T> {
-    data: T;
-    next: this | null;
-}
-export interface QueuePusher<T> {
-    push(data: T): NonNullable<TNode<T>>;
-}
-export interface QueuePusherWithPriority<T> {
-    push(data: T, priority: number): NonNullable<PNode<T>>;
-}
-export declare class TNode<T> implements AbstractNode<T> {
-    data: T;
-    next: this | null;
-    constructor(data: T);
-    static null<T>(list: AbstractNode<T> | null): list is null;
-}
-export declare class PNode<T> extends TNode<T> {
-    priority: number;
-    constructor(data: T, priority: number);
-}
-export declare abstract class Queue<T> {
-    protected abstract head: AbstractNode<T> | null;
-    /**
-     * O(1)
-     */
-    pop(): AbstractNode<T> | null;
-    /**
-     * O(1)
-     */
-    peek(): T;
-    /**
-     * O(n)
-     */
-    size(): number;
-    /**
-     * O(1)
-     */
-    isEmpty(): boolean;
-    [Symbol.iterator](): IterableIterator<T>;
-    toArray(): T[];
-    toString(): string;
-}
-export declare class LinkedList<T> extends Queue<T> implements QueuePusher<T> {
-    protected head: TNode<T> | null;
-    /**
-     * O(1)
-     */
-    push(data: T): NonNullable<TNode<T>>;
-}
-export declare class PriorityQueue<T> extends Queue<T> implements QueuePusherWithPriority<T> {
-    protected head: PNode<T> | null;
-    /**
-     * O(#priorities)
-     */
-    push(data: T, priority: number): NonNullable<PNode<T>>;
-}
-export declare class SequentialBucket {
-    private connections;
-    private capacity;
-    private spawnTimeout;
-    constructor(maxCapacity: number);
-    destroy(): Promise<void>;
-    push(promise: QueuedRequest): Promise<void>;
-    acquire(promises?: LinkedList<QueuedRequest>): Promise<boolean>;
+    acquire(force?: boolean): Promise<unknown>;
     static chunk<T>(array: T[], chunks: number): T[][];
 }