@discordeno/gateway 19.0.0-next.e2d86ea → 19.0.0-next.e30e5a2

package/dist/cjs/index.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./manager.cjs"), exports);
+_export_star(require("./Shard.cjs"), exports);
+_export_star(require("./types.cjs"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL21hbmFnZXIuanMnXG5leHBvcnQgKiBmcm9tICcuL1NoYXJkLmpzJ1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcy5qcydcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O3FCQUFjO3FCQUNBO3FCQUNBIn0=

package/dist/cjs/manager.cjs

@@ -0,0 +1,464 @@
+/* eslint-disable @typescript-eslint/no-confusing-void-expression */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createGatewayManager", {
+    enumerable: true,
+    get: function() {
+        return createGatewayManager;
+    }
+});
+const _types = require("@discordeno/types");
+const _utils = require("@discordeno/utils");
+const _Shard = /*#__PURE__*/ _interop_require_default(require("./Shard.cjs"));
+const _types1 = require("./types.cjs");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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 _utils.Collection()
+            }
+        },
+        logger: options.logger ?? _utils.logger,
+        resharding: {
+            enabled: true,
+            shardsFullPercentage: 80,
+            checkInterval: 28800000,
+            shards: new _utils.Collection(),
+            pendingShards: new _utils.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 () {
+                _utils.logger.warn(`[Resharding] Checking if resharding is needed.`);
+                // Resharding is disabled.
+                if (!gateway.resharding.enabled) return {
+                    needed: false
+                };
+                _utils.logger.warn(`[Resharding] Resharding is enabled.`);
+                const sessionInfo = await gateway.resharding.getSessionInfo();
+                _utils.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
+                };
+                _utils.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
+                };
+                _utils.logger.warn(`[Resharding] Resharding is needed.`);
+                return {
+                    needed: true,
+                    info: sessionInfo
+                };
+            },
+            async reshard (info) {
+                _utils.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;
+                _utils.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) {
+                _utils.logger.warn(`[Resharding] Telling worker to prepare. Worker: ${workerId} | Shard: ${shardId} | Bucket: ${bucketId}`);
+                const shard = new _Shard.default({
+                    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 ()=>{
+                        _utils.logger.debug(`[Shard] Shard #${shardId} is ready`);
+                        await (0, _utils.delay)(gateway.spawnShardDelay);
+                        _utils.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);
+                    _utils.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) {
+                _utils.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);
+                _utils.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;
+                _utils.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);
+                        }
+                    };
+                }
+                _utils.logger.warn(`[Resharding] Shutting down old shards.`);
+                // Close old shards
+                await gateway.shutdown(_types1.ShardSocketCloseCodes.Resharded, 'Resharded!', false);
+                _utils.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()){
+                    // eslint-disable-next-line @typescript-eslint/require-array-sort-compare
+                    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 (0, _utils.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.default({
+                    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 (0, _utils.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: _types.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: _types.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 & _types.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: _types.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: _types.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":["/* eslint-disable @typescript-eslint/no-confusing-void-expression */\nimport {\n  GatewayIntents,\n  GatewayOpcodes,\n  type AtLeastOne,\n  type BigString,\n  type Camelize,\n  type DiscordGetGatewayBot,\n  type DiscordMemberWithUser,\n  type DiscordReady,\n  type RequestGuildMembers,\n} from '@discordeno/types'\nimport { Collection, delay, logger } from '@discordeno/utils'\nimport Shard from './Shard.js'\nimport { ShardSocketCloseCodes, type ShardEvents, 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          // eslint-disable-next-line @typescript-eslint/require-array-sort-compare\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":["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","Collection","logger","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","Shard","message","_shard","payload","t","updateGuildsShardId","d","guilds","map","g","requestIdentify","identify","shardIsReady","debug","delay","get","identifyRequests","shift","forwardToBot","set","Promise","resolve","push","then","shardIsPending","guildIds","join","size","values","event","oldHandler","_","shutdown","ShardSocketCloseCodes","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","calculateShardId","guildId","Number","BigInt","joinVoiceChannel","channelId","op","GatewayOpcodes","VoiceStateUpdate","guild_id","toString","channel_id","self_mute","selfMute","self_deaf","selfDeaf","editBotStatus","data","JSON","stringify","editShardStatus","PresenceUpdate","since","afk","activities","status","limit","GatewayIntents","GuildMembers","userIds","length","members","nonce","reject","RequestGuildMembers","query","undefined","presences","user_ids","leaveVoiceChannel"],"mappings":"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"}