seyfert 1.2.0 → 1.2.2

package/lib/components/componentcontext.js

@@ -3,38 +3,82 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComponentContext = void 0;
 const v10_1 = require("discord-api-types/v10");
 const basecontex_1 = require("../commands/basecontex");
+/**
+ * Represents a context for interacting with components in a Discord bot.
+ * @template Type - The type of component interaction.
+ */
 class ComponentContext extends basecontex_1.BaseContext {
     client;
     interaction;
+    /**
+     * Creates a new instance of the ComponentContext class.
+     * @param client - The UsingClient instance.
+     * @param interaction - The component interaction object.
+     */
     constructor(client, interaction) {
         super(client);
         this.client = client;
         this.interaction = interaction;
     }
+    /**
+     * Gets the proxy object.
+     */
     get proxy() {
         return this.client.proxy;
     }
+    /**
+     * Gets the language object for the interaction's locale.
+     */
     get t() {
         return this.client.langs.get(this.interaction?.locale ?? this.client.langs?.defaultLang ?? 'en-US');
     }
+    /**
+     * Gets the custom ID of the interaction.
+     */
     get customId() {
         return this.interaction.customId;
     }
-    get write() {
-        return this.interaction.write;
-    }
+    /**
+     * Writes a response to the interaction.
+     * @param body - The body of the response.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
+    write(body, fetchReply) {
+        return this.interaction.write(body, fetchReply);
+    }
+    /**
+     * Defers the reply to the interaction.
+     * @param ephemeral - Whether the reply should be ephemeral or not.
+     */
     deferReply(ephemeral = false) {
         return this.interaction.deferReply(ephemeral ? v10_1.MessageFlags.Ephemeral : undefined);
     }
-    get editResponse() {
-        return this.interaction.editResponse;
-    }
-    get update() {
-        return this.interaction.update;
-    }
+    /**
+     * Edits the response of the interaction.
+     * @param body - The updated body of the response.
+     */
+    editResponse(body) {
+        return this.interaction.editResponse(body);
+    }
+    /**
+     * Updates the interaction with new data.
+     * @param body - The updated body of the interaction.
+     */
+    update(body) {
+        return this.interaction.update(body);
+    }
+    /**
+     * Edits the response or replies to the interaction.
+     * @param body - The body of the response or updated body of the interaction.
+     * @param fetchReply - Whether to fetch the reply or not.
+     */
     editOrReply(body, fetchReply) {
         return this.interaction.editOrReply(body, fetchReply);
     }
+    /**
+     * Deletes the response of the interaction.
+     * @returns A promise that resolves when the response is deleted.
+     */
     deleteResponse() {
         return this.interaction.deleteResponse();
     }
@@ -63,17 +107,32 @@ class ComponentContext extends basecontex_1.BaseContext {
                 return this.client.guilds.fetch(this.guildId, mode === 'rest');
         }
     }
+    /**
+     * Gets the ID of the guild of the interaction.
+     */
     get guildId() {
         return this.interaction.guildId;
     }
+    /**
+     * Gets the ID of the channel of the interaction.
+     */
     get channelId() {
         return this.interaction.channelId;
     }
+    /**
+     * Gets the author of the interaction.
+     */
     get author() {
         return this.interaction.user;
     }
+    /**
+     * Gets the member of the interaction.
+     */
     get member() {
         return this.interaction.member;
     }
+    isComponent() {
+        return true;
+    }
 }
 exports.ComponentContext = ComponentContext;

package/lib/components/index.d.ts

@@ -10,6 +10,7 @@ import { UserSelectMenuComponent } from './UserSelectMenuComponent';
 export type MessageComponents = ButtonComponent | LinkButtonComponent | RoleSelectMenuComponent | UserSelectMenuComponent | StringSelectMenuComponent | ChannelSelectMenuComponent | MentionableSelectMenuComponent | TextInputComponent;
 export type ActionRowMessageComponents = Exclude<MessageComponents, TextInputComponent>;
 export * from './command';
+export * from './componentcontext';
 /**
  * Return a new component instance based on the component type.
  *

package/lib/components/index.js

@@ -24,6 +24,7 @@ const RoleSelectMenuComponent_1 = require("./RoleSelectMenuComponent");
 const StringSelectMenuComponent_1 = require("./StringSelectMenuComponent");
 const UserSelectMenuComponent_1 = require("./UserSelectMenuComponent");
 __exportStar(require("./command"), exports);
+__exportStar(require("./componentcontext"), exports);
 /**
  * Return a new component instance based on the component type.
  *

package/lib/structures/GuildMember.d.ts

@@ -31,11 +31,7 @@ export declare class BaseGuildMember extends DiscordBase {
     } & {
         guild_id: string;
     }) | undefined>;
-    voice(): import("..").ReturnCache<(Omit<import("discord-api-types/v10").GatewayVoiceState, "member"> & {
-        guild_id: string;
-    } & {
-        guild_id: string;
-    }) | undefined>;
+    voice(): import("..").ReturnCache<import("./VoiceState").VoiceState | undefined>;
     toString(): string;
     private patch;
     get roles(): {

package/lib/structures/GuildMember.js

@@ -34,10 +34,10 @@ class BaseGuildMember extends DiscordBase_1.DiscordBase {
         return this.client.members.edit(this.guildId, this.id, body, reason);
     }
     presence() {
-        return this.cache.presences?.get(this.id);
+        return this.client.members.presence(this.id);
     }
     voice() {
-        return this.cache.voiceStates?.get(this.id, this.guildId);
+        return this.client.members.voice(this.guildId, this.id);
     }
     toString() {
         return `<@${this.id}>`;

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.js

@@ -26,7 +26,8 @@ class User extends DiscordBase_1.DiscordBase {
     }
     avatarURL(options) {
         if (!this.avatar) {
-            return this.rest.cdn.defaultAvatar(Number(this.discriminator));
+            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.avatar(this.id, this.avatar, options);
     }
@@ -36,7 +37,7 @@ class User extends DiscordBase_1.DiscordBase {
         return this.rest.cdn.banner(this.id, 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/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';
@@ -108,7 +108,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 +129,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 +168,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/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/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;

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[][];
 }