discorb 0.0.8 → 0.2.3

data/lib/discorb/common.rb

@@ -4,7 +4,7 @@ module Discorb
   # @return [String] The API base URL.
   API_BASE_URL = "https://discord.com/api/v9"
   # @return [String] The version of discorb.
-  VERSION = "0.0.8"
+  VERSION = "0.2.3"
   # @return [String] The user agent for the bot.
   USER_AGENT = "DiscordBot (https://github.com/discorb-lib/discorb #{VERSION}) Ruby/#{RUBY_VERSION}"
 
@@ -73,6 +73,8 @@ module Discorb
       @value.to_s
     end
 
+    alias to_str to_s
+
     #
     # Integerize snowflake.
     #
@@ -108,19 +110,19 @@ module Discorb
     end
 
     def timestamp
-      Time.at(((sf >> 22) + 1_420_070_400_000) / 1000)
+      Time.at(((@value >> 22) + 1_420_070_400_000) / 1000)
     end
 
     def worker_id
-      (snowflake & 0x3E0000) >> 17
+      (@value & 0x3E0000) >> 17
     end
 
     def process_id
-      (snowflake & 0x1F000) >> 12
+      (@value & 0x1F000) >> 12
     end
 
     def increment
-      snowflake & 0xFFF
+      @value & 0xFFF
     end
   end
 end

data/lib/discorb/dictionary.rb

@@ -29,7 +29,7 @@ module Discorb
     def register(id, body)
       @cache[id.to_s] = body
       @cache = @cache.sort_by(&@sort).to_h if @sort
-      @cache.remove(@cache.values[-1]) if !@limit.nil? && @cache.size > @limit
+      @cache.delete(@cache.keys[0]) if !@limit.nil? && @cache.size > @limit
       body
     end
 

data/lib/discorb/embed.rb

@@ -41,8 +41,8 @@ module Discorb
     # @param [Discorb::Embed::Author] author The author field of embed.
     # @param [Array<Discorb::Embed::Field>] fields The fields of embed.
     # @param [Discorb::Embed::Footer] footer The footer of embed.
-    # @param [Discorb::Embed::Image] image The image of embed.
-    # @param [Discorb::Embed::Thumbnail] thumbnail The thumbnail of embed.
+    # @param [Discorb::Embed::Image, String] image The image of embed.
+    # @param [Discorb::Embed::Thumbnail, String] thumbnail The thumbnail of embed.
     #
     def initialize(title = nil, description = nil, color: nil, url: nil, timestamp: nil, author: nil,
                                                    fields: nil, footer: nil, image: nil, thumbnail: nil, data: nil)
@@ -55,8 +55,8 @@ module Discorb
         @author = author
         @fields = fields || []
         @footer = footer
-        @image = image
-        @thumbnail = thumbnail
+        @image = image && (image.is_a?(String) ? Image.new(image) : image)
+        @thumbnail = thumbnail && (thumbnail.is_a?(String) ? Thumbnail.new(thumbnail) : thumbnail)
         @type = "rich"
       else
         @title = data[:title]
@@ -336,9 +336,9 @@ module Discorb
       attr_reader :url
 
       # @!visibility private
-      def initialize(name, url)
-        @name = name
-        @url = url
+      def initialize(data)
+        @name = data[:name]
+        @url = data[:url]
       end
     end
   end

data/lib/discorb/emoji.rb

@@ -179,9 +179,11 @@ module Discorb
     attr_reader :name
     # @return [String] The unicode value of the emoji. (e.g. U+1F600)
     attr_reader :value
+    # @return [Integer] The skin tone of the emoji.
+    attr_reader :skin_tone
 
     # @!visibility private
-    def initialize(name)
+    def initialize(name, tone: 0)
       if EmojiTable::DISCORD_TO_UNICODE.key?(name)
         @name = name
         @value = EmojiTable::DISCORD_TO_UNICODE[name]
@@ -191,6 +193,9 @@ module Discorb
       else
         raise ArgumentError, "No such emoji: #{name}"
       end
+      if tone > 0
+        @value += EmojiTable::SKIN_TONES[tone]
+      end
     end
 
     # @return [String] The unicode string of the emoji.

data/lib/discorb/emoji_table.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength
 module Discorb
   #
   # A table of emoji names and their unicode values.
@@ -3794,6 +3793,14 @@ module Discorb
       "\xF0\x9F\x95\x9B" => %w[clock12],
       "\xF0\x9F\x95\xA7" => %w[clock1230],
     }.freeze
-    # rubocop:enable Metrics/ModuleLength
+
+    SKIN_TONES = [
+      :dummy,
+      "\xf0\x9f\x8f\xbb",
+      "\xf0\x9f\x8f\xbc",
+      "\xf0\x9f\x8f\xbd",
+      "\xf0\x9f\x8f\xbe",
+      "\xf0\x9f\x8f\xbf",
+    ].freeze
   end
 end

data/lib/discorb/error.rb

@@ -11,6 +11,9 @@ module Discorb
     def enumerate_errors(hash)
       res = {}
       _recr_items([], hash, res)
+      if res == { "" => nil }
+        res = {}
+      end
       res
     end
 
