disgroove 1.1.4-dev.e511a6f → 1.1.5-dev.43fc5a3

package/dist/client/Client.js

@@ -0,0 +1,741 @@
+"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"));
+const _1 = require(".");
+class Client extends node_events_1.default {
+    heartbeatInterval;
+    token;
+    intents;
+    shards;
+    auth;
+    rest;
+    ws;
+    user;
+    application;
+    constructor(token, options) {
+        super();
+        this.token = token;
+        this.intents =
+            options?.intents !== undefined
+                ? Array.isArray(options.intents)
+                    ? options.intents.reduce((sum, num) => sum + num, 0)
+                    : options.intents
+                : utils_1.GatewayIntents.AllNonPrivileged;
+        this.shards = options?.shards ?? -1;
+        this.auth = options?.auth ?? "Bot";
+        this.rest = new rest_1.REST(token, this.auth);
+        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.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.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.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.roleToRaw)(role)),
+                channels: options.channels?.map((channel) => (0, utils_1.channelToRaw)(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.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, options) {
+        return new structures_1.Guild(await this.rest.post(rest_1.Endpoints.template(code), {
+            json: {
+                name: options.name,
+                icon: options.icon,
+            },
+        }), this);
+    }
+    /** https://discord.com/developers/docs/resources/invite#get-invite */
+    async getInvite(code, options) {
+        return new structures_1.Invite(await this.rest.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.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.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.get(rest_1.Endpoints.stageInstance(channelId)), this);
+    }
+    /** https://discord.com/developers/docs/resources/sticker#list-nitro-sticker-packs */
+    async getNitroStickerPacks() {
+        return this.rest
+            .get(rest_1.Endpoints.nitroStickerPacks())
+            .then((response) => ({
+            stickerPacks: response.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.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
+            .get(rest_1.Endpoints.userGuilds(), {
+            query: {
+                before: options?.before,
+                after: options?.after,
+                limit: options?.limit,
+                with_counts: options?.withCounts,
+            },
+        })
+            .then((response) => response.map((data) => ({
+            id: data.id,
+            name: data.name,
+            icon: data.icon,
+            owner: data.owner,
+            permissions: data.permissions,
+            features: data.features,
+            approximate_member_count: data.approximate_member_count,
+            approximate_presence_count: data.approximate_presence_count,
+        })));
+    }
+    /** https://discord.com/developers/docs/resources/voice#list-voice-regions */
+    async getVoiceRegions() {
+        return this.rest
+            .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,
+        })));
+    }
+    /** https://discord.com/developers/docs/topics/gateway#get-gateway */
+    async getGateway() {
+        return this.rest.get(rest_1.Endpoints.gateway());
+    }
+    /** https://discord.com/developers/docs/topics/gateway#get-gateway-bot */
+    async getGatewayBot() {
+        return this.rest
+            .get(rest_1.Endpoints.gatewayBot())
+            .then((response) => ({
+            url: response.url,
+            shards: response.shards,
+            sessionStartLimit: {
+                total: response.session_start_limit.total,
+                remaining: response.session_start_limit.remaining,
+                resetAfter: response.session_start_limit.reset_after,
+                maxConcurrency: response.session_start_limit.max_concurrency,
+            },
+        }));
+    }
+    /** https://discord.com/developers/docs/topics/gateway-events#update-presence */
+    updatePresence(options) {
+        this.ws.send(JSON.stringify({
+            op: utils_1.GatewayOPCodes.PresenceUpdate,
+            d: {
+                since: options.status === utils_1.StatusTypes.Idle ? Date.now() : null,
+                activities: options.activity !== undefined ? [options.activity] : null,
+                status: options.status ?? utils_1.StatusTypes.Online,
+                afk: !!options.afk,
+            },
+        }));
+    }
+    /** https://discord.com/developers/docs/topics/oauth2#get-current-bot-application-information */
+    async getOAuth2Application() {
+        return new structures_1.Application(await this.rest.get(rest_1.Endpoints.oauth2CurrentApplication()), this);
+    }
+    /** https://discord.com/developers/docs/topics/oauth2#get-current-authorization-information */
+    async getOAuth2Authorization() {
+        return this.rest
+            .get(rest_1.Endpoints.oauth2Authorization())
+            .then((response) => ({
+            application: new structures_1.Application(response.application, this),
+            scopes: response.scopes,
+            expires: response.expires,
+            user: response.user !== undefined
+                ? new structures_1.User(response.user, this)
+                : undefined,
+        }));
+    }
+    /** 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));
+    }
+    disconnect() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    async onWebSocketOpen() {
+        const gatewayBot = await this.getGatewayBot();
+        const shards = this.shards !== -1 ? this.shards : gatewayBot.shards;
+        for (let i = 0; i < shards; i++) {
+            this.ws.send(JSON.stringify({
+                op: utils_1.GatewayOPCodes.Identify,
+                d: {
+                    token: this.token,
+                    shard: [i, shards],
+                    intents: this.intents,
+                    properties: {
+                        os: process.platform,
+                        browser: "disgroove",
+                        device: "disgroove",
+                    },
+                },
+            }));
+        }
+    }
+    onWebSocketMessage(data) {
+        const packet = JSON.parse(data.toString());
+        switch (packet.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,
+                        }));
+                    }, packet.d.heartbeat_interval);
+                    super.emit(utils_1.GatewayEvents.Hello, {
+                        heartbeatInterval: packet.d.heartbeat_interval,
+                    });
+                }
+                break;
+        }
+        switch (packet.t) {
+            case "READY":
+                {
+                    this.user = new structures_1.User(packet.d.user, this);
+                    this.application = new _1.ClientApplication(packet.d.application, this);
+                    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: packet.d.id,
+                    applicationId: packet.d.application_id,
+                    guildId: packet.d.guild_id,
+                    permissions: packet.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(packet.d, this));
+                break;
+            case "AUTO_MODERATION_RULE_UPDATE":
+                super.emit(utils_1.GatewayEvents.AutoModerationRuleUpdate, new structures_1.AutoModerationRule(packet.d, this));
+                break;
+            case "AUTO_MODERATION_RULE_DELETE":
+                super.emit(utils_1.GatewayEvents.AutoModerationRuleDelete, new structures_1.AutoModerationRule(packet.d, this).toJSON());
+                break;
+            case "AUTO_MODERATION_ACTION_EXECUTION":
+                super.emit(utils_1.GatewayEvents.AutoModerationActionExecution, {
+                    guildId: packet.d.guild_id,
+                    action: {
+                        type: packet.d.action.type,
+                        metadata: packet.d.action.metadata,
+                    },
+                    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 "CHANNEL_CREATE":
+                super.emit(utils_1.GatewayEvents.ChannelCreate, new structures_1.Channel(packet.d, this));
+                break;
+            case "CHANNEL_UPDATE":
+                super.emit(utils_1.GatewayEvents.ChannelUpdate, new structures_1.Channel(packet.d, this));
+                break;
+            case "CHANNEL_DELETE":
+                super.emit(utils_1.GatewayEvents.ChannelDelete, new structures_1.Channel(packet.d, this).toJSON());
+                break;
+            case "CHANNEL_PINS_UPDATE":
+                super.emit(utils_1.GatewayEvents.ChannelPinsUpdate, {
+                    guildId: packet.d.guild_id,
+                    channelId: packet.d.channel_id,
+                    lastPinTimestamp: packet.d.last_pin_timestamp,
+                });
+                break;
+            case "THREAD_CREATE":
+                super.emit(utils_1.GatewayEvents.ThreadCreate, new structures_1.Channel(packet.d, this));
+                break;
+            case "THREAD_UPDATE":
+                super.emit(utils_1.GatewayEvents.ThreadUpdate, new structures_1.Channel(packet.d, this));
+                break;
+            case "THREAD_DELETE":
+                super.emit(utils_1.GatewayEvents.ThreadDelete, new structures_1.Channel(packet.d, this).toJSON());
+                break;
+            case "THREAD_LIST_SYNC":
+                super.emit(utils_1.GatewayEvents.ThreadListSync, {
+                    guildId: packet.d.guild_id,
+                    channelIds: packet.d.channel_ids,
+                    threads: packet.d.threads.map((channel) => new structures_1.Channel(channel, this)),
+                    members: packet.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: packet.d.id,
+                    userId: packet.d.user_id,
+                    joinTimestamp: packet.d.join_timestamp,
+                    flags: packet.d.flags,
+                    member: packet.d.member !== undefined
+                        ? new structures_1.GuildMember(packet.d.member, this)
+                        : undefined,
+                    guildId: packet.d.guild_id,
+                });
+                break;
+            case "THREAD_MEMBERS_UPDATE":
+                super.emit(utils_1.GatewayEvents.ThreadMembersUpdate, {
+                    id: packet.d.id,
+                    guildId: packet.d.guild_id,
+                    memberCount: packet.d.member_count,
+                    addedMembers: packet.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: packet.d.removed_member_ids,
+                });
+                break;
+            case "GUILD_CREATE":
+                super.emit(utils_1.GatewayEvents.GuildCreate, new structures_1.Guild(packet.d, this));
+                break;
+            case "GUILD_UPDATE":
+                super.emit(utils_1.GatewayEvents.GuildUpdate, new structures_1.Guild(packet.d, this));
+                break;
+            case "GUILD_DELETE":
+                super.emit(utils_1.GatewayEvents.GuildDelete, {
+                    id: packet.d.id,
+                    unavailable: packet.d.unavailable,
+                });
+                break;
+            case "GUILD_AUDIT_LOG_ENTRY_CREATE":
+                super.emit(utils_1.GatewayEvents.GuildAuditLogEntryCreate, (0, utils_1.auditLogEntryToJSON)(packet.d));
+                break;
+            case "GUILD_BAN_ADD":
+                super.emit(utils_1.GatewayEvents.GuildBanAdd, {
+                    guildId: packet.d.guild_id,
+                    user: new structures_1.User(packet.d.user, this),
+                });
+                break;
+            case "GUILD_BAN_REMOVE":
+                super.emit(utils_1.GatewayEvents.GuildBanRemove, {
+                    guildId: packet.d.guild_id,
+                    user: new structures_1.User(packet.d.user, this),
+                });
+                break;
+            case "GUILD_EMOJIS_UPDATE":
+                super.emit(utils_1.GatewayEvents.GuildEmojisUpdate, {
+                    guildId: packet.d.guild_id,
+                    emojis: packet.d.emojis.map((emoji) => new structures_1.Emoji(emoji, this).toJSON()),
+                });
+                break;
+            case "GUILD_STICKERS_UPDATE":
+                super.emit(utils_1.GatewayEvents.GuildStickersUpdate, {
+                    guildId: packet.d.guild_id,
+                    stickers: packet.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: packet.d.guild_id,
+                });
+                break;
+            case "GUILD_MEMBER_ADD":
+                super.emit(utils_1.GatewayEvents.GuildMemberAdd, new structures_1.GuildMember(packet.d, this));
+                break;
+            case "GUILD_MEMBER_REMOVE":
+                super.emit(utils_1.GatewayEvents.GuildMemberRemove, {
+                    guildId: packet.d.guild_id,
+                    user: new structures_1.User(packet.d.user, this),
+                });
+                break;
+            case "GUILD_MEMBER_UPDATE":
+                super.emit(utils_1.GatewayEvents.GuildMemberUpdate, {
+                    guildId: packet.d.guild_id,
+                    roles: packet.d.roles,
+                    user: new structures_1.User(packet.d.user, this),
+                    nick: packet.d.nick,
+                    avatar: packet.d.avatar,
+                    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,
+                });
+                break;
+            case "GUILD_MEMBERS_CHUNK":
+                super.emit(utils_1.GatewayEvents.GuildMembersChunk, {
+                    guildId: packet.d.guild_id,
+                    members: packet.d.members.map((member) => new structures_1.GuildMember(member, this)),
+                    chunkIndex: packet.d.chunk_index,
+                    chunkCount: packet.d.chunk_count,
+                    notFound: packet.d.not_found,
+                    presences: packet.d.presences,
+                    nonce: packet.d.nonce,
+                });
+                break;
+            case "GUILD_ROLE_CREATE":
+                super.emit(utils_1.GatewayEvents.GuildRoleCreate, {
+                    guildId: packet.d.guild_id,
+                    role: new structures_1.Role(packet.d.role, this),
+                });
+                break;
+            case "GUILD_ROLE_UPDATE":
+                super.emit(utils_1.GatewayEvents.GuildRoleUpdate, {
+                    guildId: packet.d.guild_id,
+                    role: new structures_1.Role(packet.d.role, this),
+                });
+                break;
+            case "GUILD_ROLE_DELETE":
+                super.emit(utils_1.GatewayEvents.GuildRoleDelete, {
+                    guildId: packet.d.guild_id,
+                    roleId: packet.d.role_id,
+                });
+                break;
+            case "GUILD_SCHEDULED_EVENT_CREATE":
+                super.emit(utils_1.GatewayEvents.GuildScheduledEventCreate, new structures_1.GuildScheduledEvent(packet.d, this));
+                break;
+            case "GUILD_SCHEDULED_EVENT_UPDATE":
+                super.emit(utils_1.GatewayEvents.GuildScheduledEventUpdate, new structures_1.GuildScheduledEvent(packet.d, this));
+                break;
+            case "GUILD_SCHEDULED_EVENT_DELETE":
+                super.emit(utils_1.GatewayEvents.GuildScheduledEventDelete, new structures_1.GuildScheduledEvent(packet.d, this).toJSON());
+                break;
+            case "GUILD_SCHEDULED_EVENT_USER_ADD":
+                super.emit(utils_1.GatewayEvents.GuildScheduledEventUserAdd, {
+                    guildScheduledEventId: packet.d.guild_scheduled_event_id,
+                    userId: packet.d.user_id,
+                    guildId: packet.d.guild_id,
+                });
+                break;
+            case "GUILD_SCHEDULED_EVENT_USER_REMOVE":
+                super.emit(utils_1.GatewayEvents.GuildScheduledEventUserRemove, {
+                    guildScheduledEventId: packet.d.guild_scheduled_event_id,
+                    userId: packet.d.user_id,
+                    guildId: packet.d.guild_id,
+                });
+                break;
+            case "INTEGRATION_CREATE":
+                super.emit(utils_1.GatewayEvents.IntegrationCreate, new structures_1.Integration(packet.d, this));
+                break;
+            case "INTEGRATION_UPDATE":
+                super.emit(utils_1.GatewayEvents.IntegrationUpdate, new structures_1.Integration(packet.d, this));
+                break;
+            case "INTEGRATION_DELETE":
+                super.emit(utils_1.GatewayEvents.IntegrationDelete, {
+                    id: packet.d.id,
+                    guildId: packet.d.guild_id,
+                    applicationId: packet.d.application_id,
+                });
+                break;
+            case "INTERACTION_CREATE":
+                super.emit(utils_1.GatewayEvents.InteractionCreate, new structures_1.Interaction(packet.d, this));
+                break;
+            case "INVITE_CREATE":
+                super.emit(utils_1.GatewayEvents.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
+                        ? new structures_1.User(packet.d.inviter, this)
+                        : undefined,
+                    maxAge: packet.d.max_age,
+                    maxUses: packet.d.max_uses,
+                    targetType: packet.d.target_type,
+                    targetUser: packet.d.target_user !== undefined
+                        ? new structures_1.User(packet.d.target_user, this)
+                        : undefined,
+                    targetApplication: packet.d.target_application !== undefined
+                        ? new structures_1.Application(packet.d.target_application, this)
+                        : undefined,
+                    temporary: packet.d.temporary,
+                    uses: packet.d.uses,
+                });
+                break;
+            case "INVITE_DELETE":
+                super.emit(utils_1.GatewayEvents.InviteDelete, {
+                    channelId: packet.d.channel_id,
+                    guildId: packet.d.guild_id,
+                    code: packet.d.code,
+                });
+                break;
+            case "MESSAGE_CREATE":
+                super.emit(utils_1.GatewayEvents.MessageCreate, new structures_1.Message(packet.d, this));
+                break;
+            case "MESSAGE_UPDATE":
+                super.emit(utils_1.GatewayEvents.MessageUpdate, new structures_1.Message(packet.d, this));
+                break;
+            case "MESSAGE_DELETE":
+                super.emit(utils_1.GatewayEvents.MessageDelete, new structures_1.Message(packet.d, this).toJSON());
+                break;
+            case "MESSAGE_DELETE_BULK":
+                super.emit(utils_1.GatewayEvents.MessageDeleteBulk, {
+                    ids: packet.d.ids,
+                    channelId: packet.d.channel_id,
+                    guildId: packet.d.guild_id,
+                });
+                break;
+            case "MESSAGE_REACTION_ADD":
+                super.emit(utils_1.GatewayEvents.MessageReactionAdd, {
+                    userId: packet.d.user_id,
+                    channelId: packet.d.channel_id,
+                    messageId: packet.d.message_id,
+                    guildId: packet.d.guild_id,
+                    member: packet.d.member !== undefined
+                        ? new structures_1.GuildMember(packet.d.member, this)
+                        : undefined,
+                    emoji: new structures_1.Emoji(packet.d.emoji, this),
+                    messageAuthorId: packet.d.message_author_id,
+                });
+                break;
+            case "MESSAGE_REACTION_REMOVE":
+                super.emit(utils_1.GatewayEvents.MessageReactionRemove, {
+                    userId: packet.d.user_id,
+                    channelId: packet.d.channel_id,
+                    messageId: packet.d.message_id,
+                    guildId: packet.d.guild_id,
+                    emoji: new structures_1.Emoji(packet.d.emoji, this),
+                });
+                break;
+            case "MESSAGE_REACTION_REMOVE_ALL":
+                super.emit(utils_1.GatewayEvents.MessageReactionRemoveAll, {
+                    channelId: packet.d.channel_id,
+                    messageId: packet.d.message_id,
+                    guildId: packet.d.guild_id,
+                });
+                break;
+            case "MESSAGE_REACTION_REMOVE_EMOJI":
+                super.emit(utils_1.GatewayEvents.MessageReactionRemoveEmoji, {
+                    channelId: packet.d.channel_id,
+                    guildId: packet.d.guild_id,
+                    messageId: packet.d.message_id,
+                    emoji: new structures_1.Emoji(packet.d.emoji, this),
+                });
+                break;
+            case "PRESENCE_UPDATE":
+                super.emit(utils_1.GatewayEvents.PresenceUpdate, {
+                    user: new structures_1.User(packet.d.user, this),
+                    guildId: packet.d.guild_id,
+                    status: packet.d.status,
+                    activities: packet.d.activities.map((activity) => ({
+                        name: activity.name,
+                        type: activity.type,
+                        url: activity.url,
+                        createdAt: activity.created_at,
+                        timestamps: {
+                            start: activity.timestamps?.start,
+                            end: activity.timestamps?.end,
+                        },
+                        applicationId: activity.application_id,
+                        details: activity.details,
+                        state: activity.state,
+                        party: activity.party,
+                        assets: {
+                            largeImage: activity.assets?.large_image,
+                            largeText: activity.assets?.large_text,
+                            smallImage: activity.assets?.small_image,
+                            smallText: activity.assets?.small_text,
+                        },
+                        secrets: activity.secrets,
+                        instance: activity.instance,
+                        flags: activity.flags,
+                        buttons: activity.buttons,
+                    })),
+                    clientStatus: {
+                        desktop: packet.d.client_status.desktop,
+                        mobile: packet.d.client_status.mobile,
+                        web: packet.d.client_status.web,
+                    },
+                });
+                break;
+            case "STAGE_INSTANCE_CREATE":
+                super.emit(utils_1.GatewayEvents.StageInstanceCreate, new structures_1.StageInstance(packet.d, this));
+                break;
+            case "STAGE_INSTANCE_UPDATE":
+                super.emit(utils_1.GatewayEvents.StageInstanceUpdate, new structures_1.StageInstance(packet.d, this));
+                break;
+            case "STAGE_INSTANCE_DELETE":
+                super.emit(utils_1.GatewayEvents.StageInstanceDelete, new structures_1.StageInstance(packet.d, this).toJSON());
+                break;
+            case "TYPING_START":
+                super.emit(utils_1.GatewayEvents.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
+                        ? new structures_1.GuildMember(packet.d.member, this)
+                        : undefined,
+                });
+                break;
+            case "USER_UPDATE":
+                super.emit(utils_1.GatewayEvents.UserUpdate, new structures_1.User(packet.d, this));
+                break;
+            case "VOICE_STATE_UPDATE":
+                super.emit(utils_1.GatewayEvents.VoiceStateUpdate, {
+                    guildId: packet.d.guild_id,
+                    channelId: packet.d.channel_id,
+                    userId: packet.d.user_id,
+                    member: packet.d.member !== undefined
+                        ? new structures_1.GuildMember(packet.d.member, this)
+                        : undefined,
+                    sessionId: packet.d.session_id,
+                    deaf: packet.d.deaf,
+                    mute: packet.d.mute,
+                    selfDeaf: packet.d.self_deaf,
+                    selfMute: packet.d.self_mute,
+                    selfStream: packet.d.self_stream,
+                    selfVideo: packet.d.self_video,
+                    suppress: packet.d.suppress,
+                    requestToSpeakTimestamp: packet.d.request_to_speak_timestamp,
+                });
+                break;
+            case "VOICE_SERVER_UPDATE":
+                super.emit(utils_1.GatewayEvents.VoiceServerUpdate, {
+                    token: packet.d.token,
+                    guildId: packet.d.guild_id,
+                    endpoint: packet.d.endpoint,
+                });
+                break;
+            case "WEBHOOKS_UPDATE":
+                super.emit(utils_1.GatewayEvents.WebhooksUpdate, {
+                    guildId: packet.d.guild_id,
+                    channelId: packet.d.channel_id,
+                });
+                break;
+        }
+    }
+    onWebSocketError(err) {
+        throw err;
+    }
+    onWebSocketClose(code, reason) {
+        if (code === 1000)
+            return;
+        throw new Error(`[${code}] ${reason}`);
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=Client.js.map