@discordeno/gateway 19.0.0-next.85ea2d9 → 19.0.0-next.87f62d2

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+export * from './manager.js';
+export * from './Shard.js';
+export * from './types.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21hbmFnZXIuanMnXG5leHBvcnQgKiBmcm9tICcuL1NoYXJkLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcydcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWM7QUFDNUIsY0FBYyxhQUFZO0FBQzFCLGNBQWMsYUFBWSJ9

package/dist/esm/manager.js

@@ -0,0 +1,448 @@
+import { GatewayIntents, GatewayOpcodes } from '@discordeno/types';
+import { Collection, delay, logger } from '@discordeno/utils';
+import Shard from './Shard.js';
+import { ShardSocketCloseCodes } from './types.js';
+export function createGatewayManager(options) {
+    const connectionOptions = options.connection ?? {
+        url: 'wss://gateway.discord.gg',
+        shards: 1,
+        sessionStartLimit: {
+            maxConcurrency: 1,
+            remaining: 1000,
+            total: 1000,
+            resetAfter: 1000 * 60 * 60 * 24
+        }
+    };
+    const gateway = {
+        events: options.events ?? {},
+        compress: options.compress ?? false,
+        intents: options.intents ?? 0,
+        properties: {
+            os: options.properties?.os ?? process.platform,
+            browser: options.properties?.browser ?? 'Discordeno',
+            device: options.properties?.device ?? 'Discordeno'
+        },
+        token: options.token,
+        url: options.url ?? connectionOptions.url ?? 'wss://gateway.discord.gg',
+        version: options.version ?? 10,
+        connection: connectionOptions,
+        totalShards: options.totalShards ?? connectionOptions.shards ?? 1,
+        lastShardId: options.lastShardId ?? (options.totalShards ? options.totalShards - 1 : connectionOptions ? connectionOptions.shards - 1 : 0),
+        firstShardId: options.firstShardId ?? 0,
+        totalWorkers: options.totalWorkers ?? 4,
+        shardsPerWorker: options.shardsPerWorker ?? 25,
+        spawnShardDelay: options.spawnShardDelay ?? 5300,
+        preferSnakeCase: options.preferSnakeCase ?? false,
+        shards: new Map(),
+        buckets: new Map(),
+        cache: {
+            requestMembers: {
+                enabled: options.cache?.requestMembers?.enabled ?? false,
+                pending: new Collection()
+            }
+        },
+        logger: options.logger ?? logger,
+        resharding: {
+            enabled: true,
+            shardsFullPercentage: 80,
+            checkInterval: 28800000,
+            shards: new Collection(),
+            pendingShards: new Collection(),
+            async getSessionInfo () {
+                throw new Error('[Resharding] was enabled but no getSessionInfo handler was provided. Please set a handler like: gateway.resharding.getSessionInfo = async () => { // insert code here to fetch getSessionInfo from rest process. }');
+            },
+            async checkIfReshardingIsNeeded () {
+                logger.warn(`[Resharding] Checking if resharding is needed.`);
+                // Resharding is disabled.
+                if (!gateway.resharding.enabled) return {
+                    needed: false
+                };
+                logger.warn(`[Resharding] Resharding is enabled.`);
+                const sessionInfo = await gateway.resharding.getSessionInfo();
+                logger.warn(`[Resharding] Session info retrieved.`);
+                // Don't have enough identify limits to try resharding
+                if (sessionInfo.sessionStartLimit.remaining < sessionInfo.shards) return {
+                    needed: false,
+                    info: sessionInfo
+                };
+                logger.warn(`[Resharding] Able to reshard, checking whether necessary now.`);
+                // 2500 is the max amount of guilds a single shard can handle
+                // 1000 is the amount of guilds discord uses to determine how many shards to recommend.
+                // This algo helps check if your bot has grown enough to reshard.
+                const percentage = 2500 * sessionInfo.shards / (gateway.totalShards * 1000) * 100;
+                // Less than necessary% being used so do nothing
+                if (percentage < gateway.resharding.shardsFullPercentage) return {
+                    needed: false,
+                    info: sessionInfo
+                };
+                logger.warn(`[Resharding] Resharding is needed.`);
+                return {
+                    needed: true,
+                    info: sessionInfo
+                };
+            },
+            async reshard (info) {
+                logger.warn(`[Resharding] Starting the reshard process. Previous total shards. ${gateway.totalShards}`);
+                // Set values on gateway
+                gateway.totalShards = info.shards;
+                // Handles preparing mid sized bots for LBS
+                gateway.totalShards = gateway.calculateTotalShards();
+                // Set first shard id if provided in info
+                if (typeof info.firstShardId === 'number') gateway.firstShardId = info.firstShardId;
+                // Set last shard id if provided in info
+                if (typeof info.lastShardId === 'number') gateway.lastShardId = info.lastShardId;
+                logger.warn(`[Resharding] Starting the reshard process. New Total Shards. ${gateway.totalShards}`);
+                // Resetting buckets
+                gateway.buckets.clear();
+                // Refilling buckets with new values
+                gateway.prepareBuckets();
+                // SPREAD THIS OUT TO DIFFERENT WORKERS TO BEGIN STARTING UP
+                gateway.buckets.forEach(async (bucket, bucketId)=>{
+                    for (const worker of bucket.workers){
+                        for (const shardId of worker.queue){
+                            await gateway.resharding.tellWorkerToPrepare(worker.id, shardId, bucketId);
+                        }
+                    }
+                });
+            },
+            async tellWorkerToPrepare (workerId, shardId, bucketId) {
+                logger.warn(`[Resharding] Telling worker to prepare. Worker: ${workerId} | Shard: ${shardId} | Bucket: ${bucketId}`);
+                const shard = new Shard({
+                    id: shardId,
+                    connection: {
+                        compress: gateway.compress,
+                        intents: gateway.intents,
+                        properties: gateway.properties,
+                        token: gateway.token,
+                        totalShards: gateway.totalShards,
+                        url: gateway.url,
+                        version: gateway.version
+                    },
+                    // Ignore events until we are ready
+                    events: {
+                        async message (_shard, payload) {
+                            if (payload.t === 'READY') {
+                                await gateway.resharding.updateGuildsShardId(payload.d.guilds.map((g)=>g.id), shardId);
+                            }
+                        }
+                    },
+                    requestIdentify: async ()=>{
+                        await gateway.identify(shardId);
+                    },
+                    shardIsReady: async ()=>{
+                        logger.debug(`[Shard] Shard #${shardId} is ready`);
+                        await delay(gateway.spawnShardDelay);
+                        logger.debug(`[Shard] Resolving shard identify request`);
+                        gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency).identifyRequests.shift()?.();
+                    }
+                });
+                if (gateway.preferSnakeCase) {
+                    shard.forwardToBot = async (payload)=>{
+                        shard.events?.message?.(shard, payload);
+                    };
+                }
+                gateway.resharding.shards.set(shardId, shard);
+                const bucket = gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency);
+                if (!bucket) return;
+                return await new Promise((resolve)=>{
+                    // Mark that we are making an identify request so another is not made.
+                    bucket.identifyRequests.push(resolve);
+                    logger.debug(`[Gateway] identifying shard #(${shardId}).`);
+                    // This will trigger identify and when READY is received it will resolve the above request.
+                    shard?.identify().then(async ()=>{
+                        // Tell the manager that this shard is online
+                        return await gateway.resharding.shardIsPending(shard);
+                    });
+                });
+            },
+            async updateGuildsShardId (guildIds, shardId) {
+                logger.debug(`[Resharding] Updating the following guild ids shard to #${shardId}: ${guildIds.join(', ')}. Override this function to update your cache if you need to.`);
+            },
+            async shardIsPending (shard) {
+                // Save this in pending at the moment, until all shards are online
+                gateway.resharding.pendingShards.set(shard.id, shard);
+                logger.warn(`[Resharding] Shard #${shard.id} is now pending`);
+                // Check if all shards are now online.
+                if (gateway.lastShardId - gateway.firstShardId + 1 > gateway.resharding.pendingShards.size) return;
+                logger.warn(`[Resharding] All shards are now online.`);
+                // New shards start processing events
+                for (const shard of gateway.resharding.pendingShards.values()){
+                    for(const event in options.events){
+                        // @ts-expect-error fixing this seems complex and doesnt seem worth it, feel free to fix if you wish
+                        shard.events[event] = options.events[event];
+                    }
+                }
+                // Old shards stop processing events
+                for (const shard of gateway.shards.values()){
+                    const oldHandler = shard.events.message;
+                    // Change with spread operator to not affect new shards, as changing anything on shard.events will directly change options.events, which changes new shards' events
+                    shard.events = {
+                        ...shard.events,
+                        message: async function(_, message) {
+                            // Member checks need to continue but others can stop
+                            if (message.t !== 'GUILD_MEMBERS_CHUNK') return;
+                            // Process only the chunking events
+                            oldHandler?.(shard, message);
+                        }
+                    };
+                }
+                logger.warn(`[Resharding] Shutting down old shards.`);
+                // Close old shards
+                await gateway.shutdown(ShardSocketCloseCodes.Resharded, 'Resharded!', false);
+                logger.warn(`[Resharding] Completed.`);
+                // Replace old shards
+                gateway.shards = gateway.resharding.shards;
+            }
+        },
+        calculateTotalShards () {
+            // Bots under 100k servers do not have access to LBS.
+            if (gateway.totalShards < 100) {
+                gateway.logger.debug(`[Gateway] Calculating total shards: ${gateway.totalShards}`);
+                return gateway.totalShards;
+            }
+            gateway.logger.debug(`[Gateway] Calculating total shards`, gateway.totalShards, gateway.connection.sessionStartLimit.maxConcurrency);
+            // Calculate a multiple of `maxConcurrency` which can be used to connect to the gateway.
+            return Math.ceil(gateway.totalShards / // If `maxConcurrency` is 1, we can safely use 16 to get `totalShards` to be in a multiple of 16 so that we can prepare bots with 100k servers for LBS.
+            (gateway.connection.sessionStartLimit.maxConcurrency === 1 ? 16 : gateway.connection.sessionStartLimit.maxConcurrency)) * (gateway.connection.sessionStartLimit.maxConcurrency === 1 ? 16 : gateway.connection.sessionStartLimit.maxConcurrency);
+        },
+        calculateWorkerId (shardId) {
+            const workerId = Math.min(shardId % gateway.shardsPerWorker, gateway.totalWorkers - 1);
+            gateway.logger.debug(`[Gateway] Calculating workerId: Shard: ${shardId} -> Worker: ${workerId} -> Per Worker: ${gateway.shardsPerWorker} -> Total: ${gateway.totalWorkers}`);
+            return workerId;
+        },
+        prepareBuckets () {
+            for(let i = 0; i < gateway.connection.sessionStartLimit.maxConcurrency; ++i){
+                gateway.logger.debug(`[Gateway] Preparing buckets for concurrency: ${i}`);
+                gateway.buckets.set(i, {
+                    workers: [],
+                    identifyRequests: []
+                });
+            }
+            // ORGANIZE ALL SHARDS INTO THEIR OWN BUCKETS
+            for(let shardId = gateway.firstShardId; shardId <= gateway.lastShardId; ++shardId){
+                gateway.logger.debug(`[Gateway] Preparing buckets for shard: ${shardId}`);
+                if (shardId >= gateway.totalShards) {
+                    throw new Error(`Shard (id: ${shardId}) is bigger or equal to the used amount of used shards which is ${gateway.totalShards}`);
+                }
+                const bucketId = shardId % gateway.connection.sessionStartLimit.maxConcurrency;
+                const bucket = gateway.buckets.get(bucketId);
+                if (!bucket) {
+                    throw new Error(`Shard (id: ${shardId}) got assigned to an illegal bucket id: ${bucketId}, expected a bucket id between 0 and ${gateway.connection.sessionStartLimit.maxConcurrency - 1}`);
+                }
+                // FIND A QUEUE IN THIS BUCKET THAT HAS SPACE
+                // const worker = bucket.workers.find((w) => w.queue.length < gateway.shardsPerWorker);
+                const workerId = gateway.calculateWorkerId(shardId);
+                const worker = bucket.workers.find((w)=>w.id === workerId);
+                if (worker) {
+                    // IF THE QUEUE HAS SPACE JUST ADD IT TO THIS QUEUE
+                    worker.queue.push(shardId);
+                } else {
+                    bucket.workers.push({
+                        id: workerId,
+                        queue: [
+                            shardId
+                        ]
+                    });
+                }
+            }
+            for (const bucket of gateway.buckets.values()){
+                for (const worker of bucket.workers.values()){
+                    worker.queue = worker.queue.sort((a, b)=>a - b);
+                }
+            }
+        },
+        async spawnShards () {
+            // PREPARES ALL SHARDS IN SPECIFIC BUCKETS
+            gateway.prepareBuckets();
+            // Prefer concurrency of forEach instead of forof
+            await Promise.all([
+                ...gateway.buckets.entries()
+            ].map(async ([bucketId, bucket])=>{
+                for (const worker of bucket.workers){
+                    for (const shardId of worker.queue){
+                        await gateway.tellWorkerToIdentify(worker.id, shardId, bucketId);
+                    }
+                }
+            }));
+            // Check and reshard automatically if auto resharding is enabled.
+            if (gateway.resharding.enabled && gateway.resharding.checkInterval !== -1) {
+                gateway.resharding.checkIntervalId = setInterval(async ()=>{
+                    const reshardingInfo = await gateway.resharding.checkIfReshardingIsNeeded();
+                    if (reshardingInfo.needed && reshardingInfo.info) await gateway.resharding.reshard(reshardingInfo.info);
+                }, gateway.resharding.checkInterval);
+            }
+        },
+        async shutdown (code, reason, clearReshardingInterval = true) {
+            gateway.shards.forEach((shard)=>shard.close(code, reason));
+            if (clearReshardingInterval && gateway.resharding.checkIntervalId) clearInterval(gateway.resharding.checkIntervalId);
+            await delay(5000);
+        },
+        async sendPayload (shardId, payload) {
+            const shard = gateway.shards.get(shardId);
+            if (!shard) {
+                throw new Error(`Shard (id: ${shardId} not found`);
+            }
+            await shard.send(payload);
+        },
+        async tellWorkerToIdentify (workerId, shardId, bucketId) {
+            gateway.logger.debug(`[Gateway] tell worker to identify (${workerId}, ${shardId}, ${bucketId})`);
+            await gateway.identify(shardId);
+        },
+        async identify (shardId) {
+            let shard = this.shards.get(shardId);
+            gateway.logger.debug(`[Gateway] identifying ${shard ? 'existing' : 'new'} shard (${shardId})`);
+            if (!shard) {
+                shard = new Shard({
+                    id: shardId,
+                    connection: {
+                        compress: this.compress,
+                        intents: this.intents,
+                        properties: this.properties,
+                        token: this.token,
+                        totalShards: this.totalShards,
+                        url: this.url,
+                        version: this.version
+                    },
+                    events: options.events ?? {},
+                    logger: this.logger,
+                    requestIdentify: async ()=>{
+                        await gateway.identify(shardId);
+                    },
+                    shardIsReady: async ()=>{
+                        gateway.logger.debug(`[Shard] Shard #${shardId} is ready`);
+                        await delay(gateway.spawnShardDelay);
+                        gateway.logger.debug(`[Shard] Resolving shard identify request`);
+                        gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency).identifyRequests.shift()?.();
+                    }
+                });
+                if (this.preferSnakeCase) {
+                    shard.forwardToBot = async (payload)=>{
+                        shard.events.message?.(shard, payload);
+                    };
+                }
+                this.shards.set(shardId, shard);
+            }
+            const bucket = gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency);
+            if (!bucket) return;
+            return await new Promise((resolve)=>{
+                // Mark that we are making an identify request so another is not made.
+                bucket.identifyRequests.push(resolve);
+                gateway.logger.debug(`[Gateway] identifying shard #(${shardId}).`);
+                // This will trigger identify and when READY is received it will resolve the above request.
+                shard?.identify();
+            });
+        },
+        async kill (shardId) {
+            const shard = this.shards.get(shardId);
+            if (!shard) {
+                return gateway.logger.debug(`[Gateway] kill shard but not found (${shardId})`);
+            }
+            gateway.logger.debug(`[Gateway] kill shard (${shardId})`);
+            this.shards.delete(shardId);
+            await shard.shutdown();
+        },
+        async requestIdentify (_shardId) {
+            gateway.logger.debug(`[Gateway] requesting identify`);
+        // const bucket = gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency)
+        // if (!bucket) return
+        // return await new Promise((resolve) => {
+        //   bucket.identifyRequests.push(resolve)
+        // })
+        },
+        // Helpers methods below this
+        calculateShardId (guildId, totalShards) {
+            // If none is provided, use the total shards number from gateway object.
+            if (!totalShards) totalShards = gateway.totalShards;
+            // If it is only 1 shard, it will always be shard id 0
+            if (totalShards === 1) {
+                gateway.logger.debug(`[Gateway] calculateShardId (1 shard)`);
+                return 0;
+            }
+            gateway.logger.debug(`[Gateway] calculateShardId (guildId: ${guildId}, totalShards: ${totalShards})`);
+            return Number((BigInt(guildId) >> 22n) % BigInt(totalShards));
+        },
+        async joinVoiceChannel (guildId, channelId, options) {
+            const shardId = gateway.calculateShardId(guildId);
+            gateway.logger.debug(`[Gateway] joinVoiceChannel guildId: ${guildId} channelId: ${channelId}`);
+            await gateway.sendPayload(shardId, {
+                op: GatewayOpcodes.VoiceStateUpdate,
+                d: {
+                    guild_id: guildId.toString(),
+                    channel_id: channelId.toString(),
+                    self_mute: options?.selfMute ?? false,
+                    self_deaf: options?.selfDeaf ?? true
+                }
+            });
+        },
+        async editBotStatus (data) {
+            gateway.logger.debug(`[Gateway] editBotStatus data: ${JSON.stringify(data)}`);
+            await Promise.all([
+                ...gateway.shards.values()
+            ].map(async (shard)=>{
+                gateway.editShardStatus(shard.id, data);
+            }));
+        },
+        async editShardStatus (shardId, data) {
+            gateway.logger.debug(`[Gateway] editShardStatus shardId: ${shardId} -> data: ${JSON.stringify(data)}`);
+            await gateway.sendPayload(shardId, {
+                op: GatewayOpcodes.PresenceUpdate,
+                d: {
+                    since: null,
+                    afk: false,
+                    activities: data.activities,
+                    status: data.status
+                }
+            });
+        },
+        async requestMembers (guildId, options) {
+            const shardId = gateway.calculateShardId(guildId);
+            if (gateway.intents && (!options?.limit || options.limit > 1) && !(gateway.intents & GatewayIntents.GuildMembers)) throw new Error('Cannot fetch more then 1 member without the GUILD_MEMBERS intent');
+            gateway.logger.debug(`[Gateway] requestMembers guildId: ${guildId} -> data: ${JSON.stringify(options)}`);
+            if (options?.userIds?.length) {
+                gateway.logger.debug(`[Gateway] requestMembers guildId: ${guildId} -> setting user limit based on userIds length: ${options.userIds.length}`);
+                options.limit = options.userIds.length;
+            }
+            const members = !gateway.cache.requestMembers.enabled || !options?.nonce ? [] : new Promise((resolve, reject)=>{
+                // Should never happen.
+                if (!gateway.cache.requestMembers.enabled || !options?.nonce) {
+                    reject(new Error("Can't request the members without the nonce or with the feature disabled."));
+                    return;
+                }
+                gateway.cache.requestMembers.pending.set(options.nonce, {
+                    nonce: options.nonce,
+                    resolve,
+                    members: []
+                });
+            });
+            await gateway.sendPayload(shardId, {
+                op: GatewayOpcodes.RequestGuildMembers,
+                d: {
+                    guild_id: guildId.toString(),
+                    // If a query is provided use it, OR if a limit is NOT provided use ""
+                    query: options?.query ?? (options?.limit ? undefined : ''),
+                    limit: options?.limit ?? 0,
+                    presences: options?.presences ?? false,
+                    user_ids: options?.userIds?.map((id)=>id.toString()),
+                    nonce: options?.nonce
+                }
+            });
+            return await members;
+        },
+        async leaveVoiceChannel (guildId) {
+            const shardId = gateway.calculateShardId(guildId);
+            gateway.logger.debug(`[Gateway] leaveVoiceChannel guildId: ${guildId} Shard ${shardId}`);
+            await gateway.sendPayload(shardId, {
+                op: GatewayOpcodes.VoiceStateUpdate,
+                d: {
+                    guild_id: guildId.toString(),
+                    channel_id: null,
+                    self_mute: false,
+                    self_deaf: false
+                }
+            });
+        }
+    };
+    return gateway;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/manager.ts"],"sourcesContent":["import {\n  type AtLeastOne,\n  type BigString,\n  type Camelize,\n  type DiscordGetGatewayBot,\n  type DiscordMemberWithUser,\n  type DiscordReady,\n  GatewayIntents,\n  GatewayOpcodes,\n  type RequestGuildMembers,\n} from '@discordeno/types'\nimport { Collection, delay, logger } from '@discordeno/utils'\nimport Shard from './Shard.js'\nimport { type ShardEvents, ShardSocketCloseCodes, type ShardSocketRequest, type StatusUpdate, type UpdateVoiceState } from './types.js'\n\nexport function createGatewayManager(options: CreateGatewayManagerOptions): GatewayManager {\n  const connectionOptions = options.connection ?? {\n    url: 'wss://gateway.discord.gg',\n    shards: 1,\n    sessionStartLimit: {\n      maxConcurrency: 1,\n      remaining: 1000,\n      total: 1000,\n      resetAfter: 1000 * 60 * 60 * 24,\n    },\n  }\n\n  const gateway: GatewayManager = {\n    events: options.events ?? {},\n    compress: options.compress ?? false,\n    intents: options.intents ?? 0,\n    properties: {\n      os: options.properties?.os ?? process.platform,\n      browser: options.properties?.browser ?? 'Discordeno',\n      device: options.properties?.device ?? 'Discordeno',\n    },\n    token: options.token,\n    url: options.url ?? connectionOptions.url ?? 'wss://gateway.discord.gg',\n    version: options.version ?? 10,\n    connection: connectionOptions,\n    totalShards: options.totalShards ?? connectionOptions.shards ?? 1,\n    lastShardId: options.lastShardId ?? (options.totalShards ? options.totalShards - 1 : connectionOptions ? connectionOptions.shards - 1 : 0),\n    firstShardId: options.firstShardId ?? 0,\n    totalWorkers: options.totalWorkers ?? 4,\n    shardsPerWorker: options.shardsPerWorker ?? 25,\n    spawnShardDelay: options.spawnShardDelay ?? 5300,\n    preferSnakeCase: options.preferSnakeCase ?? false,\n    shards: new Map(),\n    buckets: new Map(),\n    cache: {\n      requestMembers: {\n        enabled: options.cache?.requestMembers?.enabled ?? false,\n        pending: new Collection(),\n      },\n    },\n    logger: options.logger ?? logger,\n    resharding: {\n      enabled: true,\n      shardsFullPercentage: 80,\n      checkInterval: 28800000,\n      shards: new Collection(),\n      pendingShards: new Collection(),\n      async getSessionInfo() {\n        throw new Error(\n          '[Resharding] was enabled but no getSessionInfo handler was provided. Please set a handler like: gateway.resharding.getSessionInfo = async () => { // insert code here to fetch getSessionInfo from rest process. }',\n        )\n      },\n      async checkIfReshardingIsNeeded() {\n        logger.warn(`[Resharding] Checking if resharding is needed.`)\n        // Resharding is disabled.\n        if (!gateway.resharding.enabled) return { needed: false }\n        logger.warn(`[Resharding] Resharding is enabled.`)\n\n        const sessionInfo = await gateway.resharding.getSessionInfo()\n        logger.warn(`[Resharding] Session info retrieved.`)\n        // Don't have enough identify limits to try resharding\n        if (sessionInfo.sessionStartLimit.remaining < sessionInfo.shards) return { needed: false, info: sessionInfo }\n        logger.warn(`[Resharding] Able to reshard, checking whether necessary now.`)\n\n        // 2500 is the max amount of guilds a single shard can handle\n        // 1000 is the amount of guilds discord uses to determine how many shards to recommend.\n        // This algo helps check if your bot has grown enough to reshard.\n        const percentage = ((2500 * sessionInfo.shards) / (gateway.totalShards * 1000)) * 100\n        // Less than necessary% being used so do nothing\n        if (percentage < gateway.resharding.shardsFullPercentage) return { needed: false, info: sessionInfo }\n        logger.warn(`[Resharding] Resharding is needed.`)\n\n        return { needed: true, info: sessionInfo }\n      },\n      async reshard(info) {\n        logger.warn(`[Resharding] Starting the reshard process. Previous total shards. ${gateway.totalShards}`)\n        // Set values on gateway\n        gateway.totalShards = info.shards\n        // Handles preparing mid sized bots for LBS\n        gateway.totalShards = gateway.calculateTotalShards()\n        // Set first shard id if provided in info\n        if (typeof info.firstShardId === 'number') gateway.firstShardId = info.firstShardId\n        // Set last shard id if provided in info\n        if (typeof info.lastShardId === 'number') gateway.lastShardId = info.lastShardId\n        logger.warn(`[Resharding] Starting the reshard process. New Total Shards. ${gateway.totalShards}`)\n\n        // Resetting buckets\n        gateway.buckets.clear()\n        // Refilling buckets with new values\n        gateway.prepareBuckets()\n\n        // SPREAD THIS OUT TO DIFFERENT WORKERS TO BEGIN STARTING UP\n        gateway.buckets.forEach(async (bucket, bucketId) => {\n          for (const worker of bucket.workers) {\n            for (const shardId of worker.queue) {\n              await gateway.resharding.tellWorkerToPrepare(worker.id, shardId, bucketId)\n            }\n          }\n        })\n      },\n      async tellWorkerToPrepare(workerId, shardId, bucketId) {\n        logger.warn(`[Resharding] Telling worker to prepare. Worker: ${workerId} | Shard: ${shardId} | Bucket: ${bucketId}`)\n        const shard = new Shard({\n          id: shardId,\n          connection: {\n            compress: gateway.compress,\n            intents: gateway.intents,\n            properties: gateway.properties,\n            token: gateway.token,\n            totalShards: gateway.totalShards,\n            url: gateway.url,\n            version: gateway.version,\n          },\n          // Ignore events until we are ready\n          events: {\n            async message(_shard, payload) {\n              if (payload.t === 'READY') {\n                await gateway.resharding.updateGuildsShardId(\n                  (payload.d as DiscordReady).guilds.map((g) => g.id),\n                  shardId,\n                )\n              }\n            },\n          },\n          requestIdentify: async () => {\n            await gateway.identify(shardId)\n          },\n          shardIsReady: async () => {\n            logger.debug(`[Shard] Shard #${shardId} is ready`)\n            await delay(gateway.spawnShardDelay)\n            logger.debug(`[Shard] Resolving shard identify request`)\n            gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency)!.identifyRequests.shift()?.()\n          },\n        })\n\n        if (gateway.preferSnakeCase) {\n          shard.forwardToBot = async (payload) => {\n            shard.events?.message?.(shard, payload)\n          }\n        }\n\n        gateway.resharding.shards.set(shardId, shard)\n\n        const bucket = gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency)\n        if (!bucket) return\n\n        return await new Promise((resolve) => {\n          // Mark that we are making an identify request so another is not made.\n          bucket.identifyRequests.push(resolve)\n          logger.debug(`[Gateway] identifying shard #(${shardId}).`)\n          // This will trigger identify and when READY is received it will resolve the above request.\n          shard?.identify().then(async () => {\n            // Tell the manager that this shard is online\n            return await gateway.resharding.shardIsPending(shard)\n          })\n        })\n      },\n      async updateGuildsShardId(guildIds, shardId) {\n        logger.debug(\n          `[Resharding] Updating the following guild ids shard to #${shardId}: ${guildIds.join(', ')}. Override this function to update your cache if you need to.`,\n        )\n      },\n      async shardIsPending(shard) {\n        // Save this in pending at the moment, until all shards are online\n        gateway.resharding.pendingShards.set(shard.id, shard)\n        logger.warn(`[Resharding] Shard #${shard.id} is now pending`)\n        // Check if all shards are now online.\n        if (gateway.lastShardId - gateway.firstShardId + 1 > gateway.resharding.pendingShards.size) return\n        logger.warn(`[Resharding] All shards are now online.`)\n\n        // New shards start processing events\n        for (const shard of gateway.resharding.pendingShards.values()) {\n          for (const event in options.events) {\n            // @ts-expect-error fixing this seems complex and doesnt seem worth it, feel free to fix if you wish\n            shard.events[event] = options.events[event]\n          }\n        }\n\n        // Old shards stop processing events\n        for (const shard of gateway.shards.values()) {\n          const oldHandler = shard.events.message\n\n          // Change with spread operator to not affect new shards, as changing anything on shard.events will directly change options.events, which changes new shards' events\n          shard.events = {\n            ...shard.events,\n            message: async function (_, message) {\n              // Member checks need to continue but others can stop\n              if (message.t !== 'GUILD_MEMBERS_CHUNK') return\n              // Process only the chunking events\n              oldHandler?.(shard, message)\n            },\n          }\n        }\n\n        logger.warn(`[Resharding] Shutting down old shards.`)\n        // Close old shards\n        await gateway.shutdown(ShardSocketCloseCodes.Resharded, 'Resharded!', false)\n        logger.warn(`[Resharding] Completed.`)\n\n        // Replace old shards\n        gateway.shards = gateway.resharding.shards\n      },\n    },\n\n    calculateTotalShards() {\n      // Bots under 100k servers do not have access to LBS.\n      if (gateway.totalShards < 100) {\n        gateway.logger.debug(`[Gateway] Calculating total shards: ${gateway.totalShards}`)\n        return gateway.totalShards\n      }\n\n      gateway.logger.debug(`[Gateway] Calculating total shards`, gateway.totalShards, gateway.connection.sessionStartLimit.maxConcurrency)\n      // Calculate a multiple of `maxConcurrency` which can be used to connect to the gateway.\n      return (\n        Math.ceil(\n          gateway.totalShards /\n            // If `maxConcurrency` is 1, we can safely use 16 to get `totalShards` to be in a multiple of 16 so that we can prepare bots with 100k servers for LBS.\n            (gateway.connection.sessionStartLimit.maxConcurrency === 1 ? 16 : gateway.connection.sessionStartLimit.maxConcurrency),\n        ) * (gateway.connection.sessionStartLimit.maxConcurrency === 1 ? 16 : gateway.connection.sessionStartLimit.maxConcurrency)\n      )\n    },\n    calculateWorkerId(shardId) {\n      const workerId = Math.min(shardId % gateway.shardsPerWorker, gateway.totalWorkers - 1)\n      gateway.logger.debug(\n        `[Gateway] Calculating workerId: Shard: ${shardId} -> Worker: ${workerId} -> Per Worker: ${gateway.shardsPerWorker} -> Total: ${gateway.totalWorkers}`,\n      )\n      return workerId\n    },\n    prepareBuckets() {\n      for (let i = 0; i < gateway.connection.sessionStartLimit.maxConcurrency; ++i) {\n        gateway.logger.debug(`[Gateway] Preparing buckets for concurrency: ${i}`)\n        gateway.buckets.set(i, {\n          workers: [],\n          identifyRequests: [],\n        })\n      }\n\n      // ORGANIZE ALL SHARDS INTO THEIR OWN BUCKETS\n      for (let shardId = gateway.firstShardId; shardId <= gateway.lastShardId; ++shardId) {\n        gateway.logger.debug(`[Gateway] Preparing buckets for shard: ${shardId}`)\n        if (shardId >= gateway.totalShards) {\n          throw new Error(`Shard (id: ${shardId}) is bigger or equal to the used amount of used shards which is ${gateway.totalShards}`)\n        }\n\n        const bucketId = shardId % gateway.connection.sessionStartLimit.maxConcurrency\n        const bucket = gateway.buckets.get(bucketId)\n        if (!bucket) {\n          throw new Error(\n            `Shard (id: ${shardId}) got assigned to an illegal bucket id: ${bucketId}, expected a bucket id between 0 and ${\n              gateway.connection.sessionStartLimit.maxConcurrency - 1\n            }`,\n          )\n        }\n\n        // FIND A QUEUE IN THIS BUCKET THAT HAS SPACE\n        // const worker = bucket.workers.find((w) => w.queue.length < gateway.shardsPerWorker);\n        const workerId = gateway.calculateWorkerId(shardId)\n        const worker = bucket.workers.find((w) => w.id === workerId)\n        if (worker) {\n          // IF THE QUEUE HAS SPACE JUST ADD IT TO THIS QUEUE\n          worker.queue.push(shardId)\n        } else {\n          bucket.workers.push({ id: workerId, queue: [shardId] })\n        }\n      }\n\n      for (const bucket of gateway.buckets.values()) {\n        for (const worker of bucket.workers.values()) {\n          worker.queue = worker.queue.sort((a, b) => a - b)\n        }\n      }\n    },\n    async spawnShards() {\n      // PREPARES ALL SHARDS IN SPECIFIC BUCKETS\n      gateway.prepareBuckets()\n\n      // Prefer concurrency of forEach instead of forof\n      await Promise.all(\n        [...gateway.buckets.entries()].map(async ([bucketId, bucket]) => {\n          for (const worker of bucket.workers) {\n            for (const shardId of worker.queue) {\n              await gateway.tellWorkerToIdentify(worker.id, shardId, bucketId)\n            }\n          }\n        }),\n      )\n\n      // Check and reshard automatically if auto resharding is enabled.\n      if (gateway.resharding.enabled && gateway.resharding.checkInterval !== -1) {\n        gateway.resharding.checkIntervalId = setInterval(async () => {\n          const reshardingInfo = await gateway.resharding.checkIfReshardingIsNeeded()\n\n          if (reshardingInfo.needed && reshardingInfo.info) await gateway.resharding.reshard(reshardingInfo.info)\n        }, gateway.resharding.checkInterval)\n      }\n    },\n    async shutdown(code, reason, clearReshardingInterval = true) {\n      gateway.shards.forEach((shard) => shard.close(code, reason))\n\n      if (clearReshardingInterval && gateway.resharding.checkIntervalId) clearInterval(gateway.resharding.checkIntervalId)\n\n      await delay(5000)\n    },\n    async sendPayload(shardId, payload) {\n      const shard = gateway.shards.get(shardId)\n\n      if (!shard) {\n        throw new Error(`Shard (id: ${shardId} not found`)\n      }\n\n      await shard.send(payload)\n    },\n    async tellWorkerToIdentify(workerId, shardId, bucketId) {\n      gateway.logger.debug(`[Gateway] tell worker to identify (${workerId}, ${shardId}, ${bucketId})`)\n      await gateway.identify(shardId)\n    },\n    async identify(shardId: number) {\n      let shard = this.shards.get(shardId)\n      gateway.logger.debug(`[Gateway] identifying ${shard ? 'existing' : 'new'} shard (${shardId})`)\n\n      if (!shard) {\n        shard = new Shard({\n          id: shardId,\n          connection: {\n            compress: this.compress,\n            intents: this.intents,\n            properties: this.properties,\n            token: this.token,\n            totalShards: this.totalShards,\n            url: this.url,\n            version: this.version,\n          },\n          events: options.events ?? {},\n          logger: this.logger,\n          requestIdentify: async () => {\n            await gateway.identify(shardId)\n          },\n          shardIsReady: async () => {\n            gateway.logger.debug(`[Shard] Shard #${shardId} is ready`)\n            await delay(gateway.spawnShardDelay)\n            gateway.logger.debug(`[Shard] Resolving shard identify request`)\n            gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency)!.identifyRequests.shift()?.()\n          },\n        })\n\n        if (this.preferSnakeCase) {\n          shard.forwardToBot = async (payload) => {\n            shard!.events.message?.(shard!, payload)\n          }\n        }\n\n        this.shards.set(shardId, shard)\n      }\n\n      const bucket = gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency)\n      if (!bucket) return\n\n      return await new Promise((resolve) => {\n        // Mark that we are making an identify request so another is not made.\n        bucket.identifyRequests.push(resolve)\n        gateway.logger.debug(`[Gateway] identifying shard #(${shardId}).`)\n        // This will trigger identify and when READY is received it will resolve the above request.\n        shard?.identify()\n      })\n    },\n    async kill(shardId: number) {\n      const shard = this.shards.get(shardId)\n      if (!shard) {\n        return gateway.logger.debug(`[Gateway] kill shard but not found (${shardId})`)\n      }\n\n      gateway.logger.debug(`[Gateway] kill shard (${shardId})`)\n      this.shards.delete(shardId)\n      await shard.shutdown()\n    },\n    async requestIdentify(_shardId: number) {\n      gateway.logger.debug(`[Gateway] requesting identify`)\n      // const bucket = gateway.buckets.get(shardId % gateway.connection.sessionStartLimit.maxConcurrency)\n      // if (!bucket) return\n\n      // return await new Promise((resolve) => {\n      //   bucket.identifyRequests.push(resolve)\n      // })\n    },\n\n    // Helpers methods below this\n\n    calculateShardId(guildId, totalShards) {\n      // If none is provided, use the total shards number from gateway object.\n      if (!totalShards) totalShards = gateway.totalShards\n      // If it is only 1 shard, it will always be shard id 0\n      if (totalShards === 1) {\n        gateway.logger.debug(`[Gateway] calculateShardId (1 shard)`)\n        return 0\n      }\n\n      gateway.logger.debug(`[Gateway] calculateShardId (guildId: ${guildId}, totalShards: ${totalShards})`)\n      return Number((BigInt(guildId) >> 22n) % BigInt(totalShards))\n    },\n\n    async joinVoiceChannel(guildId, channelId, options) {\n      const shardId = gateway.calculateShardId(guildId)\n\n      gateway.logger.debug(`[Gateway] joinVoiceChannel guildId: ${guildId} channelId: ${channelId}`)\n\n      await gateway.sendPayload(shardId, {\n        op: GatewayOpcodes.VoiceStateUpdate,\n        d: {\n          guild_id: guildId.toString(),\n          channel_id: channelId.toString(),\n          self_mute: options?.selfMute ?? false,\n          self_deaf: options?.selfDeaf ?? true,\n        },\n      })\n    },\n\n    async editBotStatus(data) {\n      gateway.logger.debug(`[Gateway] editBotStatus data: ${JSON.stringify(data)}`)\n\n      await Promise.all(\n        [...gateway.shards.values()].map(async (shard) => {\n          gateway.editShardStatus(shard.id, data)\n        }),\n      )\n    },\n\n    async editShardStatus(shardId, data) {\n      gateway.logger.debug(`[Gateway] editShardStatus shardId: ${shardId} -> data: ${JSON.stringify(data)}`)\n\n      await gateway.sendPayload(shardId, {\n        op: GatewayOpcodes.PresenceUpdate,\n        d: {\n          since: null,\n          afk: false,\n          activities: data.activities,\n          status: data.status,\n        },\n      })\n    },\n\n    async requestMembers(guildId, options) {\n      const shardId = gateway.calculateShardId(guildId)\n\n      if (gateway.intents && (!options?.limit || options.limit > 1) && !(gateway.intents & GatewayIntents.GuildMembers))\n        throw new Error('Cannot fetch more then 1 member without the GUILD_MEMBERS intent')\n\n      gateway.logger.debug(`[Gateway] requestMembers guildId: ${guildId} -> data: ${JSON.stringify(options)}`)\n\n      if (options?.userIds?.length) {\n        gateway.logger.debug(`[Gateway] requestMembers guildId: ${guildId} -> setting user limit based on userIds length: ${options.userIds.length}`)\n\n        options.limit = options.userIds.length\n      }\n\n      const members =\n        !gateway.cache.requestMembers.enabled || !options?.nonce\n          ? []\n          : new Promise<Camelize<DiscordMemberWithUser[]>>((resolve, reject) => {\n              // Should never happen.\n              if (!gateway.cache.requestMembers.enabled || !options?.nonce) {\n                reject(new Error(\"Can't request the members without the nonce or with the feature disabled.\"))\n                return\n              }\n\n              gateway.cache.requestMembers.pending.set(options.nonce, {\n                nonce: options.nonce,\n                resolve,\n                members: [],\n              })\n            })\n\n      await gateway.sendPayload(shardId, {\n        op: GatewayOpcodes.RequestGuildMembers,\n        d: {\n          guild_id: guildId.toString(),\n          // If a query is provided use it, OR if a limit is NOT provided use \"\"\n          query: options?.query ?? (options?.limit ? undefined : ''),\n          limit: options?.limit ?? 0,\n          presences: options?.presences ?? false,\n          user_ids: options?.userIds?.map((id) => id.toString()),\n          nonce: options?.nonce,\n        },\n      })\n\n      return await members\n    },\n\n    async leaveVoiceChannel(guildId) {\n      const shardId = gateway.calculateShardId(guildId)\n\n      gateway.logger.debug(`[Gateway] leaveVoiceChannel guildId: ${guildId} Shard ${shardId}`)\n\n      await gateway.sendPayload(shardId, {\n        op: GatewayOpcodes.VoiceStateUpdate,\n        d: {\n          guild_id: guildId.toString(),\n          channel_id: null,\n          self_mute: false,\n          self_deaf: false,\n        },\n      })\n    },\n  }\n\n  return gateway\n}\n\nexport interface CreateGatewayManagerOptions {\n  /**\n   * Id of the first Shard which should get controlled by this manager.\n   * @default 0\n   */\n  firstShardId?: number\n  /**\n   * Id of the last Shard which should get controlled by this manager.\n   * @default 0\n   */\n  lastShardId?: number\n  /**\n   * Delay in milliseconds to wait before spawning next shard. OPTIMAL IS ABOVE 5100. YOU DON'T WANT TO HIT THE RATE LIMIT!!!\n   * @default 5300\n   */\n  spawnShardDelay?: number\n  /**\n   * Whether to send the discord packets in snake case form.\n   * @default false\n   */\n  preferSnakeCase?: boolean\n  /**\n   * Total amount of shards your bot uses. Useful for zero-downtime updates or resharding.\n   * @default 1\n   */\n  totalShards?: number\n  /**\n   * The amount of shards to load per worker.\n   * @default 25\n   */\n  shardsPerWorker?: number\n  /**\n   * The total amount of workers to use for your bot.\n   * @default 4\n   */\n  totalWorkers?: number\n  /** Important data which is used by the manager to connect shards to the gateway. */\n  connection?: Camelize<DiscordGetGatewayBot>\n  /** Whether incoming payloads are compressed using zlib.\n   *\n   * @default false\n   */\n  compress?: boolean\n  /** The calculated intent value of the events which the shard should receive.\n   *\n   * @default 0\n   */\n  intents?: number\n  /** Identify properties to use */\n  properties?: {\n    /** Operating system the shard runs on.\n     *\n     * @default \"darwin\" | \"linux\" | \"windows\"\n     */\n    os: string\n    /** The \"browser\" where this shard is running on.\n     *\n     * @default \"Discordeno\"\n     */\n    browser: string\n    /** The device on which the shard is running.\n     *\n     * @default \"Discordeno\"\n     */\n    device: string\n  }\n  /** Bot token which is used to connect to Discord */\n  token: string\n  /** The URL of the gateway which should be connected to.\n   *\n   * @default \"wss://gateway.discord.gg\"\n   */\n  url?: string\n  /** The gateway version which should be used.\n   *\n   * @default 10\n   */\n  version?: number\n  /** The events handlers */\n  events?: ShardEvents\n  /** This managers cache related settings. */\n  cache?: {\n    requestMembers?: {\n      /**\n       * Whether or not request member requests should be cached.\n       * @default false\n       */\n      enabled?: boolean\n    }\n  }\n  /**\n   * The logger that the gateway manager will use\n   * @default logger // The logger exported by `@discordeno/utils`\n   */\n  logger?: Pick<typeof logger, 'debug' | 'info' | 'warn' | 'error' | 'fatal'>\n}\n\nexport interface GatewayManager extends Required<CreateGatewayManagerOptions> {\n  /** The max concurrency buckets. Those will be created when the `spawnShards` (which calls `prepareBuckets` under the hood) function gets called. */\n  buckets: Map<\n    number,\n    {\n      workers: Array<{ id: number; queue: number[] }>\n      /** Requests to identify shards are made based on whether it is available to be made. */\n      identifyRequests: Array<(value: void | PromiseLike<void>) => void>\n    }\n  >\n  /** The shards that are created. */\n  shards: Map<number, Shard>\n  /** The logger for the gateway manager */\n  logger: Pick<typeof logger, 'debug' | 'info' | 'warn' | 'error' | 'fatal'>\n  /** Everything related to resharding. */\n  resharding: {\n    /**\n     * Whether or not automated resharding should be enabled.\n     * @default true\n     */\n    enabled: boolean\n    /**\n     * The % of how full a shard is when resharding should be triggered.\n     * @default 80 as in 80%\n     */\n    shardsFullPercentage: number\n    /**\n     * The interval in milliseconds, of how often to check whether resharding is needed and reshard automatically. Set to -1 to disable auto resharding.\n     * @default 28800000 (8 hours)\n     */\n    checkInterval: number\n    /**\n     * The interval id of the check interval. This is used to clear the interval when the manager is shutdown.\n     */\n    checkIntervalId?: NodeJS.Timeout | undefined\n    /** Holds the shards that resharding has created. Once resharding is done, this replaces the gateway.shards */\n    shards: Collection<number, Shard>\n    /** Holds the pending shards that have been created and are pending all shards finish loading. */\n    pendingShards: Collection<number, Shard>\n    /** Handler to get shard count and other session info. */\n    getSessionInfo: () => Promise<Camelize<DiscordGetGatewayBot>>\n    /** Handler to edit the shard id on any cached guilds. */\n    updateGuildsShardId: (guildIds: string[], shardId: number) => Promise<void>\n    /** Handler to check if resharding is necessary. */\n    checkIfReshardingIsNeeded: () => Promise<{ needed: boolean; info?: Camelize<DiscordGetGatewayBot> }>\n    /** Handler to begin resharding. */\n    reshard: (info: Camelize<DiscordGetGatewayBot> & { firstShardId?: number; lastShardId?: number }) => Promise<void>\n    /** Handler to communicate to a worker that a shard needs to be created. */\n    tellWorkerToPrepare: (workerId: number, shardId: number, bucketId: number) => Promise<void>\n    /** Handler to alert the gateway that a shard(resharded) is online. It should now wait for all shards to be pending before shutting off old shards. */\n    shardIsPending: (shard: Shard) => Promise<void>\n  }\n  /** Determine max number of shards to use based upon the max concurrency. */\n  calculateTotalShards: () => number\n  /** Determine the id of the worker which is handling a shard. */\n  calculateWorkerId: (shardId: number) => number\n  /** Prepares all the buckets that are available for identifying the shards. */\n  prepareBuckets: () => void\n  /** Start identifying all the shards. */\n  spawnShards: () => Promise<void>\n  /** Shutdown all shards. */\n  shutdown: (code: number, reason: string, clearReshardingInterval?: boolean) => Promise<void>\n  sendPayload: (shardId: number, payload: ShardSocketRequest) => Promise<void>\n  /** Allows users to hook in and change to communicate to different workers across different servers or anything they like. For example using redis pubsub to talk to other servers. */\n  tellWorkerToIdentify: (workerId: number, shardId: number, bucketId: number) => Promise<void>\n  /** Tell the manager to identify a Shard. If this Shard is not already managed this will also add the Shard to the manager. */\n  identify: (shardId: number) => Promise<void>\n  /** Kill a shard. Close a shards connection to Discord's gateway (if any) and remove it from the manager. */\n  kill: (shardId: number) => Promise<void>\n  /** This function makes sure that the bucket is allowed to make the next identify request. */\n  requestIdentify: (shardId: number) => Promise<void>\n  /** Calculates the number of shards based on the guild id and total shards. */\n  calculateShardId: (guildId: BigString, totalShards?: number) => number\n  /**\n   * Connects the bot user to a voice or stage channel.\n   *\n   * This function sends the _Update Voice State_ gateway command over the gateway behind the scenes.\n   *\n   * @param guildId - The ID of the guild the voice channel to leave is in.\n   * @param channelId - The ID of the channel you want to join.\n   *\n   * @remarks\n   * Requires the `CONNECT` permission.\n   *\n   * Fires a _Voice State Update_ gateway event.\n   *\n   * @see {@link https://discord.com/developers/docs/topics/gateway#update-voice-state}\n   */\n  joinVoiceChannel: (guildId: BigString, channelId: BigString, options?: AtLeastOne<Omit<UpdateVoiceState, 'guildId' | 'channelId'>>) => Promise<void>\n  /**\n   * Edits the bot status in all shards that this gateway manages.\n   *\n   * @param data The status data to set the bots status to.\n   * @returns nothing\n   */\n  editBotStatus: (data: StatusUpdate) => Promise<void>\n  /**\n   * Edits the bot's status on one shard.\n   *\n   * @param shardId The shard id to edit the status for.\n   * @param data The status data to set the bots status to.\n   * @returns nothing\n   */\n  editShardStatus: (shardId: number, data: StatusUpdate) => Promise<void>\n  /**\n   * Fetches the list of members for a guild over the gateway.\n   *\n   * @param guildId - The ID of the guild to get the list of members for.\n   * @param options - The parameters for the fetching of the members.\n   *\n   * @remarks\n   * If requesting the entire member list:\n   * - Requires the `GUILD_MEMBERS` intent.\n   *\n   * If requesting presences ({@link RequestGuildMembers.presences | presences} set to `true`):\n   * - Requires the `GUILD_PRESENCES` intent.\n   *\n   * If requesting a prefix ({@link RequestGuildMembers.query | query} non-`undefined`):\n   * - Returns a maximum of 100 members.\n   *\n   * If requesting a users by ID ({@link RequestGuildMembers.userIds | userIds} non-`undefined`):\n   * - Returns a maximum of 100 members.\n   *\n   * Fires a _Guild Members Chunk_ gateway event for every 1000 members fetched.\n   *\n   * @see {@link https://discord.com/developers/docs/topics/gateway#request-guild-members}\n   */\n  requestMembers: (guildId: BigString, options?: Omit<RequestGuildMembers, 'guildId'>) => Promise<Camelize<DiscordMemberWithUser[]>>\n  /**\n   * Leaves the voice channel the bot user is currently in.\n   *\n   * This function sends the _Update Voice State_ gateway command over the gateway behind the scenes.\n   *\n   * @param guildId - The ID of the guild the voice channel to leave is in.\n   *\n   * @remarks\n   * Fires a _Voice State Update_ gateway event.\n   *\n   * @see {@link https://discord.com/developers/docs/topics/gateway#update-voice-state}\n   */\n  leaveVoiceChannel: (guildId: BigString) => Promise<void>\n  /** This managers cache related settings. */\n  cache: {\n    requestMembers: {\n      /**\n       * Whether or not request member requests should be cached.\n       * @default false\n       */\n      enabled: boolean\n      /** The pending requests. */\n      pending: Collection<string, RequestMemberRequest>\n    }\n  }\n}\n\nexport interface RequestMemberRequest {\n  /** The unique nonce for this request. */\n  nonce: string\n  /** The resolver handler to run when all members arrive. */\n  resolve: (value: Camelize<DiscordMemberWithUser[]> | PromiseLike<Camelize<DiscordMemberWithUser[]>>) => void\n  /** The members that have already arrived for this request. */\n  members: DiscordMemberWithUser[]\n}\n"],"names":["GatewayIntents","GatewayOpcodes","Collection","delay","logger","Shard","ShardSocketCloseCodes","createGatewayManager","options","connectionOptions","connection","url","shards","sessionStartLimit","maxConcurrency","remaining","total","resetAfter","gateway","events","compress","intents","properties","os","process","platform","browser","device","token","version","totalShards","lastShardId","firstShardId","totalWorkers","shardsPerWorker","spawnShardDelay","preferSnakeCase","Map","buckets","cache","requestMembers","enabled","pending","resharding","shardsFullPercentage","checkInterval","pendingShards","getSessionInfo","Error","checkIfReshardingIsNeeded","warn","needed","sessionInfo","info","percentage","reshard","calculateTotalShards","clear","prepareBuckets","forEach","bucket","bucketId","worker","workers","shardId","queue","tellWorkerToPrepare","id","workerId","shard","message","_shard","payload","t","updateGuildsShardId","d","guilds","map","g","requestIdentify","identify","shardIsReady","debug","get","identifyRequests","shift","forwardToBot","set","Promise","resolve","push","then","shardIsPending","guildIds","join","size","values","event","oldHandler","_","shutdown","Resharded","Math","ceil","calculateWorkerId","min","i","find","w","sort","a","b","spawnShards","all","entries","tellWorkerToIdentify","checkIntervalId","setInterval","reshardingInfo","code","reason","clearReshardingInterval","close","clearInterval","sendPayload","send","kill","delete","_shardId","calculateShardId","guildId","Number","BigInt","joinVoiceChannel","channelId","op","VoiceStateUpdate","guild_id","toString","channel_id","self_mute","selfMute","self_deaf","selfDeaf","editBotStatus","data","JSON","stringify","editShardStatus","PresenceUpdate","since","afk","activities","status","limit","GuildMembers","userIds","length","members","nonce","reject","RequestGuildMembers","query","undefined","presences","user_ids","leaveVoiceChannel"],"mappings":"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"}

package/dist/esm/types.js

@@ -0,0 +1,23 @@
+export var ShardState;
+(function(ShardState) {
+    /** Shard is fully connected to the gateway and receiving events from Discord. */ ShardState[ShardState["Connected"] = 0] = "Connected";
+    /** Shard started to connect to the gateway. This is only used if the shard is not currently trying to identify or resume. */ ShardState[ShardState["Connecting"] = 1] = "Connecting";
+    /** Shard got disconnected and reconnection actions have been started. */ ShardState[ShardState["Disconnected"] = 2] = "Disconnected";
+    /** The shard is connected to the gateway but only heartbeating. At this state the shard has not been identified with discord. */ ShardState[ShardState["Unidentified"] = 3] = "Unidentified";
+    /** Shard is trying to identify with the gateway to create a new session. */ ShardState[ShardState["Identifying"] = 4] = "Identifying";
+    /** Shard is trying to resume a session with the gateway. */ ShardState[ShardState["Resuming"] = 5] = "Resuming";
+    /** Shard got shut down studied or due to a not (self) fixable error and may not attempt to reconnect on its own. */ ShardState[ShardState["Offline"] = 6] = "Offline";
+})(ShardState || (ShardState = {}));
+export var ShardSocketCloseCodes;
+(function(ShardSocketCloseCodes) {
+    /** A regular Shard shutdown. */ ShardSocketCloseCodes[ShardSocketCloseCodes["Shutdown"] = 3000] = "Shutdown";
+    /** A resume has been requested and therefore the old connection needs to be closed. */ ShardSocketCloseCodes[ShardSocketCloseCodes["ResumeClosingOldConnection"] = 3024] = "ResumeClosingOldConnection";
+    /** Did not receive a heartbeat ACK in time.
+   * Closing the shard and creating a new session.
+   */ ShardSocketCloseCodes[ShardSocketCloseCodes["ZombiedConnection"] = 3010] = "ZombiedConnection";
+    /** Discordeno's gateway tests hae been finished, therefore the Shard can be turned off. */ ShardSocketCloseCodes[ShardSocketCloseCodes["TestingFinished"] = 3064] = "TestingFinished";
+    /** Special close code reserved for Discordeno's zero-downtime resharding system. */ ShardSocketCloseCodes[ShardSocketCloseCodes["Resharded"] = 3065] = "Resharded";
+    /** Shard is re-identifying therefore the old connection needs to be closed. */ ShardSocketCloseCodes[ShardSocketCloseCodes["ReIdentifying"] = 3066] = "ReIdentifying";
+})(ShardSocketCloseCodes || (ShardSocketCloseCodes = {}));
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/types.ts"],"sourcesContent":["import type { ActivityTypes, Camelize, DiscordActivity, DiscordGatewayPayload, GatewayOpcodes, PresenceStatus } from '@discordeno/types'\nimport type Shard from './Shard.js'\n\nexport enum ShardState {\n  /** Shard is fully connected to the gateway and receiving events from Discord. */\n  Connected = 0,\n  /** Shard started to connect to the gateway. This is only used if the shard is not currently trying to identify or resume. */\n  Connecting = 1,\n  /** Shard got disconnected and reconnection actions have been started. */\n  Disconnected = 2,\n  /** The shard is connected to the gateway but only heartbeating. At this state the shard has not been identified with discord. */\n  Unidentified = 3,\n  /** Shard is trying to identify with the gateway to create a new session. */\n  Identifying = 4,\n  /** Shard is trying to resume a session with the gateway. */\n  Resuming = 5,\n  /** Shard got shut down studied or due to a not (self) fixable error and may not attempt to reconnect on its own. */\n  Offline = 6,\n}\n\nexport interface ShardGatewayConfig {\n  /** Whether incoming payloads are compressed using zlib.\n   *\n   * @default false\n   */\n  compress: boolean\n  /** The calculated intent value of the events which the shard should receive.\n   *\n   * @default 0\n   */\n  intents: number\n  /** Identify properties to use */\n  properties: {\n    /** Operating system the shard runs on.\n     *\n     * @default \"darwin\" | \"linux\" | \"windows\"\n     */\n    os: string\n    /** The \"browser\" where this shard is running on.\n     *\n     * @default \"Discordeno\"\n     */\n    browser: string\n    /** The device on which the shard is running.\n     *\n     * @default \"Discordeno\"\n     */\n    device: string\n  }\n  /** Bot token which is used to connect to Discord */\n  token: string\n  /** The URL of the gateway which should be connected to.\n   *\n   * @default \"wss://gateway.discord.gg\"\n   */\n  url: string\n  /** The gateway version which should be used.\n   *\n   * @default 10\n   */\n  version: number\n  /**\n   * The total number of shards to connect to across the entire bot.\n   * @default 1\n   */\n  totalShards: number\n}\n\nexport interface ShardHeart {\n  /** Whether or not the heartbeat was acknowledged by Discord in time. */\n  acknowledged: boolean\n  /** Interval between heartbeats requested by Discord. */\n  interval: number\n  /** Id of the interval, which is used for sending the heartbeats. */\n  intervalId?: NodeJS.Timeout\n  /** Unix (in milliseconds) timestamp when the last heartbeat ACK was received from Discord. */\n  lastAck?: number\n  /** Unix timestamp (in milliseconds) when the last heartbeat was sent. */\n  lastBeat?: number\n  /** Round trip time (in milliseconds) from Shard to Discord and back.\n   * Calculated using the heartbeat system.\n   * Note: this value is undefined until the first heartbeat to Discord has happened.\n   */\n  rtt?: number\n  /** Id of the timeout which is used for sending the first heartbeat to Discord since it's \"special\". */\n  timeoutId?: NodeJS.Timeout\n}\n\nexport interface ShardEvents {\n  /** A heartbeat has been send. */\n  heartbeat?: (shard: Shard) => unknown\n  /** A heartbeat ACK was received. */\n  heartbeatAck?: (shard: Shard) => unknown\n  /** Shard has received a Hello payload. */\n  hello?: (shard: Shard) => unknown\n  /** The Shards session has been invalidated. */\n  invalidSession?: (shard: Shard, resumable: boolean) => unknown\n  /** The shard has started a resume action. */\n  resuming?: (shard: Shard) => unknown\n  /** The shard has successfully resumed an old session. */\n  resumed?: (shard: Shard) => unknown\n  /** Discord has requested the Shard to reconnect. */\n  requestedReconnect?: (shard: Shard) => unknown\n  /** The shard started to connect to Discord's gateway. */\n  connecting?: (shard: Shard) => unknown\n  /** The shard is connected with Discord's gateway. */\n  connected?: (shard: Shard) => unknown\n  /** The shard has been disconnected from Discord's gateway. */\n  disconnected?: (shard: Shard) => unknown\n  /** The shard has started to identify itself to Discord. */\n  identifying?: (shard: Shard) => unknown\n  /** The shard has successfully been identified itself with Discord. */\n  identified?: (shard: Shard) => unknown\n  /** The shard has received a message from Discord. */\n  message?: (shard: Shard, payload: Camelize<DiscordGatewayPayload>) => unknown\n}\n\nexport enum ShardSocketCloseCodes {\n  /** A regular Shard shutdown. */\n  Shutdown = 3000,\n  /** A resume has been requested and therefore the old connection needs to be closed. */\n  ResumeClosingOldConnection = 3024,\n  /** Did not receive a heartbeat ACK in time.\n   * Closing the shard and creating a new session.\n   */\n  ZombiedConnection = 3010,\n  /** Discordeno's gateway tests hae been finished, therefore the Shard can be turned off. */\n  TestingFinished = 3064,\n  /** Special close code reserved for Discordeno's zero-downtime resharding system. */\n  Resharded = 3065,\n  /** Shard is re-identifying therefore the old connection needs to be closed. */\n  ReIdentifying = 3066,\n}\n\nexport interface ShardSocketRequest {\n  /** The OP-Code for the payload to send. */\n  op: GatewayOpcodes\n  /** Payload data. */\n  d: unknown\n}\n\n/** https://discord.com/developers/docs/topics/gateway-events#update-presence */\nexport interface BotStatusUpdate {\n  // /** Unix time (in milliseconds) of when the client went idle, or null if the client is not idle */\n  since: number | null\n  /** The user's activities */\n  activities: BotActivity[]\n  /** The user's new status */\n  status: keyof typeof PresenceStatus\n}\n\n/** https://discord.com/developers/docs/topics/gateway-events#activity-object */\nexport interface BotActivity {\n  name: string\n  type: ActivityTypes\n  url?: string\n}\n\n/** https://discord.com/developers/docs/topics/gateway#update-voice-state */\nexport interface UpdateVoiceState {\n  /** id of the guild */\n  guildId: string\n  /** id of the voice channel client wants to join (null if disconnecting) */\n  channelId: string | null\n  /** Is the client muted */\n  selfMute: boolean\n  /** Is the client deafened */\n  selfDeaf: boolean\n}\n\n/** https://discord.com/developers/docs/topics/gateway-events#update-presence */\nexport interface StatusUpdate {\n  // /** Unix time (in milliseconds) of when the client went idle, or null if the client is not idle */\n  // since: number | null;\n  /** The user's activities */\n  activities?: Camelize<Omit<DiscordActivity, 'created_at'>[]>\n  /** The user's new status */\n  status: keyof typeof PresenceStatus\n  // /** Whether or not the client is afk */\n  // afk: boolean;\n}\n"],"names":["ShardState","ShardSocketCloseCodes"],"mappings":";UAGYA;IACV,+EAA+E;IAE/E,2HAA2H;IAE3H,uEAAuE;IAEvE,+HAA+H;IAE/H,0EAA0E;IAE1E,0DAA0D;IAE1D,kHAAkH;GAbxGA,eAAAA;;UAkHAC;IACV,8BAA8B;IAE9B,qFAAqF;IAErF;;GAEC;IAED,yFAAyF;IAEzF,kFAAkF;IAElF,6EAA6E;GAbnEA,0BAAAA"}