@@ -56,7 +59,7 @@ module Discorb
       @code = data[:code]
       @response = resp
       DiscorbError.instance_method(:initialize).bind(self).call(
-        [data[:message], "\n", enumerate_errors(data[:errors]).map do |ek, ev|
+        [data[:message], enumerate_errors(data[:errors]).map do |ek, ev|
           "#{ek}=>#{ev}"
         end.join("\n")].join("\n")
       )

data/lib/discorb/extension.rb

@@ -25,9 +25,8 @@ module Discorb
       raise ArgumentError, "Event name must be a symbol" unless event_name.is_a?(Symbol)
       raise ArgumentError, "block must be a Proc" unless block.is_a?(Proc)
 
-      @events = {} if @events.nil?
       @events[event_name] ||= []
-      discriminator[:extension] = Extension
+      discriminator[:extension] = self.name
       @events[event_name] << Discorb::Event.new(block, id, discriminator)
     end
 
@@ -50,5 +49,9 @@ module Discorb
 
     # @!visibility private
     attr_accessor :client
+
+    def self.extended(obj)
+      obj.instance_variable_set(:@events, {})
+    end
   end
 end

data/lib/discorb/gateway.rb

@@ -4,10 +4,10 @@ require "async/http"
 
 module Discorb
   #
-  # A module to handle gateway.
+  # A module for Discord Gateway.
   # This module is internal use only.
   #
-  module GatewayHandler
+  module Gateway
     #
     # Represents an event.
     #
@@ -451,519 +451,528 @@ module Discorb
       end
     end
 
-    private
-
-    def connect_gateway(first)
-      @log.info "Connecting to gateway."
-      Async do
-        @http = HTTP.new(self) if first
-        @first = first
-        _, gateway_response = @http.get("/gateway").wait
-        gateway_url = gateway_response[:url]
-        endpoint = Async::HTTP::Endpoint.parse("#{gateway_url}?v=9&encoding=json",
-                                               alpn_protocols: Async::HTTP::Protocol::HTTP11.names)
-        begin
-          Async::WebSocket::Client.connect(endpoint, headers: [["User-Agent", Discorb::USER_AGENT]]) do |connection|
-            @connection = connection
-            while (message = @connection.read)
-              handle_gateway(message)
+    #
+    # A module to handle gateway events.
+    #
+    module Handler
+      private
+
+      def connect_gateway(first)
+        @log.info "Connecting to gateway."
+        Async do
+          @http = HTTP.new(self) if first
+          @first = first
+          _, gateway_response = @http.get("/gateway").wait
+          gateway_url = gateway_response[:url]
+          endpoint = Async::HTTP::Endpoint.parse("#{gateway_url}?v=9&encoding=json",
+                                                alpn_protocols: Async::HTTP::Protocol::HTTP11.names)
+          begin
+            Async::WebSocket::Client.connect(endpoint, headers: [["User-Agent", Discorb::USER_AGENT]]) do |connection|
+              @connection = connection
+              while (message = @connection.read)
+                handle_gateway(message)
+              end
             end
-          end
-        rescue Protocol::WebSocket::ClosedError => e
-          case e.message
-          when "Authentication failed."
-            @tasks.map(&:stop)
-            raise ClientError.new("Authentication failed."), cause: nil
-          when "Discord WebSocket requesting client reconnect."
-            @log.info "Discord WebSocket requesting client reconnect"
-            @tasks.map(&:stop)
+          rescue Protocol::WebSocket::ClosedError => e
+            case e.message
+            when "Authentication failed."
+              @tasks.map(&:stop)
+              raise ClientError.new("Authentication failed."), cause: nil
+            when "Discord WebSocket requesting client reconnect."
+              @log.info "Discord WebSocket requesting client reconnect"
+              @tasks.map(&:stop)
+              connect_gateway(false)
+            end
+          rescue EOFError, Async::Wrapper::Cancelled
             connect_gateway(false)
           end
-        rescue EOFError, Async::Wrapper::Cancelled
-          connect_gateway(false)
         end
       end
-    end
-
-    def send_gateway(opcode, **value)
-      @connection.write({ op: opcode, d: value })
-      @connection.flush
-      @log.debug "Sent message with opcode #{opcode}: #{value.to_json.gsub(@token, "[Token]")}"
-    end
 
-    def handle_gateway(payload)
-      Async do |task|
-        data = payload[:d]
-        @last_s = payload[:s] if payload[:s]
-        @log.debug "Received message with opcode #{payload[:op]} from gateway: #{data}"
-        case payload[:op]
-        when 10
-          @heartbeat_interval = data[:heartbeat_interval]
-          @tasks << handle_heartbeat(@heartbeat_interval)
-          if @first
-            payload = {
-              token: @token,
-              intents: @intents.value,
-              compress: false,
-              properties: { "$os" => RUBY_PLATFORM, "$browser" => "discorb", "$device" => "discorb" },
-            }
-            payload[:presence] = @identify_presence if @identify_presence
-            send_gateway(2, **payload)
-          else
-            payload = {
-              token: @token,
-              session_id: @session_id,
-              seq: @last_s,
-            }
-            send_gateway(6, **payload)
-          end
-        when 9
-          @log.warn "Received opcode 9, closed connection"
-          @tasks.map(&:stop)
-          if data
-            @log.info "Connection is resumable, reconnecting"
-            @connection.close
-            connect_gateway(false)
-          else
-            @log.info "Connection is not resumable, reconnecting with opcode 2"
-            task.sleep(2)
-            @connection.close
-            connect_gateway(true)
+      def send_gateway(opcode, **value)
+        @connection.write({ op: opcode, d: value })
+        @connection.flush
+        @log.debug "Sent message with opcode #{opcode}: #{value.to_json.gsub(@token, "[Token]")}"
+      end
+
+      def handle_gateway(payload)
+        Async do |task|
+          data = payload[:d]
+          @last_s = payload[:s] if payload[:s]
+          @log.debug "Received message with opcode #{payload[:op]} from gateway: #{data}"
+          case payload[:op]
+          when 10
+            @heartbeat_interval = data[:heartbeat_interval]
+            @tasks << handle_heartbeat(@heartbeat_interval)
+            if @first
+              payload = {
+                token: @token,
+                intents: @intents.value,
+                compress: false,
+                properties: { "$os" => RUBY_PLATFORM, "$browser" => "discorb", "$device" => "discorb" },
+              }
+              payload[:presence] = @identify_presence if @identify_presence
+              send_gateway(2, **payload)
+            else
+              payload = {
+                token: @token,
+                session_id: @session_id,
+                seq: @last_s,
+              }
+              send_gateway(6, **payload)
+            end
+          when 9
+            @log.warn "Received opcode 9, closed connection"
+            @tasks.map(&:stop)
+            if data
+              @log.info "Connection is resumable, reconnecting"
+              @connection.close
+              connect_gateway(false)
+            else
+              @log.info "Connection is not resumable, reconnecting with opcode 2"
+              task.sleep(2)
+              @connection.close
+              connect_gateway(true)
+            end
+          when 11
+            @log.info "Received opcode 11"
+            @ping = Time.now.to_f - @heartbeat_before
+          when 0
+            handle_event(payload[:t], data)
           end
-        when 0
-          handle_event(payload[:t], data)
         end
       end
-    end
 
-    def handle_heartbeat(interval)
-      Async do |task|
-        task.sleep((interval / 1000.0 - 1) * rand)
-        loop do
-          @connection.write({ op: 1, d: @last_s })
-          @connection.flush
-          @log.debug "Sent opcode 1."
-          @log.debug "Waiting for heartbeat."
-          sleep(interval / 1000.0 - 1)
+      def handle_heartbeat(interval)
+        Async do |task|
+          task.sleep((interval / 1000.0 - 1) * rand)
+          loop do
+            @heartbeat_before = Time.now.to_f
+            @connection.write({ op: 1, d: @last_s })
+            @connection.flush
+            @log.debug "Sent opcode 1."
+            @log.debug "Waiting for heartbeat."
+            sleep(interval / 1000.0 - 1)
+          end
         end
       end
-    end
 
-    def handle_event(event_name, data)
-      return @log.debug "Client isn't ready; event #{event_name} wasn't handled" if @wait_until_ready && !@ready && !%w[READY GUILD_CREATE].include?(event_name)
-
-      dispatch(:event_receive, event_name, data)
-      @log.debug "Handling event #{event_name}"
-      case event_name
-      when "READY"
-        @api_version = data[:v]
-        @session_id = data[:session_id]
-        @user = ClientUser.new(self, data[:user])
-        @uncached_guilds = data[:guilds].map { |g| g[:id] }
-      when "GUILD_CREATE"
-        if @uncached_guilds.include?(data[:id])
-          Guild.new(self, data, true)
-          @uncached_guilds.delete(data[:id])
-          if @uncached_guilds == []
-            @ready = true
-            dispatch(:ready)
-            @log.info("Guilds were cached")
+      def handle_event(event_name, data)
+        return @log.debug "Client isn't ready; event #{event_name} wasn't handled" if @wait_until_ready && !@ready && !%w[READY GUILD_CREATE].include?(event_name)
+
+        dispatch(:event_receive, event_name, data)
+        @log.debug "Handling event #{event_name}"
+        case event_name
+        when "READY"
+          @api_version = data[:v]
+          @session_id = data[:session_id]
+          @user = ClientUser.new(self, data[:user])
+          @uncached_guilds = data[:guilds].map { |g| g[:id] }
+        when "GUILD_CREATE"
+          if @uncached_guilds.include?(data[:id])
+            Guild.new(self, data, true)
+            @uncached_guilds.delete(data[:id])
+            if @uncached_guilds == []
+              @ready = true
+              setup_commands.wait if @overwrite_application_commands
+              dispatch(:ready)
+              @log.info("Guilds were cached")
+            end
+          elsif @guilds.has?(data[:id])
+            @guilds[data[:id]].send(:_set_data, data)
+            dispatch(:guild_available, guild)
+          else
+            guild = Guild.new(self, data, true)
+            dispatch(:guild_join, guild)
           end
-        elsif @guilds.has?(data[:id])
-          @guilds[data[:id]].send(:_set_data, data)
-          dispatch(:guild_available, guild)
-        else
-          guild = Guild.new(self, data, true)
-          dispatch(:guild_join, guild)
-        end
-        dispatch(:guild_create, @guilds[data[:id]])
-      when "MESSAGE_CREATE"
-        message = Message.new(self, data)
-        dispatch(:message, message)
-      when "GUILD_UPDATE"
-        if @guilds.has?(data[:id])
-          current = @guilds[data[:id]]
-          before = Guild.new(self, current.instance_variable_get(:@data).merge(no_cache: true), false)
-          current.send(:_set_data, data, false)
-          dispatch(:guild_update, before, current)
-        else
-          @log.warn "Unknown guild id #{data[:id]}, ignoring"
-        end
-      when "GUILD_DELETE"
-        return @log.warn "Unknown guild id #{data[:id]}, ignoring" unless (guild = @guilds.delete(data[:id]))
-
-        dispatch(:guild_delete, guild)
-        if guild.has?(:unavailable)
-          dispatch(:guild_destroy, guild)
-        else
-          dispatch(:guild_leave, guild)
-        end
-      when "GUILD_ROLE_CREATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-
-        nr = Role.new(@client, guild, data[:role])
-        guild.roles[data[:role][:id]] = nr
-        dispatch(:role_create, nr)
-      when "GUILD_ROLE_UPDATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-        return @log.warn "Unknown role id #{data[:role][:id]}, ignoring" unless guild.roles.has?(data[:role][:id])
-
-        current = guild.roles[data[:role][:id]]
-        before = Role.new(@client, guild, current.instance_variable_get(:@data).update({ no_cache: true }))
-        current.send(:_set_data, data[:role])
-        dispatch(:role_update, before, current)
-      when "GUILD_ROLE_DELETE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-        return @log.warn "Unknown role id #{data[:role_id]}, ignoring" unless (role = guild.roles.delete(data[:role_id]))
-
-        dispatch(:role_delete, role)
-      when "CHANNEL_CREATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-
-        nc = Channel.make_channel(self, data)
-        guild.channels[data[:id]] = nc
-
-        dispatch(:channel_create, nc)
-      when "CHANNEL_UPDATE"
-        return @log.warn "Unknown channel id #{data[:id]}, ignoring" unless (current = @channels[data[:id]])
-
-        before = Channel.make_channel(self, current.instance_variable_get(:@data), no_cache: true)
-        current.send(:_set_data, data)
-        dispatch(:channel_update, before, current)
-      when "CHANNEL_DELETE"
-        return @log.warn "Unknown channel id #{data[:id]}, ignoring" unless (channel = @channels.delete(data[:id]))
-
-        @guilds[data[:guild_id]]&.channels&.delete(data[:id])
-        dispatch(:channel_delete, channel)
-      when "CHANNEL_PINS_UPDATE"
-        nil # do in MESSAGE_UPDATE
-      when "THREAD_CREATE"
-        thread = Channel.make_channel(self, data)
-
-        dispatch(:thread_create, thread)
-        if data.key?(:member)
-          dispatch(:thread_join, thread)
-        else
-          dispatch(:thread_new, thread)
-        end
-      when "THREAD_UPDATE"
-        return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
-
-        before = Channel.make_channel(self, thread.instance_variable_get(:@data), no_cache: true)
-        thread.send(:_set_data, data)
-        dispatch(:thread_update, before, thread)
-      when "THREAD_DELETE"
-        return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels.delete(data[:id]))
-
-        @guilds[data[:guild_id]]&.channels&.delete(data[:id])
-        dispatch(:thread_delete, thread)
-      when "THREAD_LIST_SYNC"
-        data[:threads].each do |raw_thread|
-          thread = Channel.make_channel(self, raw_thread.merge({ member: raw_thread[:members].find { |m| m[:id] == raw_thread[:id] } }))
-          @channels[thread.id] = thread
-        end
-      when "THREAD_MEMBER_UPDATE"
-        return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
-
-        if (member = thread.members[data[:id]])
-          old = ThreadChannel::Member.new(self, member.instance_variable_get(:@data))
-          member._set_data(data)
-        else
-          old = nil
-          member = ThreadChannel::Member.new(self, data)
-          thread.members[data[:user_id]] = member
-        end
-        dispatch(:thread_member_update, thread, old, member)
-      when "THREAD_MEMBERS_UPDATE"
-        return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
-
-        thread.instance_variable_set(:@member_count, data[:member_count])
-        members = []
-        (data[:added_members] || []).each do |raw_member|
-          member = ThreadChannel::Member.new(self, raw_member)
-          thread.members[member.id] = member
-          members << member
-        end
-        removed_members = []
-        (data[:removed_member_ids] || []).each do |id|
-          removed_members << thread.members.delete(id)
-        end
-        dispatch(:thread_members_update, thread, members, removed_members)
-      when "STAGE_INSTANCE_CREATE"
-        instance = StageInstance.new(self, data)
-        dispatch(:stage_instance_create, instance)
-      when "STAGE_INSTANCE_UPDATE"
-        return @log.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
-        return @log.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances[data[:id]])
-
-        old = StageInstance.new(self, instance.instance_variable_get(:@data), no_cache: true)
-        current.send(:_set_data, data)
-        dispatch(:stage_instance_update, old, current)
-      when "STAGE_INSTANCE_DELETE"
-        return @log.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
-        return @log.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances.delete(data[:id]))
-
-        dispatch(:stage_instance_delete, instance)
-      when "GUILD_MEMBER_ADD"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-
-        nm = Member.new(self, data[:guild_id], data[:user].update({ no_cache: true }), data)
-        guild.members[nm.id] = nm
-        dispatch(:member_add, nm)
-      when "GUILD_MEMBER_UPDATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-        return @log.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (nm = guild.members[data[:user][:id]])
-
-        old = Member.new(self, data[:guild_id], data[:user], data.update({ no_cache: true }))
-        nm.send(:_set_data, data[:user], data)
-        dispatch(:member_update, old, nm)
-      when "GUILD_MEMBER_REMOVE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-        return @log.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (member = guild.members.delete(data[:user][:id]))
-
-        dispatch(:member_remove, member)
-      when "GUILD_BAN_ADD"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-
-        user = if @users.has? data[:user][:id]
-            @users[data[:user][:id]]
+          dispatch(:guild_create, @guilds[data[:id]])
+        when "MESSAGE_CREATE"
+          message = Message.new(self, data)
+          dispatch(:message, message)
+        when "GUILD_UPDATE"
+          if @guilds.has?(data[:id])
+            current = @guilds[data[:id]]
+            before = Guild.new(self, current.instance_variable_get(:@data).merge(no_cache: true), false)
+            current.send(:_set_data, data, false)
+            dispatch(:guild_update, before, current)
           else
