onyxcord 2.0.13 → 3.2.0

data/lib/onyxcord/bot.rb

@@ -1,50 +1,14 @@
 # frozen_string_literal: true
 
-require 'onyxcord/http'
 require 'zlib'
-
-require 'onyxcord/configuration'
-require 'onyxcord/event_executor'
-require 'onyxcord/events/message'
-require 'onyxcord/events/typing'
-require 'onyxcord/events/lifetime'
-require 'onyxcord/events/presence'
-require 'onyxcord/events/voice_state_update'
-require 'onyxcord/events/channels'
-require 'onyxcord/events/members'
-require 'onyxcord/events/roles'
-require 'onyxcord/events/guilds'
-require 'onyxcord/events/await'
-require 'onyxcord/events/bans'
-require 'onyxcord/events/raw'
-require 'onyxcord/events/reactions'
-require 'onyxcord/events/webhooks'
-require 'onyxcord/events/invites'
-require 'onyxcord/events/interactions'
-require 'onyxcord/events/threads'
-require 'onyxcord/events/integrations'
-require 'onyxcord/events/scheduled_events'
-require 'onyxcord/events/polls'
-
-require 'onyxcord/api'
-require 'onyxcord/api/channel'
-require 'onyxcord/api/server'
-require 'onyxcord/api/invite'
-require 'onyxcord/api/interaction'
-require 'onyxcord/api/application'
-
-require 'onyxcord/async/runtime'
-require 'onyxcord/errors'
-require 'onyxcord/message_components'
-require 'onyxcord/data'
-require 'onyxcord/await'
-require 'onyxcord/container'
-require 'onyxcord/websocket'
-require 'onyxcord/cache'
-require 'onyxcord/gateway'
-
-require 'onyxcord/application_commands'
-require 'onyxcord/voice/voice_bot'
+require_relative 'core/bot/runtime'
+require_relative 'core/bot/invites'
+require_relative 'core/bot/voice'
+require_relative 'core/bot/messaging'
+require_relative 'core/bot/oauth'
+require_relative 'core/bot/presence'
+require_relative 'core/bot/awaits'
+require_relative 'core/bot/application_commands'
 
 module OnyxCord
   # Represents a Discord bot, including servers, users, etc.
@@ -81,11 +45,20 @@ module OnyxCord
     # @return [Hash] the normalized cache policy for this bot.
     attr_reader :cache_policy
 
-    # @return [OnyxCord::EventExecutor::Inline, OnyxCord::EventExecutor::Pool]
+    # @return [Internal::EventExecutor::Inline, Internal::EventExecutor::Pool, Internal::EventExecutor::AsyncPool]
     attr_reader :event_executor
 
     include EventContainer
     include Cache
+    include Internal::EventBus
+    include Runtime
+    include Invites
+    include VoiceControl
+    include Messaging
+    include OAuth
+    include Presence
+    include Awaits
+    include ApplicationCommands
 
     # Makes a new bot with the given authentication data. It will be ready to be added event handlers to and can
     # eventually be run with {#run}.
@@ -176,7 +149,7 @@ module OnyxCord
                  end
 
       @token = process_token(@type, token)
-      @gateway = Gateway.new(self, @token, @shard_key, @compress_mode, @intents)
+      @gateway = Gateway::Client.new(self, @token, @shard_key, @compress_mode, @intents)
 
       init_cache
 
@@ -188,7 +161,7 @@ module OnyxCord
 
       @current_thread = 0
       @current_thread_mutex = Mutex.new
-      @event_executor = EventExecutor.build(executor_type, workers: executor_workers, queue_size: executor_queue_size)
+      @event_executor = Internal::EventExecutor.build(executor_type, workers: executor_workers, queue_size: executor_queue_size)
       @event_threads = @event_executor.threads
 
       @status = :online
@@ -261,7 +234,7 @@ module OnyxCord
     def profile
       return @profile if @profile
 
-      response = OnyxCord::API::User.profile(@token)
+      response = OnyxCord::REST::User.profile(@token)
       @profile = Profile.new(JSON.parse(response), self)
     end
 
@@ -270,7 +243,7 @@ module OnyxCord
     # The bot's OAuth application.
     # @return [Application] The bot's application info.
     def bot_application
-      response = API.oauth_application(token)
+      response = REST.oauth_application(token)
       Application.new(JSON.parse(response), self)
     end
 
@@ -280,7 +253,7 @@ module OnyxCord
     # Get the role connection metadata records associated with this application.
     # @return [Array<RoleConnectionMetadata>] the role connection metadata records associated with this application.
     def role_connection_metadata_records
-      response = API::Application.get_application_role_connection_metadata_records(@bot.token, @id)
+      response = REST::Application.get_application_role_connection_metadata_records(@bot.token, @id)
       JSON.parse(response).map { |role_connection| RoleConnectionMetadata.new(role_connection, @bot) }
     end
 
@@ -288,7 +261,7 @@ module OnyxCord
     # {API} methods.
     # @return [String] The API token.
     def token
-      API.bot_name = @name
+      REST.bot_name = @name
       @token
     end
 
@@ -298,1717 +271,9 @@ module OnyxCord
       @token.split(' ').last
     end
 
