disgroove 2.2.7-dev.fca4921 → 3.0.0-dev.2cf2b90

package/dist/lib/gateway/Shard.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -31,518 +41,76 @@ const ws_1 = __importDefault(require("ws"));
 const constants_1 = require("../constants");
 const utils_1 = require("../utils");
 const pkg = __importStar(require("../../package.json"));
-const transformers_1 = require("../transformers");
+const Transmitter_1 = require("./Transmitter");
+const Dispatcher_1 = require("./Dispatcher");
 class Shard {
     id;
-    heartbeatInterval;
     client;
-    ws;
-    sessionID;
+    heartbeatInterval;
+    sessionId;
     resumeGatewayURL;
+    sequence;
+    ws;
+    transmitter;
+    dispatcher;
     constructor(id, client) {
         this.id = id;
-        this.heartbeatInterval = null;
         this.client = client;
-        this.ws = new ws_1.default("wss://gateway.discord.gg/?v=10&encoding=json", client.ws);
-        this.sessionID = null;
+        this.heartbeatInterval = null;
+        this.sessionId = null;
         this.resumeGatewayURL = null;
+        this.sequence = null;
+        this.ws = new ws_1.default("wss://gateway.discord.gg/?v=10&encoding=json", this.client.ws);
+        this.transmitter = new Transmitter_1.Transmitter(this.ws);
+        this.dispatcher = new Dispatcher_1.Dispatcher(this);
     }
     /** https://discord.com/developers/docs/topics/gateway#connections */
     connect() {
-        this.ws.on("open", () => this.onWebSocketOpen());
-        this.ws.on("message", (data) => this.onWebSocketMessage(data));
-        this.ws.on("error", (err) => this.onWebSocketError(err));
-        this.ws.on("close", (code, reason) => this.onWebSocketClose(code, reason));
+        if (this.ws) {
+            this.ws.on("open", () => this.onWebSocketOpen());
+            this.ws.on("message", (data) => this.onWebSocketMessage(data));
+            this.ws.on("error", (err) => this.onWebSocketError(err));
+            this.ws.on("close", (code, reason) => this.onWebSocketClose(code, reason));
+        }
     }
-    /** https://discord.com/developers/docs/topics/gateway#connections */
-    disconnect() {
+    /** https://discord.com/developers/docs/events/gateway#initiating-a-disconnect */
+    disconnect(reconnect) {
         if (this.heartbeatInterval) {
             clearInterval(this.heartbeatInterval);
             this.heartbeatInterval = null;
         }
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#heartbeat */
-    heartbeat(lastSequence) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.Heartbeat,
-            d: lastSequence,
-        }));
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#identify */
-    identify(options) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.Identify,
-            d: {
-                token: options.token,
-                properties: {
-                    os: options.properties.os,
-                    browser: options.properties.browser,
-                    device: options.properties.device,
-                },
-                compress: options.compress,
-                large_threshold: options.largeThreshold,
-                shard: options.shard,
-                presence: options.presence,
-                intents: options.intents,
-            },
-        }));
-    }
-    onDispatch(packet) {
-        this.client.emit("dispatch", packet, this.id);
-        switch (packet.t) {
-            case constants_1.GatewayEvents.Ready:
-                {
-                    this.sessionID = packet.d.session_id;
-                    this.resumeGatewayURL = packet.d.resume_gateway_url;
-                    this.client.user = transformers_1.Users.userFromRaw(packet.d.user);
-                    this.client.application = packet.d.application;
-                    this.client.emit("ready");
+        if (this.ws) {
+            if (this.ws.readyState !== ws_1.default.CLOSED) {
+                this.ws.removeAllListeners();
+                if (reconnect &&
+                    this.sessionId &&
+                    this.sequence &&
+                    this.resumeGatewayURL) {
+                    if (this.ws.readyState === ws_1.default.OPEN) {
+                        this.ws.terminate();
+                    }
+                    else {
+                        this.ws.close(1000, "Resume Attempt - Reconnect");
+                    }
                 }
-                break;
-            case constants_1.GatewayEvents.Resumed:
-                this.client.emit("resumed");
-                break;
-            case constants_1.GatewayEvents.ApplicationCommandPermissionsUpdate:
-                this.client.emit("applicationCommandPermissionsUpdate", transformers_1.Guilds.guildApplicationCommandPermissionsFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationRuleCreate:
-                this.client.emit("autoModerationRuleCreate", transformers_1.AutoModeration.autoModerationRuleFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationRuleUpdate:
-                this.client.emit("autoModerationRuleUpdate", transformers_1.AutoModeration.autoModerationRuleFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationRuleDelete:
-                this.client.emit("autoModerationRuleDelete", transformers_1.AutoModeration.autoModerationRuleFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.AutoModerationActionExecution:
-                this.client.emit("autoModerationActionExecution", {
-                    guildID: packet.d.guild_id,
-                    action: {
-                        type: packet.d.action.type,
-                        metadata: {
-                            channelID: packet.d.action.metadata.channel_id,
-                            durationSeconds: packet.d.action.metadata.duration_seconds,
-                            customMessage: packet.d.action.metadata.custom_message,
-                        },
-                    },
-                    ruleID: packet.d.rule_id,
-                    ruleTriggerType: packet.d.rule_trigger_type,
-                    userID: packet.d.user_id,
-                    channelID: packet.d.channel_id,
-                    messageID: packet.d.message_id,
-                    alertSystemMessageID: packet.d.alert_system_message_id,
-                    content: packet.d.content,
-                    matchedKeyword: packet.d.matched_keyword,
-                    matchedContent: packet.d.matched_content,
-                });
-                break;
-            case constants_1.GatewayEvents.ChannelCreate:
-                this.client.emit("channelCreate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ChannelUpdate:
-                this.client.emit("channelUpdate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ChannelDelete:
-                this.client.emit("channelDelete", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ChannelPinsUpdate:
-                this.client.emit("channelPinsUpdate", {
-                    guildID: packet.d.guild_id,
-                    channelID: packet.d.channel_id,
-                    lastPinTimestamp: packet.d.last_pin_timestamp,
-                });
-                break;
-            case constants_1.GatewayEvents.ThreadCreate:
-                this.client.emit("threadCreate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ThreadUpdate:
-                this.client.emit("threadUpdate", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ThreadDelete:
-                this.client.emit("threadDelete", transformers_1.Channels.channelFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.ThreadListSync:
-                this.client.emit("threadListSync", {
-                    guildID: packet.d.guild_id,
-                    channelIDs: packet.d.channel_ids,
-                    threads: packet.d.threads.map((thread) => transformers_1.Channels.channelFromRaw(thread)),
-                    members: packet.d.members.map((threadMember) => transformers_1.Channels.threadMemberFromRaw(threadMember)),
-                });
-                break;
-            case constants_1.GatewayEvents.ThreadMemberUpdate:
-                this.client.emit("threadMemberUpdate", {
-                    id: packet.d.id,
-                    userID: packet.d.user_id,
-                    joinTimestamp: packet.d.join_timestamp,
-                    flags: packet.d.flags,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.ThreadMembersUpdate:
-                this.client.emit("threadMembersUpdate", {
-                    id: packet.d.id,
-                    guildID: packet.d.guild_id,
-                    memberCount: packet.d.member_count,
-                    addedMembers: packet.d.members.map((threadMember) => transformers_1.Channels.threadMemberFromRaw(threadMember)),
-                    removedMemberIDs: packet.d.removed_member_ids,
-                });
-                break;
-            case constants_1.GatewayEvents.EntitlementCreate:
-                this.client.emit("entitlementCreate", transformers_1.Entitlements.entitlementFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.EntitlementUpdate:
-                this.client.emit("entitlementUpdate", transformers_1.Entitlements.entitlementFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.EntitlementDelete:
-                this.client.emit("entitlementDelete", transformers_1.Entitlements.entitlementFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildCreate:
-                {
-                    this.client.guildShardMap[packet.d.id] = this.id;
-                    this.client.guilds.set(packet.d.id, transformers_1.Guilds.guildFromRaw(packet.d));
-                    this.client.emit("guildCreate", transformers_1.Guilds.guildFromRaw(packet.d));
-                }
-                break;
-            case constants_1.GatewayEvents.GuildUpdate:
-                {
-                    this.client.guilds.set(packet.d.id, transformers_1.Guilds.guildFromRaw(packet.d));
-                    this.client.emit("guildUpdate", transformers_1.Guilds.guildFromRaw(packet.d));
-                }
-                break;
-            case constants_1.GatewayEvents.GuildDelete:
-                {
-                    delete this.client.guildShardMap[packet.d.id];
-                    this.client.guilds.delete(packet.d.id);
-                    this.client.emit("guildDelete", {
-                        id: packet.d.id,
-                        unavailable: packet.d.unavailable,
-                    });
-                }
-                break;
-            case constants_1.GatewayEvents.GuildAuditLogEntryCreate:
-                this.client.emit("guildAuditLogEntryCreate", {
-                    ...transformers_1.AuditLogs.auditLogEntryFromRaw(packet.d),
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildBanAdd:
-                this.client.emit("guildBanAdd", {
-                    guildID: packet.d.guild_id,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                });
-                break;
-            case constants_1.GatewayEvents.GuildBanRemove:
-                this.client.emit("guildBanRemove", {
-                    guildID: packet.d.guild_id,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                });
-                break;
-            case constants_1.GatewayEvents.GuildEmojisUpdate:
-                this.client.emit("guildEmojisUpdate", packet.d.emojis.map((emoji) => transformers_1.Emojis.emojiFromRaw(emoji)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildStickersUpdate:
-                this.client.emit("guildStickersUpdate", packet.d.stickers.map((sticker) => transformers_1.Stickers.stickerFromRaw(sticker)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildIntegrationsUpdate:
-                this.client.emit("guildIntegrationsUpdate", packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildMemberAdd:
-                this.client.emit("guildMemberAdd", {
-                    ...transformers_1.Guilds.guildMemberFromRaw(packet.d),
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildMemberRemove:
-                this.client.emit("guildMemberRemove", {
-                    guildID: packet.d.guild_id,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                });
-                break;
-            case constants_1.GatewayEvents.GuildMemberUpdate:
-                this.client.emit("guildMemberUpdate", {
-                    guildID: packet.d.guild_id,
-                    roles: packet.d.roles,
-                    user: transformers_1.Users.userFromRaw(packet.d.user),
-                    nick: packet.d.nick,
-                    avatar: packet.d.avatar,
-                    banner: packet.d.banner,
-                    joinedAt: packet.d.joined_at,
-                    premiumSince: packet.d.premium_since,
-                    deaf: packet.d.deaf,
-                    mute: packet.d.mute,
-                    pending: packet.d.pending,
-                    communicationDisabledUntil: packet.d.communication_disabled_until,
-                    flags: packet.d.flags,
-                    avatarDecorationData: packet.d.avatar_decoration_data !== undefined
-                        ? {
-                            asset: packet.d.asset,
-                            skuID: packet.d.sku_id,
-                        }
-                        : undefined,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildMembersChunk:
-                this.client.emit("guildMembersChunk", {
-                    guildID: packet.d.guild_id,
-                    members: packet.d.members.map((guildMember) => transformers_1.Guilds.guildMemberFromRaw(guildMember)),
-                    chunkIndex: packet.d.chunk_index,
-                    chunkCount: packet.d.chunk_count,
-                    notFound: packet.d.not_found,
-                    presences: packet.d.presences?.map((presence) => transformers_1.Presences.presenceFromRaw(presence)),
-                    nonce: packet.d.nonce,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildRoleCreate:
-                this.client.emit("guildRoleCreate", transformers_1.Roles.roleFromRaw(packet.d.role), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildRoleUpdate:
-                this.client.emit("guildRoleUpdate", transformers_1.Roles.roleFromRaw(packet.d.role), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildRoleDelete:
-                this.client.emit("guildRoleDelete", packet.d.role_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventCreate:
-                this.client.emit("guildScheduledEventCreate", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventUpdate:
-                this.client.emit("guildScheduledEventUpdate", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventDelete:
-                this.client.emit("guildScheduledEventDelete", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventUserAdd:
-                this.client.emit("guildScheduledEventUserAdd", packet.d.user_id, packet.d.guild_scheduled_event_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildScheduledEventUserRemove:
-                this.client.emit("guildScheduledEventUserRemove", packet.d.user_id, packet.d.guild_scheduled_event_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundCreate:
-                this.client.emit("guildSoundboardSoundCreate", transformers_1.Soundboards.soundboardSoundFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundUpdate:
-                this.client.emit("guildSoundboardSoundUpdate", transformers_1.Soundboards.soundboardSoundFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundDelete:
-                this.client.emit("guildSoundboardSoundDelete", {
-                    soundID: packet.d.sound_id,
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.GuildSoundboardSoundsUpdate:
-                this.client.emit("guildSoundboardSoundsUpdate", packet.d.soundboard_sounds.map((sound) => transformers_1.Soundboards.soundboardSoundFromRaw(sound)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.SoundboardSounds:
-                this.client.emit("soundboardSounds", packet.d.soundboard_sounds.map((sound) => transformers_1.Soundboards.soundboardSoundFromRaw(sound)), packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.IntegrationCreate:
-                this.client.emit("integrationCreate", {
-                    ...transformers_1.Guilds.integrationFromRaw(packet.d),
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.IntegrationUpdate:
-                this.client.emit("integrationUpdate", {
-                    ...transformers_1.Guilds.integrationFromRaw(packet.d),
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.IntegrationDelete:
-                this.client.emit("integrationDelete", {
-                    id: packet.d.id,
-                    guildID: packet.d.guild_id,
-                    applicationID: packet.d.application_id,
-                });
-                break;
-            case constants_1.GatewayEvents.InteractionCreate:
-                this.client.emit("interactionCreate", transformers_1.Interactions.interactionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.InviteCreate:
-                this.client.emit("inviteCreate", {
-                    channelID: packet.d.channel_id,
-                    code: packet.d.code,
-                    createdAt: packet.d.created_at,
-                    guildID: packet.d.guild_id,
-                    inviter: packet.d.inviter !== undefined
-                        ? transformers_1.Users.userFromRaw(packet.d.inviter)
-                        : undefined,
-                    maxAge: packet.d.max_age,
-                    maxUses: packet.d.max_uses,
-                    targetType: packet.d.target_type,
-                    targetUser: packet.d.target_user !== undefined
-                        ? transformers_1.Users.userFromRaw(packet.d.target_user)
-                        : undefined,
-                    targetApplication: packet.d.target_application !== undefined
-                        ? transformers_1.Applications.applicationFromRaw(packet.d.target_application)
-                        : undefined,
-                    temporary: packet.d.temporary,
-                    uses: packet.d.uses,
-                });
-                break;
-            case constants_1.GatewayEvents.InviteDelete:
-                this.client.emit("inviteDelete", {
-                    channelID: packet.d.channel_id,
-                    guildID: packet.d.guild_id,
-                    code: packet.d.code,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageCreate:
-                this.client.emit("messageCreate", {
-                    ...transformers_1.Messages.messageFromRaw(packet.d),
-                    guildID: packet.d.guild_id,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                    mentions: packet.d.mentions.map((mention) => transformers_1.Users.userFromRaw(mention)),
-                });
-                break;
-            case constants_1.GatewayEvents.MessageUpdate:
-                this.client.emit("messageUpdate", transformers_1.Messages.messageFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.MessageDelete:
-                this.client.emit("messageDelete", {
-                    id: packet.d.id,
-                    channelID: packet.d.channel_id,
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageDeleteBulk:
-                this.client.emit("messageDeleteBulk", {
-                    ids: packet.d.ids,
-                    channelID: packet.d.channel_id,
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionAdd:
-                this.client.emit("messageReactionAdd", {
-                    userID: packet.d.user_id,
-                    channelID: packet.d.user_id,
-                    messageID: packet.d.user_id,
-                    guildID: packet.d.user_id,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                    emoji: transformers_1.Emojis.emojiFromRaw(packet.d.emoji),
-                    messageAuthorID: packet.d.message_author_id,
-                    burst: packet.d.burst,
-                    burstColors: packet.d.burst_colors,
-                    type: packet.d.type,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionRemove:
-                this.client.emit("messageReactionRemove", {
-                    userID: packet.d.user_id,
-                    channelID: packet.d.user_id,
-                    messageID: packet.d.user_id,
-                    guildID: packet.d.user_id,
-                    emoji: transformers_1.Emojis.emojiFromRaw(packet.d.emoji),
-                    burst: packet.d.burst,
-                    type: packet.d.type,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionRemoveAll:
-                this.client.emit("messageReactionRemoveAll", {
-                    channelID: packet.d.channel_id,
-                    messageID: packet.d.message_id,
-                    guildID: packet.d.guild_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessageReactionRemoveEmoji:
-                this.client.emit("messageReactionRemoveEmoji", {
-                    channelID: packet.d.channel_id,
-                    guildID: packet.d.guild_id,
-                    messageID: packet.d.message_id,
-                    emoji: transformers_1.Emojis.emojiFromRaw(packet.d.emoji),
-                });
-                break;
-            case constants_1.GatewayEvents.PresenceUpdate:
-                this.client.emit("presenceUpdate", transformers_1.Presences.presenceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.StageInstanceCreate:
-                this.client.emit("stageInstanceCreate", transformers_1.StageInstances.stageInstanceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.StageInstanceUpdate:
-                this.client.emit("stageInstanceUpdate", transformers_1.StageInstances.stageInstanceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.StageInstanceDelete:
-                this.client.emit("stageInstanceDelete", transformers_1.StageInstances.stageInstanceFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.TypingStart:
-                this.client.emit("typingStart", {
-                    channelID: packet.d.channel_id,
-                    guildID: packet.d.guild_id,
-                    userID: packet.d.user_id,
-                    timestamp: packet.d.timestamp,
-                    member: packet.d.member !== undefined
-                        ? transformers_1.Guilds.guildMemberFromRaw(packet.d.member)
-                        : undefined,
-                });
-                break;
-            case constants_1.GatewayEvents.UserUpdate:
-                this.client.emit("userUpdate", transformers_1.Users.userFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.VoiceChannelEffectSend:
-                this.client.emit("voiceChannelEffectSend", {
-                    channelID: packet.d.channel_id,
-                    guildID: packet.d.guild_id,
-                    userID: packet.d.user_id,
-                    emoji: packet.d.emoji !== null
-                        ? transformers_1.Emojis.emojiFromRaw(packet.d.emoji)
-                        : null,
-                    animationType: packet.d.animation_type,
-                    animationID: packet.d.animation_id,
-                    soundID: packet.d.sound_id,
-                    soundVolume: packet.d.sound_volume,
-                });
-                break;
-            case constants_1.GatewayEvents.VoiceStateUpdate:
-                this.client.emit("voiceStateUpdate", transformers_1.Voice.voiceStateFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.VoiceServerUpdate:
-                {
-                    this.client.emit("voiceServerUpdate", {
-                        token: packet.d.token,
-                        guildID: packet.d.guild_id,
-                        endpoint: packet.d.endpoint,
-                    });
+                else {
+                    this.ws.close(1000, "Session Invalidated - Disconnect");
                 }
-                break;
-            case constants_1.GatewayEvents.WebhooksUpdate:
-                this.client.emit("webhooksUpdate", packet.d.channel_id, packet.d.guild_id);
-                break;
-            case constants_1.GatewayEvents.SubscriptionCreate:
-                this.client.emit("subscriptionCreate", transformers_1.Subscriptions.subscriptionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.SubscriptionUpdate:
-                this.client.emit("subscriptionUpdate", transformers_1.Subscriptions.subscriptionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.SubscriptionDelete:
-                this.client.emit("subscriptionDelete", transformers_1.Subscriptions.subscriptionFromRaw(packet.d));
-                break;
-            case constants_1.GatewayEvents.MessagePollVoteAdd:
-                this.client.emit("messagePollVoteAdd", {
-                    userID: packet.d.user_id,
-                    channelID: packet.d.channel_id,
-                    messageID: packet.d.message_id,
-                    guildID: packet.d.guild_id,
-                    answerID: packet.d.answer_id,
-                });
-                break;
-            case constants_1.GatewayEvents.MessagePollVoteRemove:
-                this.client.emit("messagePollVoteRemove", {
-                    userID: packet.d.user_id,
-                    channelID: packet.d.channel_id,
-                    messageID: packet.d.message_id,
-                    guildID: packet.d.guild_id,
-                    answerID: packet.d.answer_id,
-                });
-                break;
+                this.ws = null;
+                this.transmitter = new Transmitter_1.Transmitter(null);
+            }
+            if (reconnect &&
+                this.sessionId &&
+                this.sequence &&
+                this.resumeGatewayURL) {
+                this.ws = new ws_1.default(this.resumeGatewayURL, this.client.ws);
+                this.transmitter = new Transmitter_1.Transmitter(this.ws);
+                this.connect();
+            }
         }
     }
-    onWebSocketOpen() {
-        this.identify({
+    identify() {
+        this.transmitter.identify({
             token: this.client.token,
             properties: {
                 os: this.client.properties?.os ?? process.platform,
@@ -572,21 +140,47 @@ class Shard {
             intents: this.client.intents,
         });
     }
+    onWebSocketOpen() { }
     onWebSocketMessage(data) {
         const packet = JSON.parse(data.toString());
         switch (packet.op) {
             case constants_1.GatewayOPCodes.Dispatch:
-                this.onDispatch(packet);
+                this.sequence = packet.s;
+                this.client.emit("dispatch", packet, this.id);
+                this.dispatcher.dispatch(packet.t, packet.d);
+                break;
+            case constants_1.GatewayOPCodes.Heartbeat:
+                this.client.emit("heartbeat", this.id);
+                this.transmitter.heartbeat(this.sequence);
                 break;
             case constants_1.GatewayOPCodes.Reconnect:
-                this.client.emit("reconnect");
+                {
+                    this.client.emit("reconnect", this.id);
+                    this.disconnect(this.client.reconnect);
+                }
                 break;
             case constants_1.GatewayOPCodes.InvalidSession:
-                this.client.emit("invalidSession");
+                {
+                    this.client.emit("invalidSession", this.id);
+                    if (packet.d) {
+                        this.resume();
+                    }
+                    else {
+                        this.sequence = null;
+                        this.sessionId = null;
+                        this.identify();
+                    }
+                }
                 break;
             case constants_1.GatewayOPCodes.Hello:
                 {
-                    this.heartbeatInterval = setInterval(() => this.heartbeat(null), packet.d.heartbeat_interval);
+                    this.heartbeatInterval = setInterval(() => this.transmitter.heartbeat(this.sequence), packet.d.heartbeat_interval);
+                    if (this.sessionId && this.sequence && this.resumeGatewayURL) {
+                        this.resume();
+                    }
+                    else {
+                        this.identify();
+                    }
                     this.client.emit("hello", packet.d.heartbeat_interval, this.id);
                 }
                 break;
@@ -599,74 +193,31 @@ class Shard {
         throw err;
     }
     onWebSocketClose(code, reason) {
-        if (code === 1000)
-            return;
-        throw new utils_1.GatewayError(code, reason.toString());
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#request-guild-members */
-    requestGuildMembers(options) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.RequestGuildMembers,
-            d: {
-                guild_id: options.guildID,
-                query: options.query,
-                limit: options.limit,
-                presences: options.presences,
-                user_ids: options.userIDs,
-                nonce: options.nonce,
-            },
-        }));
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#request-soundboard-sounds */
-    requestSoundboardSounds(options) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.RequestSoundboardSounds,
-            d: {
-                guild_ids: options.guildIDs,
-            },
-        }));
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#resume */
-    resume(options) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.Resume,
-            d: {
-                token: options.token,
-                session_id: options.sessionID,
-                seq: options.seq,
-            },
-        }));
-    }
-    /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
-    updatePresence(options) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.PresenceUpdate,
-            d: {
-                since: options.status === constants_1.StatusTypes.Idle ? Date.now() : null,
-                activities: options.activities?.map((activity) => ({
-                    name: activity.type === constants_1.ActivityType.Custom
-                        ? "Custom Status"
-                        : activity.name,
-                    type: activity.type,
-                    url: activity.url,
-                    state: activity.state,
-                })),
-                status: options.status ?? constants_1.StatusTypes.Online,
-                afk: !!options.afk,
-            },
-        }));
+        let reconnect = false;
+        switch (code) {
+            case 1000:
+                break;
+            case constants_1.GatewayCloseEventCodes.UnknownError:
+            case constants_1.GatewayCloseEventCodes.UnknownOPCode:
+            case constants_1.GatewayCloseEventCodes.DecodeError:
+            case constants_1.GatewayCloseEventCodes.NotAuthenticated:
+            case constants_1.GatewayCloseEventCodes.AlreadyAuthenticated:
+            case constants_1.GatewayCloseEventCodes.InvalidSequence:
+            case constants_1.GatewayCloseEventCodes.RateLimited:
+            case constants_1.GatewayCloseEventCodes.SessionTimedOut:
+                reconnect = this.client.reconnect;
+                break;
+            default:
+                throw new utils_1.GatewayError(code, reason.toString());
+        }
+        this.disconnect(reconnect);
     }
-    /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
-    updateVoiceState(options) {
-        this.ws.send(JSON.stringify({
-            op: constants_1.GatewayOPCodes.VoiceStateUpdate,
-            d: {
-                guild_id: options.guildID,
-                channel_id: options.channelID,
-                self_mute: options.selfMute,
-                self_deaf: options.selfDeaf,
-            },
-        }));
+    resume() {
+        this.transmitter.resume({
+            token: this.client.token,
+            sessionId: this.sessionId,
+            seq: this.sequence,
+        });
     }
 }
 exports.Shard = Shard;