disgroove 3.0.0-dev.fd521a8 → 3.0.1-dev.24a02ed

package/dist/lib/gateway/Dispatcher.js

@@ -0,0 +1,472 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Handlers = exports.Dispatcher = void 0;
+const constants_1 = require("../constants");
+const transformers_1 = require("../transformers");
+class Dispatcher {
+    shard;
+    constructor(shard) {
+        this.shard = shard;
+    }
+    dispatch(event, data) {
+        const handler = exports.Handlers[event];
+        if (handler)
+            handler(this.shard, data);
+    }
+}
+exports.Dispatcher = Dispatcher;
+exports.Handlers = {
+    [constants_1.GatewayEvents.Ready]: (shard, data) => {
+        shard.sessionId = data.session_id;
+        shard.resumeGatewayURL = `${data.resume_gateway_url}?v=10&encoding=json`;
+        shard.client.user = transformers_1.Users.userFromRaw(data.user);
+        shard.client.application = data.application;
+        shard.client.emit("ready", shard.id);
+    },
+    [constants_1.GatewayEvents.Resumed]: (shard) => {
+        shard.client.emit("resumed", shard.id);
+    },
+    [constants_1.GatewayEvents.RateLimited]: (shard, data) => {
+        if (data.opcode === constants_1.GatewayOPCodes.RequestGuildMembers) {
+            shard.client.emit("rateLimited", {
+                opcode: constants_1.GatewayOPCodes.RequestGuildMembers,
+                retryAfter: data.retry_after,
+                meta: {
+                    guildId: data.meta.guild_id,
+                    nonce: data.meta.nonce,
+                },
+            }, shard.id);
+        }
+    },
+    [constants_1.GatewayEvents.ApplicationCommandPermissionsUpdate]: (shard, data) => {
+        shard.client.emit("applicationCommandPermissionsUpdate", transformers_1.Guilds.guildApplicationCommandPermissionsFromRaw(data));
+    },
+    [constants_1.GatewayEvents.AutoModerationRuleCreate]: (shard, data) => shard.client.emit("autoModerationRuleCreate", transformers_1.AutoModeration.autoModerationRuleFromRaw(data)),
+    [constants_1.GatewayEvents.AutoModerationRuleUpdate]: (shard, data) => shard.client.emit("autoModerationRuleUpdate", transformers_1.AutoModeration.autoModerationRuleFromRaw(data)),
+    [constants_1.GatewayEvents.AutoModerationRuleDelete]: (shard, data) => shard.client.emit("autoModerationRuleDelete", transformers_1.AutoModeration.autoModerationRuleFromRaw(data)),
+    [constants_1.GatewayEvents.AutoModerationActionExecution]: (shard, data) => shard.client.emit("autoModerationActionExecution", {
+        guildId: data.guild_id,
+        action: {
+            type: data.action.type,
+            metadata: {
+                channelId: data.action.metadata.channel_id,
+                durationSeconds: data.action.metadata.duration_seconds,
+                customMessage: data.action.metadata.custom_message,
+            },
+        },
+        ruleId: data.rule_id,
+        ruleTriggerType: data.rule_trigger_type,
+        userId: data.user_id,
+        channelId: data.channel_id,
+        messageId: data.message_id,
+        alertSystemMessageId: data.alert_system_message_id,
+        content: data.content,
+        matchedKeyword: data.matched_keyword,
+        matchedContent: data.matched_content,
+    }),
+    [constants_1.GatewayEvents.ChannelCreate]: (shard, data) => shard.client.emit("channelCreate", transformers_1.Channels.channelFromRaw(data)),
+    [constants_1.GatewayEvents.ChannelUpdate]: (shard, data) => shard.client.emit("channelUpdate", transformers_1.Channels.channelFromRaw(data)),
+    [constants_1.GatewayEvents.ChannelDelete]: (shard, data) => shard.client.emit("channelDelete", transformers_1.Channels.channelFromRaw(data)),
+    [constants_1.GatewayEvents.ChannelPinsUpdate]: (shard, data) => shard.client.emit("channelPinsUpdate", {
+        guildId: data.guild_id,
+        channelId: data.channel_id,
+        lastPinTimestamp: data.last_pin_timestamp,
+    }),
+    [constants_1.GatewayEvents.ThreadCreate]: (shard, data) => shard.client.emit("threadCreate", transformers_1.Channels.channelFromRaw(data)),
+    [constants_1.GatewayEvents.ThreadUpdate]: (shard, data) => shard.client.emit("threadUpdate", transformers_1.Channels.channelFromRaw(data)),
+    [constants_1.GatewayEvents.ThreadDelete]: (shard, data) => shard.client.emit("threadDelete", transformers_1.Channels.channelFromRaw(data)),
+    [constants_1.GatewayEvents.ThreadListSync]: (shard, data) => shard.client.emit("threadListSync", {
+        guildId: data.guild_id,
+        channelIds: data.channel_ids,
+        threads: data.threads.map((thread) => transformers_1.Channels.channelFromRaw(thread)),
+        members: data.members.map((threadMember) => transformers_1.Channels.threadMemberFromRaw(threadMember)),
+    }),
+    [constants_1.GatewayEvents.ThreadMemberUpdate]: (shard, data) => {
+        shard.client.emit("threadMemberUpdate", {
+            id: data.id,
+            userId: data.user_id,
+            joinTimestamp: data.join_timestamp,
+            flags: data.flags,
+            member: data.member !== undefined
+                ? transformers_1.Guilds.guildMemberFromRaw(data.member)
+                : undefined,
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.ThreadMembersUpdate]: (shard, data) => {
+        shard.client.emit("threadMembersUpdate", {
+            id: data.id,
+            guildId: data.guild_id,
+            memberCount: data.member_count,
+            addedMembers: data.added_members?.map((threadMember) => transformers_1.Channels.threadMemberFromRaw(threadMember)),
+            removedMemberIds: data.removed_member_ids,
+        });
+    },
+    [constants_1.GatewayEvents.EntitlementCreate]: (shard, data) => {
+        shard.client.emit("entitlementCreate", transformers_1.Entitlements.entitlementFromRaw(data));
+    },
+    [constants_1.GatewayEvents.EntitlementUpdate]: (shard, data) => {
+        shard.client.emit("entitlementUpdate", transformers_1.Entitlements.entitlementFromRaw(data));
+    },
+    [constants_1.GatewayEvents.EntitlementDelete]: (shard, data) => {
+        shard.client.emit("entitlementDelete", transformers_1.Entitlements.entitlementFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildCreate]: (shard, data) => {
+        shard.client.guildShardMap.set(data.id, shard.id);
+        if (data.unavailable) {
+            const unavailableGuild = data;
+            shard.client.emit("guildCreate", unavailableGuild);
+        }
+        else {
+            const guild = data;
+            shard.client.emit("guildCreate", {
+                ...transformers_1.Guilds.guildFromRaw(guild),
+                joinedAt: guild.joined_at,
+                large: guild.large,
+                unavailable: guild.unavailable,
+                memberCount: guild.member_count,
+                voiceStates: guild.voice_states?.map((voiceState) => transformers_1.Voice.voiceStateFromRaw(voiceState)),
+                members: guild.members?.map((member) => transformers_1.Guilds.guildMemberFromRaw(member)),
+                channels: guild.channels?.map((channel) => transformers_1.Channels.channelFromRaw(channel)),
+                threads: guild.threads?.map((thread) => transformers_1.Channels.channelFromRaw(thread)),
+                presences: guild.presences?.map((presence) => transformers_1.Presences.presenceFromRaw(presence)),
+                stageInstances: guild.stage_instances?.map((stageInstance) => transformers_1.StageInstances.stageInstanceFromRaw(stageInstance)),
+                guildScheduledEvents: guild.guild_scheduled_events?.map((guildScheduledEvent) => transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(guildScheduledEvent)),
+                soundboardSounds: guild.soundboard_sounds?.map((soundboardSound) => transformers_1.Soundboards.soundboardSoundFromRaw(soundboardSound)),
+            });
+            shard.client.guilds.set(data.id, transformers_1.Guilds.guildFromRaw(data));
+        }
+    },
+    [constants_1.GatewayEvents.GuildUpdate]: (shard, data) => {
+        shard.client.guilds.set(data.id, transformers_1.Guilds.guildFromRaw(data));
+        shard.client.emit("guildUpdate", transformers_1.Guilds.guildFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildDelete]: (shard, data) => {
+        shard.client.guildShardMap.delete(data.id);
+        shard.client.guilds.delete(data.id);
+        shard.client.emit("guildDelete", data);
+    },
+    [constants_1.GatewayEvents.GuildAuditLogEntryCreate]: (shard, data) => {
+        shard.client.emit("guildAuditLogEntryCreate", {
+            ...transformers_1.AuditLogs.auditLogEntryFromRaw(data),
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.GuildBanAdd]: (shard, data) => {
+        shard.client.emit("guildBanAdd", {
+            guildId: data.guild_id,
+            user: transformers_1.Users.userFromRaw(data.user),
+        });
+    },
+    [constants_1.GatewayEvents.GuildBanRemove]: (shard, data) => {
+        shard.client.emit("guildBanRemove", {
+            guildId: data.guild_id,
+            user: transformers_1.Users.userFromRaw(data.user),
+        });
+    },
+    [constants_1.GatewayEvents.GuildEmojisUpdate]: (shard, data) => {
+        shard.client.emit("guildEmojisUpdate", data.emojis.map((emoji) => transformers_1.Emojis.emojiFromRaw(emoji)), data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildStickersUpdate]: (shard, data) => {
+        shard.client.emit("guildStickersUpdate", data.stickers.map((sticker) => transformers_1.Stickers.stickerFromRaw(sticker)), data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildIntegrationsUpdate]: (shard, data) => {
+        shard.client.emit("guildIntegrationsUpdate", data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildMemberAdd]: (shard, data) => {
+        shard.client.emit("guildMemberAdd", {
+            ...transformers_1.Guilds.guildMemberFromRaw(data),
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.GuildMemberRemove]: (shard, data) => {
+        shard.client.emit("guildMemberRemove", {
+            guildId: data.guild_id,
+            user: transformers_1.Users.userFromRaw(data.user),
+        });
+    },
+    [constants_1.GatewayEvents.GuildMemberUpdate]: (shard, data) => {
+        shard.client.emit("guildMemberUpdate", {
+            guildId: data.guild_id,
+            roles: data.roles,
+            user: transformers_1.Users.userFromRaw(data.user),
+            nick: data.nick,
+            avatar: data.avatar,
+            banner: data.banner,
+            joinedAt: data.joined_at,
+            premiumSince: data.premium_since,
+            deaf: data.deaf,
+            mute: data.mute,
+            pending: data.pending,
+            communicationDisabledUntil: data.communication_disabled_until,
+            flags: data.flags,
+            avatarDecorationData: data.avatar_decoration_data !== undefined
+                ? data.avatar_decoration_data !== null
+                    ? {
+                        asset: data.avatar_decoration_data.asset,
+                        skuId: data.avatar_decoration_data.sku_id,
+                    }
+                    : null
+                : undefined,
+        });
+    },
+    [constants_1.GatewayEvents.GuildMembersChunk]: (shard, data) => {
+        shard.client.emit("guildMembersChunk", {
+            guildId: data.guild_id,
+            members: data.members.map((guildMember) => transformers_1.Guilds.guildMemberFromRaw(guildMember)),
+            chunkIndex: data.chunk_index,
+            chunkCount: data.chunk_count,
+            notFound: data.not_found,
+            presences: data.presences?.map((presence) => transformers_1.Presences.presenceFromRaw(presence)),
+            nonce: data.nonce,
+        });
+    },
+    [constants_1.GatewayEvents.GuildRoleCreate]: (shard, data) => {
+        shard.client.emit("guildRoleCreate", transformers_1.Roles.roleFromRaw(data.role), data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildRoleUpdate]: (shard, data) => {
+        shard.client.emit("guildRoleUpdate", transformers_1.Roles.roleFromRaw(data.role), data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildRoleDelete]: (shard, data) => {
+        shard.client.emit("guildRoleDelete", data.role_id, data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildScheduledEventCreate]: (shard, data) => {
+        shard.client.emit("guildScheduledEventCreate", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildScheduledEventUpdate]: (shard, data) => {
+        shard.client.emit("guildScheduledEventUpdate", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildScheduledEventDelete]: (shard, data) => {
+        shard.client.emit("guildScheduledEventDelete", transformers_1.GuildScheduledEvents.guildScheduledEventFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildScheduledEventUserAdd]: (shard, data) => {
+        shard.client.emit("guildScheduledEventUserAdd", data.user_id, data.guild_scheduled_event_id, data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildScheduledEventUserRemove]: (shard, data) => {
+        shard.client.emit("guildScheduledEventUserRemove", data.user_id, data.guild_scheduled_event_id, data.guild_id);
+    },
+    [constants_1.GatewayEvents.GuildSoundboardSoundCreate]: (shard, data) => {
+        shard.client.emit("guildSoundboardSoundCreate", transformers_1.Soundboards.soundboardSoundFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildSoundboardSoundUpdate]: (shard, data) => {
+        shard.client.emit("guildSoundboardSoundUpdate", transformers_1.Soundboards.soundboardSoundFromRaw(data));
+    },
+    [constants_1.GatewayEvents.GuildSoundboardSoundDelete]: (shard, data) => {
+        shard.client.emit("guildSoundboardSoundDelete", {
+            soundId: data.sound_id,
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.GuildSoundboardSoundsUpdate]: (shard, data) => {
+        shard.client.emit("guildSoundboardSoundsUpdate", data.soundboard_sounds.map((sound) => transformers_1.Soundboards.soundboardSoundFromRaw(sound)), data.guild_id);
+    },
+    [constants_1.GatewayEvents.SoundboardSounds]: (shard, data) => {
+        shard.client.emit("soundboardSounds", data.soundboard_sounds.map((sound) => transformers_1.Soundboards.soundboardSoundFromRaw(sound)), data.guild_id);
+    },
+    [constants_1.GatewayEvents.IntegrationCreate]: (shard, data) => {
+        shard.client.emit("integrationCreate", {
+            ...transformers_1.Guilds.integrationFromRaw(data),
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.IntegrationUpdate]: (shard, data) => {
+        shard.client.emit("integrationUpdate", {
+            ...transformers_1.Guilds.integrationFromRaw(data),
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.IntegrationDelete]: (shard, data) => {
+        shard.client.emit("integrationDelete", {
+            id: data.id,
+            guildId: data.guild_id,
+            applicationId: data.application_id,
+        });
+    },
+    [constants_1.GatewayEvents.InteractionCreate]: (shard, data) => {
+        shard.client.emit("interactionCreate", transformers_1.Interactions.interactionFromRaw(data));
+    },
+    [constants_1.GatewayEvents.InviteCreate]: (shard, data) => {
+        shard.client.emit("inviteCreate", {
+            channelId: data.channel_id,
+            code: data.code,
+            createdAt: data.created_at,
+            guildId: data.guild_id,
+            inviter: data.inviter !== undefined
+                ? transformers_1.Users.userFromRaw(data.inviter)
+                : undefined,
+            maxAge: data.max_age,
+            maxUses: data.max_uses,
+            targetType: data.target_type,
+            targetUser: data.target_user !== undefined
+                ? transformers_1.Users.userFromRaw(data.target_user)
+                : undefined,
+            targetApplication: data.target_application !== undefined
+                ? transformers_1.Applications.applicationFromRaw(data.target_application)
+                : undefined,
+            temporary: data.temporary,
+            uses: data.uses,
+            expiresAt: data.expires_at,
+            roleIds: data.roles_ids
+        });
+    },
+    [constants_1.GatewayEvents.InviteDelete]: (shard, data) => {
+        shard.client.emit("inviteDelete", {
+            channelId: data.channel_id,
+            guildId: data.guild_id,
+            code: data.code,
+        });
+    },
+    [constants_1.GatewayEvents.MessageCreate]: (shard, data) => {
+        shard.client.emit("messageCreate", {
+            ...transformers_1.Messages.messageFromRaw(data),
+            guildId: data.guild_id,
+            member: data.member !== undefined
+                ? transformers_1.Guilds.guildMemberFromRaw(data.member)
+                : undefined,
+            mentions: data.mentions.map((mention) => transformers_1.Users.userFromRaw(mention)),
+        });
+    },
+    [constants_1.GatewayEvents.MessageUpdate]: (shard, data) => {
+        shard.client.emit("messageUpdate", transformers_1.Messages.messageFromRaw(data));
+    },
+    [constants_1.GatewayEvents.MessageDelete]: (shard, data) => {
+        shard.client.emit("messageDelete", {
+            id: data.id,
+            channelId: data.channel_id,
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.MessageDeleteBulk]: (shard, data) => {
+        shard.client.emit("messageDeleteBulk", {
+            ids: data.ids,
+            channelId: data.channel_id,
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.MessageReactionAdd]: (shard, data) => {
+        shard.client.emit("messageReactionAdd", {
+            userId: data.user_id,
+            channelId: data.channel_id,
+            messageId: data.message_id,
+            guildId: data.guild_id,
+            member: data.member !== undefined
+                ? transformers_1.Guilds.guildMemberFromRaw(data.member)
+                : undefined,
+            emoji: transformers_1.Emojis.emojiFromRaw(data.emoji),
+            messageAuthorId: data.message_author_id,
+            burst: data.burst,
+            burstColors: data.burst_colors,
+            type: data.type,
+        });
+    },
+    [constants_1.GatewayEvents.MessageReactionRemove]: (shard, data) => {
+        shard.client.emit("messageReactionRemove", {
+            userId: data.user_id,
+            channelId: data.channel_id,
+            messageId: data.message_id,
+            guildId: data.guild_id,
+            emoji: transformers_1.Emojis.emojiFromRaw(data.emoji),
+            burst: data.burst,
+            type: data.type,
+        });
+    },
+    [constants_1.GatewayEvents.MessageReactionRemoveAll]: (shard, data) => {
+        shard.client.emit("messageReactionRemoveAll", {
+            channelId: data.channel_id,
+            messageId: data.message_id,
+            guildId: data.guild_id,
+        });
+    },
+    [constants_1.GatewayEvents.MessageReactionRemoveEmoji]: (shard, data) => {
+        shard.client.emit("messageReactionRemoveEmoji", {
+            channelId: data.channel_id,
+            guildId: data.guild_id,
+            messageId: data.message_id,
+            emoji: transformers_1.Emojis.emojiFromRaw(data.emoji),
+        });
+    },
+    [constants_1.GatewayEvents.PresenceUpdate]: (shard, data) => {
+        shard.client.emit("presenceUpdate", transformers_1.Presences.presenceFromRaw(data));
+    },
+    [constants_1.GatewayEvents.StageInstanceCreate]: (shard, data) => {
+        shard.client.emit("stageInstanceCreate", transformers_1.StageInstances.stageInstanceFromRaw(data));
+    },
+    [constants_1.GatewayEvents.StageInstanceUpdate]: (shard, data) => {
+        shard.client.emit("stageInstanceUpdate", transformers_1.StageInstances.stageInstanceFromRaw(data));
+    },
+    [constants_1.GatewayEvents.StageInstanceDelete]: (shard, data) => {
+        shard.client.emit("stageInstanceDelete", transformers_1.StageInstances.stageInstanceFromRaw(data));
+    },
+    [constants_1.GatewayEvents.TypingStart]: (shard, data) => {
+        shard.client.emit("typingStart", {
+            channelId: data.channel_id,
+            guildId: data.guild_id,
+            userId: data.user_id,
+            timestamp: data.timestamp,
+            member: data.member !== undefined
+                ? transformers_1.Guilds.guildMemberFromRaw(data.member)
+                : undefined,
+        });
+    },
+    [constants_1.GatewayEvents.UserUpdate]: (shard, data) => {
+        shard.client.emit("userUpdate", transformers_1.Users.userFromRaw(data));
+    },
+    [constants_1.GatewayEvents.VoiceChannelEffectSend]: (shard, data) => {
+        shard.client.emit("voiceChannelEffectSend", {
+            channelId: data.channel_id,
+            guildId: data.guild_id,
+            userId: data.user_id,
+            emoji: data.emoji !== undefined
+                ? data.emoji !== null
+                    ? transformers_1.Emojis.emojiFromRaw(data.emoji)
+                    : null
+                : undefined,
+            animationType: data.animation_type,
+            animationId: data.animation_id,
+            soundId: data.sound_id,
+            soundVolume: data.sound_volume,
+        });
+    },
+    [constants_1.GatewayEvents.VoiceStateUpdate]: (shard, data) => {
+        shard.client.emit("voiceStateUpdate", transformers_1.Voice.voiceStateFromRaw(data));
+    },
+    [constants_1.GatewayEvents.VoiceServerUpdate]: (shard, data) => {
+        {
+            shard.client.emit("voiceServerUpdate", {
+                token: data.token,
+                guildId: data.guild_id,
+                endpoint: data.endpoint,
+            });
+        }
+    },
+    [constants_1.GatewayEvents.WebhooksUpdate]: (shard, data) => {
+        shard.client.emit("webhooksUpdate", data.channel_id, data.guild_id);
+    },
+    [constants_1.GatewayEvents.SubscriptionCreate]: (shard, data) => {
+        shard.client.emit("subscriptionCreate", transformers_1.Subscriptions.subscriptionFromRaw(data));
+    },
+    [constants_1.GatewayEvents.SubscriptionUpdate]: (shard, data) => {
+        shard.client.emit("subscriptionUpdate", transformers_1.Subscriptions.subscriptionFromRaw(data));
+    },
+    [constants_1.GatewayEvents.SubscriptionDelete]: (shard, data) => {
+        shard.client.emit("subscriptionDelete", transformers_1.Subscriptions.subscriptionFromRaw(data));
+    },
+    [constants_1.GatewayEvents.MessagePollVoteAdd]: (shard, data) => {
+        shard.client.emit("messagePollVoteAdd", {
+            userId: data.user_id,
+            channelId: data.channel_id,
+            messageId: data.message_id,
+            guildId: data.guild_id,
+            answerId: data.answer_id,
+        });
+    },
+    [constants_1.GatewayEvents.MessagePollVoteRemove]: (shard, data) => {
+        shard.client.emit("messagePollVoteRemove", {
+            userId: data.user_id,
+            channelId: data.channel_id,
+            messageId: data.message_id,
+            guildId: data.guild_id,
+            answerId: data.answer_id,
+        });
+    },
+};

package/dist/lib/gateway/Shard.d.ts

@@ -1,38 +1,26 @@
 import WebSocket from "ws";
 import { Client } from "../Client";
-import type { GatewayPresenceUpdate, GatewayVoiceStateUpdate, Identify, RequestGuildMembers, RequestSoundboardSounds, Resume } from "../types/gateway-events";
+import { Transmitter } from "./Transmitter";
+import { Dispatcher } from "./Dispatcher";
 export declare class Shard {
     id: number;
-    private heartbeatInterval;
     client: Client;
-    ws: WebSocket | null;
+    private heartbeatInterval;
     sessionId: string | null;
     resumeGatewayURL: string | null;
     sequence: number | null;
+    ws: WebSocket | null;
+    transmitter: Transmitter;
+    dispatcher: Dispatcher;
     constructor(id: number, client: Client);
     /** https://discord.com/developers/docs/topics/gateway#connections */
-    connect(reconnect: boolean): void;
+    connect(): void;
     /** https://discord.com/developers/docs/events/gateway#initiating-a-disconnect */
-    disconnect(): void;
-    /** https://discord.com/developers/docs/events/gateway#resuming */
-    reconnect(): void;
-    /** https://discord.com/developers/docs/topics/gateway-events#heartbeat */
-    heartbeat(lastSequence: number | null): void;
-    /** https://discord.com/developers/docs/topics/gateway-events#identify */
-    identify(options: Identify): void;
-    private onDispatch;
+    disconnect(reconnect: boolean): void;
+    identify(): void;
     private onWebSocketOpen;
     private onWebSocketMessage;
     private onWebSocketError;
     private onWebSocketClose;
-    /** https://discord.com/developers/docs/topics/gateway-events#request-guild-members */
-    requestGuildMembers(options: RequestGuildMembers): void;
-    /** https://discord.com/developers/docs/topics/gateway-events#request-soundboard-sounds */
-    requestSoundboardSounds(options: RequestSoundboardSounds): void;
-    /** https://discord.com/developers/docs/topics/gateway-events#resume */
-    resume(options: Resume): void;
-    /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
-    updatePresence(options: Partial<Pick<GatewayPresenceUpdate, "activities" | "status" | "afk">>): void;
-    /** https://discord.com/developers/docs/topics/gateway-events#update-voice-state */
-    updateVoiceState(options: GatewayVoiceStateUpdate): void;
+    resume(): void;
 }