-            User.new(self, data[:user].update({ no_cache: true }))
+            @log.warn "Unknown guild id #{data[:id]}, ignoring"
           end
+        when "GUILD_DELETE"
+          return @log.warn "Unknown guild id #{data[:id]}, ignoring" unless (guild = @guilds.delete(data[:id]))
 
-        dispatch(:guild_ban_add, guild, user)
-      when "GUILD_BAN_REMOVE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          dispatch(:guild_delete, guild)
+          if guild.has?(:unavailable)
+            dispatch(:guild_destroy, guild)
+          else
+            dispatch(:guild_leave, guild)
+          end
+        when "GUILD_ROLE_CREATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          nr = Role.new(@client, guild, data[:role])
+          guild.roles[data[:role][:id]] = nr
+          dispatch(:role_create, nr)
+        when "GUILD_ROLE_UPDATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return @log.warn "Unknown role id #{data[:role][:id]}, ignoring" unless guild.roles.has?(data[:role][:id])
+
+          current = guild.roles[data[:role][:id]]
+          before = Role.new(@client, guild, current.instance_variable_get(:@data).update({ no_cache: true }))
+          current.send(:_set_data, data[:role])
+          dispatch(:role_update, before, current)
+        when "GUILD_ROLE_DELETE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return @log.warn "Unknown role id #{data[:role_id]}, ignoring" unless (role = guild.roles.delete(data[:role_id]))
+
+          dispatch(:role_delete, role)
+        when "CHANNEL_CREATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          nc = Channel.make_channel(self, data)
+          guild.channels[data[:id]] = nc
+
+          dispatch(:channel_create, nc)
+        when "CHANNEL_UPDATE"
+          return @log.warn "Unknown channel id #{data[:id]}, ignoring" unless (current = @channels[data[:id]])
+
+          before = Channel.make_channel(self, current.instance_variable_get(:@data), no_cache: true)
+          current.send(:_set_data, data)
+          dispatch(:channel_update, before, current)
+        when "CHANNEL_DELETE"
+          return @log.warn "Unknown channel id #{data[:id]}, ignoring" unless (channel = @channels.delete(data[:id]))
+
+          @guilds[data[:guild_id]]&.channels&.delete(data[:id])
+          dispatch(:channel_delete, channel)
+        when "CHANNEL_PINS_UPDATE"
+          nil # do in MESSAGE_UPDATE
+        when "THREAD_CREATE"
+          thread = Channel.make_channel(self, data)
+
+          dispatch(:thread_create, thread)
+          if data.key?(:member)
+            dispatch(:thread_join, thread)
+          else
+            dispatch(:thread_new, thread)
+          end
+        when "THREAD_UPDATE"
+          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
+
+          before = Channel.make_channel(self, thread.instance_variable_get(:@data), no_cache: true)
+          thread.send(:_set_data, data)
+          dispatch(:thread_update, before, thread)
+        when "THREAD_DELETE"
+          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels.delete(data[:id]))
+
+          @guilds[data[:guild_id]]&.channels&.delete(data[:id])
+          dispatch(:thread_delete, thread)
+        when "THREAD_LIST_SYNC"
+          data[:threads].each do |raw_thread|
+            thread = Channel.make_channel(self, raw_thread.merge({ member: raw_thread[:members].find { |m| m[:id] == raw_thread[:id] } }))
+            @channels[thread.id] = thread
+          end
+        when "THREAD_MEMBER_UPDATE"
+          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
 
