disgroove 0.0.1

package/dist/class/Client.js

@@ -0,0 +1,771 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const ws_1 = __importDefault(require("ws"));
+const utils_1 = require("../utils");
+const rest_1 = require("../rest");
+const structures_1 = require("../structures");
+const node_events_1 = __importDefault(require("node:events"));
+class Client extends node_events_1.default {
+    heartbeatInterval;
+    token;
+    intents;
+    rest;
+    ws;
+    constructor(token, options) {
+        super();
+        this.token = token;
+        this.intents = options?.intents || utils_1.GatewayIntents.AllNonPrivileged;
+        this.rest = new rest_1.REST(token);
+        this.ws = new ws_1.default("wss://gateway.discord.gg/?v=10&encoding=json");
+    }
+    /* https://discord.com/developers/docs/resources/application#get-current-application */
+    async getApplication() {
+        return new structures_1.Application(await this.rest.request("GET", rest_1.Endpoints.applicationCurrentUser()), this);
+    }
+    /* https://discord.com/developers/docs/resources/channel#get-channel */
+    async getChannel(channelId) {
+        return new structures_1.Channel(await this.rest.request("GET", rest_1.Endpoints.channel(channelId)), this);
+    }
+    /* https://discord.com/developers/docs/resources/guild#create-guild */
+    async createGuild(options) {
+        return new structures_1.Guild(await this.rest.request("POST", rest_1.Endpoints.guilds(), {
+            json: {
+                name: options.name,
+                region: options.region,
+                icon: options.icon,
+                verification_level: options.verificationLevel,
+                default_message_notifications: options.defaultMessageNotifications,
+                explicit_content_filter: options.explicitContentFilter,
+                roles: options.roles?.map((role) => (0, utils_1.rawRole)(role)),
+                channels: options.channels?.map((channel) => (0, utils_1.rawChannel)(channel)),
+                afk_channel_id: options.afkChannelId,
+                afk_timeout: options.afkTimeout,
+                system_channel_id: options.systemChannelId,
+                system_channel_flags: options.systemChannelFlags,
+            },
+        }), this);
+    }
+    /* https://discord.com/developers/docs/resources/guild#get-guild */
+    async getGuild(guildId, options) {
+        return new structures_1.Guild(await this.rest.request("GET", rest_1.Endpoints.guild(guildId), {
+            query: {
+                with_counts: options?.withCounts,
+            },
+        }), this);
+    }
+    /* https://discord.com/developers/docs/resources/guild-template#create-guild-from-guild-template */
+    async createGuildFromTemplate(code) {
+        return new structures_1.Guild(await this.rest.request("POST", rest_1.Endpoints.template(code)), this);
+    }
+    /* https://discord.com/developers/docs/resources/invite#get-invite */
+    async getInvite(code, options) {
+        return new structures_1.Invite(await this.rest.request("GET", rest_1.Endpoints.invite(code), {
+            query: {
+                with_counts: options?.withCounts,
+                with_expiration: options?.withExpiration,
+                guild_scheduled_event_id: options?.guildScheduledEventId,
+            },
+        }), this);
+    }
+    /* https://discord.com/developers/docs/resources/invite#delete-invite */
+    async deleteInvite(code, reason) {
+        return new structures_1.Invite(await this.rest.request("DELETE", rest_1.Endpoints.invite(code), {
+            reason,
+        }), this).toJSON();
+    }
+    /* https://discord.com/developers/docs/resources/stage-instance#create-stage-instance */
+    async createStageInstance(options, reason) {
+        return new structures_1.StageInstance(await this.rest.request("POST", rest_1.Endpoints.stageInstances(), {
+            json: {
+                channel_id: options.channelId,
+                topic: options.topic,
+                privacy_level: options.privacyLevel,
+                send_start_notifications: options.sendStartNotifications,
+            },
+            reason,
+        }), this);
+    }
+    /* https://discord.com/developers/docs/resources/stage-instance#get-stage-instance */
+    async getStageInstance(channelId) {
+        return new structures_1.StageInstance(await this.rest.request("GET", rest_1.Endpoints.stageInstance(channelId)), this);
+    }
+    /* https://discord.com/developers/docs/resources/sticker#list-nitro-sticker-packs */
+    async listNitroStickerPacks() {
+        const data = await this.rest.request("GET", rest_1.Endpoints.nitroStickerPacks());
+        return {
+            stickerPacks: data.sticker_packs.map((stickerPack) => ({
+                id: stickerPack.id,
+                stickers: stickerPack.stickers.map((sticker) => ({
+                    id: sticker.id,
+                    packId: sticker.pack_id,
+                    name: sticker.name,
+                    description: sticker.description,
+                    tags: sticker.tags,
+                    asset: sticker.asset,
+                    type: sticker.type,
+                    formatType: sticker.format_type,
+                    available: sticker.available,
+                    guildId: sticker.guild_id,
+                    user: sticker.user !== undefined
+                        ? new structures_1.User(sticker.user, this)
+                        : undefined,
+                    sortValue: sticker.sort_value,
+                })),
+                name: stickerPack.name,
+                skuId: stickerPack.sku_id,
+                coverStickerId: stickerPack.cover_sticker_id,
+                description: stickerPack.description,
+                bannerAssetId: stickerPack.banner_asset_id,
+            })),
+        };
+    }
+    /* https://discord.com/developers/docs/resources/user#get-user */
+    async getUser(userId) {
+        return new structures_1.User(await this.rest.request("GET", rest_1.Endpoints.user(userId ?? "@me")), this);
+    }
+    /* https://discord.com/developers/docs/resources/user#get-current-user-guilds */
+    async getGuilds(options) {
+        return this.rest
+            .request("GET", rest_1.Endpoints.userGuilds(), {
+            query: {
+                before: options?.before,
+                after: options?.after,
+                limit: options?.limit,
+                with_counts: options?.withCounts,
+            },
+        })
+            .then((response) => response.map((data) => new structures_1.Guild(data, this)));
+    }
+    /* https://discord.com/developers/docs/resources/voice#list-voice-regions */
+    async listVoiceRegions() {
+        return this.rest.request("GET", rest_1.Endpoints.voiceRegions()).then((response) => response.map((data) => ({
+            id: data.id,
+            name: data.name,
+            optimal: data.optimal,
+            deprecated: data.deprecated,
+            custom: data.custom,
+        })));
+    }
+    connect() {
+        this.ws.on("open", () => {
+            this.ws.send(JSON.stringify({
+                op: utils_1.GatewayOPCodes.Identify,
+                d: {
+                    token: this.token,
+                    intents: this.intents,
+                    properties: {
+                        os: process.platform,
+                        browser: "disgroove",
+                        device: "disgroove",
+                    },
+                },
+            }));
+        });
+        this.ws.on("message", (data) => {
+            const { t, op, d } = JSON.parse(data.toString());
+            switch (op) {
+                case utils_1.GatewayOPCodes.Reconnect:
+                    super.emit(utils_1.GatewayEvents.Reconnect);
+                    break;
+                case utils_1.GatewayOPCodes.InvalidSession:
+                    super.emit(utils_1.GatewayEvents.InvalidSession);
+                    break;
+                case utils_1.GatewayOPCodes.Hello:
+                    {
+                        this.heartbeatInterval = setInterval(() => {
+                            this.ws.send(JSON.stringify({
+                                op: utils_1.GatewayOPCodes.Heartbeat,
+                                d: null,
+                            }));
+                        }, d.heartbeat_interval);
+                        super.emit(utils_1.GatewayEvents.Hello, {
+                            heartbeatInterval: d.heartbeat_interval,
+                        });
+                    }
+                    break;
+            }
+            switch (t) {
+                case "READY":
+                    super.emit(utils_1.GatewayEvents.Ready);
+                    break;
+                case "RESUMED":
+                    super.emit(utils_1.GatewayEvents.Resumed);
+                    break;
+                case "APPLICATION_COMMAND_PERMISSIONS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.ApplicationCommandPermissionsUpdate, {
+                        id: d.id,
+                        applicationId: d.application_id,
+                        guildId: d.guild_id,
+                        permissions: d.permissions.map((permission) => ({
+                            id: permission.id,
+                            type: permission.type,
+                            permission: permission.permission,
+                        })),
+                    });
+                    break;
+                case "AUTO_MODERATION_RULE_CREATE":
+                    super.emit(utils_1.GatewayEvents.AutoModerationRuleCreate, new structures_1.AutoModerationRule(d, this));
+                    break;
+                case "AUTO_MODERATION_RULE_UPDATE":
+                    super.emit(utils_1.GatewayEvents.AutoModerationRuleUpdate, new structures_1.AutoModerationRule(d, this));
+                    break;
+                case "AUTO_MODERATION_RULE_DELETE":
+                    super.emit(utils_1.GatewayEvents.AutoModerationRuleDelete, new structures_1.AutoModerationRule(d, this).toJSON());
+                    break;
+                case "AUTO_MODERATION_ACTION_EXECUTION":
+                    super.emit(utils_1.GatewayEvents.AutoModerationActionExecution, {
+                        guildId: d.guild_id,
+                        action: {
+                            type: d.action.type,
+                            metadata: d.action.metadata,
+                        },
+                        ruleId: d.rule_id,
+                        ruleTriggerType: d.rule_trigger_type,
+                        userId: d.user_id,
+                        channelId: d.channel_id,
+                        messageId: d.message_id,
+                        alertSystemMessageId: d.alert_system_message_id,
+                        content: d.content,
+                        matchedKeyword: d.matched_keyword,
+                        matchedContent: d.matched_content,
+                    });
+                    break;
+                case "CHANNEL_CREATE":
+                    super.emit(utils_1.GatewayEvents.ChannelCreate, new structures_1.Channel(d, this));
+                    break;
+                case "CHANNEL_UPDATE":
+                    super.emit(utils_1.GatewayEvents.ChannelUpdate, new structures_1.Channel(d, this));
+                    break;
+                case "CHANNEL_DELETE":
+                    super.emit(utils_1.GatewayEvents.ChannelDelete, new structures_1.Channel(d, this).toJSON());
+                    break;
+                case "CHANNEL_PINS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.ChannelPinsUpdate, {
+                        guildId: d.guild_id,
+                        channelId: d.channel_id,
+                        lastPinTimestamp: d.last_pin_timestamp,
+                    });
+                    break;
+                case "THREAD_CREATE":
+                    super.emit(utils_1.GatewayEvents.ThreadCreate, new structures_1.Channel(d, this));
+                    break;
+                case "THREAD_UPDATE":
+                    super.emit(utils_1.GatewayEvents.ThreadUpdate, new structures_1.Channel(d, this));
+                    break;
+                case "THREAD_DELETE":
+                    super.emit(utils_1.GatewayEvents.ThreadDelete, new structures_1.Channel(d, this).toJSON());
+                    break;
+                case "THREAD_LIST_SYNC":
+                    super.emit(utils_1.GatewayEvents.ThreadListSync, {
+                        guildId: d.guild_id,
+                        channelIds: d.channel_ids,
+                        threads: d.threads.map((channel) => new structures_1.Channel(channel, this)),
+                        members: d.members.map((member) => ({
+                            id: member.id,
+                            userId: member.user_id,
+                            joinTimestamp: member.join_timestamp,
+                            flags: member.flags,
+                            member: member.member !== undefined
+                                ? new structures_1.GuildMember(member.member, this)
+                                : undefined,
+                        })),
+                    });
+                    break;
+                case "THREAD_MEMBER_UPDATE":
+                    super.emit(utils_1.GatewayEvents.ThreadMemberUpdate, {
+                        id: d.id,
+                        userId: d.user_id,
+                        joinTimestamp: d.join_timestamp,
+                        flags: d.flags,
+                        member: d.member !== undefined
+                            ? new structures_1.GuildMember(d.member, this)
+                            : undefined,
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "THREAD_MEMBERS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.ThreadMembersUpdate, {
+                        id: d.id,
+                        guildId: d.guild_id,
+                        memberCount: d.member_count,
+                        addedMembers: d.added_members?.map((member) => ({
+                            id: member.id,
+                            userId: member.user_id,
+                            joinTimestamp: member.join_timestamp,
+                            flags: member.flags,
+                            member: member.member !== undefined
+                                ? new structures_1.GuildMember(member.member, this)
+                                : undefined,
+                        })),
+                        removedMemberIds: d.removed_member_ids,
+                    });
+                    break;
+                case "GUILD_CREATE":
+                    super.emit(utils_1.GatewayEvents.GuildCreate, new structures_1.Guild(d, this), {
+                        joinedAt: d.joined_at,
+                        large: d.large,
+                        unavailable: d.unavailable,
+                        memberCount: d.member_count,
+                        voiceStates: d.voice_states.map((voiceState) => ({
+                            guildId: voiceState.guild_id,
+                            channelId: voiceState.channel_id,
+                            userId: voiceState.user_id,
+                            member: voiceState.member !== undefined
+                                ? new structures_1.GuildMember(voiceState.member, this)
+                                : undefined,
+                            sessionId: voiceState.session_id,
+                            deaf: voiceState.deaf,
+                            mute: voiceState.mute,
+                            selfDeaf: voiceState.self_deaf,
+                            selfMute: voiceState.self_mute,
+                            selfStream: voiceState.self_stream,
+                            selfVideo: voiceState.self_video,
+                            suppress: voiceState.suppress,
+                            requestToSpeakTimestamp: voiceState.request_to_speak_timestamp,
+                        })),
+                        members: d.members.map((member) => new structures_1.GuildMember(member, this)),
+                        channels: d.channels.map((channel) => new structures_1.Channel(channel, this)),
+                        threads: d.threads.map((thread) => new structures_1.Channel(thread, this)),
+                        presences: d.presences.map((presence) => ({
+                            user: new structures_1.User(presence.user, this),
+                            guildId: presence.guild_id,
+                            status: presence.status,
+                            activities: presence.activities.map((activity) => ({
+                                name: activity.name,
+                                type: activity.type,
+                                url: activity.url,
+                                createdAt: activity.created_at,
+                                timestamps: {
+                                    start: activity.timestamps?.start,
+                                    end: activity.timestamp.end,
+                                },
+                                applicationId: activity.application_id,
+                                details: activity.details,
+                                state: activity.state,
+                                party: {
+                                    id: activity.party?.id,
+                                    size: activity.party?.size,
+                                },
+                                assets: {
+                                    largeImage: activity.assets?.large_image,
+                                    largeText: activity.assets?.large_text,
+                                    smallImage: activity.assets?.small_image,
+                                    smallText: activity.assets?.small_text,
+                                },
+                                secrets: {
+                                    join: activity.secrets.join,
+                                    spectate: activity.secrets.spectate,
+                                    match: activity.secrets.match,
+                                },
+                                instance: activity.instance,
+                                flags: activity.flags,
+                                buttons: activity.buttons?.map((button) => ({
+                                    label: button.label,
+                                    url: button.url,
+                                })),
+                            })),
+                            clientStatus: {
+                                desktop: presence.client_status.desktop,
+                                mobile: presence.client_status.mobile,
+                                web: presence.client_status.web,
+                            },
+                        })),
+                        stageInstances: d.stage_instances.map((stageInstance) => new structures_1.StageInstance(stageInstance, this)),
+                        guildScheduledEvents: d.guild_scheduled_events.map((guildScheduledEvent) => new structures_1.GuildScheduledEvent(guildScheduledEvent, this)),
+                    });
+                    break;
+                case "GUILD_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildUpdate, new structures_1.Guild(d, this));
+                    break;
+                case "GUILD_DELETE":
+                    super.emit(utils_1.GatewayEvents.GuildDelete, {
+                        id: d.id,
+                        unavailable: d.unavailable,
+                    });
+                    break;
+                case "GUILD_AUDIT_LOG_ENTRY_CREATE":
+                    super.emit(utils_1.GatewayEvents.GuildAuditLogEntryCreate, new structures_1.AuditLogEntry(d, this));
+                    break;
+                case "GUILD_BAN_ADD":
+                    super.emit(utils_1.GatewayEvents.GuildBanAdd, {
+                        guildId: d.guild_id,
+                        user: new structures_1.User(d.user, this),
+                    });
+                    break;
+                case "GUILD_BAN_REMOVE":
+                    super.emit(utils_1.GatewayEvents.GuildBanRemove, {
+                        guildId: d.guild_id,
+                        user: new structures_1.User(d.user, this),
+                    });
+                    break;
+                case "GUILD_EMOJIS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildEmojisUpdate, {
+                        guildId: d.guild_id,
+                        emojis: d.emojis.map((emoji) => ({
+                            id: emoji.id,
+                            name: emoji.name,
+                            roles: emoji.roles,
+                            user: emoji.roles,
+                            requireColons: emoji.require_colons,
+                            managed: emoji.managed,
+                            animated: emoji.animated,
+                            available: emoji.available,
+                        })),
+                    });
+                    break;
+                case "GUILD_STICKERS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildStickersUpdate, {
+                        guildId: d.guild_id,
+                        stickers: d.stickers.map((sticker) => ({
+                            id: sticker.id,
+                            packId: sticker.pack_id,
+                            name: sticker.name,
+                            description: sticker.description,
+                            tags: sticker.tags,
+                            asset: sticker.asset,
+                            type: sticker.type,
+                            formatType: sticker.format_type,
+                            available: sticker.available,
+                            guildId: sticker.guild_id,
+                            user: sticker.user !== undefined
+                                ? new structures_1.User(sticker.user, this)
+                                : undefined,
+                            sortValue: sticker.sort_value,
+                        })),
+                    });
+                    break;
+                case "GUILD_INTEGRATIONS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildIntegrationsUpdate, {
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "GUILD_MEMBER_ADD":
+                    super.emit(utils_1.GatewayEvents.GuildMemberAdd, new structures_1.GuildMember(d, this));
+                    break;
+                case "GUILD_MEMBER_REMOVE":
+                    super.emit(utils_1.GatewayEvents.GuildMemberRemove, {
+                        guildId: d.guild_id,
+                        user: new structures_1.User(d.user, this),
+                    });
+                    break;
+                case "GUILD_MEMBER_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildMemberUpdate, {
+                        guildId: d.guild_id,
+                        roles: d.roles,
+                        user: new structures_1.User(d.user, this),
+                        nick: d.nick,
+                        avatar: d.avatar,
+                        joinedAt: d.joined_at,
+                        premiumSince: d.premium_since,
+                        deaf: d.deaf,
+                        mute: d.mute,
+                        pending: d.pending,
+                        communicationDisabledUntil: d.communication_disabled_until,
+                    });
+                    break;
+                case "GUILD_MEMBERS_CHUNK":
+                    super.emit(utils_1.GatewayEvents.GuildMembersChunk, {
+                        guildId: d.guild_id,
+                        members: d.members.map((member) => new structures_1.GuildMember(member, this)),
+                        chunkIndex: d.chunk_index,
+                        chunkCount: d.chunk_count,
+                        notFound: d.not_found,
+                        presences: d.presences,
+                        nonce: d.nonce,
+                    });
+                    break;
+                case "GUILD_ROLE_CREATE":
+                    super.emit(utils_1.GatewayEvents.GuildRoleCreate, {
+                        guildId: d.guild_id,
+                        role: new structures_1.Role(d.role, this),
+                    });
+                    break;
+                case "GUILD_ROLE_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildRoleUpdate, {
+                        guildId: d.guild_id,
+                        role: new structures_1.Role(d.role, this),
+                    });
+                    break;
+                case "GUILD_ROLE_DELETE":
+                    super.emit(utils_1.GatewayEvents.GuildRoleDelete, {
+                        guildId: d.guild_id,
+                        roleId: d.role_id,
+                    });
+                    break;
+                case "GUILD_SCHEDULED_EVENT_CREATE":
+                    super.emit(utils_1.GatewayEvents.GuildScheduledEventCreate, new structures_1.GuildScheduledEvent(d, this));
+                    break;
+                case "GUILD_SCHEDULED_EVENT_UPDATE":
+                    super.emit(utils_1.GatewayEvents.GuildScheduledEventUpdate, new structures_1.GuildScheduledEvent(d, this));
+                    break;
+                case "GUILD_SCHEDULED_EVENT_DELETE":
+                    super.emit(utils_1.GatewayEvents.GuildScheduledEventDelete, new structures_1.GuildScheduledEvent(d, this).toJSON());
+                    break;
+                case "GUILD_SCHEDULED_EVENT_USER_ADD":
+                    super.emit(utils_1.GatewayEvents.GuildScheduledEventUserAdd, {
+                        guildScheduledEventId: d.guild_scheduled_event_id,
+                        userId: d.user_id,
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "GUILD_SCHEDULED_EVENT_USER_REMOVE":
+                    super.emit(utils_1.GatewayEvents.GuildScheduledEventUserRemove, {
+                        guildScheduledEventId: d.guild_scheduled_event_id,
+                        userId: d.user_id,
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "INTEGRATION_CREATE":
+                    super.emit(utils_1.GatewayEvents.IntegrationCreate, new structures_1.Integration(d, this), {
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "INTEGRATION_UPDATE":
+                    super.emit(utils_1.GatewayEvents.IntegrationUpdate, new structures_1.Integration(d, this), {
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "INTEGRATION_DELETE":
+                    super.emit(utils_1.GatewayEvents.IntegrationDelete, {
+                        id: d.id,
+                        guildId: d.guild_id,
+                        applicationId: d.application_id,
+                    });
+                    break;
+                case "INTERACTION_CREATE":
+                    super.emit(utils_1.GatewayEvents.InteractionCreate, new structures_1.Interaction(d, this));
+                    break;
+                case "INVITE_CREATE":
+                    super.emit(utils_1.GatewayEvents.InviteCreate, {
+                        channelId: d.channel_id,
+                        code: d.code,
+                        createdAt: d.created_at,
+                        guildId: d.guild_id,
+                        inviter: d.inviter !== undefined ? new structures_1.User(d.inviter, this) : undefined,
+                        maxAge: d.max_age,
+                        maxUses: d.max_uses,
+                        targetType: d.target_type,
+                        targetUser: d.target_user !== undefined
+                            ? new structures_1.User(d.target_user, this)
+                            : undefined,
+                        targetApplication: d.target_application !== undefined
+                            ? new structures_1.Application(d.target_application, this)
+                            : undefined,
+                        temporary: d.temporary,
+                        uses: d.uses,
+                    });
+                    break;
+                case "INVITE_DELETE":
+                    super.emit(utils_1.GatewayEvents.InviteDelete, {
+                        channelId: d.channel_id,
+                        guildId: d.guild_id,
+                        code: d.code,
+                    });
+                    break;
+                case "MESSAGE_CREATE":
+                    super.emit(utils_1.GatewayEvents.MessageCreate, new structures_1.Message(d, this));
+                    break;
+                case "MESSAGE_UPDATE":
+                    super.emit(utils_1.GatewayEvents.MessageUpdate, new structures_1.Message(d, this));
+                    break;
+                case "MESSAGE_DELETE":
+                    super.emit(utils_1.GatewayEvents.MessageDelete, new structures_1.Message(d, this).toJSON());
+                    break;
+                case "MESSAGE_DELETE_BULK":
+                    super.emit(utils_1.GatewayEvents.MessageDeleteBulk, {
+                        ids: d.ids,
+                        channelId: d.channel_id,
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "MESSAGE_REACTION_ADD":
+                    super.emit(utils_1.GatewayEvents.MessageReactionAdd, {
+                        userId: d.user_id,
+                        channelId: d.channel_id,
+                        messageId: d.message_id,
+                        guildId: d.guild_id,
+                        member: d.member !== undefined
+                            ? new structures_1.GuildMember(d.member, this)
+                            : undefined,
+                        emoji: {
+                            id: d.emoji.id,
+                            name: d.emoji.name,
+                            roles: d.emoji.roles,
+                            user: d.emoji.user !== undefined
+                                ? new structures_1.User(d.emoji.user, this)
+                                : undefined,
+                            requireColons: d.emoji.require_colons,
+                            managed: d.emoji.managed,
+                            animated: d.emoji.animated,
+                            available: d.emoji.available,
+                        },
+                        messageAuthorId: d.message_author_id,
+                    });
+                    break;
+                case "MESSAGE_REACTION_REMOVE":
+                    super.emit(utils_1.GatewayEvents.MessageReactionRemove, {
+                        userId: d.user_id,
+                        channelId: d.channel_id,
+                        messageId: d.message_id,
+                        guildId: d.guild_id,
+                        emoji: {
+                            id: d.emoji.id,
+                            name: d.emoji.name,
+                            roles: d.emoji.roles,
+                            user: d.emoji.user !== undefined
+                                ? new structures_1.User(d.emoji.user, this)
+                                : undefined,
+                            requireColons: d.emoji.require_colons,
+                            managed: d.emoji.managed,
+                            animated: d.emoji.animated,
+                            available: d.emoji.available,
+                        },
+                    });
+                    break;
+                case "MESSAGE_REACTION_REMOVE_ALL":
+                    super.emit(utils_1.GatewayEvents.MessageReactionRemoveAll, {
+                        channelId: d.channel_id,
+                        messageId: d.message_id,
+                        guildId: d.guild_id,
+                    });
+                    break;
+                case "MESSAGE_REACTION_REMOVE_EMOJI":
+                    super.emit(utils_1.GatewayEvents.MessageReactionRemoveEmoji, {
+                        channelId: d.channel_id,
+                        guildId: d.guild_id,
+                        messageId: d.message_id,
+                        emoji: {
+                            id: d.emoji.id,
+                            name: d.emoji.name,
+                            roles: d.emoji.roles,
+                            user: d.emoji.user !== undefined
+                                ? new structures_1.User(d.emoji.user, this)
+                                : undefined,
+                            requireColons: d.emoji.require_colons,
+                            managed: d.emoji.managed,
+                            animated: d.emoji.animated,
+                            available: d.emoji.available,
+                        },
+                    });
+                    break;
+                case "PRESENCE_UPDATE":
+                    super.emit(utils_1.GatewayEvents.PresenceUpdate, {
+                        user: new structures_1.User(d.user, this),
+                        guildId: d.guild_id,
+                        status: d.status,
+                        activities: d.activities.map((activity) => ({
+                            name: activity.name,
+                            type: activity.type,
+                            url: activity.url,
+                            createdAt: activity.created_at,
+                            timestamps: {
+                                start: activity.timestamps?.start,
+                                end: activity.timestamp.end,
+                            },
+                            applicationId: activity.application_id,
+                            details: activity.details,
+                            state: activity.state,
+                            party: {
+                                id: activity.party?.id,
+                                size: activity.party?.size,
+                            },
+                            assets: {
+                                largeImage: activity.assets?.large_image,
+                                largeText: activity.assets?.large_text,
+                                smallImage: activity.assets?.small_image,
+                                smallText: activity.assets?.small_text,
+                            },
+                            secrets: {
+                                join: activity.secrets.join,
+                                spectate: activity.secrets.spectate,
+                                match: activity.secrets.match,
+                            },
+                            instance: activity.instance,
+                            flags: activity.flags,
+                            buttons: activity.buttons?.map((button) => ({
+                                label: button.label,
+                                url: button.url,
+                            })),
+                        })),
+                        clientStatus: {
+                            desktop: d.client_status.desktop,
+                            mobile: d.client_status.mobile,
+                            web: d.client_status.web,
+                        },
+                    });
+                    break;
+                case "STAGE_INSTANCE_CREATE":
+                    super.emit(utils_1.GatewayEvents.StageInstanceCreate, new structures_1.StageInstance(d, this));
+                    break;
+                case "STAGE_INSTANCE_UPDATE":
+                    super.emit(utils_1.GatewayEvents.StageInstanceUpdate, new structures_1.StageInstance(d, this));
+                    break;
+                case "STAGE_INSTANCE_DELETE":
+                    super.emit(utils_1.GatewayEvents.StageInstanceDelete, new structures_1.StageInstance(d, this).toJSON());
+                    break;
+                case "TYPING_START":
+                    super.emit(utils_1.GatewayEvents.TypingStart, {
+                        channelId: d.channel_id,
+                        guildId: d.guild_id,
+                        userId: d.user_id,
+                        timestamp: d.timestamp,
+                        member: d.member !== undefined
+                            ? new structures_1.GuildMember(d.member, this)
+                            : undefined,
+                    });
+                    break;
+                case "USER_UPDATE":
+                    super.emit(utils_1.GatewayEvents.UserUpdate, new structures_1.User(d, this));
+                    break;
+                case "VOICE_STATE_UPDATE":
+                    super.emit(utils_1.GatewayEvents.VoiceStateUpdate, {
+                        guildId: d.guild_id,
+                        channelId: d.channel_id,
+                        userId: d.user_id,
+                        member: d.member !== undefined
+                            ? new structures_1.GuildMember(d.member, this)
+                            : undefined,
+                        sessionId: d.session_id,
+                        deaf: d.deaf,
+                        mute: d.mute,
+                        selfDeaf: d.self_deaf,
+                        selfMute: d.self_mute,
+                        selfStream: d.self_stream,
+                        selfVideo: d.self_video,
+                        suppress: d.suppress,
+                        requestToSpeakTimestamp: d.request_to_speak_timestamp,
+                    });
+                    break;
+                case "VOICE_SERVER_UPDATE":
+                    super.emit(utils_1.GatewayEvents.VoiceServerUpdate, {
+                        token: d.token,
+                        guildId: d.guildId,
+                        endpoint: d.endpoint,
+                    });
+                    break;
+                case "WEBHOOKS_UPDATE":
+                    super.emit(utils_1.GatewayEvents.WebhooksUpdate, {
+                        guildId: d.guild_id,
+                        channelId: d.channel_id,
+                    });
+                    break;
+            }
+        });
+        this.ws.on("error", (err) => {
+            throw new Error(err.message);
+        });
+        this.ws.on("close", (code, reason) => {
+            throw new Error(`${code}: ${reason}`);
+        });
+    }
+    disconnect() {
+        clearInterval(this.heartbeatInterval);
+        this.heartbeatInterval = null;
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=Client.js.map