@discordeno/gateway 19.0.0 → 20.0.0-next.3fd075a

package/dist/cjs/manager.cjs

@@ -0,0 +1,513 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createGatewayManager", {
+    enumerable: true,
+    get: function() {
+        return createGatewayManager;
+    }
+});
+const _nodecrypto = require("node:crypto");
+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,
+        transportCompression: options.transportCompression ?? null,
+        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,
+        makePresence: options.makePresence ?? (()=>Promise.resolve(undefined)),
+        resharding: {
+            enabled: options.resharding?.enabled ?? true,
+            shardsFullPercentage: options.resharding?.shardsFullPercentage ?? 80,
+            checkInterval: options.resharding?.checkInterval ?? 28800000,
+            shards: new _utils.Collection(),
+            pendingShards: new _utils.Collection(),
+            getSessionInfo: options.resharding?.getSessionInfo,
+            updateGuildsShardId: options.resharding?.updateGuildsShardId,
+            async checkIfReshardingIsNeeded () {
+                gateway.logger.debug('[Resharding] Checking if resharding is needed.');
+                if (!gateway.resharding.enabled) {
+                    gateway.logger.debug('[Resharding] Resharding is disabled.');
+                    return {
+                        needed: false
+                    };
+                }
+                if (!gateway.resharding.getSessionInfo) {
+                    throw new Error("[Resharding] Resharding is enabled but no 'resharding.getSessionInfo()' is not provided.");
+                }
+                gateway.logger.debug('[Resharding] Resharding is enabled.');
+                const sessionInfo = await gateway.resharding.getSessionInfo();
+                gateway.logger.debug(`[Resharding] Session info retrieved: ${JSON.stringify(sessionInfo)}`);
+                // Don't have enough identify limits to try resharding
+                if (sessionInfo.sessionStartLimit.remaining < sessionInfo.shards) {
+                    gateway.logger.debug('[Resharding] Not enough session start limits left to reshard.');
+                    return {
+                        needed: false,
+                        info: sessionInfo
+                    };
+                }
+                gateway.logger.debug('[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.
+                // While this is imprecise as discord changes the recommended number of shard every 1000 guilds it is good enough
+                // The alternative is to store the guild count for each shard and require the Guilds intent for `GUILD_CREATE` and `GUILD_DELETE` events
+                const percentage = sessionInfo.shards / (gateway.totalShards * 2500 / 1000) * 100;
+                // Less than necessary% being used so do nothing
+                if (percentage < gateway.resharding.shardsFullPercentage) {
+                    gateway.logger.debug('[Resharding] Resharding not needed.');
+                    return {
+                        needed: false,
+                        info: sessionInfo
+                    };
+                }
+                gateway.logger.info('[Resharding] Resharding is needed.');
+                return {
+                    needed: true,
+                    info: sessionInfo
+                };
+            },
+            async reshard (info) {
+                gateway.logger.info(`[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;
+                gateway.logger.info(`[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) {
+                gateway.logger.debug(`[Resharding] Telling worker to prepare. Worker: ${workerId} | Shard: ${shardId} | Bucket: ${bucketId}.`);
+                const shard = new _Shard.default({
+                    id: shardId,
+                    connection: {
+                        compress: gateway.compress,
+                        transportCompression: gateway.transportCompression ?? null,
+                        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);
+                            }
+                        }
+                    },
+                    logger: gateway.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()?.();
+                    },
+                    makePresence: gateway.makePresence
+                });
+                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);
+                    gateway.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 shardIsPending (shard) {
+                // Save this in pending at the moment, until all shards are online
+                gateway.resharding.pendingShards.set(shard.id, shard);
+                gateway.logger.debug(`[Resharding] Shard #${shard.id} is now pending.`);
+                // Check if all shards are now online.
+                if (gateway.lastShardId - gateway.firstShardId >= gateway.resharding.pendingShards.size) return;
+                gateway.logger.info(`[Resharding] All shards are now online.`);
+                // New shards start processing events
+                for (const shard of gateway.resharding.shards.values()){
+                    for(const event in options.events){
+                        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') {
+                                oldHandler?.(shard, message);
+                            }
+                        }
+                    };
+                }
+                gateway.logger.info(`[Resharding] Shutting down old shards.`);
+                // Close old shards
+                await gateway.shutdown(_types1.ShardSocketCloseCodes.Resharded, 'Resharded!', false);
+                gateway.logger.info(`[Resharding] Completed.`);
+                // Replace old shards
+                gateway.shards = new _utils.Collection(gateway.resharding.shards);
+                // Clear our collections and keep only one reference to the shards, the one in gateway.shards
+                gateway.resharding.shards.clear();
+                gateway.resharding.pendingShards.clear();
+            }
+        },
+        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) {
+                // It is better to ensure there is always only one
+                clearInterval(gateway.resharding.checkIntervalId);
+                if (!gateway.resharding.getSessionInfo) {
+                    gateway.resharding.enabled = false;
+                    gateway.logger.warn("[Resharding] Resharding is enabled but 'resharding.getSessionInfo()' was not provided. Disabling resharding.");
+                    return;
+                }
+                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) {
+            if (clearReshardingInterval) clearInterval(gateway.resharding.checkIntervalId);
+            await Promise.all(Array.from(gateway.shards.values()).map((shard)=>shard.close(code, reason)));
+        },
+        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,
+                        transportCompression: gateway.transportCompression,
+                        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()?.();
+                    },
+                    makePresence: gateway.makePresence
+                });
+                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] A kill for Shard #${shardId} was requested, but the shard could not be found`);
+            }
+            gateway.logger.debug(`[Gateway] Killing Shard #${shardId}`);
+            this.shards.delete(shardId);
+            await shard.shutdown();
+        },
+        async requestIdentify (_shardId) {
+            gateway.logger.debug(`[Gateway] Requesting identify`);
+        },
+        // 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;
+            }
+            if (!options?.nonce) {
+                let nonce = '';
+                while(!nonce || gateway.cache.requestMembers.pending.has(nonce)){
+                    nonce = (0, _nodecrypto.randomBytes)(16).toString('hex');
+                }
+                options ??= {
+                    limit: 0
+                };
+                options.nonce = nonce;
+            }
+            const members = !gateway.cache.requestMembers.enabled ? [] : 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
+                }
+            });
+        },
+        async requestSoundboardSounds (guildIds) {
+            /**
+       * Discord will send the events for the guilds that are "under the shard" that sends the opcode.
+       * For this reason we need to group the ids with the shard the calculateShardId method gives
+       */ const map = new Map();
+            for (const guildId of guildIds){
+                const shardId = gateway.calculateShardId(guildId);
+                const ids = map.get(shardId) ?? [];
+                map.set(shardId, ids);
+                ids.push(guildId);
+            }
+            await Promise.all([
+                ...map.entries()
+            ].map(([shardId, ids])=>gateway.sendPayload(shardId, {
+                    op: _types.GatewayOpcodes.RequestSoundboardSounds,
+                    d: {
+                        guild_ids: ids
+                    }
+                })));
+        }
+    };
+    return gateway;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/manager.ts"],"sourcesContent":["import { randomBytes } from 'node:crypto'\nimport {\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 {\n  type BotStatusUpdate,\n  type ShardEvents,\n  ShardSocketCloseCodes,\n  type ShardSocketRequest,\n  type StatusUpdate,\n  type TransportCompression,\n  type UpdateVoiceState,\n} 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    transportCompression: options.transportCompression ?? null,\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    makePresence: options.makePresence ?? (() => Promise.resolve(undefined)),\n    resharding: {\n      enabled: options.resharding?.enabled ?? true,\n      shardsFullPercentage: options.resharding?.shardsFullPercentage ?? 80,\n      checkInterval: options.resharding?.checkInterval ?? 28800000, // 8 hours\n      shards: new Collection(),\n      pendingShards: new Collection(),\n      getSessionInfo: options.resharding?.getSessionInfo,\n      updateGuildsShardId: options.resharding?.updateGuildsShardId,\n      async checkIfReshardingIsNeeded() {\n        gateway.logger.debug('[Resharding] Checking if resharding is needed.')\n\n        if (!gateway.resharding.enabled) {\n          gateway.logger.debug('[Resharding] Resharding is disabled.')\n\n          return { needed: false }\n        }\n\n        if (!gateway.resharding.getSessionInfo) {\n          throw new Error(\"[Resharding] Resharding is enabled but no 'resharding.getSessionInfo()' is not provided.\")\n        }\n\n        gateway.logger.debug('[Resharding] Resharding is enabled.')\n\n        const sessionInfo = await gateway.resharding.getSessionInfo()\n\n        gateway.logger.debug(`[Resharding] Session info retrieved: ${JSON.stringify(sessionInfo)}`)\n\n        // Don't have enough identify limits to try resharding\n        if (sessionInfo.sessionStartLimit.remaining < sessionInfo.shards) {\n          gateway.logger.debug('[Resharding] Not enough session start limits left to reshard.')\n\n          return { needed: false, info: sessionInfo }\n        }\n\n        gateway.logger.debug('[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        // While this is imprecise as discord changes the recommended number of shard every 1000 guilds it is good enough\n        // The alternative is to store the guild count for each shard and require the Guilds intent for `GUILD_CREATE` and `GUILD_DELETE` events\n        const percentage = (sessionInfo.shards / ((gateway.totalShards * 2500) / 1000)) * 100\n\n        // Less than necessary% being used so do nothing\n        if (percentage < gateway.resharding.shardsFullPercentage) {\n          gateway.logger.debug('[Resharding] Resharding not needed.')\n\n          return { needed: false, info: sessionInfo }\n        }\n\n        gateway.logger.info('[Resharding] Resharding is needed.')\n\n        return { needed: true, info: sessionInfo }\n      },\n      async reshard(info) {\n        gateway.logger.info(`[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        gateway.logger.info(`[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        gateway.logger.debug(`[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            transportCompression: gateway.transportCompression ?? null,\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          logger: gateway.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          makePresence: gateway.makePresence,\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          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().then(async () => {\n            // Tell the manager that this shard is online\n            return await gateway.resharding.shardIsPending(shard)\n          })\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        gateway.logger.debug(`[Resharding] Shard #${shard.id} is now pending.`)\n\n        // Check if all shards are now online.\n        if (gateway.lastShardId - gateway.firstShardId >= gateway.resharding.pendingShards.size) return\n\n        gateway.logger.info(`[Resharding] All shards are now online.`)\n\n        // New shards start processing events\n        for (const shard of gateway.resharding.shards.values()) {\n          for (const event in options.events) {\n            shard.events[event as keyof ShardEvents] = options.events[event as keyof ShardEvents] as (...args: unknown[]) => unknown\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') {\n                oldHandler?.(shard, message)\n              }\n            },\n          }\n        }\n\n        gateway.logger.info(`[Resharding] Shutting down old shards.`)\n        // Close old shards\n        await gateway.shutdown(ShardSocketCloseCodes.Resharded, 'Resharded!', false)\n\n        gateway.logger.info(`[Resharding] Completed.`)\n\n        // Replace old shards\n        gateway.shards = new Collection(gateway.resharding.shards)\n\n        // Clear our collections and keep only one reference to the shards, the one in gateway.shards\n        gateway.resharding.shards.clear()\n        gateway.resharding.pendingShards.clear()\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        // It is better to ensure there is always only one\n        clearInterval(gateway.resharding.checkIntervalId)\n\n        if (!gateway.resharding.getSessionInfo) {\n          gateway.resharding.enabled = false\n          gateway.logger.warn(\"[Resharding] Resharding is enabled but 'resharding.getSessionInfo()' was not provided. Disabling resharding.\")\n\n          return\n        }\n\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      if (clearReshardingInterval) clearInterval(gateway.resharding.checkIntervalId)\n\n      await Promise.all(Array.from(gateway.shards.values()).map((shard) => shard.close(code, reason)))\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            transportCompression: gateway.transportCompression,\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          makePresence: gateway.makePresence,\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] A kill for Shard #${shardId} was requested, but the shard could not be found`)\n      }\n\n      gateway.logger.debug(`[Gateway] Killing 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    },\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      if (!options?.nonce) {\n        let nonce = ''\n\n        while (!nonce || gateway.cache.requestMembers.pending.has(nonce)) {\n          nonce = randomBytes(16).toString('hex')\n        }\n\n        options ??= { limit: 0 }\n        options.nonce = nonce\n      }\n\n      const members = !gateway.cache.requestMembers.enabled\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    async requestSoundboardSounds(guildIds) {\n      /**\n       * Discord will send the events for the guilds that are \"under the shard\" that sends the opcode.\n       * For this reason we need to group the ids with the shard the calculateShardId method gives\n       */\n\n      const map = new Map<number, BigString[]>()\n\n      for (const guildId of guildIds) {\n        const shardId = gateway.calculateShardId(guildId)\n\n        const ids = map.get(shardId) ?? []\n        map.set(shardId, ids)\n\n        ids.push(guildId)\n      }\n\n      await Promise.all(\n        [...map.entries()].map(([shardId, ids]) =>\n          gateway.sendPayload(shardId, {\n            op: GatewayOpcodes.RequestSoundboardSounds,\n            d: {\n              guild_ids: ids,\n            },\n          }),\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  /** What transport compression should be used */\n  transportCompression?: TransportCompression | null\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   * Make the presence for when the bot connects to the gateway\n   *\n   * @remarks\n   * This function will be called each time a Shard is going to identify\n   */\n  makePresence?: () => Promise<BotStatusUpdate | undefined>\n  /** Options 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     *\n     * @remarks\n     * We use discord recommended shard value to get an **approximation** of the shard full percentage to compare with this value so the bot may not reshard at the exact percentage provided but may reshard when it is a bit higher than the provided percentage.\n     * For accurate calculation, you may override the `checkIfReshardingIsNeeded` function\n     *\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    /** 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  }\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: CreateGatewayManagerOptions['resharding'] & {\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 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. If `gateway.cache.requestMembers.enabled` is not set, this function will return an empty array and you'll have to handle the `GUILD_MEMBERS_CHUNK` events yourself.\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  /**\n   * Used to request soundboard sounds for a list of guilds.\n   *\n   * This function sends multiple (see remarks) _Request Soundboard Sounds_ gateway command over the gateway behind the scenes.\n   *\n   * @param guildIds - The guilds to get the sounds from\n   *\n   * @remarks\n   * Fires a _Soundboard Sounds_ gateway event.\n   *\n   * ⚠️ Discord will send the _Soundboard Sounds_ for each of the guild ids\n   * however you may not receive the same number of events as the ids passed to _Request Soundboard Sounds_ for one of the following reasons:\n   * - The bot is not in the server provided\n   * - The shard the message has been sent from does not receive events for the specified guild\n   *\n   * To avoid this Discordeno will automatically try to group the ids based on what shard they will need to be sent, but this involves sending multiple messages in multiple shards\n   *\n   * @see {@link https://discord.com/developers/docs/topics/gateway-events#request-soundboard-sounds}\n   */\n  requestSoundboardSounds: (guildIds: 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","transportCompression","intents","properties","os","process","platform","browser","device","token","version","totalShards","lastShardId","firstShardId","totalWorkers","shardsPerWorker","spawnShardDelay","preferSnakeCase","Map","buckets","cache","requestMembers","enabled","pending","Collection","logger","makePresence","Promise","resolve","undefined","resharding","shardsFullPercentage","checkInterval","pendingShards","getSessionInfo","updateGuildsShardId","checkIfReshardingIsNeeded","debug","needed","Error","sessionInfo","JSON","stringify","info","percentage","reshard","calculateTotalShards","clear","prepareBuckets","forEach","bucket","bucketId","worker","workers","shardId","queue","tellWorkerToPrepare","id","workerId","shard","Shard","message","_shard","payload","t","d","guilds","map","g","requestIdentify","identify","shardIsReady","delay","get","identifyRequests","shift","forwardToBot","set","push","then","shardIsPending","size","values","event","oldHandler","_","shutdown","ShardSocketCloseCodes","Resharded","Math","ceil","calculateWorkerId","min","i","find","w","sort","a","b","spawnShards","all","entries","tellWorkerToIdentify","clearInterval","checkIntervalId","warn","setInterval","reshardingInfo","code","reason","clearReshardingInterval","Array","from","close","sendPayload","send","kill","delete","_shardId","calculateShardId","guildId","Number","BigInt","joinVoiceChannel","channelId","op","GatewayOpcodes","VoiceStateUpdate","guild_id","toString","channel_id","self_mute","selfMute","self_deaf","selfDeaf","editBotStatus","data","editShardStatus","PresenceUpdate","since","afk","activities","status","limit","GatewayIntents","GuildMembers","userIds","length","nonce","has","randomBytes","members","reject","RequestGuildMembers","query","presences","user_ids","leaveVoiceChannel","requestSoundboardSounds","guildIds","ids","RequestSoundboardSounds","guild_ids"],"mappings":"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"}