-        user = if @users.has? data[:user][:id]
-            @users[data[:user][:id]]
+          if (member = thread.members[data[:id]])
+            old = ThreadChannel::Member.new(self, member.instance_variable_get(:@data))
+            member._set_data(data)
           else
-            User.new(self, data[:user].update({ no_cache: true }))
+            old = nil
+            member = ThreadChannel::Member.new(self, data)
+            thread.members[data[:user_id]] = member
+          end
+          dispatch(:thread_member_update, thread, old, member)
+        when "THREAD_MEMBERS_UPDATE"
+          return @log.warn "Unknown thread id #{data[:id]}, ignoring" unless (thread = @channels[data[:id]])
+
+          thread.instance_variable_set(:@member_count, data[:member_count])
+          members = []
+          (data[:added_members] || []).each do |raw_member|
+            member = ThreadChannel::Member.new(self, raw_member)
+            thread.members[member.id] = member
+            members << member
+          end
+          removed_members = []
+          (data[:removed_member_ids] || []).each do |id|
+            removed_members << thread.members.delete(id)
           end
+          dispatch(:thread_members_update, thread, members, removed_members)
+        when "STAGE_INSTANCE_CREATE"
+          instance = StageInstance.new(self, data)
+          dispatch(:stage_instance_create, instance)
+        when "STAGE_INSTANCE_UPDATE"
+          return @log.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
+          return @log.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances[data[:id]])
+
+          old = StageInstance.new(self, instance.instance_variable_get(:@data), no_cache: true)
+          current.send(:_set_data, data)
+          dispatch(:stage_instance_update, old, current)
+        when "STAGE_INSTANCE_DELETE"
+          return @log.warn "Unknown channel id #{data[:channel_id]} , ignoring" unless (channel = @channels[data[:channel_id]])
+          return @log.warn "Unknown stage instance id #{data[:id]}, ignoring" unless (instance = channel.stage_instances.delete(data[:id]))
+
+          dispatch(:stage_instance_delete, instance)
+        when "GUILD_MEMBER_ADD"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          nm = Member.new(self, data[:guild_id], data[:user].update({ no_cache: true }), data)
+          guild.members[nm.id] = nm
+          dispatch(:member_add, nm)
+        when "GUILD_MEMBER_UPDATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return @log.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (nm = guild.members[data[:user][:id]])
+
+          old = Member.new(self, data[:guild_id], data[:user], data.update({ no_cache: true }))
+          nm.send(:_set_data, data[:user], data)
+          dispatch(:member_update, old, nm)
+        when "GUILD_MEMBER_REMOVE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return @log.warn "Unknown member id #{data[:user][:id]}, ignoring" unless (member = guild.members.delete(data[:user][:id]))
+
+          dispatch(:member_remove, member)
+        when "GUILD_BAN_ADD"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          user = if @users.has? data[:user][:id]
+              @users[data[:user][:id]]
+            else
+              User.new(self, data[:user].update({ no_cache: true }))
+            end
 