-    # Runs the bot, which logs into Discord and connects the WebSocket. This
-    # prevents all further execution unless it is executed with
-    # `background` = `true`.
-    # @param background [true, false] If it is `true`, then the bot will run in
-    #   another thread to allow further execution. If it is `false`, this method
-    #   will block until {#stop} is called. If the bot is run with `true`, make
-    #   sure to eventually call {#join} so the script doesn't stop prematurely.
-    # @note Running the bot in the background means that you can call some
-    #   methods that require a gateway connection *before* that connection is
-    #   established. In most cases an exception will be raised if you try to do
-    #   this. If you need a way to safely run code after the bot is fully
-    #   connected, use a {#ready} event handler instead.
-    def run(background = false)
-      if background
-        @run_task = OnyxCord::AsyncRuntime.async { run_forever }
-        return @run_task
-      end
-
-      OnyxCord::AsyncRuntime.run { run_forever }
-    end
-
-    def run_forever
-      @gateway.run
-    end
-
-    def join
-      @run_task&.wait
-    end
-    alias_method :sync, :join
-
-    def stop(_no_sync = nil)
-      @gateway.stop
-      @event_executor.shutdown
-      @run_task&.stop if @run_task.respond_to?(:stop)
-      nil
-    end
-
-    # @return [true, false] whether or not the bot is currently connected to Discord.
-    def connected?
-      @gateway.open?
-    end
-
-    # Makes the bot join an invite to a server.
-    # @param invite [String, Invite] The invite to join. For possible formats see {#resolve_invite_code}.
-    def accept_invite(invite)
-      resolved = invite(invite).code
-      API::Invite.accept(token, resolved)
-    end
-
-    # Creates an OAuth invite URL that can be used to invite this bot to a particular server.
-    # @param server [Server, nil] The server the bot should be invited to, or nil if a general invite should be created.
-    # @param permission_bits [String, Integer] Permission bits that should be appended to invite url.
-    # @param redirect_uri [String] Redirect URI that should be appended to invite url.
-    # @param scopes [Array<String>] Scopes that should be appended to invite url.
-    # @return [String] the OAuth invite URL.
-    def invite_url(server: nil, permission_bits: nil, redirect_uri: nil, scopes: ['bot'])
-      @client_id ||= bot_application.id
-
-      query = URI.encode_www_form({
-        client_id: @client_id,
-        guild_id: server&.id,
-        permissions: permission_bits,
-        redirect_uri: redirect_uri,
-        scope: scopes.join(' ')
-      }.compact)
-
-      "https://discord.com/oauth2/authorize?#{query}"
-    end
-
-    # @return [Hash<Integer => VoiceBot>] the voice connections this bot currently has, by the server ID to which they are connected.
-    attr_reader :voices
-
-    # Gets the voice bot for a particular server or channel. You can connect to a new channel using the {#voice_connect}
-    # method.
-    # @param thing [Channel, Server, Integer] the server or channel you want to get the voice bot for, or its ID.
-    # @return [Voice::VoiceBot, nil] the VoiceBot for the thing you specified, or nil if there is no connection yet
-    def voice(thing)
-      id = thing.resolve_id
-      return @voices[id] if @voices[id]
-
-      channel = channel(id)
-      return nil unless channel
-
-      server_id = channel.server.id
-      return @voices[server_id] if @voices[server_id]
-    end
-
-    # Connects to a voice channel, initializes network connections and returns the {Voice::VoiceBot} over which audio
-    # data can then be sent. After connecting, the bot can also be accessed using {#voice}. If the bot is already
-    # connected to voice, the existing connection will be terminated - you don't have to call
-    # {OnyxCord::Voice::VoiceBot#destroy} before calling this method.
-    # @param chan [Channel, String, Integer] The voice channel, or its ID, to connect to.
-    # @param encrypted [true, false] Whether voice communication should be encrypted using
-    #   (uses an XSalsa20 stream cipher for encryption and Poly1305 for authentication)
-    # @return [Voice::VoiceBot] the initialized bot over which audio data can then be sent.
-    def voice_connect(chan, encrypted = true)
-      raise ArgumentError, 'Unencrypted voice connections are no longer supported.' unless encrypted
-
-      chan = channel(chan.resolve_id)
-      server_id = chan.server.id
-
-      if @voices[chan.id]
-        debug('Voice bot exists already! Destroying it')
-        @voices[chan.id].destroy
-        @voices.delete(chan.id)
-      end
-
-      debug("Got voice channel: #{chan}")
-
-      @should_connect_to_voice[server_id] = chan
-      @gateway.send_voice_state_update(server_id.to_s, chan.id.to_s, false, false)
-
-      debug('Voice channel init packet sent! Now waiting.')
-
-      OnyxCord::AsyncRuntime.sleep(0.05) until @voices[server_id]
-      debug('Voice connect succeeded!')
-      @voices[server_id]
-    end
-
-    # Disconnects the client from a specific voice connection given the server ID. Usually it's more convenient to use
-    # {OnyxCord::Voice::VoiceBot#destroy} rather than this.
-    # @param server [Server, String, Integer] The server, or server ID, the voice connection is on.
-    # @param destroy_vws [true, false] Whether or not the VWS should also be destroyed. If you're calling this method
-    #   directly, you should leave it as true.
-    def voice_destroy(server, destroy_vws = true)
-      server = server.resolve_id
-      @gateway.send_voice_state_update(server.to_s, nil, false, false)
-      @voices[server].destroy if @voices[server] && destroy_vws
-      @voices.delete(server)
-    end
-
-    # Revokes an invite to a server. Will fail unless you have the *Manage Server* permission.
-    # It is recommended that you use {Invite#delete} instead.
-    # @param code [String, Invite] The invite to revoke. For possible formats see {#resolve_invite_code}.
-    def delete_invite(code)
-      invite = resolve_invite_code(code)
-      API::Invite.delete(token, invite)
-    end
-
-    # Sends a text message to a channel given its ID and the message's content.
-    # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
-    # @param content [String] The text that should be sent as a message. It is limited to 2000 characters (Discord imposed).
-    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
-    # @param embeds [Hash, OnyxCord::Webhooks::Embed, Array<Hash>, Array<OnyxCord::Webhooks::Embed> nil] The rich embed(s) to append to this message.
-    # @param allowed_mentions [Hash, OnyxCord::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
-    # @param message_reference [Message, String, Integer, Hash, nil] The message, or message ID, to reply to if any.
-    # @param components [View, Array<Hash>] Interaction components to associate with this message.
-    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
-    # @param nonce [String, nil] A optional nonce in order to verify that a message was sent. Maximum of twenty-five characters.
-    # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
-    # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
-    # @return [Message] The message that was sent.
-    def send_message(channel, content, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
-      channel = channel.resolve_id
-      debug("Sending message to #{channel} with content '#{content}'")
-      allowed_mentions = { parse: [] } if allowed_mentions == false
-      message_reference = { message_id: message_reference.resolve_id } if message_reference.respond_to?(:resolve_id)
-      embeds = (embeds.instance_of?(Array) ? embeds.map(&:to_hash) : [embeds&.to_hash]).compact
-      flags = OnyxCord::MessageComponents.apply_v2_flag(flags, components)
-
-      response = API::Channel.create_message(token, channel, content, tts, embeds, nonce, attachments, allowed_mentions&.to_hash, message_reference, components, flags, enforce_nonce, poll&.to_h)
-      Message.new(JSON.parse(response), self)
-    end
-
-    # Sends a text message to a channel given its ID and the message's content,
-    # then deletes it after the specified timeout in seconds.
-    # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
-    # @param content [String] The text that should be sent as a message. It is limited to 2000 characters (Discord imposed).
-    # @param timeout [Float] The amount of time in seconds after which the message sent will be deleted.
-    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
-    # @param embeds [Hash, OnyxCord::Webhooks::Embed, Array<Hash>, Array<OnyxCord::Webhooks::Embed> nil] The rich embed(s) to append to this message.
-    # @param attachments [Array<File>] Files that can be referenced in embeds via `attachment://file.png`
-    # @param allowed_mentions [Hash, OnyxCord::AllowedMentions, false, nil] Mentions that are allowed to ping on this message. `false` disables all pings
-    # @param message_reference [Message, String, Integer, nil] The message, or message ID, to reply to if any.
-    # @param components [View, Array<Hash>] Interaction components to associate with this message.
-    # @param flags [Integer] Flags for this message. Currently only SUPPRESS_EMBEDS (1 << 2), SUPPRESS_NOTIFICATIONS (1 << 12), and IS_COMPONENTS_V2 (1 << 15) can be set.
-    # @param nonce [String, nil] A optional nonce in order to verify that a message was sent. Maximum of twenty-five characters.
-    # @param enforce_nonce [true, false] Whether the nonce should be enforced and used for message de-duplication.
-    # @param poll [Hash, Poll::Builder, Poll, nil] The poll that should be attached to this message.
-    def send_temporary_message(channel, content, timeout, tts = false, embeds = nil, attachments = nil, allowed_mentions = nil, message_reference = nil, components = nil, flags = 0, nonce = nil, enforce_nonce = false, poll = nil)
-      OnyxCord::AsyncRuntime.async do
-        message = send_message(channel, content, tts, embeds, attachments, allowed_mentions, message_reference, components, flags, nonce, enforce_nonce, poll)
-        OnyxCord::AsyncRuntime.sleep(timeout)
-        message.delete
-      end
-
-      nil
-    end
-
-    # Sends a file to a channel. If it is an image, it will automatically be embedded.
-    # @note This executes in a blocking way, so if you're sending long files, be wary of delays.
-    # @param channel [Channel, String, Integer] The channel, or its ID, to send something to.
-    # @param file [File] The file that should be sent.
-    # @param caption [string] The caption for the file.
-    # @param tts [true, false] Whether or not this file's caption should be sent using Discord text-to-speech.
-    # @param filename [String] Overrides the filename of the uploaded file
-    # @param spoiler [true, false] Whether or not this file should appear as a spoiler.
-    # @example Send a file from disk
-    #   bot.send_file(83281822225530880, File.open('rubytaco.png', 'r'))
-    def send_file(channel, file, caption: nil, tts: false, filename: nil, spoiler: nil)
-      if file.respond_to?(:read)
-        if spoiler
-          filename ||= File.basename(file.path)
-          filename = "SPOILER_#{filename}" unless filename.start_with? 'SPOILER_'
-        end
-        file.define_singleton_method(:original_filename) { filename } if filename
-        file.define_singleton_method(:path) { filename } if filename
-      end
-
-      channel = channel.resolve_id
-      response = API::Channel.upload_file(token, channel, file, caption: caption, tts: tts)
-      Message.new(JSON.parse(response), self)
-    end
-
-    # Creates a new application to do OAuth authorization with. This allows you to use OAuth to authorize users using
-    # Discord. For information how to use this, see the docs: https://discord.com/developers/docs/topics/oauth2
-    # @param name [String] What your application should be called.
-    # @param redirect_uris [Array<String>] URIs that Discord should redirect your users to after authorizing.
-    # @return [Array(String, String)] your applications' client ID and client secret to be used in OAuth authorization.
-    def create_oauth_application(name, redirect_uris)
-      response = JSON.parse(API.create_oauth_application(@token, name, redirect_uris))
-      [response['id'], response['secret']]
-    end
-
-    # Changes information about your OAuth application
-    # @param name [String] What your application should be called.
-    # @param redirect_uris [Array<String>] URIs that Discord should redirect your users to after authorizing.
-    # @param description [String] A string that describes what your application does.
-    # @param icon [String, nil] A data URI for your icon image (for example a base 64 encoded image), or nil if no icon
-    #   should be set or changed.
-    def update_oauth_application(name, redirect_uris, description = '', icon = nil)
-      API.update_oauth_application(@token, name, redirect_uris, description, icon)
-    end
-
-    # Gets the users, channels, roles and emoji from a string.
-    # @param mentions [String] The mentions, which should look like `<@12314873129>`, `<#123456789>`, `<@&123456789>` or `<:name:126328:>`.
-    # @param server [Server, nil] The server of the associated mentions. (recommended for role parsing, to speed things up)
-    # @return [Array<User, Channel, Role, Emoji>] The array of users, channels, roles and emoji identified by the mentions, or `nil` if none exists.
-    def parse_mentions(mentions, server = nil)
-      array_to_return = []
-      # While possible mentions may be in message
-      while mentions.include?('<') && mentions.include?('>')
-        # Removing all content before the next possible mention
-        mentions = mentions.split('<', 2)[1]
-        # Locate the first valid mention enclosed in `<...>`, otherwise advance to the next open `<`
-        next unless mentions.split('>', 2).first.length < mentions.split('<', 2).first.length
-
-        # Store the possible mention value to be validated with RegEx
-        mention = mentions.split('>', 2).first
-        if /@!?(?<id>\d+)/ =~ mention
-          array_to_return << user(id) unless user(id).nil?
-        elsif /#(?<id>\d+)/ =~ mention
-          array_to_return << channel(id, server) unless channel(id, server).nil?
-        elsif /@&(?<id>\d+)/ =~ mention
-          if server
-            array_to_return << server.role(id) unless server.role(id).nil?
-          else
-            @servers.each_value do |element|
-              array_to_return << element.role(id) unless element.role(id).nil?
-            end
-          end
-        elsif /(?<animated>^a|^${0}):(?<name>\w+):(?<id>\d+)/ =~ mention
-          array_to_return << (emoji(id) || Emoji.new({ 'animated' => animated != '', 'name' => name, 'id' => id }, self, nil))
-        end
-      end
-      array_to_return
-    end
-
-    # Gets the user, channel, role or emoji from a string.
-    # @param mention [String] The mention, which should look like `<@12314873129>`, `<#123456789>`, `<@&123456789>` or `<:name:126328:>`.
-    # @param server [Server, nil] The server of the associated mention. (recommended for role parsing, to speed things up)
-    # @return [User, Channel, Role, Emoji] The user, channel, role or emoji identified by the mention, or `nil` if none exists.
-    def parse_mention(mention, server = nil)
-      parse_mentions(mention, server).first
-    end
-
-    # Updates presence status.
-    # @param status [String] The status the bot should show up as. Can be `online`, `dnd`, `idle`, or `invisible`
-    # @param activity [String, nil] The name of the activity to be played/watched/listened to/stream name on the stream.
-    # @param url [String, nil] The Twitch URL to display as a stream. nil for no stream.
-    # @param since [Integer] When this status was set.
-    # @param afk [true, false] Whether the bot is AFK.
-    # @param activity_type [Integer] The type of activity status to display.
-    #   Can be 0 (Playing), 1 (Streaming), 2 (Listening), 3 (Watching), or 5 (Competing).
-    # @see Gateway#send_status_update
-    def update_status(status, activity, url, since = 0, afk = false, activity_type = 0)
-      gateway_check
-
-      @activity = activity
-      @status = status
-      @streamurl = url
-      type = url ? 1 : activity_type
-
-      activity_obj = activity || url ? { 'name' => activity, 'url' => url, 'type' => type } : nil
-      @gateway.send_status_update(status, since, activity_obj, afk)
-
-      # Update the status in the cache
-      profile.update_presence('status' => status.to_s, 'activities' => [activity_obj].compact)
-    end
-
-    # Sets the currently playing game to the specified game.
-    # @param name [String] The name of the game to be played.
-    # @return [String] The game that is being played now.
-    def game=(name)
-      gateway_check
-      update_status(@status, name, nil)
-    end
-
-    alias_method :playing=, :game=
-
-    # Sets the current listening status to the specified name.
-    # @param name [String] The thing to be listened to.
-    # @return [String] The thing that is now being listened to.
-    def listening=(name)
-      gateway_check
-      update_status(@status, name, nil, nil, nil, 2)
-    end
-
-    # Sets the current watching status to the specified name.
-    # @param name [String] The thing to be watched.
-    # @return [String] The thing that is now being watched.
-    def watching=(name)
-      gateway_check
-      update_status(@status, name, nil, nil, nil, 3)
-    end
-
-    # Sets the currently online stream to the specified name and Twitch URL.
-    # @param name [String] The name of the stream to display.
-    # @param url [String] The url of the current Twitch stream.
-    # @return [String] The stream name that is being displayed now.
-    def stream(name, url)
-      gateway_check
-      update_status(@status, name, url)
-      name
-    end
-
-    # Sets the currently competing status to the specified name.
-    # @param name [String] The name of the game to be competing in.
-    # @return [String] The game that is being competed in now.
-    def competing=(name)
-      gateway_check
-      update_status(@status, name, nil, nil, nil, 5)
-    end
-
-    # Sets status to online.
-    def online
-      gateway_check
-      update_status(:online, @activity, @streamurl)
-    end
-
-    alias_method :on, :online
-
-    # Sets status to idle.
-    def idle
-      gateway_check
-      update_status(:idle, @activity, nil)
-    end
-
-    alias_method :away, :idle
-
-    # Sets the bot's status to DnD (red icon).
-    def dnd
-      gateway_check
-      update_status(:dnd, @activity, nil)
-    end
-
-    # Sets the bot's status to invisible (appears offline).
-    def invisible
-      gateway_check
-      update_status(:invisible, @activity, nil)
-    end
-
-    # Join a thread
-    # @param channel [Channel, Integer, String]
-    def join_thread(channel)
-      API::Channel.join_thread(@token, channel.resolve_id)
-      nil
-    end
-
-    # Leave a thread
-    # @param channel [Channel, Integer, String]
-    def leave_thread(channel)
-      API::Channel.leave_thread(@token, channel.resolve_id)
-      nil
-    end
-
-    # Add a member to a thread
-    # @param channel [Channel, Integer, String]
-    # @param member [Member, Integer, String]
-    def add_thread_member(channel, member)
-      API::Channel.add_thread_member(@token, channel.resolve_id, member.resolve_id)
-      nil
-    end
-
-    # Remove a member from a thread
-    # @param channel [Channel, Integer, String]
-    # @param member [Member, Integer, String]
-    def remove_thread_member(channel, member)
-      API::Channel.remove_thread_member(@token, channel.resolve_id, member.resolve_id)
-      nil
-    end
-
-    # Sets debug mode. If debug mode is on, many things will be outputted to STDOUT.
-    def debug=(new_debug)
-      LOGGER.debug = new_debug
-    end
-
-    # Sets the logging mode
-    # @see Logger#mode=
-    def mode=(new_mode)
-      LOGGER.mode = new_mode
-    end
-
-    def runtime_stats
-      {
-        mode: @mode,
-        cache: cache_stats,
-        event_executor: @event_executor.class.name,
-        event_threads: @event_threads&.count(&:alive?) || 0,
-        event_queue_size: @event_executor.respond_to?(:queue_size) ? @event_executor.queue_size : 0
-      }
-    end
-
-    # Prevents the READY packet from being printed regardless of debug mode.
-    def suppress_ready_debug
-      @prevent_ready = true
-    end
-
-    # Add an await the bot should listen to. For information on awaits, see {Await}.
-    # @param key [Symbol] The key that uniquely identifies the await for {AwaitEvent}s to listen to (see {#await}).
-    # @param type [Class] The event class that should be listened for.
-    # @param attributes [Hash] The attributes the event should check for. The block will only be executed if all attributes match.
-    # @yield Is executed when the await is triggered.
-    # @yieldparam event [Event] The event object that was triggered.
-    # @return [Await] The await that was created.
-    # @deprecated Will be changed to blocking behavior in v4.0. Use {#add_await!} instead.
-    def add_await(key, type, attributes = {}, &block)
-      raise "You can't await an AwaitEvent!" if type == OnyxCord::Events::AwaitEvent
-
-      await = Await.new(self, key, type, attributes, block)
-      @awaits ||= {}
-      @awaits[key] = await
-    end
-
-    # Awaits an event, blocking the current thread until a response is received.
-    # @param type [Class] The event class that should be listened for.
-    # @option attributes [Numeric] :timeout the amount of time (in seconds) to wait for a response before returning `nil`. Waits forever if omitted.
-    # @yield Executed when a matching event is received.
-    # @yieldparam event [Event] The event object that was triggered.
-    # @yieldreturn [true, false] Whether the event matches extra await criteria described by the block
-    # @return [Event, nil] The event object that was triggered, or `nil` if a `timeout` was set and no event was raised in time.
-    # @raise [ArgumentError] if `timeout` is given and is not a positive numeric value
-    def add_await!(type, attributes = {})
-      raise "You can't await an AwaitEvent!" if type == OnyxCord::Events::AwaitEvent
-
-      timeout = attributes[:timeout]
-      raise ArgumentError, 'Timeout must be a number > 0' if timeout.is_a?(Numeric) && !timeout.positive?
-
-      mutex = Mutex.new
-      cv = ConditionVariable.new
-      response = nil
-      block = lambda do |event|
-        mutex.synchronize do
-          response = event
-          if block_given?
-            result = yield(event)
-            cv.signal if result.is_a?(TrueClass)
-          else
-            cv.signal
-          end
-        end
-      end
-
-      handler = register_event(type, attributes, block)
-
-      if timeout
-        Thread.new do
-          sleep timeout
-          mutex.synchronize { cv.signal }
-        end
-      end
-
-      mutex.synchronize { cv.wait(mutex) }
-
-      remove_handler(handler)
-      raise 'ConditionVariable was signaled without returning an event!' if response.nil? && timeout.nil?
-
-      response
-    end
-
-    # Add a user to the list of ignored users. Those users will be ignored in message events at event processing level.
-    # @note Ignoring a user only prevents any message events (including mentions, commands etc.) from them! Typing and
-    #   presence and any other events will still be received.
-    # @param user [User, String, Integer] The user, or its ID, to be ignored.
-    def ignore_user(user)
-      @ignored_ids << user.resolve_id
-    end
-
-    # Remove a user from the ignore list.
-    # @param user [User, String, Integer] The user, or its ID, to be unignored.
-    def unignore_user(user)
-      @ignored_ids.delete(user.resolve_id)
-    end
-
-    # Checks whether a user is being ignored.
-    # @param user [User, String, Integer] The user, or its ID, to check.
-    # @return [true, false] whether or not the user is ignored.
-    def ignored?(user)
-      @ignored_ids.include?(user.resolve_id)
-    end
-
-    # @see Logger#debug
-    def debug(message)
-      LOGGER.debug(message)
-    end
-
-    # @see Logger#log_exception
-    def log_exception(e)
-      LOGGER.log_exception(e)
-    end
-
-    # Dispatches an event to this bot. Called by the gateway connection handler used internally.
-    def dispatch(type, data = nil)
-      return dispatch_packet(type) if data.nil? && type.is_a?(Hash)
-
-      handle_dispatch(type, data)
-    end
-
-    # Raises a heartbeat event. Called by the gateway connection handler used internally.
-    def raise_heartbeat_event
-      raise_event(HeartbeatEvent.new(self))
-    end
-
-    # Makes the bot leave any groups with no recipients remaining
-    def prune_empty_groups
-      @channels.each_value do |channel|
-        channel.leave_group if channel.group? && channel.recipients.empty?
-      end
-    end
-
-    # Get all application commands.
-    # @param server_id [String, Integer, nil] The ID of the server to get the commands from. Global if `nil`.
-    # @return [Array<ApplicationCommand>]
-    def get_application_commands(server_id: nil)
-      resp = if server_id
-               API::Application.get_guild_commands(@token, profile.id, server_id)
-             else
-               API::Application.get_global_commands(@token, profile.id)
-             end
-
-      JSON.parse(resp).map do |command_data|
-        ApplicationCommand.new(command_data, self, server_id)
-      end
-    end
-
-    # Get an application command by ID.
-    # @param command_id [String, Integer]
-    # @param server_id [String, Integer, nil] The ID of the server to get the command from. Global if `nil`.
-    def get_application_command(command_id, server_id: nil)
-      resp = if server_id
-               API::Application.get_guild_command(@token, profile.id, server_id, command_id)
-             else
-               API::Application.get_global_command(@token, profile.id, command_id)
-             end
-      ApplicationCommand.new(JSON.parse(resp), self, server_id)
-    end
-
-    # @return [OnyxCord::ApplicationCommands::Registry]
-    def commands
-      @modern_command_registry ||= OnyxCord::ApplicationCommands::Registry.new(self)
-    end
-
-    def slash(name, description: nil, **attributes, &block)
-      commands.slash(name, description: description, **attributes, &block)
-    end
-
-    def user_command(name, **attributes, &block)
-      commands.user(name, **attributes, &block)
-    end
-
-    def message_command(name, **attributes, &block)
-      commands.message(name, **attributes, &block)
-    end
-
-    def sync_application_commands!(server_id: nil, delete_unknown: false)
-      commands.sync!(server_id: server_id, delete_unknown: delete_unknown)
-    end
-
-    def bulk_overwrite_global_application_commands(commands)
-      response = API::Application.bulk_overwrite_global_commands(@token, profile.id, commands)
-      JSON.parse(response).map { |data| ApplicationCommand.new(data, self) }
-    end
-
-    def bulk_overwrite_guild_application_commands(server_id, commands)
-      response = API::Application.bulk_overwrite_guild_commands(@token, profile.id, server_id.resolve_id, commands)
-      JSON.parse(response).map { |data| ApplicationCommand.new(data, self, server_id) }
-    end
-
-    # @yieldparam [OptionBuilder]
-    # @yieldparam [PermissionBuilder]
-    # @example
-    #   bot.register_application_command(:reddit, 'Reddit Commands') do |cmd|
-    #     cmd.subcommand_group(:subreddit, 'Subreddit Commands') do |group|
-    #       group.subcommand(:hot, "What's trending") do |sub|
-    #         sub.string(:subreddit, 'Subreddit to search')
-    #       end
-    #       group.subcommand(:new, "What's new") do |sub|
-    #         sub.string(:since, 'How long ago', choices: ['this hour', 'today', 'this week', 'this month', 'this year', 'all time'])
-    #         sub.string(:subreddit, 'Subreddit to search')
-    #       end
-    #     end
-    #   end
-    def register_application_command(name, description, server_id: nil, default_permission: nil, type: :chat_input, default_member_permissions: nil, contexts: nil, nsfw: false, integration_types: nil)
-      type = ApplicationCommand::TYPES[type] || type
-
-      contexts = contexts&.map { |context| Interaction::CONTEXTS[context] || context }
-      integration_types = integration_types&.map { |type| Interaction::INTEGRATION_TYPES[type] || type }
-      default_member_permissions = Permissions.bits(default_member_permissions) if default_member_permissions.is_a?(Array)
-
-      builder = Interactions::OptionBuilder.new
-      permission_builder = Interactions::PermissionBuilder.new
-      yield(builder, permission_builder) if block_given?
-
-      resp = if server_id
-               API::Application.create_guild_command(@token, profile.id, server_id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw)
-             else
-               API::Application.create_global_command(@token, profile.id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw, integration_types)
-             end
-      cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
-
-      if permission_builder.to_a.any?
-        raise ArgumentError, 'Permissions can only be set for guild commands' unless server_id
-
-        edit_application_command_permissions(cmd.id, server_id, permission_builder.to_a)
-      end
-
-      cmd
-    end
-
-    # @yieldparam [OptionBuilder]
-    # @yieldparam [PermissionBuilder]
-    def edit_application_command(command_id, server_id: nil, name: nil, description: nil, default_permission: nil, type: :chat_input, default_member_permissions: nil, contexts: nil, nsfw: nil, integration_types: nil)
-      type = ApplicationCommand::TYPES[type] || type
-
-      contexts = contexts&.map { |context| Interaction::CONTEXTS[context] || context }
-      integration_types = integration_types&.map { |type| Interaction::INTEGRATION_TYPES[type] || type }
-      default_member_permissions = Permissions.bits(default_member_permissions) if default_member_permissions.is_a?(Array)
-
-      builder = Interactions::OptionBuilder.new
-      permission_builder = Interactions::PermissionBuilder.new
-
-      yield(builder, permission_builder) if block_given?
-
-      resp = if server_id
-               API::Application.edit_guild_command(@token, profile.id, server_id, command_id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw)
-             else
-               API::Application.edit_global_command(@token, profile.id, command_id, name, description, builder.to_a, default_permission, type, default_member_permissions&.to_s, contexts, nsfw, integration_types)
-             end
-      cmd = ApplicationCommand.new(JSON.parse(resp), self, server_id)
-
-      if permission_builder.to_a.any?
-        raise ArgumentError, 'Permissions can only be set for guild commands' unless server_id
-
-        edit_application_command_permissions(cmd.id, server_id, permission_builder.to_a)
-      end
-
-      cmd
-    end
-
-    # Remove an application command from the commands registered with discord.
-    # @param command_id [String, Integer] The ID of the command to remove.
-    # @param server_id [String, Integer] The ID of the server to delete this command from, global if `nil`.
-    def delete_application_command(command_id, server_id: nil)
-      if server_id
-        API::Application.delete_guild_command(@token, profile.id, server_id, command_id)
-      else
-        API::Application.delete_global_command(@token, profile.id, command_id)
-      end
-    end
-
-    # @param command_id [Integer, String]
-    # @param server_id [Integer, String]
-    # @param permissions [Array<Hash>] An array of objects formatted as `{ id: ENTITY_ID, type: 1 or 2, permission: true or false }`
-    # @param bearer_token [String] A valid bearer token that has permission to manage the server and its roles.
-    def edit_application_command_permissions(command_id, server_id, permissions = [], bearer_token = nil)
-      builder = Interactions::PermissionBuilder.new
-      yield builder if block_given?
-
-      raise ArgumentError, 'This method requires a valid bearer token to be provided' unless bearer_token
-
-      permissions += builder.to_a
-      bearer_token = "Bearer #{bearer_token.delete_prefix('Bearer ')}"
-      API::Application.edit_guild_command_permissions(bearer_token, profile.id, server_id, command_id, permissions)
-    end
-
-    # Get the permissions for all of the application commands in a specific server.
-    # @param server_id [Integer, String, nil] The ID of the server to fetch application command permissions for.
-    # @return [Array<ApplicationCommand::Permission>] The permissions for all of the application commands in the given server.
-    def application_command_permissions(server_id:)
-      response = API::Application.get_guild_application_command_permissions(@token, profile.id, server_id.resolve_id)
-      JSON.parse(response).flat_map { |data| data['permissions'].map { |inner| ApplicationCommand::Permission.new(inner, data, self) } }
-    end
-
-    # Fetches all the application emojis that the bot can use.
-    # @return [Array<Emoji>] Returns an array of emoji objects.
-    def application_emojis
-      response = API::Application.list_application_emojis(@token, profile.id)
-      JSON.parse(response)['items'].map { |emoji| Emoji.new(emoji, self) }
-    end
-
-    # Fetches a single application emoji from its ID.
-    # @param emoji_id [Integer, String] ID of the application emoji.
-    # @return [Emoji] The application emoji.
-    def application_emoji(emoji_id)
-      response = API::Application.get_application_emoji(@token, profile.id, emoji_id.resolve_id)
-      Emoji.new(JSON.parse(response), self)
-    end
-
-    # Creates a new custom emoji that can be used by this application.
-    # @param name [String] The name of emoji to create.
-    # @param image [String, #read] Base64 string with the image data, or an object that responds to #read.
-    # @return [Emoji] The emoji that has been created.
-    def create_application_emoji(name:, image:)
-      image = image.respond_to?(:read) ? OnyxCord.encode64(image) : image
-      response = API::Application.create_application_emoji(@token, profile.id, name, image)
-      Emoji.new(JSON.parse(response), self)
-    end
-
-    # Edits an existing application emoji.
-    # @param emoji_id [Integer, String, Emoji] ID of the application emoji to edit.
-    # @param name [String] The new name of the emoji.
-    # @return [Emoji] Returns the updated emoji object on success.
-    def edit_application_emoji(emoji_id, name:)
-      response = API::Application.edit_application_emoji(@token, profile.id, emoji_id.resolve_id, name)
-      Emoji.new(JSON.parse(response), self)
-    end
-
-    # Deletes an existing application emoji.
-    # @param emoji_id [Integer, String, Emoji] ID of the application emoji to delete.
-    def delete_application_emoji(emoji_id)
-      API::Application.delete_application_emoji(@token, profile.id, emoji_id.resolve_id)
-    end
-
     # @!visibility private
     def inspect
       "<Bot client_id=#{@client_id.inspect} redact_token=#{@redact_token.inspect}>"
     end
-
-    private
-
-    # Throws a useful exception if there's currently no gateway connection.
-    def gateway_check
-      raise "A gateway connection is necessary to call this method! You'll have to do it inside any event (e.g. `ready`) or after `bot.run :async`." unless connected?
-    end
-
-    # Logs a warning if there are servers which are still unavailable.
-    # e.g. due to a Discord outage or because the servers are large and taking a while to load.
-    def unavailable_servers_check
-      # Return unless there are servers that are unavailable.
-      return unless @unavailable_servers&.positive?
-
-      LOGGER.warn("#{@unavailable_servers} servers haven't been cached yet.")
-      LOGGER.warn('Servers may be unavailable due to an outage, or your bot is on very large servers that are taking a while to load.')
-    end
-
-    ### ##    ## ######## ######## ########  ##    ##    ###    ##        ######
-    ##  ###   ##    ##    ##       ##     ## ###   ##   ## ##   ##       ##    ##
-    ##  ####  ##    ##    ##       ##     ## ####  ##  ##   ##  ##       ##
-    ##  ## ## ##    ##    ######   ########  ## ## ## ##     ## ##        ######
-    ##  ##  ####    ##    ##       ##   ##   ##  #### ######### ##             ##
-    ##  ##   ###    ##    ##       ##    ##  ##   ### ##     ## ##       ##    ##
-    ### ##    ##    ##    ######## ##     ## ##    ## ##     ## ########  ######
-
-    # Internal handler for PRESENCE_UPDATE
-    def update_presence(data)
-      # Friends list presences have no server ID so ignore these to not cause an error
-      return unless data['guild_id']
-
-      user_id = data['user']['id'].to_i
-      server_id = data['guild_id'].to_i
-      server = server(server_id)
-      return unless server
-
-      member_is_new = false
-
-      if server.member_cached?(user_id)
-        member = server.member(user_id)
-      else
-        # If the member is not cached yet, it means that it just came online from not being cached at all
-        # due to large_threshold. Fortunately, Discord sends the entire member object in this case, and
-        # not just a part of it - we can just cache this member directly
-        member = Member.new(data, server, self)
-        debug("Implicitly adding presence-obtained member #{user_id} to #{server_id} cache")
-
-        member_is_new = true
-      end
-
-      username = data['user']['username']
-      if username && !member_is_new # Don't set the username for newly-cached members
-        debug "Implicitly updating presence-obtained information username for member #{user_id}"
-        member.update_username(username)
-      end
-
-      global_name = data['user']['global_name']
-      if global_name && !member_is_new # Don't set the global_name for newly-cached members
-        debug "Implicitly updating presence-obtained information global_name for member #{user_id}"
-        member.update_global_name(global_name)
-      end
-
-      member.update_presence(data)
-
-      member.avatar_id = data['user']['avatar'] if data['user']['avatar']
-
-      server.cache_member(member)
-    end
-
-    # Internal handler for VOICE_STATE_UPDATE
-    def update_voice_state(data)
-      @session_id = data['session_id']
-
-      server_id = data['guild_id'].to_i
-      server = @servers&.[](server_id)
-      return unless server
-
-      user_id = data['user_id'].to_i
-      old_voice_state = server.voice_states[user_id]
-      old_channel_id = old_voice_state&.channel_id || old_voice_state&.voice_channel&.id
-
-      server.update_voice_state(data)
-
-      existing_voice = @voices[server_id]
-      if user_id == @profile.id && existing_voice
-        new_channel_id = data['channel_id']
-        if new_channel_id
-          channel_id = new_channel_id.to_i
-          new_channel = @channels&.[](channel_id) || server.channels.find { |channel| channel.id == channel_id }
-          existing_voice.channel = new_channel
-        else
-          voice_destroy(server_id)
-        end
-      end
-
-      old_channel_id
-    end
-
-    # Internal handler for VOICE_SERVER_UPDATE
-    def update_voice_server(data)
-      server_id = data['guild_id'].to_i
-      channel = @should_connect_to_voice[server_id]
-
-      debug("Voice server update received! chan: #{channel.inspect}")
-      return unless channel
-
-      @should_connect_to_voice.delete(server_id)
-      debug('Updating voice server!')
-
-      token = data['token']
-      endpoint = data['endpoint']
-
-      unless endpoint
-        debug('VOICE_SERVER_UPDATE sent with nil endpoint! Ignoring')
-        return
-      end
-
-      debug('Got data, now creating the bot.')
-      @voices[server_id] = OnyxCord::Voice::VoiceBot.new(channel, self, token, @session_id, endpoint)
-    end
-
-    # Internal handler for CHANNEL_CREATE
-    def create_channel(data)
-      channel = data.is_a?(OnyxCord::Channel) ? data : Channel.new(data, self)
-      server = channel.server
-
-      # The last message ID of a forum channel is the most recent post
-      channel.parent.process_last_message_id(channel.id) if channel.parent&.forum? || channel.parent&.media?
-
-      # Handle normal and private channels separately
-      if server
-        server.add_channel(channel)
-        @channels[channel.id] = channel if @channels
-      elsif channel.private?
-        @pm_channels[channel.recipient.id] = channel if @pm_channels
-      elsif channel.group?
-        @channels[channel.id] = channel if @channels
-      end
-    end
-
-    # Internal handler for CHANNEL_UPDATE
-    def update_channel(data)
-      @channels&.[](data['id'].to_i)&.update_data(data)
-    end
-
-    # Internal handler for CHANNEL_DELETE
-    def delete_channel(data)
-      channel = Channel.new(data, self)
-      server = channel.server
-
-      # Handle normal and private channels separately
-      if server
-        @channels&.delete(channel.id)
-        server.delete_channel(channel.id)
-      elsif channel.pm?
-        @pm_channels&.delete(channel.recipient.id)
-      elsif channel.group?
-        @channels&.delete(channel.id)
-      end
-
-      @thread_members&.delete(channel.id) if channel.thread?
-    end
-
-    # Internal handler for GUILD_MEMBER_ADD
-    def add_guild_member(data)
-      server_id = data['guild_id'].to_i
-      server = self.server(server_id)
-
-      member = Member.new(data, server, self)
-      server.add_member(member)
-    end
-
-    # Internal handler for GUILD_MEMBER_UPDATE
-    def update_guild_member(data)
-      server_id = data['guild_id'].to_i
-      server = self.server(server_id)
-
-      # Only attempt to update members that're already cached
-      if (member = server.member(data['user']['id'].to_i, false))
-        member.update_data(data)
-      else
-        ensure_user(data['user'])
-      end
-    end
-
-    # Internal handler for GUILD_MEMBER_DELETE
-    def delete_guild_member(data)
-      server_id = data['guild_id'].to_i
-      server = self.server(server_id)
-      return unless server
-
-      user_id = data['user']['id'].to_i
-      server.delete_member(user_id)
-    rescue OnyxCord::Errors::NoPermission
-      OnyxCord::LOGGER.warn("delete_guild_member attempted to access a server for which the bot doesn't have permission! Not sure what happened here, ignoring")
-    end
-
-    # Internal handler for GUILD_CREATE
-    def create_guild(data)
-      ensure_server(data, true)
-    end
-
-    # Internal handler for GUILD_UPDATE
-    def update_guild(data)
-      server_id = data['id'].to_i
-      server = @servers&.[](server_id)
-
-      if server
-        server.update_data(data)
-      else
-        LOGGER.warn("GUILD_UPDATE received for uncached server #{server_id}; caching from payload")
-        ensure_server(data, true)
-      end
-    end
-
-    # Internal handler for GUILD_DELETE
-    def delete_guild(data)
-      id = data['id'].to_i
-      @servers.delete(id)
-    end
-
-    # Internal handler for GUILD_ROLE_CREATE and GUILD_ROLE_UPDATE
-    def update_guild_role(data)
-      server = @servers[data['guild_id'].to_i]
-
-      if (role = server&.role(data['role']['id'].to_i))
-        role.update_data(data['role'])
-      else
-        server&.add_role(Role.new(data['role'], self, server))
-      end
-    end
-
-    # Internal handler for GUILD_ROLE_DELETE
-    def delete_guild_role(data)
-      role_id = data['role_id'].to_i
-      server_id = data['guild_id'].to_i
-      server = @servers[server_id]
-      server&.delete_role(role_id)
-    end
-
-    # Internal handler for GUILD_EMOJIS_UPDATE
-    def update_guild_emoji(data)
-      server_id = data['guild_id'].to_i
-      server = @servers[server_id]
-      server&.update_emoji_data(data)
-    end
-
-    # Internal handler for GUILD_SCHEDULED_EVENT_CREATE and GUILD_SCHEDULED_EVENT_UPDATE
-    def update_guild_scheduled_event(data)
-      server = @servers[data['guild_id'].to_i]
-
-      if (event = server&.scheduled_event(data['id'].to_i, request: false))
-        event&.update_data(data)
-      else
-        server&.cache_scheduled_event(ScheduledEvent.new(data, server, self))
-      end
-    end
-
-    # Internal handler for MESSAGE_CREATE
-    def create_message(data); end
-
-    # Internal handler for TYPING_START
-    def start_typing(data); end
-
-    # Internal handler for MESSAGE_UPDATE
-    def update_message(data); end
-
-    # Internal handler for MESSAGE_DELETE
-    def delete_message(data); end
-
-    # Internal handler for MESSAGE_REACTION_ADD
-    def add_message_reaction(data); end
-
-    # Internal handler for MESSAGE_REACTION_REMOVE
-    def remove_message_reaction(data); end
-
-    # Internal handler for MESSAGE_REACTION_REMOVE_ALL
-    def remove_all_message_reactions(data); end
-
-    # Internal handler for GUILD_BAN_ADD
-    def add_user_ban(data); end
-
-    # Internal handler for GUILD_BAN_REMOVE
-    def remove_user_ban(data); end
-
-    ##        #######   ######   #### ##    ##
-    ##       ##     ## ##    ##   ##  ###   ##
-    ##       ##     ## ##         ##  ####  ##
-    ##       ##     ## ##   ####  ##  ## ## ##
-    ##       ##     ## ##    ##   ##  ##  ####
-    ##       ##     ## ##    ##   ##  ##   ###
-    ########  #######   ######   #### ##    ##
-
-    def process_token(type, token)
-      # Remove the "Bot " prefix if it exists
-      token = token[4..] if token.start_with? 'Bot '
-
-      token = "Bot #{token}" unless type == :user
-      token
-    end
-
-    def handle_dispatch(type, data)
-      # Check whether there are still unavailable servers and there have been more than 10 seconds since READY
-      if @unavailable_servers&.positive? && (Time.now - @unavailable_timeout_time) > 10 && !(@intents || 0).nobits?(INTENTS[:servers])
-        # The server streaming timed out!
-        LOGGER.debug("Server streaming timed out with #{@unavailable_servers} servers remaining")
-        LOGGER.debug('Calling ready now because server loading is taking a long time. Servers may be unavailable due to an outage, or your bot is on very large servers.')
-
-        # Unset the unavailable server count so this doesn't get triggered again
-        @unavailable_servers = 0
-
-        notify_ready
-      end
-
-      case type
-      when :READY
-        # As READY may be called multiple times over a single process lifetime, we here need to reset the cache entirely
-        # to prevent possible inconsistencies, like objects referencing old versions of other objects which have been
-        # replaced.
-        init_cache
-
-        @profile = Profile.new(data['user'], self)
-
-        @client_id ||= data['application']['id']&.to_i
-
-        # Initialize servers
-        @servers = {}
-
-        # Count unavailable servers
-        @unavailable_servers = 0
-
-        data['guilds'].each do |element|
-          # Check for true specifically because unavailable=false indicates that a previously unavailable server has
-          # come online
-          if element['unavailable']
-            @unavailable_servers += 1
-
-            # Ignore any unavailable servers
-            next
-          end
-
-          ensure_server(element, true)
-        end
-
-        # Don't notify yet if there are unavailable servers because they need to get available before the bot truly has
-        # all the data
-        if @unavailable_servers.zero?
-          # No unavailable servers - we're ready!
-          notify_ready
-        end
-
-        @ready_time = Time.now
-        @unavailable_timeout_time = Time.now
-      when :GUILD_MEMBERS_CHUNK
-        id = data['guild_id'].to_i
-        server = server(id)
-        server.process_chunk(data['members'], data['chunk_index'], data['chunk_count'])
-      when :USER_UPDATE
-        @profile = Profile.new(data, self)
-      when :INVITE_CREATE
-        invite = Invite.new(data, self)
-        raise_event(InviteCreateEvent.new(data, invite, self))
-      when :INVITE_DELETE
-        raise_event(InviteDeleteEvent.new(data, self))
-      when :MESSAGE_CREATE
-        if ignored?(data['author']['id'])
-          debug("Ignored author with ID #{data['author']['id']}")
-          return
-        end
-
-        if @ignore_bots && data['author']['bot']
-          debug("Ignored Bot account with ID #{data['author']['id']}")
-          return
-        end
-
-        if !should_parse_self && profile.id == data['author']['id'].to_i
-          debug('Ignored message from the current bot')
-          return
-        end
-
-        # If create_message is overwritten with a method that returns the parsed message, use that instead, so we don't
-        # parse the message twice (which is just thrown away performance)
-        message = create_message(data)
-        message = Message.new(data, self) unless message.is_a? Message
-
-        # Update the existing member if it exists in the cache.
-        if data['member']
-          member = message.channel.server&.member(data['author']['id'].to_i, false)
-          data['member']['user'] = data['author']
-          member&.update_data(data['member'])
-        end
-
-        # Dispatch a ChannelCreateEvent for channels we don't have cached
-        if message.channel.private? && !@pm_channels&.key?(message.channel.recipient.id)
-          create_channel(message.channel)
-
-          raise_event(ChannelCreateEvent.new(message.channel, self))
-        end
-
-        message.channel.process_last_message_id(message.id)
-
-        event = MessageEvent.new(message, self)
-        raise_event(event)
-
-        # Raise a mention event for any direct mentions.
-        if message.mentions.any? { |user| user.id == profile.id }
-          event = MentionEvent.new(message, self, false)
-          raise_event(event)
-        end
-
-        # Raise a mention event for the current bot's auto-generated role.
-        if message.role_mentions.any? { |role| role.tags&.bot_id == profile.id }
-          event = MentionEvent.new(message, self, true)
-          raise_event(event)
-        end
-
-        if message.channel.private?
-          event = PrivateMessageEvent.new(message, self)
-          raise_event(event)
-        end
-      when :MESSAGE_UPDATE
-        update_message(data)
-
-        if !should_parse_self && profile.id == data['author']['id'].to_i
-          debug('Ignored message from the current bot')
-          return
-        end
-
-        message = Message.new(data, self)
-
-        event = MessageUpdateEvent.new(message, self)
-        raise_event(event)
-
-        if data['author'].nil?
-          LOGGER.debug("Edited a message with nil author! Content: #{message.content.inspect}, channel: #{message.channel.inspect}")
-          return
-        end
-
-        # Update the existing member if it exists in the cache.
-        if data['member']
-          member = message.channel.server&.member(data['author']['id'].to_i, false)
-          data['member']['user'] = data['author']
-          member&.update_data(data['member'])
-        end
-
-        event = MessageEditEvent.new(message, self)
-        raise_event(event)
-      when :MESSAGE_DELETE
-        delete_message(data)
-
-        event = MessageDeleteEvent.new(data, self)
-        raise_event(event)
-      when :MESSAGE_DELETE_BULK
-        debug("MESSAGE_DELETE_BULK will raise #{data['ids'].length} events")
-
-        data['ids'].each do |single_id|
-          # Form a data hash for a single ID so the methods get what they want
-          single_data = {
-            'id' => single_id,
-            'channel_id' => data['channel_id']
-          }
-
-          # Raise as normal
-          delete_message(single_data)
-
-          event = MessageDeleteEvent.new(single_data, self)
-          raise_event(event)
-        end
-      when :TYPING_START
-        start_typing(data)
-
-        begin
-          event = TypingEvent.new(data, self)
-          raise_event(event)
-        rescue OnyxCord::Errors::NoPermission
-          debug 'Typing started in channel the bot has no access to, ignoring'
-        end
-      when :MESSAGE_REACTION_ADD
-        add_message_reaction(data)
-
-        return if profile.id == data['user_id'].to_i && !should_parse_self
-
-        if data['member']
-          server = self.server(data['guild_id'].to_i)
-
-          server&.cache_member(Member.new(data['member'], server, self))
-        end
-
-        event = ReactionAddEvent.new(data, self)
-        raise_event(event)
-      when :MESSAGE_REACTION_REMOVE
-        remove_message_reaction(data)
-
-        return if profile.id == data['user_id'].to_i && !should_parse_self
-
-        event = ReactionRemoveEvent.new(data, self)
-        raise_event(event)
-      when :MESSAGE_REACTION_REMOVE_ALL
-        remove_all_message_reactions(data)
-
-        event = ReactionRemoveAllEvent.new(data, self)
-        raise_event(event)
-      when :MESSAGE_REACTION_REMOVE_EMOJI
-
-        event = ReactionRemoveEmojiEvent.new(data, self)
-        raise_event(event)
-      when :PRESENCE_UPDATE
-        # Ignore friends list presences
-        return unless data['guild_id']
-
-        new_activities = (data['activities'] || []).map { |act_data| Activity.new(act_data, self) }
-        presence_user = @users[data['user']['id'].to_i]
-        old_activities = (presence_user&.activities || [])
-        update_presence(data)
-
-        # Starting a new game
-        playing_change = new_activities.reject do |act|
-          old_activities.find { |old| old.name == act.name }
-        end
-
-        # Exiting an existing game
-        playing_change += old_activities.reject do |old|
-          new_activities.find { |act| act.name == old.name }
-        end
-
-        if playing_change.any?
-          playing_change.each do |act|
-            raise_event(PlayingEvent.new(data, act, self))
-          end
-        else
-          raise_event(PresenceEvent.new(data, self))
-        end
-      when :VOICE_STATE_UPDATE
-        old_channel_id = update_voice_state(data)
-
-        event = VoiceStateUpdateEvent.new(data, old_channel_id, self)
-        raise_event(event)
-      when :VOICE_SERVER_UPDATE
-        update_voice_server(data)
-
-        event = VoiceServerUpdateEvent.new(data, self)
-        raise_event(event)
-      when :CHANNEL_CREATE
-        create_channel(data)
-
-        event = ChannelCreateEvent.new(data, self)
-        raise_event(event)
-      when :CHANNEL_UPDATE
-        update_channel(data)
-
-        event = ChannelUpdateEvent.new(data, self)
-        raise_event(event)
-      when :CHANNEL_DELETE
-        delete_channel(data)
-
-        event = ChannelDeleteEvent.new(data, self)
-        raise_event(event)
-      when :CHANNEL_PINS_UPDATE
-        event = ChannelPinsUpdateEvent.new(data, self)
-
-        event.channel.process_last_pin_timestamp(data['last_pin_timestamp']) if data.key?('last_pin_timestamp')
-
-        raise_event(event)
-      when :GUILD_MEMBER_ADD
-        add_guild_member(data)
-
-        event = ServerMemberAddEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_MEMBER_UPDATE
-        update_guild_member(data)
-
-        event = ServerMemberUpdateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_MEMBER_REMOVE
-        delete_guild_member(data)
-
-        event = ServerMemberDeleteEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_AUDIT_LOG_ENTRY_CREATE
-        event = AuditLogEntryCreateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_BAN_ADD
-        add_user_ban(data)
-
-        event = UserBanEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_BAN_REMOVE
-        remove_user_ban(data)
-
-        event = UserUnbanEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_ROLE_UPDATE
-        update_guild_role(data)
-
-        event = ServerRoleUpdateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_ROLE_CREATE
-        update_guild_role(data)
-
-        event = ServerRoleCreateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_ROLE_DELETE
-        delete_guild_role(data)
-
-        event = ServerRoleDeleteEvent.new(data, self)
-        raise_event(event)
-      when :INTEGRATION_CREATE
-        event = IntegrationCreateEvent.new(data, self)
-        raise_event(event)
-      when :INTEGRATION_UPDATE
-        event = IntegrationUpdateEvent.new(data, self)
-        raise_event(event)
-      when :INTEGRATION_DELETE
-        event = IntegrationDeleteEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_CREATE
-        create_guild(data)
-
-        # Check for false specifically (no data means the server has never been unavailable)
-        if data['unavailable'].is_a? FalseClass
-          @unavailable_servers -= 1 if @unavailable_servers
-          @unavailable_timeout_time = Time.now
-
-          notify_ready if @unavailable_servers.zero?
-
-          # Return here so the event doesn't get triggered
-          return
-        end
-
-        event = ServerCreateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_UPDATE
-        update_guild(data)
-
-        event = ServerUpdateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_DELETE
-        delete_guild(data)
-
-        if data['unavailable'].is_a? TrueClass
-          LOGGER.warn("Server #{data['id']} is unavailable due to an outage!")
-          return # Don't raise an event
-        end
-
-        event = ServerDeleteEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_EMOJIS_UPDATE
-        server_id = data['guild_id'].to_i
-        server = @servers[server_id]
-        old_emoji_data = server.emoji.clone
-        update_guild_emoji(data)
-        new_emoji_data = server.emoji
-
-        created_ids = new_emoji_data.keys - old_emoji_data.keys
-        deleted_ids = old_emoji_data.keys - new_emoji_data.keys
-        updated_ids = old_emoji_data.select do |k, v|
-          new_emoji_data[k] && (v.name != new_emoji_data[k].name || v.roles != new_emoji_data[k].roles)
-        end.keys
-
-        event = ServerEmojiChangeEvent.new(server, data, self)
-        raise_event(event)
-
-        created_ids.each do |e|
-          event = ServerEmojiCreateEvent.new(server, new_emoji_data[e], self)
-          raise_event(event)
-        end
-
-        deleted_ids.each do |e|
-          event = ServerEmojiDeleteEvent.new(server, old_emoji_data[e], self)
-          raise_event(event)
-        end
-
-        updated_ids.each do |e|
-          event = ServerEmojiUpdateEvent.new(server, old_emoji_data[e], new_emoji_data[e], self)
-          raise_event(event)
-        end
-      when :APPLICATION_COMMAND_PERMISSIONS_UPDATE
-        event = ApplicationCommandPermissionsUpdateEvent.new(data, self)
-
-        raise_event(event)
-      when :INTERACTION_CREATE
-        event = InteractionCreateEvent.new(data, self)
-        raise_event(event)
-
-        case data['type']
-        when Interaction::TYPES[:command]
-          event = ApplicationCommandEvent.new(data, self)
-
-          @event_executor.post do
-            Thread.current[:onyxcord_name] = next_event_thread_name('it')
-            handler = @application_commands[event.command_name]
-            handler&.call(event)
-          rescue StandardError => e
-            log_exception(e)
-          end
-        when Interaction::TYPES[:component]
-          case data['data']['component_type']
-          when Webhooks::View::COMPONENT_TYPES[:button]
-            event = ButtonEvent.new(data, self)
-
-            raise_event(event)
-          when Webhooks::View::COMPONENT_TYPES[:string_select]
-            event = StringSelectEvent.new(data, self)
-
-            raise_event(event)
-          when Webhooks::View::COMPONENT_TYPES[:user_select]
-            event = UserSelectEvent.new(data, self)
-
-            raise_event(event)
-          when Webhooks::View::COMPONENT_TYPES[:role_select]
-            event = RoleSelectEvent.new(data, self)
-
-            raise_event(event)
-          when Webhooks::View::COMPONENT_TYPES[:mentionable_select]
-            event = MentionableSelectEvent.new(data, self)
-
-            raise_event(event)
-          when Webhooks::View::COMPONENT_TYPES[:channel_select]
-            event = ChannelSelectEvent.new(data, self)
-
-            raise_event(event)
-          end
-        when Interaction::TYPES[:modal_submit]
-
-          event = ModalSubmitEvent.new(data, self)
-          raise_event(event)
-        when Interaction::TYPES[:autocomplete]
-
-          event = AutocompleteEvent.new(data, self)
-          raise_event(event)
-        end
-      when :WEBHOOKS_UPDATE
-        event = WebhookUpdateEvent.new(data, self)
-        raise_event(event)
-      when :THREAD_CREATE
-        create_channel(data)
-
-        event = ThreadCreateEvent.new(data, self)
-        raise_event(event)
-      when :THREAD_UPDATE
-        update_channel(data)
-
-        event = ThreadUpdateEvent.new(data, self)
-        raise_event(event)
-      when :THREAD_DELETE
-        delete_channel(data)
-        @thread_members.delete(data['id']&.resolve_id)
-
-        # raise ThreadDeleteEvent
-      when :THREAD_LIST_SYNC
-        server_id = data['guild_id'].to_i
-        server = @servers[server_id]
-
-        # The `channel_ids` field has two meanings:
-        #
-        # 1. If the field is not present, the thread list is being synced for the whole server.
-        #
-        # 2. We are syncing the threads for a specific channel. This can happen when gaining access
-        #    to a channel.
-        if (ids = data['channel_ids']&.map(&:to_i))
-          @channels.delete_if { |_, channel| channel.thread? && ids.any?(channel.parent&.id) }
-          server&.clear_threads(ids)
-        else
-          @channels.delete_if { |_, channel| channel.server.id == server_id && channel.thread? }
-          server&.clear_threads
-        end
-
-        data['members'].each { |member| ensure_thread_member(member) }
-        data['threads'].each { |channel| ensure_channel(channel) }
-
-        # raise ThreadListSyncEvent?
-      when :THREAD_MEMBER_UPDATE
-        ensure_thread_member(data)
-      when :THREAD_MEMBERS_UPDATE
-        data['added_members']&.each do |added_member|
-          ensure_thread_member(added_member) if added_member['user_id']
-        end
-
-        data['removed_member_ids']&.each do |member_id|
-          @thread_members[data['id']&.resolve_id]&.delete(member_id&.resolve_id)
-        end
-
-        event = ThreadMembersUpdateEvent.new(data, self)
-        raise_event(event)
-      when :MESSAGE_POLL_VOTE_ADD
-        event = PollVoteAddEvent.new(data, self)
-        raise_event(event)
-      when :MESSAGE_POLL_VOTE_REMOVE
-        event = PollVoteRemoveEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_SCHEDULED_EVENT_CREATE
-        update_guild_scheduled_event(data)
-
-        event = ScheduledEventCreateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_SCHEDULED_EVENT_UPDATE
-        update_guild_scheduled_event(data)
-
-        event = ScheduledEventUpdateEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_SCHEDULED_EVENT_DELETE
-        @servers[data['guild_id'].to_i]&.delete_scheduled_event(data['id'].to_i)
-
-        event = ScheduledEventDeleteEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_SCHEDULED_EVENT_USER_ADD
-        server = @servers[data['guild_id'].to_i]
-        server&.scheduled_event(data['guild_scheduled_event_id'], request: false)&.increment_user_count
-
-        event = ScheduledEventUserAddEvent.new(data, self)
-        raise_event(event)
-      when :GUILD_SCHEDULED_EVENT_USER_REMOVE
-        server = @servers[data['guild_id'].to_i]
-        server&.scheduled_event(data['guild_scheduled_event_id'], request: false)&.deincrement_user_count
-
-        event = ScheduledEventUserRemoveEvent.new(data, self)
-        raise_event(event)
-      else
-        # another event that we don't support yet
-        debug "Event #{type} has been received but is unsupported. Raising UnknownEvent"
-
-        event = UnknownEvent.new(type, data, self)
-        raise_event(event)
-      end
-
-      # The existence of this array is checked before for performance reasons, since this has to be done for *every*
-      # dispatch.
-      if @event_handlers && @event_handlers[RawEvent]
-        event = RawEvent.new(type, data, self)
-        raise_event(event)
-      end
-    rescue Exception => e
-      if defined?(Async::Cancel) && e.is_a?(Async::Cancel)
-        LOGGER.debug('Gateway message handling was cancelled.')
-        return
-      end
-
-      LOGGER.error('Gateway message error!')
-      log_exception(e)
-    end
-
-    # Notifies everything there is to be notified that the connection is now ready
-    def notify_ready
-      if @mode == :raw
-        notify_raw_ready
-        return
-      end
-
-      # Make sure to raise the event
-      raise_event(ReadyEvent.new(self))
-      LOGGER.good 'Ready'
-
-      @gateway.notify_ready
-    end
-
-    def raise_event(event)
-      debug("Raised a #{event.class}")
-      handle_awaits(event)
-
-      @event_handlers ||= {}
-      handlers = @event_handlers[event.class]
-      return unless handlers
-
-      handlers.dup.each do |handler|
-        call_event(handler, event) if handler.matches?(event)
-      end
-    end
-
-    def call_event(handler, event)
-      @event_executor.post do
-        Thread.current[:onyxcord_name] = next_event_thread_name('et')
-        begin
-          handler.call(event)
-          handler.after_call(event)
-        rescue StandardError => e
-          log_exception(e)
-        end
-      end
-    end
-
-    def handle_awaits(event)
-      @awaits ||= {}
-      @awaits.each_value do |await|
-        key, should_delete = await.match(event)
-        next unless key
-
-        debug("should_delete: #{should_delete}")
-        @awaits.delete(await.key) if should_delete
-
-        await_event = OnyxCord::Events::AwaitEvent.new(await, event, self)
-        raise_event(await_event)
-      end
-    end
-
-    def calculate_intents(intents)
-      intents = [intents] unless intents.is_a? Array
-
-      intents.reduce(0) do |sum, intent|
-        case intent
-        when Symbol
-          intent = INTENT_ALIASES[intent] || intent
-
-          if INTENTS[intent]
-            sum | INTENTS[intent]
-          else
-            LOGGER.warn("Unknown intent: #{intent}")
-            sum
-          end
-        when Integer
-          sum | intent
-        else
-          LOGGER.warn("Invalid intent: #{intent}")
-          sum
-        end
-      end
-    end
-
-    def dispatch_packet(packet)
-      type = packet['t']&.intern
-      data = packet['d']
-
-      case @mode
-      when :raw
-        dispatch_raw_packet(packet)
-        notify_raw_ready if type == :READY
-      when :hybrid
-        dispatch_raw_packet(packet)
-        handle_dispatch(type, data)
-      else
-        handle_dispatch(type, data)
-      end
-    end
-
-    def dispatch_raw_packet(packet)
-      handlers = @raw_handlers
-      return unless handlers
-
-      handlers.dup.each do |handler|
-        call_raw_handler(handler, packet) if handler.matches?(packet)
-      end
-    end
-
-    def call_raw_handler(handler, packet)
-      @event_executor.post do
-        Thread.current[:onyxcord_name] = next_event_thread_name('rt')
-        handler.call(packet)
-      rescue StandardError => e
-        log_exception(e)
-      end
-    end
-
-    def notify_raw_ready
-      return if @raw_ready_notified
-
-      @raw_ready_notified = true
-      LOGGER.good 'Ready'
-      @gateway.notify_ready
-    end
-
-    def next_event_thread_name(prefix)
-      @current_thread_mutex.synchronize do
-        @current_thread += 1
-        "#{prefix}-#{@current_thread}"
-      end
-    end
   end
 end