elynn-baileys 1.0.1

package/lib/Discord/gateway/Shard.cjs

@@ -0,0 +1,723 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = __importDefault(require("./compression/config.cjs"));
+const TypedEmitter_1 = __importDefault(require("../util/TypedEmitter.cjs"));
+const Bucket_1 = __importDefault(require("../rest/Bucket.cjs"));
+const Constants_1 = require("../Constants.cjs");
+const Base_1 = __importDefault(require("../structures/Base.cjs"));
+const ExtendedUser_1 = __importDefault(require("../structures/ExtendedUser.cjs"));
+const Errors_1 = require("../util/Errors.cjs");
+const ClientApplication_1 = __importDefault(require("../structures/ClientApplication.cjs"));
+const ws_1 = __importDefault(require("ws"));
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment, unicorn/prefer-module, @typescript-eslint/no-unsafe-member-access */
+// @ts-ignore
+let Erlpack;
+try {
+    Erlpack = require("erlpack");
+}
+catch { }
+/* eslint-enable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-redundant-type-constituents, @typescript-eslint/no-var-requires, @typescript-eslint/no-unsafe-assignment, unicorn/prefer-module */
+/** Represents a gateway connection to Discord. See {@link Types.Events.ShardEvents | Shard Events} for a list of events. */
+class Shard extends TypedEmitter_1.default {
+    _compressor;
+    _connectTimeout;
+    _getAllUsersCount;
+    _getAllUsersQueue;
+    _guildCreateTimeout;
+    _heartbeatInterval;
+    _requestMembersPromise;
+    _requestSoundboardSoundsPromise;
+    client;
+    connectAttempts;
+    connecting;
+    globalBucket;
+    id;
+    lastHeartbeatAck;
+    lastHeartbeatReceived;
+    lastHeartbeatSent;
+    latency;
+    manager;
+    preReady;
+    presence;
+    presenceUpdateBucket;
+    ready;
+    reconnectInterval;
+    resumeURL;
+    sequence;
+    sessionID;
+    status;
+    ws;
+    constructor(id, manager) {
+        super();
+        Object.defineProperties(this, {
+            client: {
+                value: manager.client,
+                enumerable: false,
+                writable: false,
+                configurable: false
+            },
+            manager: {
+                value: manager,
+                enumerable: false,
+                writable: true,
+                configurable: false
+            },
+            ws: {
+                value: null,
+                enumerable: false,
+                writable: true,
+                configurable: false
+            }
+        });
+        this.onPacket = this.onPacket.bind(this);
+        this.onWSClose = this.onWSClose.bind(this);
+        this.onWSError = this.onWSError.bind(this);
+        this.onWSMessage = this.onWSMessage.bind(this);
+        this.onWSOpen = this.onWSOpen.bind(this);
+        this.connectAttempts = 0;
+        this._connectTimeout = null;
+        this.connecting = false;
+        this._getAllUsersCount = {};
+        this._getAllUsersQueue = [];
+        this._guildCreateTimeout = null;
+        this._heartbeatInterval = null;
+        this.id = id;
+        this.lastHeartbeatAck = true;
+        this.lastHeartbeatReceived = 0;
+        this.lastHeartbeatSent = 0;
+        this.latency = Infinity;
+        this.preReady = false;
+        this.ready = false;
+        this.reconnectInterval = 1000;
+        this._requestMembersPromise = {};
+        this._requestSoundboardSoundsPromise = {};
+        this.resumeURL = null;
+        this.sequence = 0;
+        this.sessionID = null;
+        this.status = "disconnected";
+        this.hardReset();
+    }
+    _ready(data) {
+        this.connectAttempts = 0;
+        this.reconnectInterval = 1000;
+        this.connecting = false;
+        if (this._connectTimeout) {
+            clearTimeout(this._connectTimeout);
+        }
+        this.status = "ready";
+        this.client.shards["_ready"](this.id);
+        this.client["_application"] = new ClientApplication_1.default(data.application, this.client);
+        if (this.client["_user"]) {
+            this.client.users.update(data.user);
+        }
+        else {
+            this.client["_user"] = this.client.users.add(new ExtendedUser_1.default(data.user, this.client));
+        }
+        let url = data.resume_gateway_url;
+        if (url.includes("?")) {
+            url = url.slice(0, url.indexOf("?"));
+        }
+        if (!url.endsWith("/")) {
+            url += "/";
+        }
+        this.resumeURL = `${url}?v=${Constants_1.GATEWAY_VERSION}&encoding=${Erlpack ? "etf" : "json"}`;
+        if (this.client.shards.options.compress) {
+            const type = this.client.shards.options.compress === "zstd-stream" ? "zstd-stream" : "zlib-stream";
+            this.resumeURL += `&compress=${type}`;
+        }
+        this.sessionID = data.session_id;
+        for (const guild of data.guilds) {
+            this.client.guilds.delete(guild.id);
+            this.client.unavailableGuilds.update(guild);
+        }
+        this.preReady = true;
+        this.emit("preReady");
+        if (this.client.unavailableGuilds.size !== 0 && data.guilds.length !== 0) {
+            void this.restartGuildCreateTimeout();
+        }
+        else {
+            void this.checkReady();
+        }
+    }
+    _resume() {
+        this.connectAttempts = 0;
+        this.reconnectInterval = 1000;
+        this.connecting = false;
+        if (this._connectTimeout) {
+            clearTimeout(this._connectTimeout);
+        }
+        this.status = "ready";
+        this.client.shards["_ready"](this.id);
+        void this.checkReady();
+        this.emit("resume");
+    }
+    async checkReady() {
+        if (!this.ready) {
+            if (this._getAllUsersQueue.length !== 0) {
+                const id = this._getAllUsersQueue.shift();
+                await this.requestGuildMembers(id);
+                return;
+            }
+            if (Object.keys(this._getAllUsersCount).length === 0) {
+                this.ready = true;
+                this.emit("ready");
+            }
+        }
+    }
+    createGuild(data) {
+        this.client.guildShardMap.set(data.id, this.id);
+        const guild = this.client.guilds.update(data);
+        if (this.client.shards.options.getAllUsers && guild.members.size < guild.memberCount) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+            void this.requestGuildMembers(guild.id, { presences: (this.client.shards.options.intents & Constants_1.Intents.GUILD_PRESENCES) === Constants_1.Intents.GUILD_PRESENCES });
+        }
+        return guild;
+    }
+    async initialize() {
+        if (!this._token) {
+            return this.disconnect(false, new TypeError("Invalid Token."));
+        }
+        this.status = "connecting";
+        if (this.client.shards.options.compress) {
+            const type = this.client.shards.options.compress;
+            const library = this.client.shards.options.compressLibrary;
+            const config = config_1.default[type]?.find(cnf => cnf.name === library);
+            if (!config) {
+                throw new Error("Invalid compression config");
+            }
+            this.client.emit("debug", `Initializing ${type} compression with ${library}.`);
+            this._compressor = new (config.getClass())(this);
+        }
+        if (!this.client.shards.options.override.gatewayURLIsResumeURL && this.sessionID) {
+            if (this.resumeURL === null) {
+                this.client.emit("warn", "Resume url is not currently present. Discord may disconnect you quicker.", this.id);
+            }
+            this.ws = new ws_1.default(this.resumeURL ?? await this.client.shards["_gatewayURLForShard"](this), this.client.shards.options.ws);
+        }
+        else {
+            this.ws = new ws_1.default(await this.client.shards["_gatewayURLForShard"](this), this.client.shards.options.ws);
+        }
+        /* eslint-disable @typescript-eslint/unbound-method */
+        this.ws.on("close", this.onWSClose);
+        this.ws.on("error", this.onWSError);
+        this.ws.on("message", this.onWSMessage);
+        this.ws.on("open", this.onWSOpen);
+        /* eslint-enable @typescript-eslint/unbound-method */
+        this._connectTimeout = setTimeout(() => {
+            if (this.connecting) {
+                this.disconnect(undefined, new Error("Connection timeout."));
+            }
+        }, this.client.shards.options.connectionTimeout);
+    }
+    onPacket(packet) {
+        if ("s" in packet && packet.s) {
+            if (packet.s > this.sequence + 1 && this.ws && this.status !== "resuming") {
+                this.client.emit("warn", `Non-consecutive sequence (${this.sequence} -> ${packet.s})`, this.id);
+            }
+            this.sequence = packet.s;
+        }
+        switch (packet.op) {
+            case Constants_1.GatewayOPCodes.DISPATCH: {
+                this.client.emit("packet", packet, this.id);
+                this.manager.dispatcher["handle"](packet, this);
+                break;
+            }
+            case Constants_1.GatewayOPCodes.HEARTBEAT: {
+                this.heartbeat(true);
+                break;
+            }
+            case Constants_1.GatewayOPCodes.INVALID_SESSION: {
+                if (packet.d) {
+                    this.client.emit("warn", "Session Invalidated. Session may be resumable, attempting to resume..", this.id);
+                    this.resume();
+                }
+                else {
+                    this.sequence = 0;
+                    this.sessionID = null;
+                    this.client.emit("warn", "Session Invalidated. Session is not resumable, requesting a new session..", this.id);
+                    this.identify();
+                }
+                break;
+            }
+            case Constants_1.GatewayOPCodes.RECONNECT: {
+                this.client.emit("debug", "Reconnect requested by Discord.", this.id);
+                this.disconnect(true);
+                break;
+            }
+            case Constants_1.GatewayOPCodes.HELLO: {
+                if (this._heartbeatInterval) {
+                    clearInterval(this._heartbeatInterval);
+                }
+                this._heartbeatInterval = setInterval(() => this.heartbeat(false), packet.d.heartbeat_interval);
+                this.connecting = false;
+                if (this._connectTimeout) {
+                    clearTimeout(this._connectTimeout);
+                }
+                this._connectTimeout = null;
+                if (this.sessionID) {
+                    this.resume();
+                }
+                else {
+                    this.identify();
+                    this.heartbeat();
+                }
+                this.client.emit("hello", packet.d.heartbeat_interval, this.id);
+                break;
+            }
+            case Constants_1.GatewayOPCodes.HEARTBEAT_ACK: {
+                this.lastHeartbeatAck = true;
+                this.lastHeartbeatReceived = Date.now();
+                this.latency = this.lastHeartbeatReceived - this.lastHeartbeatSent;
+                if (isNaN(this.latency)) {
+                    this.latency = Infinity;
+                }
+                break;
+            }
+            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+            default: {
+                this.client.emit("warn", `Unrecognized gateway packet: ${packet}`, this.id);
+            }
+        }
+    }
+    async onWSClose(code, r) {
+        const reason = r.toString();
+        let err;
+        let reconnect;
+        if (code) {
+            this.client.emit("debug", `${code === 1000 ? "Clean" : "Unclean"} WS close: ${code}: ${reason}`, this.id);
+            switch (code) {
+                case 1001: {
+                    err = new Errors_1.GatewayError("CloudFlare WebSocket proxy restarting.", code);
+                    break;
+                }
+                case 1006: {
+                    err = new Errors_1.GatewayError("Connection reset by peer. This is a network issue. If you are concerned, talk to your ISP or host.", code);
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.UNKNOWN_OPCODE: {
+                    err = new Errors_1.GatewayError("Gateway received an unknown opcode.", code);
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.DECODE_ERROR: {
+                    err = new Errors_1.GatewayError("Gateway received an improperly encoded packet.", code);
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.NOT_AUTHENTICATED: {
+                    err = new Errors_1.GatewayError("Gateway received a packet before authentication.", code);
+                    this.sessionID = null;
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.AUTHENTICATION_FAILED: {
+                    err = new Errors_1.GatewayError("Authentication failed.", code);
+                    this.sessionID = null;
+                    reconnect = false;
+                    this.client.emit("error", new Error(`Invalid Token: ${this._token}`));
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.ALREADY_AUTHENTICATED: {
+                    err = new Errors_1.GatewayError("Gateway received an authentication attempt while already authenticated.", code);
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.INVALID_SEQUENCE: {
+                    err = new Errors_1.GatewayError("Gateway received an invalid sequence.", code);
+                    this.sequence = 0;
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.RATE_LIMITED: {
+                    err = new Errors_1.GatewayError("Gateway connection was ratelimited.", code);
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.INVALID_SHARD: {
+                    err = new Errors_1.GatewayError("Invalid sharding specified.", code);
+                    this.sessionID = null;
+                    reconnect = false;
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.SHARDING_REQUIRED: {
+                    err = new Errors_1.GatewayError("Shard would handle too many guilds (>2500 each).", code);
+                    this.sessionID = null;
+                    reconnect = false;
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.INVALID_API_VERSION: {
+                    err = new Errors_1.GatewayError("Invalid API version.", code);
+                    this.sessionID = null;
+                    reconnect = false;
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.INVALID_INTENTS: {
+                    err = new Errors_1.GatewayError("Invalid intents specified.", code);
+                    this.sessionID = null;
+                    reconnect = false;
+                    break;
+                }
+                case Constants_1.GatewayCloseCodes.DISALLOWED_INTENTS: {
+                    const disallowed = this.client.shards.options.lookupDisallowedIntents ? await this.client.util.detectMissingPrivilegedIntents() : [];
+                    let message = "Disallowed intents specified. Make sure any privileged intents you're trying to access have been enabled in the developer portal.";
+                    if (disallowed.length !== 0) {
+                        // application should always be present after the call to detectMissingPrivilegedIntents, but just in case it isn't, we don't want to swallow this disallowed intents error with a lib error
+                        message = `Disallowed intents specified. You are missing: ${disallowed.join(", ")}. Make sure they are enabled here: https://discord.com/developers/applications/${this.client["_application"]?.id || "unknown"}/bot`;
+                    }
+                    err = new Errors_1.GatewayError(message, code);
+                    this.sessionID = null;
+                    reconnect = false;
+                    break;
+                }
+                default: {
+                    err = new Errors_1.GatewayError(`Unknown close: ${code}: ${reason}`, code);
+                    break;
+                }
+            }
+            this.disconnect(reconnect, err);
+        }
+    }
+    onWSError(err) {
+        this.client.emit("error", err, this.id);
+    }
+    /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-unsafe-argument */
+    async onWSMessage(data) {
+        if (typeof data === "string") {
+            data = Buffer.from(data);
+        }
+        try {
+            if (data instanceof ArrayBuffer) {
+                if (this.client.shards.options.compress || Erlpack) {
+                    data = Buffer.from(data);
+                }
+            }
+            else if (Array.isArray(data)) {
+                data = Buffer.concat(data);
+            }
+            const buf = data;
+            if (this.client.shards.options.compress) {
+                let result = await this._compressor.decompress(buf);
+                if (result === null) {
+                    return;
+                }
+                if (Erlpack) {
+                    return this.onPacket(Erlpack.unpack(result));
+                }
+                else {
+                    // After the valid data, all the remaining octets are filled with zero, so remove them.
+                    let last = result.length - 1;
+                    if (result[last] === 0) {
+                        while (result[last - 1] === 0 && last > 0)
+                            last--;
+                        result = result.subarray(0, last);
+                    }
+                    return this.onPacket(JSON.parse(String(result)));
+                }
+            }
+            else if (Erlpack) {
+                return this.onPacket(Erlpack.unpack(buf));
+            }
+            else {
+                return this.onPacket(JSON.parse(String(buf)));
+            }
+        }
+        catch (err) {
+            this.client.emit("error", err, this.id);
+        }
+    }
+    /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call, @typescript-eslint/restrict-template-expressions, @typescript-eslint/no-unsafe-argument */
+    onWSOpen() {
+        this.status = "handshaking";
+        this.client.emit("connect", this.id);
+        this.lastHeartbeatAck = true;
+    }
+    async restartGuildCreateTimeout() {
+        if (this._guildCreateTimeout) {
+            clearTimeout(this._guildCreateTimeout);
+            this._guildCreateTimeout = null;
+        }
+        if (!this.ready) {
+            if (this.client.unavailableGuilds.size === 0) {
+                return this.checkReady();
+            }
+            this._guildCreateTimeout = setTimeout(this.checkReady.bind(this), this.client.shards.options.guildCreateTimeout);
+        }
+    }
+    sendPresenceUpdate() {
+        this.send(Constants_1.GatewayOPCodes.PRESENCE_UPDATE, {
+            activities: this.presence.activities,
+            afk: !!this.presence.afk,
+            since: this.presence.status === "idle" ? Date.now() : null,
+            status: this.presence.status
+        });
+    }
+    get _token() {
+        return this.client.options.auth;
+    }
+    /** Connect this shard. */
+    async connect() {
+        if (this.ws && this.ws.readyState !== ws_1.default.CLOSED) {
+            this.client.emit("error", new Error("Shard#connect called while existing connection is established."), this.id);
+            return;
+        }
+        ++this.connectAttempts;
+        this.connecting = true;
+        await this.initialize();
+    }
+    disconnect(reconnect = this.client.shards.options.autoReconnect, error) {
+        if (!this.ws) {
+            return;
+        }
+        if (this._heartbeatInterval) {
+            clearInterval(this._heartbeatInterval);
+            this._heartbeatInterval = null;
+        }
+        if (this.ws.readyState !== ws_1.default.CLOSED) {
+            this.ws.removeAllListeners();
+            try {
+                if (reconnect && this.sessionID) {
+                    if (this.ws.readyState === ws_1.default.OPEN) {
+                        this.client.emit("debug", `Closing websocket (state: ${this.ws.readyState})`, this.id);
+                        this.ws.terminate();
+                    }
+                    else {
+                        this.ws.close(4999, "Reconnect");
+                    }
+                }
+                else {
+                    this.ws.close(1000, "Normal Close");
+                }
+            }
+            catch (err) {
+                this.client.emit("error", err, this.id);
+            }
+        }
+        this.ws = null;
+        this.reset();
+        if (error) {
+            if (error instanceof Errors_1.GatewayError && [1001, 1006].includes(error.code)) {
+                this.client.emit("debug", error.message, this.id);
+            }
+            else {
+                this.client.emit("error", error, this.id);
+            }
+        }
+        this.emit("disconnect", error);
+        if (this.sessionID && this.connectAttempts >= this.client.shards.options.maxReconnectAttempts) {
+            this.client.emit("debug", `Automatically invalidating session due to excessive resume attempts | Attempt ${this.connectAttempts}`, this.id);
+            this.sessionID = null;
+        }
+        if (reconnect) {
+            if (this.sessionID) {
+                this.client.emit("debug", `Immediately reconnecting for potential resume | Attempt ${this.connectAttempts}`, this.id);
+                void this.client.shards["_connect"](this);
+            }
+            else {
+                this.client.emit("debug", `Queueing reconnect in ${this.reconnectInterval}ms | Attempt ${this.connectAttempts}`, this.id);
+                setTimeout(() => {
+                    void this.client.shards["_connect"](this);
+                }, this.reconnectInterval);
+                this.reconnectInterval = Math.min(Math.round(this.reconnectInterval * (Math.random() * 2 + 1)), 30000);
+            }
+        }
+        else {
+            this.hardReset();
+        }
+    }
+    /**
+     * Edit this shard's status.
+     * @param status The status.
+     * @param activities An array of activities.
+     */
+    async editStatus(status, activities = []) {
+        this.presence.status = status;
+        this.presence.activities = activities;
+        return this.sendPresenceUpdate();
+    }
+    hardReset() {
+        this.reset();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        for (const [, voiceAdapter] of this.client.voiceAdapters)
+            voiceAdapter.destroy();
+        this.sequence = 0;
+        this.sessionID = null;
+        this.reconnectInterval = 1000;
+        this.connectAttempts = 0;
+        this.ws = null;
+        this._heartbeatInterval = null;
+        this._guildCreateTimeout = null;
+        this.globalBucket = new Bucket_1.default(120, 60000, { reservedTokens: 5 });
+        this.presence = structuredClone(this.client.shards.options.presence);
+        this.presenceUpdateBucket = new Bucket_1.default(5, 20000);
+        this.resumeURL = null;
+    }
+    heartbeat(requested = false) {
+        // discord/discord-api-docs#1619
+        if (this.status === "resuming" || this.status === "identifying") {
+            return;
+        }
+        if (!requested) {
+            if (!this.lastHeartbeatAck) {
+                this.client.emit("debug", "Heartbeat timeout; " + JSON.stringify({
+                    lastReceived: this.lastHeartbeatReceived,
+                    lastSent: this.lastHeartbeatSent,
+                    interval: this._heartbeatInterval,
+                    status: this.status,
+                    timestamp: Date.now()
+                }));
+                return this.disconnect(undefined, new Error("Server didn't acknowledge previous heartbeat, possible lost connection."));
+            }
+            this.lastHeartbeatAck = false;
+        }
+        this.lastHeartbeatSent = Date.now();
+        this.send(Constants_1.GatewayOPCodes.HEARTBEAT, this.sequence, true);
+    }
+    identify() {
+        const data = {
+            token: this._token,
+            properties: this.client.shards.options.connectionProperties,
+            compress: this.client.shards.options.compress,
+            large_threshold: this.client.shards.options.largeThreshold,
+            shard: [this.id, this.client.shards.options.maxShards],
+            presence: this.presence,
+            intents: this.client.shards.options.intents
+        };
+        this.send(Constants_1.GatewayOPCodes.IDENTIFY, data);
+    }
+    [node_util_1.inspect.custom]() {
+        return Base_1.default.prototype[node_util_1.inspect.custom].call(this);
+    }
+    /**
+     * Request the members of a guild.
+     * @param guildID The ID of the guild to request the members of.
+     * @param options The options for requesting the members.
+     */
+    async requestGuildMembers(guildID, options) {
+        const opts = {
+            guild_id: guildID,
+            limit: options?.limit ?? 0,
+            user_ids: options?.userIDs,
+            query: options?.query,
+            nonce: (0, node_crypto_1.randomBytes)(16).toString("hex"),
+            presences: options?.presences ?? false
+        };
+        if (!opts.user_ids && !opts.query) {
+            opts.query = "";
+        }
+        if (!opts.query && !opts.user_ids) {
+            if (!(this.client.shards.options.intents & Constants_1.Intents.GUILD_MEMBERS)) {
+                throw new TypeError("Cannot request all members without the GUILD_MEMBERS intent.");
+            }
+            const guild = this.client.guilds.get(guildID);
+            if (guild) {
+                guild["updateMemberLimit"](true);
+            }
+        }
+        if (opts.presences && (!(this.client.shards.options.intents & Constants_1.Intents.GUILD_PRESENCES))) {
+            throw new TypeError("Cannot request presences without the GUILD_PRESENCES intent.");
+        }
+        if (opts.user_ids && opts.user_ids.length > 100) {
+            throw new TypeError("Cannot request more than 100 users at once.");
+        }
+        this.send(Constants_1.GatewayOPCodes.REQUEST_GUILD_MEMBERS, opts);
+        return new Promise((resolve, reject) => this._requestMembersPromise[opts.nonce] = {
+            members: [],
+            received: 0,
+            timeout: setTimeout(() => {
+                resolve(this._requestMembersPromise[opts.nonce].members);
+                delete this._requestMembersPromise[opts.nonce];
+            }, options?.timeout ?? this.client.rest.options.requestTimeout),
+            resolve,
+            reject
+        });
+    }
+    async requestSoundboardSounds(guildID, options) {
+        const opts = {
+            guild_ids: [guildID],
+            nonce: (0, node_crypto_1.randomBytes)(16).toString("hex")
+        };
+        this.send(Constants_1.GatewayOPCodes.REQUEST_SOUNDBOARD_SOUNDS, opts);
+        return new Promise((resolve, reject) => this._requestSoundboardSoundsPromise[opts.nonce] = {
+            guildID,
+            soundboardSounds: [],
+            timeout: setTimeout(() => {
+                resolve(this._requestSoundboardSoundsPromise[opts.nonce].soundboardSounds);
+                delete this._requestSoundboardSoundsPromise[opts.nonce];
+            }, options?.timeout ?? this.client.rest.options.requestTimeout),
+            resolve,
+            reject
+        });
+    }
+    reset() {
+        this.connecting = false;
+        this.ready = false;
+        this.preReady = false;
+        if (this._requestMembersPromise !== undefined) {
+            for (const guildID in this._requestMembersPromise) {
+                if (!this._requestMembersPromise[guildID]) {
+                    continue;
+                }
+                clearTimeout(this._requestMembersPromise[guildID].timeout);
+                this._requestMembersPromise[guildID].resolve(this._requestMembersPromise[guildID].received);
+            }
+        }
+        this._requestMembersPromise = {};
+        this._getAllUsersCount = {};
+        this._getAllUsersQueue = [];
+        this.latency = Infinity;
+        this.lastHeartbeatAck = true;
+        this.lastHeartbeatReceived = 0;
+        this.lastHeartbeatSent = 0;
+        this.status = "disconnected";
+        if (this._connectTimeout) {
+            clearTimeout(this._connectTimeout);
+        }
+        this._connectTimeout = null;
+    }
+    resume() {
+        this.status = "resuming";
+        this.send(Constants_1.GatewayOPCodes.RESUME, {
+            token: this._token,
+            session_id: this.sessionID,
+            seq: this.sequence
+        });
+    }
+    send(op, data, priority = false) {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            let i = 0, waitFor = 1;
+            const func = () => {
+                if (++i >= waitFor && this.ws && this.ws.readyState === ws_1.default.OPEN) {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
+                    const d = Erlpack ? Erlpack.pack({ op, d: data }) : JSON.stringify({ op, d: data });
+                    this.ws.send(d);
+                    if (typeof data === "object" && data && "token" in data) {
+                        data.token = "[REMOVED]";
+                    }
+                    this.client.emit("debug", JSON.stringify({ op, d: data }), this.id);
+                }
+            };
+            if (op === Constants_1.GatewayOPCodes.PRESENCE_UPDATE) {
+                ++waitFor;
+                this.presenceUpdateBucket.queue(func, priority);
+            }
+            this.globalBucket.queue(func, priority);
+        }
+    }
+    toString() {
+        return Base_1.default.prototype.toString.call(this);
+    }
+    /**
+     * Update the voice state of this shard.
+     * @param guildID The ID of the guild to update the voice state of.
+     * @param channelID The ID of the voice channel to join. Null to disconnect.
+     * @param options The options for updating the voice state.
+     */
+    updateVoiceState(guildID, channelID, options) {
+        this.send(Constants_1.GatewayOPCodes.VOICE_STATE_UPDATE, {
+            channel_id: channelID,
+            guild_id: guildID,
+            self_deaf: options?.selfDeaf ?? false,
+            self_mute: options?.selfMute ?? false
+        });
+    }
+}
+exports.default = Shard;