-        dispatch(:guild_ban_remove, guild, user)
-      when "GUILD_EMOJIS_UPDATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          dispatch(:guild_ban_add, guild, user)
+        when "GUILD_BAN_REMOVE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
 
-        before_emojis = guild.emojis.values.map(&:id).to_set
-        data[:emojis].each do |emoji|
-          guild.emojis[emoji[:id]] = CustomEmoji.new(self, guild, emoji)
-        end
-        deleted_emojis = before_emojis - guild.emojis.values.map(&:id).to_set
-        deleted_emojis.each do |emoji|
-          guild.emojis.delete(emoji)
-        end
-      when "GUILD_INTEGRATIONS_UPDATE"
-        # dispatch(:guild_integrations_update, GuildIntegrationsUpdateEvent.new(self, data))
-        # Currently not implemented
-      when "INTEGRATION_CREATE"
-        dispatch(:integration_create, Integration.new(self, data, data[:guild_id]))
-      when "INTEGRATION_UPDATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-        return @log.warn "Unknown integration id #{data[:id]}, ignoring" unless (integration = guild.integrations[data[:id]])
-
-        before = Integration.new(self, integration.instance_variable_get(:@data), data[:guild_id], no_cache: true)
-        integration.send(:_set_data, data)
-        dispatch(:integration_update, before, integration)
-      when "INTEGRATION_DELETE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-        return @log.warn "Unknown integration id #{data[:id]}, ignoring" unless (integration = guild.integrations.delete(data[:id]))
-
-        dispatch(:integration_delete, integration)
-      when "WEBHOOKS_UPDATE"
-        dispatch(:webhooks_update, WebhooksUpdateEvent.new(self, data))
-      when "INVITE_CREATE"
-        dispatch(:invite_create, Invite.new(self, data, true))
-      when "INVITE_DELETE"
-        dispatch(:invite_delete, InviteDeleteEvent.new(self, data))
-      when "VOICE_STATE_UPDATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-
-        current = guild.voice_states[data[:user_id]]
-        if current.nil?
-          old = nil
-          current = VoiceState.new(self, data)
-          guild.voice_states[data[:user_id]] = current
-        else
-          old = VoiceState.new(self, current.instance_variable_get(:@data))
-          current.send(:_set_data, data)
-        end
-        dispatch(:voice_state_update, old, current)
-        if old&.channel != current&.channel
-          dispatch(:voice_channel_update, old, current)
-          case [old&.channel, current&.channel]
-          in [nil, _]
-            dispatch(:voice_channel_connect, current)
-          in [_, nil]
-            dispatch(:voice_channel_disconnect, old)
-          in _
-            dispatch(:voice_channel_move, old, current)
+          user = if @users.has? data[:user][:id]
+              @users[data[:user][:id]]
+            else
+              User.new(self, data[:user].update({ no_cache: true }))
+            end
+
+          dispatch(:guild_ban_remove, guild, user)
+        when "GUILD_EMOJIS_UPDATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          before_emojis = guild.emojis.values.map(&:id).to_set
+          data[:emojis].each do |emoji|
+            guild.emojis[emoji[:id]] = CustomEmoji.new(self, guild, emoji)
           end
