seyfert 1.5.0 → 2.1.0

package/lib/websocket/discord/sharder.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShardManager = void 0;
-const v10_1 = require("discord-api-types/v10");
 const common_1 = require("../../common");
+const types_1 = require("../../types");
 const constants_1 = require("../constants");
 const structures_1 = require("../structures");
 const timeout_1 = require("../structures/timeout");
-const shard_js_1 = require("./shard.js");
+const shard_1 = require("./shard");
 let parentPort;
 let workerData;
 class ShardManager extends Map {
@@ -15,8 +15,9 @@ class ShardManager extends Map {
     debugger;
     constructor(options) {
         super();
-        options.totalShards ??= options.info.shards;
-        this.options = (0, common_1.MergeOptions)(constants_1.ShardManagerDefaults, options);
+        this.options = (0, common_1.MergeOptions)(constants_1.ShardManagerDefaults, {
+            totalShards: options.info.shards,
+        }, options);
         this.connectQueue = new timeout_1.ConnectQueue(5.5e3, this.concurrency);
         if (this.options.debug) {
             this.debugger = new common_1.Logger({
@@ -30,6 +31,64 @@ class ShardManager extends Map {
             if (worker_threads.parentPort)
                 parentPort = worker_threads.parentPort;
         }
+        if (this.options.resharding.interval <= 0)
+            return;
+        setInterval(async () => {
+            this.debugger?.debug('Checking if reshard is needed');
+            const info = await this.options.resharding.getInfo();
+            if (info.shards <= this.totalShards)
+                return this.debugger?.debug('Resharding not needed');
+            //https://github.com/discordeno/discordeno/blob/6a5f446c0651b9fad9f1550ff1857fe7a026426b/packages/gateway/src/manager.ts#L106C8-L106C94
+            const percentage = (info.shards / ((this.totalShards * 2500) / 1000)) * 100;
+            if (percentage < this.options.resharding.percentage)
+                return this.debugger?.debug(`Percentage is not enough to reshard ${percentage}/${this.options.resharding.percentage}`);
+            this.debugger?.info('Starting resharding process');
+            this.connectQueue.concurrency = info.session_start_limit.max_concurrency;
+            this.options.totalShards = info.shards;
+            this.options.info.session_start_limit.max_concurrency = info.session_start_limit.max_concurrency;
+            let shardsConnected = 0;
+            let handlePayload = async (sharder, _, packet) => {
+                if ((packet.t === 'GUILD_CREATE' || packet.t === 'GUILD_DELETE') &&
+                    this.options.resharding.onGuild(packet.d.id)) {
+                    return;
+                }
+                if (packet.t !== 'READY')
+                    return;
+                this.options.resharding.reloadGuilds(packet.d.guilds.map(x => x.id));
+                if (++shardsConnected < info.shards)
+                    return; //waiting for last shard to connect
+                // dont listen more events when all shards are ready
+                handlePayload = async () => { };
+                await this.disconnectAll();
+                this.clear();
+                for (const [id, shard] of sharder) {
+                    shard.options.handlePayload = (shardId, packet) => {
+                        return this.options.handlePayload(shardId, packet);
+                    };
+                    this.set(id, shard);
+                }
+                sharder.clear();
+            };
+            const resharder = new ShardManager({
+                ...this.options,
+                resharding: {
+                    // getInfo mock, we don't need it
+                    getInfo: () => ({}),
+                    interval: 0,
+                    percentage: 0,
+                    reloadGuilds() { },
+                    onGuild() {
+                        return true;
+                    },
+                },
+                handlePayload: (shardId, packet) => {
+                    return handlePayload(resharder, shardId, packet);
+                },
+            });
+            // share ratelimit
+            resharder.connectQueue = this.connectQueue;
+            await resharder.spawnShards();
+        }, this.options.resharding.interval);
     }
     get totalShards() {
         return this.options.totalShards ?? this.options.info.shards;
@@ -52,19 +111,19 @@ class ShardManager extends Map {
         return acc / this.size;
     }
     calculateShardId(guildId) {
-        return Number((BigInt(guildId) >> 22n) % BigInt(this.options.info.shards ?? 1));
+        return (0, common_1.calculateShardId)(guildId, this.totalShards);
     }
     spawn(shardId) {
         this.debugger?.info(`Spawn shard ${shardId}`);
         let shard = this.get(shardId);
-        shard ??= new shard_js_1.Shard(shardId, {
+        shard ??= new shard_1.Shard(shardId, {
             token: this.options.token,
             intents: this.options.intents,
             info: { ...this.options.info, shards: this.totalShards },
             handlePayload: this.options.handlePayload,
             properties: this.options.properties,
             debugger: this.debugger,
-            compress: false,
+            compress: this.options.compress ?? false,
             presence: this.options.presence?.(shardId, -1),
         });
         this.set(shardId, shard);
@@ -117,7 +176,7 @@ class ShardManager extends Map {
     setShardPresence(shardId, payload) {
         this.debugger?.info(`Shard #${shardId} update presence`);
         return this.send(shardId, {
-            op: v10_1.GatewayOpcodes.PresenceUpdate,
+            op: types_1.GatewayOpcodes.PresenceUpdate,
             d: payload,
         });
     }
@@ -133,11 +192,11 @@ class ShardManager extends Map {
         const shardId = this.calculateShardId(guild_id);
         this.debugger?.info(`Shard #${shardId} join voice ${channel_id} in ${guild_id}`);
         return this.send(shardId, {
-            op: v10_1.GatewayOpcodes.VoiceStateUpdate,
+            op: types_1.GatewayOpcodes.VoiceStateUpdate,
             d: {
                 guild_id,
                 channel_id,
-                ...(0, common_1.toSnakeCase)(options),
+                ...options,
             },
         });
     }
@@ -145,7 +204,7 @@ class ShardManager extends Map {
         const shardId = this.calculateShardId(guild_id);
         this.debugger?.info(`Shard #${shardId} leave voice in ${guild_id}`);
         return this.send(shardId, {
-            op: v10_1.GatewayOpcodes.VoiceStateUpdate,
+            op: types_1.GatewayOpcodes.VoiceStateUpdate,
             d: {
                 guild_id,
                 channel_id: null,

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

@@ -1,5 +1,5 @@
-import type { APIGatewayBotInfo, GatewayDispatchPayload, GatewayIntentBits, GatewayPresenceUpdateData } from 'discord-api-types/v10';
-import type { Logger } from '../../common';
+import type { APIGatewayBotInfo, GatewayDispatchPayload, GatewayIntentBits, GatewayPresenceUpdateData } from '../../types';
+import type { Awaitable, DeepPartial, Logger } from '../../common';
 import type { IdentifyProperties } from '../constants';
 export interface ShardManagerOptions extends ShardDetails {
     /** Important data which is used by the manager to connect shards to the gateway. */
@@ -29,21 +29,47 @@ export interface ShardManagerOptions extends ShardDetails {
      */
     presence?: (shardId: number, workerId: number) => GatewayPresenceUpdateData;
     compress?: boolean;
+    resharding?: {
+        /**
+         * @returns the gateway connection info
+         */
+        getInfo(): Promise<APIGatewayBotInfo>;
+        interval: number;
+        percentage: number;
+        /**
+         *
+         * @param ids
+         * @returns
+         */
+        reloadGuilds: (ids: string[]) => unknown;
+        /**
+         *
+         * @param id
+         * @returns true if deleted
+         */
+        onGuild: (id: string) => boolean;
+    };
+}
+export interface CustomManagerAdapter {
+    postMessage(workerId: number, body: unknown): Awaitable<unknown>;
+    spawn(workerData: WorkerData, env: Record<string, any>): Awaitable<unknown>;
 }
-export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload'> {
-    mode: 'threads' | 'clusters';
+export interface WorkerManagerOptions extends Omit<ShardManagerOptions, 'handlePayload' | 'properties'> {
+    mode: 'threads' | 'clusters' | 'custom';
+    adapter?: CustomManagerAdapter;
     workers?: number;
     /**
-     * @default 32
+     * @default 16
      */
     shardsPerWorker?: number;
     workerProxy?: boolean;
     path: string;
     handlePayload(shardId: number, workerId: number, packet: GatewayDispatchPayload): unknown;
+    properties?: DeepPartial<NonNullable<ShardManagerOptions['properties']>>;
 }
 export interface ShardData {
     /** resume seq to resume connections */
-    resumeSeq: number | null;
+    resume_seq: number | null;
     /**
      * resume_gateway_url is the url to resume the connection
      * @link https://discord.com/developers/docs/topics/gateway#ready-event
@@ -97,6 +123,8 @@ export interface WorkerData {
     token: string;
     path: string;
     shards: number[];
+    totalShards: number;
+    mode: 'custom' | 'clusters' | 'threads';
     workerId: number;
     debug: boolean;
     workerProxy: boolean;

package/lib/websocket/discord/socket/custom.d.ts

@@ -0,0 +1,52 @@
+import type { Socket } from 'node:net';
+export declare class SeyfertWebSocket {
+    #private;
+    socket?: Socket;
+    hostname: string;
+    path: string;
+    __stored: Buffer[];
+    __opcode: number;
+    __promises: Map<string, {
+        resolve: () => void;
+        reject: (reason?: any) => void;
+    }>;
+    __lastError: null | {
+        code: number;
+        reason: string;
+    };
+    __closeCalled?: boolean;
+    constructor(url: string);
+    private connect;
+    handleReadable(): void;
+    handleEvent(body: Buffer, opcode: number): void;
+    handleClose(): Promise<void>;
+    send(data: string): void;
+    private _write;
+    onping(_data: string): void;
+    onpong(_data: string): void;
+    onopen(): void;
+    onmessage(_payload: {
+        data: string | Buffer;
+    }): void;
+    onclose(_close: {
+        code: number;
+        reason: string;
+    }): void;
+    onerror(_err: unknown): void;
+    close(code: number, reason: string): void;
+    pong(data: string): void;
+    ping(data: string): void;
+    waitPing(): Promise<number>;
+    get readyState(): number;
+    /**
+     *
+     * @param start Start calculating bytes from `start`
+     * @param bits Num of bits since `start`
+     * @returns
+     */
+    private readBytes;
+}
+export type ReadableHeadData = {
+    next?: ReadableHeadData;
+    data: Buffer;
+};

package/lib/websocket/discord/socket/custom.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SeyfertWebSocket = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_https_1 = require("node:https");
+class SeyfertWebSocket {
+    socket = undefined;
+    hostname;
+    path;
+    __stored = [];
+    __opcode = 0;
+    __promises = new Map();
+    __lastError = null;
+    __closeCalled;
+    constructor(url) {
+        const urlParts = new URL(url);
+        this.hostname = urlParts.hostname || '';
+        this.path = `${urlParts.pathname}${urlParts.search || ''}`;
+        this.connect();
+    }
+    connect(retries = 0) {
+        return new Promise((resolve, rej) => {
+            const key = (0, node_crypto_1.randomBytes)(16).toString('base64');
+            const req = (0, node_https_1.request)({
+                //discord gateway hostname
+                hostname: this.hostname,
+                path: this.path,
+                headers: {
+                    Connection: 'Upgrade',
+                    Upgrade: 'websocket',
+                    'Sec-WebSocket-Key': key,
+                    'Sec-WebSocket-Version': '13',
+                },
+            });
+            req.on('upgrade', (res, socket) => {
+                const hash = (0, node_crypto_1.createHash)('sha1').update(`${key}258EAFA5-E914-47DA-95CA-C5AB0DC85B11`).digest('base64');
+                const accept = res.headers['sec-websocket-accept'];
+                if (accept !== hash) {
+                    socket.end(() => {
+                        rej(new Error('Invalid sec-websocket-accept header'));
+                    });
+                    return;
+                }
+                this.socket = socket;
+                socket.on('readable', this.handleReadable.bind(this));
+                socket.on('close', this.handleClose.bind(this));
+                socket.on('error', err => this.onerror(err));
+                resolve();
+                this.onopen();
+            });
+            req.on('close', () => {
+                req.removeAllListeners();
+            });
+            req.on('error', e => {
+                if (retries < 5) {
+                    setTimeout(() => {
+                        resolve(this.connect(retries + 1));
+                    }, 500);
+                }
+                else {
+                    rej(e);
+                }
+            });
+            req.end();
+        });
+    }
+    handleReadable() {
+        // Keep reading until no data, this is useful when two payloads merges.
+        while (this.socket.readableLength > 0) {
+            // Read length without consuming the buffer
+            let length = this.readBytes(1, 1) & 127;
+            const slice = length === 126 ? 4 : length === 127 ? 10 : 2;
+            // Check if frame/data is complete
+            if (this.socket.readableLength < slice)
+                return; // Wait to next cycle if not
+            if (length > 125) {
+                // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
+                // If length is 126/127, read extended payload length instead
+                // Equivalent to readUint32BE
+                length = this.readBytes(2, slice - 2);
+            }
+            const payloadLength = slice + length;
+            // Read the frame, ignore data next to it, leave it to next `while` cycle
+            const frame = this.socket.read(payloadLength);
+            // unfinished object when socket closes while reading the data
+            if (!frame || frame.length !== payloadLength)
+                return;
+            // Get fin (0 | 1)
+            const fin = frame[0] >> 7;
+            // Read opcode (continuation, text, binary, close, ping, pong)
+            let opcode = frame[0] & 15;
+            // Cut frame to get payload
+            let payload = frame.subarray(slice);
+            // If fin is 0, store the data and wait to next `while` cycle to be fin=1
+            if (fin === 0) {
+                this.__stored.push(payload);
+                // Only store opcode when is not 0 (continuation)
+                if (opcode !== 0) {
+                    this.__opcode = opcode;
+                }
+                return;
+            }
+            // When the message is from ws fragmentation, opcode of last message is 0
+            // If so, merge all messages.
+            if (opcode === 0) {
+                this.__stored.push(payload);
+                payload = Buffer.concat(this.__stored);
+                opcode = this.__opcode;
+                // Reset body
+                this.__stored = [];
+                // Reset opcode, should set as -1?
+                this.__opcode = 0;
+            }
+            // Handle opcodes
+            this.handleEvent(payload, opcode);
+        }
+    }
+    handleEvent(body, opcode) {
+        switch (opcode) {
+            // text
+            case 0x1:
+                this.onmessage({ data: body.toString() });
+                break;
+            // binary
+            case 0x2:
+                {
+                    if (body[1] === 80)
+                        body = body.subarray(6);
+                    this.onmessage({ data: body });
+                }
+                break;
+            // pong
+            case 0x9:
+                this.onping(body.toString());
+                break;
+            // ping
+            case 0xa:
+                this.onpong(body.toString());
+                break;
+            // close
+            case 0x8:
+                this.__lastError = {
+                    code: body.readUInt16BE(0),
+                    reason: body.subarray(2).toString(),
+                };
+                break;
+        }
+    }
+    async handleClose() {
+        this.socket?.removeAllListeners();
+        this.socket?.destroy();
+        this.socket = undefined;
+        if (this.__closeCalled)
+            return;
+        if (!this.__lastError)
+            return this.connect();
+        this.onclose(this.__lastError);
+        this.__lastError = null;
+    }
+    send(data) {
+        this._write(Buffer.from(data), 1);
+    }
+    _write(buffer, opcode) {
+        if (!this.socket?.writable)
+            return;
+        const length = buffer.length;
+        let frame;
+        // Kinda same logic as above, but client-side
+        if (length < 126) {
+            frame = Buffer.allocUnsafe(6 + length);
+            frame[1] = 128 + length;
+        }
+        else if (length < 65536) {
+            frame = Buffer.allocUnsafe(8 + length);
+            frame[1] = 254;
+            frame[2] = (length >> 8) & 255;
+            frame[3] = length & 255;
+        }
+        else {
+            frame = Buffer.allocUnsafe(14 + length);
+            frame[1] = 255;
+            frame.writeBigUint64BE(BigInt(length), 2);
+        }
+        frame[0] = 128 + opcode;
+        frame.writeUint32BE(0, frame.length - length - 4);
+        frame.set(buffer, frame.length - length);
+        this.socket?.write(frame);
+    }
+    onping(_data) { }
+    onpong(_data) { }
+    onopen() { }
+    onmessage(_payload) { }
+    onclose(_close) { }
+    onerror(_err) { }
+    close(code, reason) {
+        this.__closeCalled = true;
+        // alloc payload length
+        const buffer = Buffer.alloc(2 + Buffer.byteLength(reason));
+        // gateway close code
+        buffer.writeUInt16BE(code, 0);
+        // reason
+        buffer.write(reason, 2);
+        // message, close opcode
+        this._write(buffer, 0x8);
+        this.socket?.end();
+    }
+    pong(data) {
+        //send pong opcode (10)
+        this._write(Buffer.from(data), 0xa);
+    }
+    ping(data) {
+        //send ping opcode (9)
+        this._write(Buffer.from(data), 0x9);
+    }
+    waitPing() {
+        const id = this.#randomUUID();
+        let timeout;
+        const start = performance.now();
+        this.ping(id);
+        return new Promise((resolve, reject) => {
+            this.__promises.set(id, {
+                reject,
+                resolve,
+            });
+            timeout = setTimeout(() => {
+                resolve();
+            }, 60e3);
+        })
+            .then(() => {
+            return performance.now() - start;
+        })
+            .finally(() => {
+            clearTimeout(timeout);
+        });
+    }
+    #randomUUID() {
+        const id = (0, node_crypto_1.randomUUID)();
+        if (this.__promises.has(id))
+            return this.#randomUUID();
+        return id;
+    }
+    get readyState() {
+        return ['opening', 'open', 'closed', 'closed'].indexOf(this.socket?.readyState ?? 'closed');
+    }
+    /**
+     *
+     * @param start Start calculating bytes from `start`
+     * @param bits Num of bits since `start`
+     * @returns
+     */
+    readBytes(start, bits) {
+        // @ts-expect-error this is private, thanks nodejs
+        const readable = this.socket._readableState;
+        // Num of bit read
+        let bitIndex = 0;
+        // Num of bit read counting since start
+        let read = 0;
+        // Bytes value
+        let value = 0;
+        // Node v20
+        if ('bufferIndex' in readable) {
+            // actual index of the buffer to read
+            let blockIndex = readable.bufferIndex;
+            // Buffer to read
+            let block;
+            while ((block = readable.buffer[blockIndex++])) {
+                for (let i = 0; i < block.length; i++) {
+                    if (++bitIndex > start) {
+                        value *= 256; // shift 8 bits (1 byte) `*= 256 is faster than <<= 8`
+                        value += block[i]; // sum value to bits
+                        // Read until read all bits
+                        if (++read === bits) {
+                            return value;
+                        }
+                    }
+                }
+            }
+        } /* Support for olders versions*/
+        else {
+            // readable.buffer is kinda a LinkedList
+            let head = readable.buffer.head;
+            while (head) {
+                for (let i = 0; i < head.data.length; i++) {
+                    if (++bitIndex > start) {
+                        value *= 256; // shift 8 bits (1 byte) `*= 256 is faster than <<= 8`
+                        value += head.data[i]; // sum value to bits
+                        // Read until read all bits
+                        if (++read === bits) {
+                            return value;
+                        }
+                    }
+                }
+                // continue with next node
+                head = head.next;
+            }
+        }
+        return 0;
+    }
+}
+exports.SeyfertWebSocket = SeyfertWebSocket;

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

@@ -1,5 +1,5 @@
-import type { GatewayDispatchPayload } from 'discord-api-types/v10';
 import type { ApiRequestOptions, HttpMethods } from '../..';
+import type { GatewayDispatchPayload } from '../../types';
 export interface WorkerShardInfo {
     open: boolean;
     shardId: number;
@@ -25,8 +25,8 @@ export type WorkerSendResultPayload = CreateWorkerMessage<'RESULT_PAYLOAD', {
 }>;
 export type WorkerSendCacheRequest = CreateWorkerMessage<'CACHE_REQUEST', {
     nonce: string;
-    method: 'scan' | 'get' | 'set' | 'patch' | 'values' | 'keys' | 'count' | 'remove' | 'flush' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
-    args: any[];
+    method: 'scan' | 'bulkGet' | 'get' | 'bulkSet' | 'set' | 'bulkPatch' | 'patch' | 'values' | 'keys' | 'count' | 'bulkRemove' | 'remove' | 'flush' | 'contains' | 'getToRelationship' | 'bulkAddToRelationShip' | 'addToRelationship' | 'removeRelationship' | 'removeToRelationship';
+    args: unknown[];
 }>;
 export type WorkerSendShardInfo = CreateWorkerMessage<'SHARD_INFO', WorkerShardInfo & {
     nonce: string;
@@ -35,6 +35,7 @@ export type WorkerSendInfo = CreateWorkerMessage<'WORKER_INFO', WorkerInfo & {
     nonce: string;
 }>;
 export type WorkerReady = CreateWorkerMessage<'WORKER_READY'>;
+export type WorkerShardsConnected = CreateWorkerMessage<'WORKER_SHARDS_CONNECTED'>;
 export type WorkerStart = CreateWorkerMessage<'WORKER_START'>;
 export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
     method: HttpMethods;
@@ -42,13 +43,8 @@ export type WorkerSendApiRequest = CreateWorkerMessage<'WORKER_API_REQUEST', {
     requestOptions: ApiRequestOptions;
     nonce: string;
 }>;
-export type WorkerExecuteEval = CreateWorkerMessage<'EXECUTE_EVAL', {
-    func: string;
-    nonce: string;
-    toWorkerId: number;
-}>;
 export type WorkerSendEvalResponse = CreateWorkerMessage<'EVAL_RESPONSE', {
-    response: any;
+    response: unknown;
     nonce: string;
 }>;
 export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
@@ -56,5 +52,5 @@ export type WorkerSendEval = CreateWorkerMessage<'EVAL', {
     nonce: string;
     toWorkerId: number;
 }>;
-export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerSendApiRequest | WorkerExecuteEval | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
+export type WorkerMessage = WorkerRequestConnect | WorkerReceivePayload | WorkerSendResultPayload | WorkerSendCacheRequest | WorkerSendShardInfo | WorkerSendInfo | WorkerReady | WorkerShardsConnected | WorkerSendApiRequest | WorkerSendEvalResponse | WorkerSendEval | WorkerStart;
 export {};

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

@@ -1,33 +1,25 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import type { GatewayPresenceUpdateData, GatewaySendPayload } from 'discord-api-types/v10';
+import type { GatewayPresenceUpdateData, GatewaySendPayload } from '../../types';
 import { type Worker as ClusterWorker } from 'node:cluster';
 import { ApiHandler, Logger } from '../..';
 import { type Adapter } from '../../cache';
 import { type MakePartial } from '../../common';
 import { ConnectQueue } from '../structures/timeout';
-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, (ClusterWorker | import('node:worker_threads').Worker) & {
+export declare class WorkerManager extends Map<number, (ClusterWorker | import('node:worker_threads').Worker | {
+    ready: boolean;
+}) & {
     ready?: boolean;
 }> {
-    options: Required<WorkerManagerOptions>;
+    options: MakePartial<Required<WorkerManagerOptions>, 'adapter'>;
     debugger?: Logger;
     connectQueue: ConnectQueue;
+    workerQueue: (() => void)[];
     cacheAdapter: Adapter;
     promises: Map<string, {
         resolve: (value: any) => void;
         timeout: NodeJS.Timeout;
     }>;
-    memberUpdateHandler: MemberUpdateHandler;
-    presenceUpdateHandler: PresenceUpdateHandler;
     rest: ApiHandler;
     constructor(options: MakePartial<WorkerManagerOptions, 'token' | 'intents' | 'info' | 'handlePayload'>);
     setCache(adapter: Adapter): void;
@@ -49,7 +41,9 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | import('
     prepareSpaces(): number[][];
     postMessage(id: number, body: any): void;
     prepareWorkers(shards: number[][]): Promise<void>;
-    createWorker(workerData: WorkerData): ClusterWorker | import("worker_threads").Worker;
+    createWorker(workerData: WorkerData): ClusterWorker | import("worker_threads").Worker | {
+        ready: boolean;
+    };
     spawn(workerId: number, shardId: number): void;
     handleWorkerMessage(message: WorkerMessage): Promise<void>;
     private generateNonce;
@@ -57,7 +51,7 @@ export declare class WorkerManager extends Map<number, (ClusterWorker | import('
     send(data: GatewaySendPayload, shardId: number): Promise<true>;
     getShardInfo(shardId: number): Promise<WorkerShardInfo>;
     getWorkerInfo(workerId: number): Promise<WorkerInfo>;
-    start(): Promise<void>;
+    start(): Promise<void | undefined>;
 }
 type CreateManagerMessage<T extends string, D extends object = {}> = {
     type: T;