seyfert 1.0.1 → 1.1.0

package/lib/structures/Message.d.ts

@@ -1,5 +1,5 @@
 import type { ListenerOptions } from '../builders';
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIChannelMention, APIMessage, GatewayMessageCreateDispatchData, ObjectToLower } from '../common';
 import type { EmojiResolvable } from '../common/types/resolvables';
 import type { MessageCreateBodyRequest, MessageUpdateBodyRequest } from '../common/types/write';
@@ -23,21 +23,22 @@ export declare class BaseMessage extends DiscordBase {
         channels: APIChannelMention[];
         users: (GuildMember | User)[];
     };
-    constructor(client: BaseClient, data: MessageData);
+    constructor(client: UsingClient, data: MessageData);
+    get user(): User;
     createComponentCollector(options?: ListenerOptions): {
-        run: (customId: string, callback: import("../builders").ComponentCallback) => any;
+        run: (customId: string | RegExp | string[], callback: import("../builders").ComponentCallback) => any;
         stop: (reason?: string | undefined) => void;
     };
     get url(): string;
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     channel(force?: boolean): Promise<import("./channels").AllChannels>;
-    react(emoji: EmojiResolvable): Promise<never>;
+    react(emoji: EmojiResolvable): Promise<void>;
     private patch;
 }
 export interface Message extends BaseMessage, ObjectToLower<Omit<MessageData, 'timestamp' | 'author' | 'mentions' | 'components'>> {
 }
 export declare class Message extends BaseMessage {
-    constructor(client: BaseClient, data: MessageData);
+    constructor(client: UsingClient, data: MessageData);
     fetch(): Promise<Message>;
     reply(body: Omit<MessageCreateBodyRequest, 'message_reference'>, fail?: boolean): Promise<Message>;
     edit(body: MessageUpdateBodyRequest): Promise<Message>;
@@ -50,7 +51,7 @@ export type WriteMessageWebhook = MessageWebhookMethodWriteParams;
 export declare class WebhookMessage extends BaseMessage {
     readonly webhookId: string;
     readonly webhookToken: string;
-    constructor(client: BaseClient, data: MessageData, webhookId: string, webhookToken: string);
+    constructor(client: UsingClient, data: MessageData, webhookId: string, webhookToken: string);
     fetch(): Promise<import("discord-api-types/rest/v10/webhook").RESTGetAPIWebhookWithTokenResult>;
     edit(body: EditMessageWebhook): Promise<WebhookMessage>;
     write(body: WriteMessageWebhook): Promise<WebhookMessage | null>;

package/lib/structures/Message.js

@@ -23,6 +23,9 @@ class BaseMessage extends DiscordBase_1.DiscordBase {
         this.components = data.components?.map(x => new ActionRow_1.MessageActionRowComponent(x)) ?? [];
         this.patch(data);
     }
+    get user() {
+        return this.author;
+    }
     createComponentCollector(options) {
         return this.client.components.createComponentCollector(this.id, options);
     }
@@ -38,7 +41,7 @@ class BaseMessage extends DiscordBase_1.DiscordBase {
         return this.client.channels.fetch(this.channelId, force);
     }
     react(emoji) {
-        return this.client.messages.reactions.add(this.id, this.channelId, emoji);
+        return this.client.reactions.add(this.id, this.channelId, emoji);
     }
     patch(data) {
         if ('guild_id' in data) {
@@ -114,13 +117,13 @@ class WebhookMessage extends BaseMessage {
         return this.api.webhooks(this.webhookId)(this.webhookToken).get({ query: this.thread?.id });
     }
     edit(body) {
-        return this.client.webhooks.messages.edit(this.webhookId, this.webhookToken, { ...body, messageId: this.id });
+        return this.client.webhooks.editMessage(this.webhookId, this.webhookToken, { ...body, messageId: this.id });
     }
     write(body) {
-        return this.client.webhooks.messages.write(this.webhookId, this.webhookToken, body);
+        return this.client.webhooks.writeMessage(this.webhookId, this.webhookToken, body);
     }
     delete(reason) {
-        return this.client.webhooks.messages.delete(this.webhookId, this.webhookToken, this.id, reason);
+        return this.client.webhooks.deleteMessage(this.webhookId, this.webhookToken, this.id, reason);
     }
 }
 exports.WebhookMessage = WebhookMessage;

package/lib/structures/Sticker.d.ts

@@ -1,5 +1,5 @@
+import type { UsingClient } from '..';
 import type { Attachment } from '../builders';
-import type { BaseClient } from '../client/base';
 import type { APISticker, MethodContext, ObjectToLower, RESTPatchAPIGuildStickerJSONBody, RESTPostAPIGuildStickerFormDataBody } from '../common';
 import { User } from './User';
 import { DiscordBase } from './extra/DiscordBase';
@@ -7,7 +7,7 @@ export interface Sticker extends DiscordBase, ObjectToLower<Omit<APISticker, 'us
 }
 export declare class Sticker extends DiscordBase {
     user?: User;
-    constructor(client: BaseClient, data: APISticker);
+    constructor(client: UsingClient, data: APISticker);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     edit(body: RESTPatchAPIGuildStickerJSONBody, reason?: string): Promise<Sticker> | undefined;
     fetch(force?: boolean): Promise<Sticker> | undefined;

package/lib/structures/Webhook.d.ts

@@ -1,4 +1,4 @@
-import type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIWebhook, ImageOptions, MessageWebhookCreateBodyRequest, MessageWebhookPayload, MessageWebhookUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIWebhookWithTokenMessageQuery, RESTPatchAPIWebhookJSONBody, RESTPatchAPIWebhookWithTokenJSONBody, RESTPostAPIWebhookWithTokenQuery } from '../common';
 import { AnonymousGuild } from './AnonymousGuild';
 import { User } from './User';
@@ -9,7 +9,7 @@ export declare class Webhook extends DiscordBase {
     user?: User;
     sourceGuild?: Partial<AnonymousGuild>;
     messages: ReturnType<typeof Webhook.messages>;
-    constructor(client: BaseClient, data: APIWebhook);
+    constructor(client: UsingClient, data: APIWebhook);
     guild(force?: boolean): Promise<import("./Guild").Guild<"cached"> | import("./Guild").Guild<"api">> | undefined;
     channel(force?: boolean): Promise<import("./channels").BaseChannel<import("discord-api-types/payloads/v10/channel").ChannelType> | import("./channels").DMChannel | import("./channels").CategoryChannel | undefined>;
     avatarURL(options?: ImageOptions): string | null;

package/lib/structures/Webhook.js

@@ -47,9 +47,9 @@ class Webhook extends DiscordBase_1.DiscordBase {
     }
     static messages({ client, webhookId, webhookToken }) {
         return {
-            write: (payload) => client.webhooks.messages.write(webhookId, webhookToken, payload),
-            edit: (payload) => client.webhooks.messages.edit(webhookId, webhookToken, payload),
-            delete: (messageId, reason) => client.webhooks.messages.delete(webhookId, webhookToken, messageId, reason),
+            write: (payload) => client.webhooks.writeMessage(webhookId, webhookToken, payload),
+            edit: (payload) => client.webhooks.editMessage(webhookId, webhookToken, payload),
+            delete: (messageId, reason) => client.webhooks.deleteMessage(webhookId, webhookToken, messageId, reason),
         };
     }
     static methods({ client, webhookId, webhookToken }) {

package/lib/structures/channels.d.ts

@@ -1,13 +1,12 @@
 import { ChannelType, 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 type { BaseClient } from '../client/base';
+import type { UsingClient } from '../commands';
 import type { APIChannelBase, APIGuildChannel, APIGuildForumDefaultReactionEmoji, APIGuildForumTag, EmojiResolvable, MessageCreateBodyRequest, MessageUpdateBodyRequest, MethodContext, ObjectToLower, RESTGetAPIChannelMessageReactionUsersQuery, RESTPatchAPIChannelJSONBody, RESTPatchAPIGuildChannelPositionsJSONBody, RESTPostAPIChannelWebhookJSONBody, RESTPostAPIGuildChannelJSONBody, SortOrderType, StringToNumber, ToClass } from '../common';
 import type { GuildMember } from './GuildMember';
 import type { GuildRole } from './GuildRole';
-import { Webhook } from './Webhook';
 import { DiscordBase } from './extra/DiscordBase';
 export declare class BaseChannel<T extends ChannelType> extends DiscordBase<APIChannelBase<ChannelType>> {
     type: T;
-    constructor(client: BaseClient, data: APIChannelBase<ChannelType>);
+    constructor(client: UsingClient, data: APIChannelBase<ChannelType>);
     static __intent__(id: '@me'): 'DirectMessages';
     static __intent__(id: string): 'DirectMessages' | 'Guilds';
     /** The URL to the channel */
@@ -58,7 +57,7 @@ interface IChannelTypes {
 export interface BaseGuildChannel extends ObjectToLower<Omit<APIGuildChannel<ChannelType>, 'permission_overwrites'>> {
 }
 export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
-    constructor(client: BaseClient, data: APIGuildChannel<ChannelType>);
+    constructor(client: UsingClient, data: APIGuildChannel<ChannelType>);
     permissionOverwrites: {
         fetch: () => import("..").ReturnCache<{
             type: number;
@@ -104,7 +103,7 @@ export declare class BaseGuildChannel extends BaseChannel<ChannelType> {
 export interface MessagesMethods extends BaseChannel<ChannelType> {
 }
 export declare class MessagesMethods extends DiscordBase {
-    typing(): Promise<never>;
+    typing(): Promise<void>;
     messages: {
         write: (body: MessageCreateBodyRequest) => Promise<import("./Message").Message>;
         edit: (messageId: string, body: MessageUpdateBodyRequest) => Promise<import("./Message").Message>;
@@ -119,10 +118,10 @@ export declare class MessagesMethods extends DiscordBase {
         delete: (messageId: string, reason?: string) => Promise<never>;
     };
     reactions: {
-        add: (messageId: string, emoji: EmojiResolvable) => Promise<never>;
-        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<never>;
+        add: (messageId: string, emoji: EmojiResolvable) => Promise<void>;
+        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<void>;
         fetch: (messageId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery) => Promise<import("./User").User[]>;
-        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<never>;
+        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<void>;
     };
     static messages(ctx: MethodContext<{
         channelId: string;
@@ -137,10 +136,10 @@ export declare class MessagesMethods extends DiscordBase {
     static reactions(ctx: MethodContext<{
         channelId: string;
     }>): {
-        add: (messageId: string, emoji: EmojiResolvable) => Promise<never>;
-        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<never>;
+        add: (messageId: string, emoji: EmojiResolvable) => Promise<void>;
+        delete: (messageId: string, emoji: EmojiResolvable, userId?: string) => Promise<void>;
         fetch: (messageId: string, emoji: EmojiResolvable, query?: RESTGetAPIChannelMessageReactionUsersQuery) => Promise<import("./User").User[]>;
-        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<never>;
+        purge: (messageId: string, emoji?: EmojiResolvable) => Promise<void>;
     };
     static pins(ctx: MethodContext<{
         channelId: string;
@@ -155,7 +154,7 @@ export interface TextBaseGuildChannel extends ObjectToLower<Omit<APITextChannel,
 }
 export declare class TextBaseGuildChannel extends BaseGuildChannel {
 }
-export default function channelFrom(data: APIChannelBase<ChannelType>, client: BaseClient): AllChannels;
+export default function channelFrom(data: APIChannelBase<ChannelType>, client: UsingClient): AllChannels;
 export interface TopicableGuildChannel extends BaseChannel<ChannelType> {
 }
 export declare class TopicableGuildChannel extends DiscordBase {
@@ -180,24 +179,24 @@ export declare class VoiceChannelMethods extends DiscordBase {
 }
 export declare class WebhookGuildMethods extends DiscordBase {
     webhooks: {
-        list: () => Promise<Webhook[]>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
     };
     static guild(ctx: MethodContext<{
         guildId: string;
     }>): {
-        list: () => Promise<Webhook[]>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
     };
 }
 export declare class WebhookChannelMethods extends DiscordBase {
     webhooks: {
-        list: () => Promise<Webhook[]>;
-        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<import("./Webhook").Webhook>;
     };
     static channel(ctx: MethodContext<{
         channelId: string;
     }>): {
-        list: () => Promise<Webhook[]>;
-        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<import("./Webhook").Webhook>;
     };
 }
 export interface TextGuildChannel extends ObjectToLower<Omit<APITextChannel, 'type' | 'permission_overwrites'>>, BaseGuildChannel, TextBaseGuildChannel, WebhookChannelMethods {
@@ -238,8 +237,8 @@ export interface ThreadChannel extends ObjectToLower<Omit<APIThreadChannel, 'per
 export declare class ThreadChannel extends BaseChannel<ChannelType.PublicThread | ChannelType.AnnouncementThread | ChannelType.PrivateThread> {
     type: ChannelType.PublicThread | ChannelType.AnnouncementThread | ChannelType.PrivateThread;
     webhooks: {
-        list: () => Promise<Webhook[]>;
-        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<Webhook>;
+        list: () => Promise<import("./Webhook").Webhook[]>;
+        create: (body: RESTPostAPIChannelWebhookJSONBody) => Promise<import("./Webhook").Webhook>;
     };
     setRatelimitPerUser(rate_limit_per_user: number | null | undefined): Promise<AllChannels>;
     pin(reason?: string): Promise<AllChannels>;

package/lib/structures/channels.js

@@ -10,7 +10,6 @@ exports.DirectoryChannel = exports.NewsChannel = exports.CategoryChannel = expor
 const v10_1 = require("discord-api-types/v10");
 const ts_mixer_1 = require("ts-mixer");
 const builders_1 = require("../builders");
-const Webhook_1 = require("./Webhook");
 const DiscordBase_1 = require("./extra/DiscordBase");
 const functions_1 = require("./extra/functions");
 class BaseChannel extends DiscordBase_1.DiscordBase {
@@ -103,13 +102,13 @@ class BaseGuildChannel extends BaseChannel {
         values: () => (this.guildId ? this.client.cache.overwrites?.values(this.guildId) ?? [] : []),
     };
     memberPermissions(member, checkAdmin = true) {
-        return this.client.channels.overwrites.memberPermissions(this.id, member, checkAdmin);
+        return this.client.channels.memberPermissions(this.id, member, checkAdmin);
     }
     rolePermissions(role, checkAdmin = true) {
-        return this.client.channels.overwrites.rolePermissions(this.id, role, checkAdmin);
+        return this.client.channels.rolePermissions(this.id, role, checkAdmin);
     }
     overwritesFor(member) {
-        return this.client.channels.overwrites.overwritesFor(this.id, member);
+        return this.client.channels.overwritesFor(this.id, member);
     }
     guild(force = false) {
         return this.client.guilds.fetch(this.guildId, force);
@@ -147,17 +146,17 @@ class MessagesMethods extends DiscordBase_1.DiscordBase {
     }
     static reactions(ctx) {
         return {
-            add: (messageId, emoji) => ctx.client.messages.reactions.add(messageId, ctx.channelId, emoji),
-            delete: (messageId, emoji, userId = '@me') => ctx.client.messages.reactions.delete(messageId, ctx.channelId, emoji, userId),
-            fetch: (messageId, emoji, query) => ctx.client.messages.reactions.fetch(messageId, ctx.channelId, emoji, query),
-            purge: (messageId, emoji) => ctx.client.messages.reactions.purge(messageId, ctx.channelId, emoji),
+            add: (messageId, emoji) => ctx.client.reactions.add(messageId, ctx.channelId, emoji),
+            delete: (messageId, emoji, userId = '@me') => ctx.client.reactions.delete(messageId, ctx.channelId, emoji, userId),
+            fetch: (messageId, emoji, query) => ctx.client.reactions.fetch(messageId, ctx.channelId, emoji, query),
+            purge: (messageId, emoji) => ctx.client.reactions.purge(messageId, ctx.channelId, emoji),
         };
     }
     static pins(ctx) {
         return {
-            fetch: () => ctx.client.channels.pins.fetch(ctx.channelId),
-            set: (messageId, reason) => ctx.client.channels.pins.set(messageId, ctx.channelId, reason),
-            delete: (messageId, reason) => ctx.client.channels.pins.delete(messageId, ctx.channelId, reason),
+            fetch: () => ctx.client.channels.pins(ctx.channelId),
+            set: (messageId, reason) => ctx.client.channels.setPin(messageId, ctx.channelId, reason),
+            delete: (messageId, reason) => ctx.client.channels.deletePin(messageId, ctx.channelId, reason),
         };
     }
     static transformMessageBody(body) {
@@ -254,10 +253,7 @@ class WebhookGuildMethods extends DiscordBase_1.DiscordBase {
     webhooks = WebhookGuildMethods.guild({ client: this.client, guildId: this.id });
     static guild(ctx) {
         return {
-            list: async () => {
-                const webhooks = await ctx.client.proxy.guilds(ctx.guildId).webhooks.get();
-                return webhooks.map(webhook => new Webhook_1.Webhook(ctx.client, webhook));
-            },
+            list: () => ctx.client.webhooks.listFromChannel(ctx.guildId),
         };
     }
 }
@@ -266,16 +262,8 @@ class WebhookChannelMethods extends DiscordBase_1.DiscordBase {
     webhooks = WebhookChannelMethods.channel({ client: this.client, channelId: this.id });
     static channel(ctx) {
         return {
-            list: async () => {
-                const webhooks = await ctx.client.proxy.channels(ctx.channelId).webhooks.get();
-                return webhooks.map(webhook => new Webhook_1.Webhook(ctx.client, webhook));
-            },
-            create: async (body) => {
-                const webhook = await ctx.client.proxy.channels(ctx.channelId).webhooks.post({
-                    body,
-                });
-                return new Webhook_1.Webhook(ctx.client, webhook);
-            },
+            list: () => ctx.client.webhooks.listFromChannel(ctx.channelId),
+            create: async (body) => ctx.client.webhooks.create(ctx.channelId, body),
         };
     }
 }

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

@@ -1,7 +1,6 @@
-import type { BaseClient } from '../../client/base';
 import type { UsingClient } from '../../commands';
 /** */
 export declare abstract class Base {
-    constructor(client: BaseClient);
+    constructor(client: UsingClient);
     readonly client: UsingClient;
 }

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

@@ -1,10 +1,10 @@
-import type { BaseClient } from '../../client/base';
+import type { UsingClient } from '../../commands';
 import { Base } from './Base';
 export declare class DiscordBase<Data extends Record<string, any> = {
     id: string;
 }> extends Base {
     id: string;
-    constructor(client: BaseClient, 
+    constructor(client: UsingClient, 
     /** Unique ID of the object */
     data: Data);
     /**

package/lib/websocket/constants/index.js

@@ -16,6 +16,7 @@ const ShardManagerDefaults = {
     intents: 0,
     properties,
     version: 10,
+    shardStart: 0,
     handlePayload: (shardId, packet) => {
         console.info(`Packet ${packet.t} on shard ${shardId}`);
     },

package/lib/websocket/discord/shard.js

@@ -42,7 +42,9 @@ class Shard {
         });
     }
     get latency() {
-        return this.heart.lastAck && this.heart.lastBeat ? this.heart.lastAck - this.heart.lastBeat : Infinity;
+        return this.heart.lastAck && this.heart.lastBeat
+            ? this.heart.lastAck - this.heart.lastBeat
+            : Number.POSITIVE_INFINITY;
     }
     get isOpen() {
         return this.websocket?.readyState === ws_1.WebSocket.OPEN;
@@ -94,7 +96,7 @@ class Shard {
             d: {
                 token: `Bot ${this.options.token}`,
                 compress: this.options.compress,
-                properties: constants_1.properties,
+                properties: this.options.properties ?? constants_1.properties,
                 shard: [this.id, this.options.info.shards],
                 intents: this.options.intents,
                 presence: this.options.presence,

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

@@ -7,6 +7,9 @@ export declare class ShardManager extends Map<number, Shard> {
     options: ShardManagerOptions;
     debugger?: Logger;
     constructor(options: ShardManagerOptions);
+    get totalShards(): number;
+    get shardStart(): number;
+    get shardEnd(): number;
     get remaining(): number;
     get concurrency(): number;
     get latency(): number;

package/lib/websocket/discord/sharder.js

@@ -23,6 +23,15 @@ class ShardManager extends Map {
             });
         }
     }
+    get totalShards() {
+        return this.options.totalShards ?? this.options.info.shards;
+    }
+    get shardStart() {
+        return this.options.shardStart ?? 0;
+    }
+    get shardEnd() {
+        return this.options.shardEnd ?? this.totalShards;
+    }
     get remaining() {
         return this.options.info.session_start_limit.remaining;
     }
@@ -43,7 +52,7 @@ class ShardManager extends Map {
         shard ??= new shard_js_1.Shard(shardId, {
             token: this.options.token,
             intents: this.options.intents,
-            info: { ...this.options.info, shards: (this.options.shardEnd ?? this.options.totalShards) },
+            info: { ...this.options.info, shards: this.totalShards },
             handlePayload: this.options.handlePayload,
             properties: this.options.properties,
             debugger: this.debugger,
@@ -72,12 +81,10 @@ class ShardManager extends Map {
      */
     spawnBuckets() {
         this.debugger?.info('#0 Preparing buckets');
-        const chunks = structures_1.SequentialBucket.chunk(new Array(this.options.shardStart !== undefined && this.options.shardEnd !== undefined
-            ? this.options.shardEnd - this.options.shardStart
-            : this.options.totalShards), this.concurrency);
+        const chunks = structures_1.SequentialBucket.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.options.shardStart ?? 0);
+                const id = i + (index > 0 ? index * this.concurrency : 0) + this.shardStart;
                 chunks[index][i] = this.spawn(id);
             }
         });

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

@@ -30,6 +30,7 @@ export interface ShardManagerOptions extends ShardDetails {
     compress?: boolean;
 }
 export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload'> {
+    mode: 'threads' | 'clusters';
     workers?: number;
     /**
      * @default 32

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

@@ -35,6 +35,7 @@ export type WorkerSendInfo = CreateWorkerMessage<'WORKER_INFO', WorkerInfo & {
     nonce: string;
 }>;
 export type WorkerReady = CreateWorkerMessage<'WORKER_READY'>;
+export type WorkerStart = CreateWorkerMessage<'WORKER_START'>;
 export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
     method: HttpMethods;
     url: `/${string}`;
@@ -55,5 +56,5 @@ export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
     nonce: string;
     toWorkerId: number;
 }>;
-export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval;
+export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
 export {};

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

@@ -4,7 +4,9 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
-import { Worker } from 'node:worker_threads';
+/// <reference types="node" />
+import { type Worker as ClusterWorker } from 'node:cluster';
+import { Worker as ThreadWorker } from 'node:worker_threads';
 import { ApiHandler } from '../..';
 import { type Adapter } from '../../cache';
 import { Logger, type GatewayPresenceUpdateData, type GatewaySendPayload, type MakePartial } from '../../common';
@@ -13,7 +15,7 @@ import { MemberUpdateHandler } from './events/memberUpdate';
 import { PresenceUpdateHandler } from './events/presenceUpdate';
 import type { ShardOptions, WorkerData, WorkerManagerOptions } from './shared';
 import type { WorkerInfo, WorkerMessage, WorkerShardInfo } from './worker';
-export declare class WorkerManager extends Map<number, Worker & {
+export declare class WorkerManager extends Map<number, (ClusterWorker | ThreadWorker) & {
     ready?: boolean;
 }> {
     options: Required<WorkerManagerOptions>;
@@ -34,6 +36,8 @@ export declare class WorkerManager extends Map<number, Worker & {
     get concurrency(): number;
     get totalWorkers(): number;
     get totalShards(): number;
+    get shardStart(): number;
+    get shardEnd(): number;
     get shardsPerWorker(): number;
     get workers(): number;
     syncLatency({ shardId, workerId }: {
@@ -43,8 +47,9 @@ export declare class WorkerManager extends Map<number, Worker & {
     calculateShardId(guildId: string): number;
     calculateWorkerId(shardId: number): number;
     prepareSpaces(): number[][];
+    postMessage(id: number, body: any): void;
     prepareWorkers(shards: number[][]): Promise<void>;
-    createWorker(workerData: WorkerData): Worker;
+    createWorker(workerData: WorkerData): ClusterWorker | ThreadWorker;
     spawn(workerId: number, shardId: number): void;
     handleWorkerMessage(message: WorkerMessage): Promise<void>;
     private generateNonce;