-        end
-        if old&.mute? != current&.mute?
-          dispatch(:voice_mute_update, old, current)
-          case [old&.mute?, current&.mute?]
-          when [false, true]
-            dispatch(:voice_mute_enable, current)
-          when [true, false]
-            dispatch(:voice_mute_disable, old)
+          deleted_emojis = before_emojis - guild.emojis.values.map(&:id).to_set
+          deleted_emojis.each do |emoji|
+            guild.emojis.delete(emoji)
           end
-        end
-        if old&.deaf? != current&.deaf?
-          dispatch(:voice_deaf_update, old, current)
-          case [old&.deaf?, current&.deaf?]
-          when [false, true]
-            dispatch(:voice_deaf_enable, current)
-          when [true, false]
-            dispatch(:voice_deaf_disable, old)
+        when "GUILD_INTEGRATIONS_UPDATE"
+          # dispatch(:guild_integrations_update, GuildIntegrationsUpdateEvent.new(self, data))
+          # Currently not implemented
+        when "INTEGRATION_CREATE"
+          dispatch(:integration_create, Integration.new(self, data, data[:guild_id]))
+        when "INTEGRATION_UPDATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return @log.warn "Unknown integration id #{data[:id]}, ignoring" unless (integration = guild.integrations[data[:id]])
+
+          before = Integration.new(self, integration.instance_variable_get(:@data), data[:guild_id], no_cache: true)
+          integration.send(:_set_data, data)
+          dispatch(:integration_update, before, integration)
+        when "INTEGRATION_DELETE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+          return @log.warn "Unknown integration id #{data[:id]}, ignoring" unless (integration = guild.integrations.delete(data[:id]))
+
+          dispatch(:integration_delete, integration)
+        when "WEBHOOKS_UPDATE"
+          dispatch(:webhooks_update, WebhooksUpdateEvent.new(self, data))
+        when "INVITE_CREATE"
+          dispatch(:invite_create, Invite.new(self, data, true))
+        when "INVITE_DELETE"
+          dispatch(:invite_delete, InviteDeleteEvent.new(self, data))
+        when "VOICE_STATE_UPDATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          current = guild.voice_states[data[:user_id]]
+          if current.nil?
+            old = nil
+            current = VoiceState.new(self, data)
+            guild.voice_states[data[:user_id]] = current
+          else
+            old = VoiceState.new(self, current.instance_variable_get(:@data))
+            current.send(:_set_data, data)
           end
-        end
-        if old&.self_mute? != current&.self_mute?
-          dispatch(:voice_self_mute_update, old, current)
-          case [old&.self_mute?, current&.self_mute?]
-          when [false, true]
-            dispatch(:voice_self_mute_enable, current)
-          when [true, false]
-            dispatch(:voice_self_mute_disable, old)
+          dispatch(:voice_state_update, old, current)
+          if old&.channel != current&.channel
+            dispatch(:voice_channel_update, old, current)
+            case [old&.channel, current&.channel]
+            in [nil, _]
+              dispatch(:voice_channel_connect, current)
+            in [_, nil]
+              dispatch(:voice_channel_disconnect, old)
+            in _
+              dispatch(:voice_channel_move, old, current)
+            end
           end
-        end
-        if old&.self_deaf? != current&.self_deaf?
-          dispatch(:voice_self_deaf_update, old, current)
-          case [old&.self_deaf?, current&.self_deaf?]
-          when [false, true]
-            dispatch(:voice_self_deaf_enable, current)
-          when [true, false]
-            dispatch(:voice_self_deaf_disable, old)
+          if old&.mute? != current&.mute?
+            dispatch(:voice_mute_update, old, current)
+            case [old&.mute?, current&.mute?]
+            when [false, true]
+              dispatch(:voice_mute_enable, current)
+            when [true, false]
+              dispatch(:voice_mute_disable, old)
+            end
           end
-        end
-        if old&.server_mute? != current&.server_mute?
-          dispatch(:voice_server_mute_update, old, current)
-          case [old&.server_mute?, current&.server_mute?]
-          when [false, true]
-            dispatch(:voice_server_mute_enable, current)
-          when [true, false]
-            dispatch(:voice_server_mute_disable, old)
+          if old&.deaf? != current&.deaf?
+            dispatch(:voice_deaf_update, old, current)
+            case [old&.deaf?, current&.deaf?]
+            when [false, true]
+              dispatch(:voice_deaf_enable, current)
+            when [true, false]
+              dispatch(:voice_deaf_disable, old)
+            end
           end
-        end
-        if old&.server_deaf? != current&.server_deaf?
-          dispatch(:voice_server_deaf_update, old, current)
-          case [old&.server_deaf?, current&.server_deaf?]
-          when [false, true]
-            dispatch(:voice_server_deaf_enable, current)
-          when [true, false]
-            dispatch(:voice_server_deaf_disable, old)
+          if old&.self_mute? != current&.self_mute?
+            dispatch(:voice_self_mute_update, old, current)
+            case [old&.self_mute?, current&.self_mute?]
+            when [false, true]
+              dispatch(:voice_self_mute_enable, current)
+            when [true, false]
+              dispatch(:voice_self_mute_disable, old)
+            end
           end
-        end
-        if old&.video? != current&.video?
-          dispatch(:voice_video_update, old, current)
-          case [old&.video?, current&.video?]
-          when [false, true]
-            dispatch(:voice_video_start, current)
-          when [true, false]
-            dispatch(:voice_video_end, old)
+          if old&.self_deaf? != current&.self_deaf?
+            dispatch(:voice_self_deaf_update, old, current)
+            case [old&.self_deaf?, current&.self_deaf?]
+            when [false, true]
+              dispatch(:voice_self_deaf_enable, current)
+            when [true, false]
+              dispatch(:voice_self_deaf_disable, old)
+            end
           end
-        end
-        if old&.stream? != current&.stream?
-          dispatch(:voice_stream_update, old, current)
-          case [old&.stream?, current&.stream?]
-          when [false, true]
-            dispatch(:voice_stream_start, current)
-          when [true, false]
-            dispatch(:voice_stream_end, old)
+          if old&.server_mute? != current&.server_mute?
+            dispatch(:voice_server_mute_update, old, current)
+            case [old&.server_mute?, current&.server_mute?]
+            when [false, true]
+              dispatch(:voice_server_mute_enable, current)
+            when [true, false]
+              dispatch(:voice_server_mute_disable, old)
+            end
           end
-        end
-      when "PRESENCE_UPDATE"
-        return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
-
-        guild.presences[data[:user][:id]] = Presence.new(self, data)
-      when "MESSAGE_UPDATE"
-        if (message = @messages[data[:id]])
-          before = Message.new(self, message.instance_variable_get(:@data), no_cache: true)
-          message.send(:_set_data, message.instance_variable_get(:@data).merge(data))
-        else
-          @log.info "Uncached message ID #{data[:id]}, ignoring"
-          before = nil
-          message = nil
-        end
-        if data[:edited_timestamp].nil?
-          if message.nil?
-            nil
-          elsif message.pinned?
-            message.instance_variable_set(:@pinned, false)
-          else
-            message.instance_variable_set(:@pinned, true)
+          if old&.server_deaf? != current&.server_deaf?
+            dispatch(:voice_server_deaf_update, old, current)
+            case [old&.server_deaf?, current&.server_deaf?]
+            when [false, true]
+              dispatch(:voice_server_deaf_enable, current)
+            when [true, false]
+              dispatch(:voice_server_deaf_disable, old)
+            end
           end
-          dispatch(:message_pin_update, MessagePinEvent.new(self, data, message))
-        else
-          dispatch(:message_update, MessageUpdateEvent.new(self, data, before, current))
-        end
-      when "MESSAGE_DELETE"
-        message.instance_variable_set(:@deleted, true) if (message = @messages[data[:id]])
-
-        dispatch(:message_delete_id, Snowflake.new(data[:id]), channels[data[:channel_id]], data[:guild_id] && guilds[data[:guild_id]])
-        dispatch(:message_delete, message, channels[data[:channel_id]], data[:guild_id] && guilds[data[:guild_id]])
-      when "MESSAGE_DELETE_BULK"
-        messages = []
-        data[:ids].each do |id|
-          if (message = @messages[id])
-            message.instance_variable_set(:@deleted, true)
-            messages.push(message)
+          if old&.video? != current&.video?
+            dispatch(:voice_video_update, old, current)
+            case [old&.video?, current&.video?]
+            when [false, true]
+              dispatch(:voice_video_start, current)
+            when [true, false]
+              dispatch(:voice_video_end, old)
+            end
+          end
+          if old&.stream? != current&.stream?
+            dispatch(:voice_stream_update, old, current)
+            case [old&.stream?, current&.stream?]
+            when [false, true]
+              dispatch(:voice_stream_start, current)
+            when [true, false]
+              dispatch(:voice_stream_end, old)
+            end
+          end
+        when "PRESENCE_UPDATE"
+          return @log.warn "Unknown guild id #{data[:guild_id]}, ignoring" unless (guild = @guilds[data[:guild_id]])
+
+          guild.presences[data[:user][:id]] = Presence.new(self, data)
+        when "MESSAGE_UPDATE"
+          if (message = @messages[data[:id]])
+            before = Message.new(self, message.instance_variable_get(:@data), no_cache: true)
+            message.send(:_set_data, message.instance_variable_get(:@data).merge(data))
           else
-            messages.push(UnknownDeleteBulkMessage.new(self, id))
+            before = nil
+            message = nil
           end
-        end
-        dispatch(:message_delete_bulk, messages)
-      when "MESSAGE_REACTION_ADD"
-        if (target_message = @messages[data[:message_id]])
-          if (target_reaction = target_message.reactions.find do |r|
-            r.emoji.is_a?(UnicodeEmoji) ? r.emoji.value == data[:emoji][:name] : r.emoji.id == data[:emoji][:id]
-          end)
-            target_reaction.set_instance_variable(:@count, target_reaction.count + 1)
+          if data[:edited_timestamp].nil?
+            if message.nil?
+              nil
+            elsif message.pinned?
+              message.instance_variable_set(:@pinned, false)
+            else
+              message.instance_variable_set(:@pinned, true)
+            end
+            dispatch(:message_pin_update, MessagePinEvent.new(self, data, message))
           else
-            target_message.reactions << Reaction.new(
-              self,
-              {
-                count: 1,
-                me: @user.id == data[:user_id],
-                emoji: data[:emoji],
-              }
-            )
+            dispatch(:message_update, MessageUpdateEvent.new(self, data, before, current))
           end
+        when "MESSAGE_DELETE"
+          message.instance_variable_set(:@deleted, true) if (message = @messages[data[:id]])
+
+          dispatch(:message_delete_id, Snowflake.new(data[:id]), channels[data[:channel_id]], data[:guild_id] && guilds[data[:guild_id]])
+          dispatch(:message_delete, message, channels[data[:channel_id]], data[:guild_id] && guilds[data[:guild_id]])
+        when "MESSAGE_DELETE_BULK"
+          messages = []
+          data[:ids].each do |id|
+            if (message = @messages[id])
+              message.instance_variable_set(:@deleted, true)
+              messages.push(message)
+            else
+              messages.push(UnknownDeleteBulkMessage.new(self, id))
+            end
+          end
+          dispatch(:message_delete_bulk, messages)
+        when "MESSAGE_REACTION_ADD"
+          if (target_message = @messages[data[:message_id]])
+            if (target_reaction = target_message.reactions.find do |r|
+              r.emoji.is_a?(UnicodeEmoji) ? r.emoji.value == data[:emoji][:name] : r.emoji.id == data[:emoji][:id]
+            end)
+              target_reaction.instance_variable_set(:@count, target_reaction.count + 1)
+            else
+              target_message.reactions << Reaction.new(
+                self,
+                {
+                  count: 1,
+                  me: @user.id == data[:user_id],
+                  emoji: data[:emoji],
+                }
+              )
+            end
+          end
+          dispatch(:reaction_add, ReactionEvent.new(self, data))
+        when "MESSAGE_REACTION_REMOVE"
+          if (target_message = @messages[data[:message_id]]) &&
+            (target_reaction = target_message.reactions.find do |r|
+              data[:emoji][:id].nil? ? r.emoji.name == data[:emoji][:name] : r.emoji.id == data[:emoji][:id]
+            end)
+            target_reaction.instance_variable_set(:@count, target_reaction.count - 1)
+            target_message.reactions.delete(target_reaction) if target_reaction.count.zero?
+          end
+          dispatch(:reaction_remove, ReactionEvent.new(self, data))
+        when "MESSAGE_REACTION_REMOVE_ALL"
+          if (target_message = @messages[data[:message_id]])
+            target_message.reactions = []
+          end
+          dispatch(:reaction_remove_all, ReactionRemoveAllEvent.new(self, data))
+        when "MESSAGE_REACTION_REMOVE_EMOJI"
+          if (target_message = @messages[data[:message_id]]) &&
+            (target_reaction = target_message.reactions.find { |r| data[:emoji][:id].nil? ? r.name == data[:emoji][:name] : r.id == data[:emoji][:id] })
+            target_message.reactions.delete(target_reaction)
+          end
+          dispatch(:reaction_remove_emoji, ReactionRemoveEmojiEvent.new(data))
+        when "TYPING_START"
+          dispatch(:typing_start, TypingStartEvent.new(self, data))
+        when "INTERACTION_CREATE"
+          interaction = Interaction.make_interaction(self, data)
+          dispatch(:integration_create, interaction)
+
+          dispatch(interaction.class.event_name, interaction)
+        when "RESUMED"
+          @log.info("Successfully resumed connection")
+          dispatch(:resumed)
+        else
+          @log.warn "Unknown event: #{event_name}\n#{data.inspect}"
         end
-        dispatch(:reaction_add, ReactionEvent.new(self, data))
-      when "MESSAGE_REACTION_REMOVE"
-        if (target_message = @messages[data[:message_id]]) &&
-           (target_reaction = target_message.reactions.find do |r|
-             data[:emoji][:id].nil? ? r.emoji.name == data[:emoji][:name] : r.emoji.id == data[:emoji][:id]
-           end)
-          target_reaction.set_instance_variable(:@count, target_reaction.count - 1)
-          target_message.reactions.delete(target_reaction) if target_reaction.count.zero?
-        end
-        dispatch(:reaction_remove, ReactionEvent.new(self, data))
-      when "MESSAGE_REACTION_REMOVE_ALL"
-        if (target_message = @messages[data[:message_id]])
-          target_message.reactions = []
-        end
-        dispatch(:reaction_remove_all, ReactionRemoveAllEvent.new(self, data))
-      when "MESSAGE_REACTION_REMOVE_EMOJI"
-        if (target_message = @messages[data[:message_id]]) &&
-           (target_reaction = target_message.reactions.find { |r| data[:emoji][:id].nil? ? r.name == data[:emoji][:name] : r.id == data[:emoji][:id] })
-          target_message.reactions.delete(target_reaction)
-        end
-        dispatch(:reaction_remove_emoji, ReactionRemoveEmojiEvent.new(data))
-      when "TYPING_START"
-        dispatch(:typing_start, TypingStartEvent.new(self, data))
-      when "INTERACTION_CREATE"
-        interaction = Interaction.make_interaction(self, data)
-        dispatch(:integration_create, interaction)
-
-        dispatch(interaction.class.event_name, interaction)
-      when "RESUMED"
-        @log.info("Successfully resumed connection")
-        dispatch(:resumed)
-      else
-        @log.warn "Unknown event: #{event_name}\n#{data.inspect}"
       end
     end
   end
-end
+end