discordrb 3.2.1 → 3.3.0

data/lib/discordrb/container.rb

@@ -37,7 +37,7 @@ module Discordrb
       register_event(MessageEvent, attributes, block)
     end
 
-    # This **event** is raised when the READY packet is received, i. e. servers and channels have finished
+    # This **event** is raised when the READY packet is received, i.e. servers and channels have finished
     # initialization. It's the recommended way to do things when the bot has finished starting up.
     # @param attributes [Hash] Event attributes, none in this particular case
     # @yield The block is executed when the event is raised.
@@ -237,7 +237,8 @@ module Discordrb
       register_event(ChannelRecipientRemoveEvent, attributes, block)
     end
 
-    # This **event** is raised when a user's voice state changes.
+    # This **event** is raised when a user's voice state changes. This includes when a user joins, leaves, or
+    # moves between voice channels, as well as their mute and deaf status for themselves and on the server.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, User] :from Matches the user that sent the message.
     # @option attributes [String, Integer, Channel] :channel Matches the voice channel the user has joined.
@@ -263,7 +264,8 @@ module Discordrb
       register_event(ServerMemberAddEvent, attributes, block)
     end
 
-    # This **event** is raised when a member update happens.
+    # This **event** is raised when a member update happens. This includes when a members nickname
+    # or roles are updated.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String] :username Matches the username of the updated user.
     # @yield The block is executed when the event is raised.
@@ -305,9 +307,8 @@ module Discordrb
       register_event(UserUnbanEvent, attributes, block)
     end
 
-    # This **event** is raised when a server is created respective to the bot, i. e. the bot joins a server or creates
-    # a new one itself. It should never be necessary to listen to this event as it will only ever be triggered by
-    # things the bot itself does, but one can never know.
+    # This **event** is raised when a server is created respective to the bot, i.e. the bot joins a server or creates
+    # a new one itself.
     # @param attributes [Hash] The event's attributes.
     # @option attributes [String, Integer, Server] :server Matches the server that was created.
     # @yield The block is executed when the event is raised.
@@ -385,6 +386,48 @@ module Discordrb
       register_event(ServerEmojiUpdateEvent, attributes, block)
     end
 
+    # This **event** is raised when a role is created.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String] :name Matches the role name.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerRoleCreateEvent] The event that was raised.
+    # @return [ServerRoleCreateEventHandler] the event handler that was registered.
+    def server_role_create(attributes = {}, &block)
+      register_event(ServerRoleCreateEvent, attributes, block)
+    end
+
+    # This **event** is raised when a role is deleted.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [#resolve_id] :id Matches the role id.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerRoleDeleteEvent] The event that was raised.
+    # @return [ServerRoleDeleteEventHandler] the event handler that was registered.
+    def server_role_delete(attributes = {}, &block)
+      register_event(ServerRoleDeleteEvent, attributes, block)
+    end
+
+    # This **event** is raised when a role is updated.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String] :name Matches the role name.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [ServerRoleUpdateEvent] The event that was raised.
+    # @return [ServerRoleUpdateEventHandler] the event handler that was registered.
+    def server_role_update(attributes = {}, &block)
+      register_event(ServerRoleUpdateEvent, attributes, block)
+    end
+
+    # This **event** is raised when a webhook is updated.
+    # @param attributes [Hash] The event's attributes.
+    # @option attributes [String, Integer, Server] :server Matches the server by name, id or instance.
+    # @option attributes [String, Integer, Channel] :channel Matches the channel by name, id or instance.
+    # @option attribute [String, Integer, Webhook] :webhook Matches the webhook by name, id or instance.
+    # @yield The block is executed when the event is raised.
+    # @yieldparam event [WebhookUpdateEvent] The event that was raised.
+    # @return [WebhookUpdateEventHandler] the event handler that was registered.
+    def webhook_update(attributes = {}, &block)
+      register_event(WebhookUpdateEvent, attributes, block)
+    end
+
     # This **event** is raised when an {Await} is triggered. It provides an easy way to execute code
     # on an await without having to rely on the await's block.
     # @param attributes [Hash] The event's attributes.
@@ -460,6 +503,7 @@ module Discordrb
     def add_handler(handler)
       clazz = EventContainer.event_class(handler.class)
       @event_handlers ||= {}
+      @event_handlers[clazz] ||= []
       @event_handlers[clazz] << handler
     end
 
@@ -487,7 +531,7 @@ module Discordrb
     # Returns the event class for a handler class type
     # @see #handler_class
     # @param handler_class [Class] The handler type
-    # @return [Class, nil] the event type, or nil if the handler_class isn't a handler class (i. e. ends with Handler)
+    # @return [Class, nil] the event type, or nil if the handler_class isn't a handler class (i.e. ends with Handler)
     def self.event_class(handler_class)
       class_name = handler_class.to_s
       return nil unless class_name.end_with? 'Handler'

data/lib/discordrb/data.rb

@@ -2,7 +2,6 @@
 
 # These classes hold relevant Discord data, such as messages or channels.
 
-require 'ostruct'
 require 'discordrb/permissions'
 require 'discordrb/errors'
 require 'discordrb/api'
@@ -10,6 +9,7 @@ require 'discordrb/api/channel'
 require 'discordrb/api/server'
 require 'discordrb/api/invite'
 require 'discordrb/api/user'
+require 'discordrb/api/webhook'
 require 'discordrb/webhooks/embeds'
 require 'time'
 require 'base64'
@@ -71,12 +71,15 @@ module Discordrb
     # @return [Integer] the ID which uniquely identifies this object across Discord.
     attr_reader :id
     alias_method :resolve_id, :id
+    alias_method :hash, :id
 
     # ID based comparison
     def ==(other)
       Discordrb.id_compare(@id, other)
     end
 
+    alias_method :eql?, :==
+
     # Estimates the time this object was generated on based on the beginning of the ID. This is fairly accurate but
     # shouldn't be relied on as Discord might change its algorithm at any time
     # @return [Time] when this object was created at
@@ -125,16 +128,18 @@ module Discordrb
       "<@#{@id}>"
     end
 
-    # Utility function to get Discord's distinct representation of a user, i. e. username + discriminator
+    # Utility function to get Discord's distinct representation of a user, i.e. username + discriminator
     # @return [String] distinct representation of user
     def distinct
       "#{@username}##{@discriminator}"
     end
 
     # Utility function to get a user's avatar URL.
+    # @param format [String, nil] If `nil`, the URL will default to `webp` for static avatars, and will detect if the user has a `gif` avatar. You can otherwise specify one of `webp`, `jpg`, `png`, or `gif` to override this. Will always be PNG for default avatars.
     # @return [String] the URL to the avatar image.
-    def avatar_url
-      API::User.avatar_url(@id, @avatar_id)
+    def avatar_url(format = nil)
+      return API::User.default_avatar(@discriminator) unless @avatar_id
+      API::User.avatar_url(@id, @avatar_id, format)
     end
   end
 
@@ -196,6 +201,8 @@ module Discordrb
     # @param file [File] The file to send to the user
     # @param caption [String] The caption of the file being sent
     # @return [Message] the message sent to this user.
+    # @example Send a file from disk
+    #   user.send_file(File.open('rubytaco.png', 'r'))
     def send_file(file, caption = nil)
       pm.send_file(file, caption: caption)
     end
@@ -231,6 +238,13 @@ module Discordrb
       @bot.add_await(key, Discordrb::Events::MessageEvent, { from: @id }.merge(attributes), &block)
     end
 
+    # Add a blocking await for a message from this user. Specifically, this adds a global await for a MessageEvent with this
+    # user's ID as a :from attribute.
+    # @see Bot#add_await!
+    def await!(attributes = {})
+      @bot.add_await!(Discordrb::Events::MessageEvent, { from: @id }.merge(attributes))
+    end
+
     # Gets the member this user is on a server
     # @param server [Server] The server to get the member for
     # @return [Member] this user as a member on a particular server
@@ -250,7 +264,7 @@ module Discordrb
       @discriminator == Message::ZERO_DISCRIM
     end
 
-    [:offline, :idle, :online].each do |e|
+    %i[offline idle online].each do |e|
       define_method(e.to_s + '?') do
         @status.to_sym == e
       end
@@ -272,14 +286,14 @@ module Discordrb
     # @return [String] the application description
     attr_reader :description
 
-    # @return [Array<String>] the applications origins permitted to use RPC
+    # @return [Array<String>] the application's origins permitted to use RPC
     attr_reader :rpc_origins
 
     # @return [Integer]
     attr_reader :flags
 
     # Gets the user object of the owner. May be limited to username, discriminator,
-    # ID and avatar if the bot cannot reach the owner.
+    # ID, and avatar if the bot cannot reach the owner.
     # @return [User] the user object of the owner
     attr_reader :owner
 
@@ -296,7 +310,7 @@ module Discordrb
     end
 
     # Utility function to get a application's icon URL.
-    # @return [String, nil] the URL to the icon image (nil if no image is set).
+    # @return [String, nil] the URL of the icon image (nil if no image is set).
     def icon_url
       return nil if @icon_id.nil?
       API.app_icon_url(@id, @icon_id)
@@ -313,7 +327,7 @@ module Discordrb
     # @return [Time] when this member joined the server.
     attr_reader :joined_at
 
-    # @return [String, nil] the nickname this member has, or nil if it has none.
+    # @return [String, nil] the nickname this member has, or `nil` if it has none.
     attr_reader :nick
     alias_method :nickname, :nick
 
@@ -348,7 +362,7 @@ module Discordrb
       defined_permission?(action, channel)
     end
 
-    # Checks whether this user has a particular permission defined (i. e. not implicit, through for example
+    # Checks whether this user has a particular permission defined (i.e. not implicit, through for example
     # Manage Roles)
     # @param action [Symbol] The permission that should be checked. See also {Permissions::Flags} for a list.
     # @param channel [Channel, nil] If channel overrides should be checked too, this channel specifies where the overrides should be checked.
@@ -380,10 +394,12 @@ module Discordrb
     private
 
     def defined_role_permission?(action, channel)
+      roles_to_check = [@server.everyone_role] + @roles
+
       # For each role, check if
       #   (1) the channel explicitly allows or permits an action for the role and
       #   (2) if the user is allowed to do the action if the channel doesn't specify
-      @roles.reduce(false) do |can_act, role|
+      roles_to_check.reduce(false) do |can_act, role|
         # Get the override defined for the role on the channel
         channel_allow = permission_overwrite(action, channel, role.id)
         can_act = if channel_allow
@@ -453,7 +469,47 @@ module Discordrb
     end
   end
 
-  # A presence represents a
+  # Voice regions are the locations of servers that handle voice communication in Discord
+  class VoiceRegion
+    # @return [String] unique ID for the region
+    attr_reader :id
+    alias_method :to_s, :id
+
+    # @return [String] name of the region
+    attr_reader :name
+
+    # @return [String] an example hostname for the region
+    attr_reader :sample_hostname
+
+    # @return [Integer] an example port for the region
+    attr_reader :sample_port
+
+    # @return [true, false] if this is a VIP-only server
+    attr_reader :vip
+
+    # @return [true, false] if this voice server is the closest to the client
+    attr_reader :optimal
+
+    # @return [true, false] whether this is a deprecated voice region (avoid switching to these)
+    attr_reader :deprecated
+
+    # @return [true, false] whether this is a custom voice region (used for events/etc)
+    attr_reader :custom
+
+    def initialize(data)
+      @id = data['id']
+
+      @name = data['name']
+
+      @sample_hostname = data['sample_hostname']
+      @sample_port = data['sample_port']
+
+      @vip = data['vip']
+      @optimal = data['optimal']
+      @deprecated = data['deprecated']
+      @custom = data['custom']
+    end
+  end
 
   # A member is a user on a server. It differs from regular users in that it has roles, voice statuses and things like
   # that.
@@ -520,48 +576,92 @@ module Discordrb
       @roles.any? { |e| e.id == role }
     end
 
+    # @see Member#set_roles
+    def roles=(role)
+      set_roles(role)
+    end
+
     # Bulk sets a member's roles.
     # @param role [Role, Array<Role>] The role(s) to set.
-    def roles=(role)
+    # @param reason [String] The reason the user's roles are being changed.
+    def set_roles(role, reason = nil)
       role_ids = role_id_array(role)
-      API::Server.update_member(@bot.token, @server.id, @user.id, roles: role_ids)
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: role_ids, reason: reason)
     end
 
     # Adds and removes roles from a member.
     # @param add [Role, Array<Role>] The role(s) to add.
     # @param remove [Role, Array<Role>] The role(s) to remove.
+    # @param reason [String] The reason the user's roles are being changed.
     # @example Remove the 'Member' role from a user, and add the 'Muted' role to them.
     #   to_add = server.roles.find {|role| role.name == 'Muted'}
     #   to_remove = server.roles.find {|role| role.name == 'Member'}
     #   member.modify_roles(to_add, to_remove)
-    def modify_roles(add, remove)
+    def modify_roles(add, remove, reason = nil)
       add_role_ids = role_id_array(add)
       remove_role_ids = role_id_array(remove)
       old_role_ids = @roles.map(&:id)
       new_role_ids = (old_role_ids - remove_role_ids + add_role_ids).uniq
 
-      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids)
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
     end
 
     # Adds one or more roles to this member.
-    # @param role [Role, Array<Role>] The role(s) to add.
-    def add_role(role)
+    # @param role [Role, Array<Role, #resolve_id>, #resolve_id] The role(s) to add.
+    # @param reason [String] The reason the user's roles are being changed.
+    def add_role(role, reason = nil)
       role_ids = role_id_array(role)
-      old_role_ids = @roles.map(&:id)
-      new_role_ids = (old_role_ids + role_ids).uniq
 
-      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids)
+      if role_ids.count == 1
+        API::Server.add_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
+      else
+        old_role_ids = @roles.map(&:id)
+        new_role_ids = (old_role_ids + role_ids).uniq
+        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+      end
     end
 
     # Removes one or more roles from this member.
     # @param role [Role, Array<Role>] The role(s) to remove.
-    def remove_role(role)
-      old_role_ids = @roles.map(&:id)
+    # @param reason [String] The reason the user's roles are being changed.
+    def remove_role(role, reason = nil)
       role_ids = role_id_array(role)
-      new_role_ids = old_role_ids.reject { |i| role_ids.include?(i) }
 
-      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids)
+      if role_ids.count == 1
+        API::Server.remove_member_role(@bot.token, @server.id, @user.id, role_ids[0], reason)
+      else
+        old_role_ids = @roles.map(&:id)
+        new_role_ids = old_role_ids.reject { |i| role_ids.include?(i) }
+        API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids, reason: reason)
+      end
+    end
+
+    # @return [Role] the highest role this member has.
+    def highest_role
+      @roles.sort_by(&:position).last
+    end
+
+    # @return [Role, nil] the role this member is being hoisted with.
+    def hoist_role
+      hoisted_roles = @roles.select(&:hoist)
+      return nil if hoisted_roles.empty?
+      hoisted_roles.sort_by(&:position).last
+    end
+
+    # @return [Role, nil] the role this member is basing their colour on.
+    def colour_role
+      coloured_roles = @roles.select { |v| v.colour.combined.nonzero? }
+      return nil if coloured_roles.empty?
+      coloured_roles.sort_by(&:position).last
     end
+    alias_method :color_role, :colour_role
+
+    # @return [ColourRGB, nil] the colour this member has.
+    def colour
+      return nil unless colour_role
+      colour_role.color
+    end
+    alias_method :color, :colour
 
     # Server deafens this member.
     def server_deafen
@@ -583,21 +683,29 @@ module Discordrb
       API::Server.update_member(@bot.token, @server.id, @user.id, mute: false)
     end
 
+    # @see Member#set_nick
+    def nick=(nick)
+      set_nick(nick)
+    end
+
+    alias_method :nickname=, :nick=
+
     # Sets or resets this member's nickname. Requires the Change Nickname permission for the bot itself and Manage
     # Nicknames for other users.
     # @param nick [String, nil] The string to set the nickname to, or nil if it should be reset.
-    def nick=(nick)
+    # @param reason [String] The reason the user's nickname is being changed.
+    def set_nick(nick, reason = nil)
       # Discord uses the empty string to signify 'no nickname' so we convert nil into that
       nick ||= ''
 
       if @user.current_bot?
-        API::User.change_own_nickname(@bot.token, @server.id, nick)
+        API::User.change_own_nickname(@bot.token, @server.id, nick, reason)
       else
-        API::Server.update_member(@bot.token, @server.id, @user.id, nick: nick)
+        API::Server.update_member(@bot.token, @server.id, @user.id, nick: nick, reason: nil)
       end
     end
 
-    alias_method :nickname=, :nick=
+    alias_method :set_nickname, :set_nick
 
     # @return [String] the name the user displays as (nickname if they have one, username otherwise)
     def display_name
@@ -607,9 +715,13 @@ module Discordrb
     # Update this member's roles
     # @note For internal use only.
     # @!visibility private
-    def update_roles(roles)
-      @roles = roles.map do |role|
-        role.is_a?(Role) ? role : @server.role(role.to_i)
+    def update_roles(role_ids)
+      @roles = []
+      role_ids.each do |id|
+        # It is posible for members to have roles that do not exist
+        # on the server any longer. See https://github.com/meew0/discordrb/issues/371
+        role = @server.role(id)
+        @roles << role if role
       end
     end
 
@@ -699,7 +811,7 @@ module Discordrb
 
     # Changes the bot's avatar.
     # @param avatar [String, #read] A JPG file to be used as the avatar, either
-    #  something readable (e. g. File Object) or as a data URL.
+    #  something readable (e.g. File Object) or as a data URL.
     def avatar=(avatar)
       if avatar.respond_to? :read
         # Set the file to binary mode if supported, so we don't get problems with Windows
@@ -778,9 +890,16 @@ module Discordrb
     # @return [String] this role's name ("new role" if it hasn't been changed)
     attr_reader :name
 
+    # @return [Server] the server this role belongs to
+    attr_reader :server
+
     # @return [true, false] whether or not this role should be displayed separately from other users
     attr_reader :hoist
 
+    # @return [true, false] whether or not this role is managed by an integration or a bot
+    attr_reader :managed
+    alias_method :managed?, :managed
+
     # @return [true, false] whether this role can be mentioned using a role mention
     attr_reader :mentionable
     alias_method :mentionable?, :mentionable
@@ -824,6 +943,7 @@ module Discordrb
 
       @hoist = data['hoist']
       @mentionable = data['mentionable']
+      @managed = data['managed']
 
       @colour = ColourRGB.new(data['color'])
     end
@@ -836,7 +956,7 @@ module Discordrb
     # @return [Array<Member>] an array of members who have this role.
     # @note This requests a member chunk if it hasn't for the server before, which may be slow initially
     def members
-      @server.members.select { |m| m.role? role }
+      @server.members.select { |m| m.role? self }
     end
 
     alias_method :users, :members
@@ -850,6 +970,7 @@ module Discordrb
       @hoist = other.hoist
       @colour = other.colour
       @position = other.position
+      @managed = other.managed
     end
 
     # Updates the data cache from a hash containing data
@@ -903,9 +1024,29 @@ module Discordrb
       @permissions.bits = packed if update_perms
     end
 
+    # Moves this role above another role in the list.
+    # @param other [Role, #resolve_id, nil] The role above which this role should be moved. If it is `nil`,
+    #   the role will be moved above the @everyone role.
+    # @return [Integer] the new position of this role
+    def sort_above(other = nil)
+      other = @server.role(other.resolve_id) if other
+      roles = @server.roles.sort_by(&:position)
+      roles.delete_at(@position)
+
+      index = other ? roles.index { |role| role.id == other.id } + 1 : 1
+      roles.insert(index, self)
+
+      updated_roles = roles.map.with_index { |role, position| { id: role.id, position: position } }
+      @server.update_role_positions(updated_roles)
+      index
+    end
+
+    alias_method :move_above, :sort_above
+
     # Deletes this role. This cannot be undone without recreating the role!
-    def delete
-      API::Server.delete_role(@bot.token, @server.id, @id)
+    # @param reason [String] the reason for this role's deletion
+    def delete(reason = nil)
+      API::Server.delete_role(@bot.token, @server.id, @id, reason)
       @server.delete_role(@id)
     end
 
@@ -984,7 +1125,7 @@ module Discordrb
     attr_reader :inviter
     alias_method :user, :inviter
 
-    # @return [true, false] whether or not this invite is temporary.
+    # @return [true, false] whether or not this invite grants temporary membership. If someone joins a server with this invite, they will be removed from the server when they go offline unless they've received a role.
     attr_reader :temporary
     alias_method :temporary?, :temporary
 
@@ -995,6 +1136,20 @@ module Discordrb
     # @return [String] this invite's code
     attr_reader :code
 
+    # @return [Integer, nil] the amount of members in the server. Will be nil if it has not been resolved.
+    attr_reader :member_count
+    alias_method :user_count, :member_count
+
+    # @return [Integer, nil] the amount of online members in the server. Will be nil if it has not been resolved.
+    attr_reader :online_member_count
+    alias_method :online_user_count, :online_member_count
+
+    # @return [Integer, nil] the invites max age before it expires, or nil if it's unknown. If the max age is 0, the invite will never expire unless it's deleted.
+    attr_reader :max_age
+
+    # @return [Time, nil] when this invite was created, or nil if it's unknown
+    attr_reader :created_at
+
     # @!visibility private
     def initialize(data, bot)
       @bot = bot
@@ -1005,6 +1160,10 @@ module Discordrb
       @inviter = data['inviter'] ? (@bot.user(data['inviter']['id'].to_i) || User.new(data['inviter'], bot)) : nil
       @temporary = data['temporary']
       @revoked = data['revoked']
+      @online_member_count = data['approximate_presence_count']
+      @member_count = data['approximate_member_count']
+      @max_age = data['max_age']
+      @created_at = data['created_at']
 
       @code = data['code']
     end
@@ -1015,15 +1174,16 @@ module Discordrb
     end
 
     # Deletes this invite
-    def delete
-      API::Invite.delete(@bot.token, @code)
+    # @param reason [String] The reason the invite is being deleted.
+    def delete(reason = nil)
+      API::Invite.delete(@bot.token, @code, reason)
     end
 
     alias_method :revoke, :delete
 
     # The inspect method is overwritten to give more useful output
     def inspect
-      "<Invite code=#{@code} channel=#{@channel} uses=#{@uses} temporary=#{@temporary} revoked=#{@revoked}>"
+      "<Invite code=#{@code} channel=#{@channel} uses=#{@uses} temporary=#{@temporary} revoked=#{@revoked} created_at=#{@created_at} max_age=#{@max_age}>"
     end
 
     # Creates an invite URL.
@@ -1032,16 +1192,126 @@ module Discordrb
     end
   end
 
+  # A permissions overwrite, when applied to channels describes additional
+  # permissions a member needs to perform certain actions in context.
+  class Overwrite
+    # @return [Integer] id of the thing associated with this overwrite type
+    attr_accessor :id
+
+    # @return [Symbol] either :role or :member
+    attr_accessor :type
+
+    # @return [Permissions] allowed permissions for this overwrite type
+    attr_accessor :allow
+
+    # @return [Permissions] denied permissions for this overwrite type
+    attr_accessor :deny
+
+    # Creates a new Overwrite object
+    # @example Create an overwrite for a role that can mention everyone, send TTS messages, but can't create instant invites
+    #   allow = Discordrb::Permissions.new
+    #   allow.can_mention_everyone = true
+    #   allow.can_send_tts_messages = true
+    #
+    #   deny = Discordrb::Permissions.new
+    #   deny.can_create_instant_invite = true
+    #
+    #   # Find some role by name
+    #   role = server.roles.find { |r| r.name == 'some role' }
+    #
+    #   Overwrite.new(role, allow: allow, deny: deny)
+    # @example Create an overwrite by ID and permissions bits
+    #   Overwrite.new(120571255635181568, type: 'member', allow: 1024, deny: 0)
+    # @param object [Integer, #id] the ID or object this overwrite is for
+    # @param type [String] the type of object this overwrite is for (only required if object is an Integer)
+    # @param allow [Integer, Permissions] allowed permissions for this overwrite, by bits or a Permissions object
+    # @param deny [Integer, Permissions] denied permissions for this overwrite, by bits or a Permissions object
+    # @raise [ArgumentError] if type is not :member or :role
+    def initialize(object = nil, type: nil, allow: 0, deny: 0)
+      if type
+        type = type.to_sym
+        raise ArgumentError, 'Overwrite type must be :member or :role' unless (type != :member) || (type != :role)
+      end
+
+      @id = object.respond_to?(:id) ? object.id : object
+
+      @type = if object.is_a?(User) || object.is_a?(Member) || object.is_a?(Recipient) || object.is_a?(Profile)
+                :member
+              elsif object.is_a? Role
+                :role
+              else
+                type
+              end
+
+      @allow = allow.is_a?(Permissions) ? allow : Permissions.new(allow)
+      @deny = deny.is_a?(Permissions) ? deny : Permissions.new(deny)
+    end
+
+    # Comparison by attributes [:id, :type, :allow, :deny]
+    def ==(other)
+      false unless other.is_a? Discordrb::Overwrite
+      id == other.id &&
+        type == other.type &&
+        allow == other.allow &&
+        deny == other.deny
+    end
+
+    # @return [Overwrite] create an overwrite from a hash payload
+    # @!visibility private
+    def self.from_hash(data)
+      new(
+        data['id'].to_i,
+        type: data['type'],
+        allow: Permissions.new(data['allow']),
+        deny: Permissions.new(data['deny'])
+      )
+    end
+
+    # @return [Overwrite] copies an overwrite from another Overwrite
+    # @!visibility private
+    def self.from_other(other)
+      new(
+        other.id,
+        type: other.type,
+        allow: Permissions.new(other.allow.bits),
+        deny: Permissions.new(other.deny.bits)
+      )
+    end
+
+    # @return [Hash] hash representation of an overwrite
+    # @!visibility private
+    def to_hash
+      {
+        id: id,
+        type: type,
+        allow: allow.bits,
+        deny: deny.bits
+      }
+    end
+  end
+
   # A Discord channel, including data like the topic
   class Channel
     include IDObject
 
+    # Map of channel types
+    TYPES = {
+      text: 0,
+      dm: 1,
+      voice: 2,
+      group: 3,
+      category: 4
+    }.freeze
+
     # @return [String] this channel's name.
     attr_reader :name
 
     # @return [Server, nil] the server this channel is on. If this channel is a PM channel, it will be nil.
     attr_reader :server
 
+    # @return [Integer, nil] the ID of the parent channel, if this channel is inside a cateogry
+    attr_reader :parent_id
+
     # @return [Integer] the type of this channel (0: text, 1: private, 2: voice, 3: group)
     attr_reader :type
 
@@ -1064,11 +1334,13 @@ module Discordrb
     # @return [Integer] the channel's position on the channel list
     attr_reader :position
 
-    # This channel's permission overwrites, represented as a hash of role/user ID to an OpenStruct which has the
-    # `allow` and `deny` properties which are {Permissions} objects respectively.
-    # @return [Hash<Integer => OpenStruct>] the channel's permission overwrites
-    attr_reader :permission_overwrites
-    alias_method :overwrites, :permission_overwrites
+    # @return [true, false] if this channel is marked as nsfw
+    attr_reader :nsfw
+    alias_method :nsfw?, :nsfw
+
+    # @return [Integer] the amount of time (in seconds) users need to wait to send in between messages.
+    attr_reader :rate_limit_per_user
+    alias_method :slowmode_rate, :rate_limit_per_user
 
     # @return [true, false] whether or not this channel is a PM or group channel.
     def private?
@@ -1088,7 +1360,7 @@ module Discordrb
     # @!visibility private
     def initialize(data, bot, server = nil)
       @bot = bot
-      # data is a sometimes a Hash and other times an array of Hashes, you only want the last one if it's an array
+      # data is sometimes a Hash and other times an array of Hashes, you only want the last one if it's an array
       data = data[-1] if data.is_a?(Array)
 
       @id = data['id'].to_i
@@ -1097,6 +1369,7 @@ module Discordrb
       @bitrate = data['bitrate']
       @user_limit = data['user_limit']
       @position = data['position']
+      @parent_id = data['parent_id'].to_i if data['parent_id']
 
       if private?
         @recipients = []
@@ -1121,17 +1394,10 @@ module Discordrb
                   end
       end
 
-      # Populate permission overwrites
-      @permission_overwrites = {}
-      return unless data['permission_overwrites']
-      data['permission_overwrites'].each do |element|
-        role_id = element['id'].to_i
-        deny = Permissions.new(element['deny'])
-        allow = Permissions.new(element['allow'])
-        @permission_overwrites[role_id] = OpenStruct.new
-        @permission_overwrites[role_id].deny = deny
-        @permission_overwrites[role_id].allow = allow
-      end
+      @nsfw = data['nsfw'] || false || @name.start_with?('nsfw')
+      @rate_limit_per_user = data['rate_limit_per_user'] || 0
+
+      process_permission_overwrites(data['permission_overwrites'])
     end
 
     # @return [true, false] whether or not this channel is a text channel
@@ -1154,6 +1420,194 @@ module Discordrb
       @type == 3
     end
 
+    # @return [true, false]
+    def category?
+      @type == 4
+    end
+
+    # @return [Channel, nil] the category channel, if this channel is in a category
+    def category
+      @bot.channel(@parent_id) if @parent_id
+    end
+
+    alias_method :parent, :category
+
+    # Sets this channels parent category
+    # @param channel [Channel, #resolve_id] the target category channel
+    # @raise [ArgumentError] if the target channel isn't a category
+    def category=(channel)
+      channel = @bot.channel(channel)
+      raise ArgumentError, 'Cannot set parent category to a channel that isn\'t a category' unless channel.category?
+      update_channel_data(parent_id: channel.id)
+    end
+
+    alias_method :parent=, :category=
+
+    # Sorts this channel's position to follow another channel.
+    # @param other [Channel, #resolve_id, nil] The channel below which this channel should be sorted. If the given
+    #   channel is a category, this channel will be sorted at the top of that category. If it is `nil`, the channel will
+    #   be sorted at the top of the channel list.
+    # @param lock_permissions [true, false] Whether the channel's permissions should be synced to the category's
+    def sort_after(other = nil, lock_permissions = false)
+      raise TypeError, 'other must be one of Channel, NilClass, or #resolve_id' unless other.is_a?(Channel) || other.nil? || other.respond_to?(:resolve_id)
+      other = @bot.channel(other.resolve_id) if other
+
+      # Container for the API request payload
+      move_argument = []
+
+      if other
+        raise ArgumentError, 'Can only sort a channel after a channel of the same type!' unless other.category? || (@type == other.type)
+
+        raise ArgumentError, 'Can only sort a channel after a channel in the same server!' unless other.server == server
+
+        # Store `others` parent (or if `other` is a category itself)
+        parent = if category? && other.category?
+                   # If we're sorting two categories, there is no new parent
+                   nil
+                 elsif other.category?
+                   # `other` is the category this channel will be moved into
+                   other
+                 else
+                   # `other`'s parent is the category this channel will be
+                   # moved into (if it exists)
+                   other.parent
+                 end
+      end
+
+      # Collect and sort the IDs within the context (category or not) that we
+      # need to form our payload with
+      ids = if parent
+              parent.children
+            else
+              @server.channels.reject(&:parent_id).select { |c| c.type == @type }
+            end.sort_by(&:position).map(&:id)
+
+      # Move our channel ID after the target ID by deleting it,
+      # getting the index of `other`, and inserting it after.
+      ids.delete(@id) if ids.include?(@id)
+      index = other ? (ids.index { |c| c == other.id } || -1) + 1 : 0
+      ids.insert(index, @id)
+
+      # Generate `move_argument`, making the positions in order from how
+      # we have sorted them in the above logic
+      ids.each_with_index do |id, pos|
+        # These keys are present in each element
+        hash = { id: id, position: pos }
+
+        # Conditionally add `lock_permissions` and `parent_id` if we're
+        # iterating past ourself
+        if id == @id
+          hash[:lock_permissions] = true if lock_permissions
+          hash[:parent_id] = parent.nil? ? nil : parent.id
+        end
+
+        # Add it to the stack
+        move_argument << hash
+      end
+
+      API::Server.update_channel_positions(@bot.token, @server.id, move_argument)
+    end
+
+    # Sets whether this channel is NSFW
+    # @param nsfw [true, false]
+    # @raise [ArguementError] if value isn't one of true, false
+    def nsfw=(nsfw)
+      raise ArgumentError, 'nsfw value must be true or false' unless nsfw.is_a?(TrueClass) || nsfw.is_a?(FalseClass)
+      update_channel_data(nsfw: nsfw)
+    end
+
+    # This channel's permission overwrites
+    # @overload permission_overwrites
+    #   The overwrites represented as a hash of role/user ID
+    #   to an Overwrite object
+    #   @return [Hash<Integer => Overwrite>] the channel's permission overwrites
+    # @overload permission_overwrites(type)
+    #   Return an array of a certain type of overwrite
+    #   @param type [Symbol] the kind of overwrite to return
+    #   @return [Array<Overwrite>]
+    def permission_overwrites(type = nil)
+      return @permission_overwrites unless type
+      @permission_overwrites.values.select { |e| e.type == type }
+    end
+
+    alias_method :overwrites, :permission_overwrites
+
+    # Bulk sets this channels permission overwrites
+    # @param overwrites [Array<Overwrite>]
+    def permission_overwrites=(overwrites)
+      update_channel_data(permission_overwrites: overwrites)
+    end
+
+    # Sets the amount of time (in seconds) users have to wait in between sending messages.
+    # @param rate [Integer]
+    # @raise [ArgumentError] if value isn't between 0 and 120
+    def rate_limit_per_user=(rate)
+      raise ArgumentError, 'rate_limit_per_user must be between 0 and 120' unless rate.between?(0, 120)
+      update_channel_data(rate_limit_per_user: rate)
+    end
+
+    alias_method :slowmode_rate=, :rate_limit_per_user=
+
+    # Syncs this channels overwrites with its parent category
+    # @raise [RuntimeError] if this channel is not in a category
+    def sync_overwrites
+      raise 'Cannot sync overwrites on a channel with no parent category' unless parent
+      self.permission_overwrites = parent.permission_overwrites
+    end
+
+    alias_method :sync, :sync_overwrites
+
+    # @return [true, false, nil] whether this channels permissions match the permission overwrites of the category that it's in, or nil if it is not in a category
+    def synchronized?
+      return unless parent
+      permission_overwrites == parent.permission_overwrites
+    end
+
+    alias_method :synced?, :synchronized?
+
+    # Returns the children of this channel, if it is a category. Otherwise returns an empty array.
+    # @return [Array<Channel>]
+    def children
+      return [] unless category?
+      server.channels.select { |c| c.parent_id == id }
+    end
+
+    alias_method :channels, :children
+
+    # Returns the text channels in this category, if it is a category channel. Otherwise returns an empty array.
+    # @return [Array<Channel>]
+    def text_channels
+      children.select(&:text?)
+    end
+
+    # Returns the voice channels in this category, if it is a category channel. Otherwise returns an empty array.
+    # @return [Array<Channel>]
+    def voice_channels
+      children.select(&:voice?)
+    end
+
+    # @return [Overwrite] any member-type permission overwrites on this channel
+    def member_overwrites
+      permission_overwrites :member
+    end
+
+    # @return [Overwrite] any role-type permission overwrites on this channel
+    def role_overwrites
+      permission_overwrites :role
+    end
+
+    # @return [true, false] whether or not this channel is the default channel
+    def default_channel?
+      server.default_channel == self
+    end
+
+    alias_method :default?, :default_channel?
+
+    # @return [true, false] whether or not this channel has slowmode enabled
+    def slowmode?
+      @rate_limit_per_user != 0
+    end
+
     # Sends a message to this channel.
     # @param content [String] The content to send. Should not be longer than 2000 characters or it will result in an error.
     # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
@@ -1207,6 +1661,8 @@ module Discordrb
     # @param file [File] The file to send. There's no clear size limit for this, you'll have to attempt it for yourself (most non-image files are fine, large images may fail to embed)
     # @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.
+    # @example Send a file from disk
+    #   channel.send_file(File.open('rubytaco.png', 'r'))
     def send_file(file, caption: nil, tts: false)
       @bot.send_file(@id, file, caption: caption, tts: tts)
     end
@@ -1218,39 +1674,36 @@ module Discordrb
     end
 
     # Permanently deletes this channel
-    def delete
-      API::Channel.delete(@bot.token, @id)
+    # @param reason [String] The reason the for the channel deletion.
+    def delete(reason = nil)
+      API::Channel.delete(@bot.token, @id, reason)
     end
 
     # Sets this channel's name. The name must be alphanumeric with dashes, unless this is a voice channel (then there are no limitations)
     # @param name [String] The new name.
     def name=(name)
-      @name = name
-      update_channel_data
+      update_channel_data(name: name)
     end
 
     # Sets this channel's topic.
     # @param topic [String] The new topic.
     def topic=(topic)
       raise 'Tried to set topic on voice channel' if voice?
-      @topic = topic
-      update_channel_data
+      update_channel_data(topic: topic)
     end
 
     # Sets this channel's bitrate.
     # @param bitrate [Integer] The new bitrate (in bps). Number has to be between 8000-96000 (128000 for VIP servers)
     def bitrate=(bitrate)
       raise 'Tried to set bitrate on text channel' if text?
-      @bitrate = bitrate
-      update_channel_data
+      update_channel_data(bitrate: bitrate)
     end
 
     # Sets this channel's user limit.
     # @param limit [Integer] The new user limit. `0` for unlimited, has to be a number between 0-99
     def user_limit=(limit)
       raise 'Tried to set user_limit on text channel' if text?
-      @user_limit = limit
-      update_channel_data
+      update_channel_data(user_limit: limit)
     end
 
     alias_method :limit=, :user_limit=
@@ -1258,47 +1711,48 @@ module Discordrb
     # Sets this channel's position in the list.
     # @param position [Integer] The new position.
     def position=(position)
-      @position = position
-      update_channel_data
+      update_channel_data(position: position)
     end
 
     # Defines a permission overwrite for this channel that sets the specified thing to the specified allow and deny
     # permission sets, or change an existing one.
-    # @param thing [User, Role] What to define an overwrite for.
-    # @param allow [#bits, Permissions, Integer] The permission sets that should receive an `allow` override (i. e. a
-    #   green checkmark on Discord)
-    # @param deny [#bits, Permissions, Integer] The permission sets that should receive a `deny` override (i. e. a red
-    #   cross on Discord)
-    # @example Define a permission overwrite for a user that can then mention everyone and use TTS, but not create any invites
-    #   allow = Discordrb::Permissions.new
-    #   allow.can_mention_everyone = true
-    #   allow.can_send_tts_messages = true
+    # @overload define_overwrite(overwrite)
+    #   @param thing [Overwrite] an Overwrite object to apply to this channel
+    #   @param reason [String] The reason the for defining the overwrite.
+    # @overload define_overwrite(thing, allow, deny)
+    #   @param thing [User, Role] What to define an overwrite for.
+    #   @param allow [#bits, Permissions, Integer] The permission sets that should receive an `allow` override (i.e. a
+    #     green checkmark on Discord)
+    #   @param deny [#bits, Permissions, Integer] The permission sets that should receive a `deny` override (i.e. a red
+    #     cross on Discord)
+    #   @param reason [String] The reason the for defining the overwrite.
+    #   @example Define a permission overwrite for a user that can then mention everyone and use TTS, but not create any invites
+    #     allow = Discordrb::Permissions.new
+    #     allow.can_mention_everyone = true
+    #     allow.can_send_tts_messages = true
     #
-    #   deny = Discordrb::Permissions.new
-    #   deny.can_create_instant_invite = true
+    #     deny = Discordrb::Permissions.new
+    #     deny.can_create_instant_invite = true
     #
-    #   channel.define_overwrite(user, allow, deny)
-    def define_overwrite(thing, allow, deny)
-      allow_bits = allow.respond_to?(:bits) ? allow.bits : allow
-      deny_bits = deny.respond_to?(:bits) ? deny.bits : deny
+    #     channel.define_overwrite(user, allow, deny)
+    def define_overwrite(thing, allow = 0, deny = 0, reason: nil)
+      unless thing.is_a? Overwrite
+        allow_bits = allow.respond_to?(:bits) ? allow.bits : allow
+        deny_bits = deny.respond_to?(:bits) ? deny.bits : deny
 
-      type = if thing.is_a?(User) || thing.is_a?(Member) || thing.is_a?(Recipient) || thing.is_a?(Profile)
-               :member
-             elsif thing.is_a? Role
-               :role
-             else
-               raise ArgumentError, '`thing` in define_overwrite needs to be a kind of User (User, Member, Recipient, Profile) or a Role!'
-             end
+        thing = Overwrite.new thing, allow: allow_bits, deny: deny_bits
+      end
 
-      API::Channel.update_permission(@bot.token, @id, thing.id, allow_bits, deny_bits, type)
+      API::Channel.update_permission(@bot.token, @id, thing.id, thing.allow.bits, thing.deny.bits, thing.type, reason)
     end
 
     # Deletes a permission overwrite for this channel
     # @param target [Member, User, Role, Profile, Recipient, #resolve_id] What permission overwrite to delete
-    def delete_overwrite(target)
+    #   @param reason [String] The reason the for the overwrite deletion.
+    def delete_overwrite(target, reason = nil)
       raise 'Tried deleting a overwrite for an invalid target' unless target.is_a?(Member) || target.is_a?(User) || target.is_a?(Role) || target.is_a?(Profile) || target.is_a?(Recipient) || target.respond_to?(:resolve_id)
 
-      API::Channel.delete_permission(@bot.token, @id, target.resolve_id)
+      API::Channel.delete_permission(@bot.token, @id, target.resolve_id, reason)
     end
 
     # Updates the cached data from another channel.
@@ -1313,6 +1767,9 @@ module Discordrb
       @bitrate = other.bitrate
       @user_limit = other.user_limit
       @permission_overwrites = other.permission_overwrites
+      @nsfw = other.nsfw
+      @parent_id = other.parent_id
+      @rate_limit_per_user = other.rate_limit_per_user
     end
 
     # The list of users currently in this channel. For a voice channel, it will return all the members currently
@@ -1333,25 +1790,28 @@ module Discordrb
     #   start at the current message.
     # @param after_id [Integer] The ID of the oldest message the retrieval should start at, or nil if it should start
     #   as soon as possible with the specified amount.
+    # @param around_id [Integer] The ID of the message retrieval should start from, reading in both directions
     # @example Count the number of messages in the last 50 messages that contain the letter 'e'.
     #   message_count = channel.history(50).count {|message| message.content.include? "e"}
+    # @example Get the last 10 messages before the provided message.
+    #   last_ten_messages = channel.history(10, message.id)
     # @return [Array<Message>] the retrieved messages.
-    def history(amount, before_id = nil, after_id = nil)
-      logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id)
+    def history(amount, before_id = nil, after_id = nil, around_id = nil)
+      logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id, around_id)
       JSON.parse(logs).map { |message| Message.new(message, @bot) }
     end
 
-    # Retrieves message history, but only message IDs for use with prune
+    # Retrieves message history, but only message IDs for use with prune.
     # @note For internal use only
     # @!visibility private
-    def history_ids(amount, before_id = nil, after_id = nil)
-      logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id)
+    def history_ids(amount, before_id = nil, after_id = nil, around_id = nil)
+      logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id, around_id)
       JSON.parse(logs).map { |message| message['id'].to_i }
     end
 
     # Returns a single message from this channel's history by ID.
     # @param message_id [Integer] The ID of the message to retrieve.
-    # @return [Message] the retrieved message.
+    # @return [Message, nil] the retrieved message, or `nil` if it couldn't be found.
     def load_message(message_id)
       response = API::Channel.message(@bot.token, @id, message_id)
       return Message.new(JSON.parse(response), @bot)
@@ -1361,7 +1821,7 @@ module Discordrb
 
     alias_method :message, :load_message
 
-    # Requests all pinned messages of a channel.
+    # Requests all pinned messages in a channel.
     # @return [Array<Message>] the received messages.
     def pins
       msgs = API::Channel.pinned_messages(@bot.token, @id)
@@ -1369,22 +1829,41 @@ module Discordrb
     end
 
     # Delete the last N messages on this channel.
-    # @param amount [Integer] How many messages to delete. Must be a value between 2 and 100 (Discord limitation)
+    # @param amount [Integer] The amount of message history to consider for pruning. Must be a value between 2 and 100 (Discord limitation)
     # @param strict [true, false] Whether an error should be raised when a message is reached that is too old to be bulk
     #   deleted. If this is false only a warning message will be output to the console.
     # @raise [ArgumentError] if the amount of messages is not a value between 2 and 100
-    def prune(amount, strict = false)
-      raise ArgumentError, 'Can only prune between 2 and 100 messages!' unless amount.between?(2, 100)
+    # @yield [message] Yields each message in this channels history for filtering the messages to delete
+    # @example Pruning messages from a specific user ID
+    #   channel.prune(100) { |m| m.author.id == 83283213010599936 }
+    # @return [Integer] The amount of messages that were successfully deleted
+    def prune(amount, strict = false, &block)
+      raise ArgumentError, 'Can only delete between 1 and 100 messages!' unless amount.between?(1, 100)
+
+      messages =
+        if block_given?
+          history(amount).select(&block).map(&:id)
+        else
+          history_ids(amount)
+        end
 
-      messages = history_ids(amount)
-      bulk_delete(messages, strict)
+      case messages.size
+      when 0
+        0
+      when 1
+        API::Channel.delete_message(@bot.token, @id, messages.first)
+        1
+      else
+        bulk_delete(messages, strict)
+      end
     end
 
     # Deletes a collection of messages
-    # @param messages [Array<Message, Integer>] the messages (or message IDs) to delete. Total must be an amount between 2 and 100 (Discord limitation)
+    # @param messages [Array<Message, Integer, #resolve_id>] the messages (or message IDs) to delete. Total must be an amount between 2 and 100 (Discord limitation)
     # @param strict [true, false] Whether an error should be raised when a message is reached that is too old to be bulk
     #   deleted. If this is false only a warning message will be output to the console.
     # @raise [ArgumentError] if the amount of messages is not a value between 2 and 100
+    # @return [Integer] The amount of messages that were successfully deleted
     def delete_messages(messages, strict = false)
       raise ArgumentError, 'Can only delete between 2 and 100 messages!' unless messages.count.between?(2, 100)
 
@@ -1402,17 +1881,27 @@ module Discordrb
     # Add an {Await} for a message in this channel. This is identical in functionality to adding a
     # {Discordrb::Events::MessageEvent} await with the `in` attribute as this channel.
     # @see Bot#add_await
+    # @deprecated Will be changed to blocking behavior in v4.0. Use {#await!} instead.
     def await(key, attributes = {}, &block)
       @bot.add_await(key, Discordrb::Events::MessageEvent, { in: @id }.merge(attributes), &block)
     end
 
+    # Add a blocking {Await} for a message in this channel. This is identical in functionality to adding a
+    # {Discordrb::Events::MessageEvent} await with the `in` attribute as this channel.
+    # @see Bot#add_await!
+    def await!(attributes = {})
+      @bot.add_await!(Discordrb::Events::MessageEvent, { in: @id }.merge(attributes))
+    end
+
     # Creates a new invite to this channel.
     # @param max_age [Integer] How many seconds this invite should last.
     # @param max_uses [Integer] How many times this invite should be able to be used.
     # @param temporary [true, false] Whether membership should be temporary (kicked after going offline).
+    # @param unique [true, false] If true, Discord will always send a unique invite instead of possibly re-using a similar one
+    # @param reason [String] The reason the for the creation of this invite.
     # @return [Invite] the created invite.
-    def make_invite(max_age = 0, max_uses = 0, temporary = false)
-      response = API::Channel.create_invite(@bot.token, @id, max_age, max_uses, temporary)
+    def make_invite(max_age = 0, max_uses = 0, temporary = false, unique = false, reason = nil)
+      response = API::Channel.create_invite(@bot.token, @id, max_age, max_uses, temporary, unique, reason)
       Invite.new(JSON.parse(response), @bot)
     end
 
@@ -1421,13 +1910,15 @@ module Discordrb
     # Starts typing, which displays the typing indicator on the client for five seconds.
     # If you want to keep typing you'll have to resend this every five seconds. (An abstraction
     # for this will eventually be coming)
+    # @example Send a typing indicator for the bot in a given channel.
+    #   channel.start_typing()
     def start_typing
       API::Channel.start_typing(@bot.token, @id)
     end
 
     # Creates a Group channel
     # @param user_ids [Array<Integer>] Array of user IDs to add to the new group channel (Excluding
-    # the recipient of the PM channel).
+    #   the recipient of the PM channel).
     # @return [Channel] the created channel.
     def create_group(user_ids)
       raise 'Attempted to create group channel on a non-pm channel!' unless pm?
@@ -1436,7 +1927,7 @@ module Discordrb
       channel.add_group_users(user_ids)
     end
 
-    # Adds a user to a Group channel
+    # Adds a user to a group channel.
     # @param user_ids [Array<#resolve_id>, #resolve_id] User ID or array of user IDs to add to the group channel.
     # @return [Channel] the group channel.
     def add_group_users(user_ids)
@@ -1464,7 +1955,7 @@ module Discordrb
 
     alias_method :remove_group_user, :remove_group_users
 
-    # Leaves the group
+    # Leaves the group.
     def leave_group
       raise 'Attempted to leave a non-group channel!' unless group?
       API::Channel.leave_group(@bot.token, @id)
@@ -1472,7 +1963,23 @@ module Discordrb
 
     alias_method :leave, :leave_group
 
-    # The inspect method is overwritten to give more useful output
+    # Requests a list of Webhooks on the channel.
+    # @return [Array<Webhook>] webhooks on the channel.
+    def webhooks
+      raise 'Tried to request webhooks from a non-server channel' unless server
+      webhooks = JSON.parse(API::Channel.webhooks(@bot.token, @id))
+      webhooks.map { |webhook_data| Webhook.new(webhook_data, @bot) }
+    end
+
+    # Requests a list of Invites to the channel.
+    # @return [Array<Invite>] invites to the channel.
+    def invites
+      raise 'Tried to request invites from a non-server channel' unless server
+      invites = JSON.parse(API::Channel.invites(@bot.token, @id))
+      invites.map { |invite_data| Invite.new(invite_data, @bot) }
+    end
+
+    # The default `inspect` method is overwritten to give more useful output.
     def inspect
       "<Channel name=#{@name} id=#{@id} topic=\"#{@topic}\" type=#{@type} position=#{@position} server=#{@server}>"
     end
@@ -1499,12 +2006,29 @@ module Discordrb
       @recipients.delete(recipient)
     end
 
+    # Updates the cached data with new data
+    # @note For internal use only
+    # @!visibility private
+    def update_data(new_data = nil)
+      new_data ||= JSON.parse(API::Channel.resolve(@bot.token, @id))
+      @name = new_data[:name] || new_data['name'] || @name
+      @topic = new_data[:topic] || new_data['topic'] || @topic
+      @position = new_data[:position] || new_data['position'] || @position
+      @bitrate = new_data[:bitrate] || new_data['bitrate'] || @bitrate
+      @user_limit = new_data[:user_limit] || new_data['user_limit'] || @user_limit
+      new_nsfw = new_data.key?(:nsfw) ? new_data[:nsfw] : new_data['nsfw']
+      @nsfw = new_nsfw.nil? ? @nsfw : new_nsfw
+      @parent_id = new_data[:parent_id] || new_data['parent_id'] || @parent_id
+      process_permission_overwrites(new_data[:permission_overwrites] || new_data['permission_overwrites'])
+      @rate_limit_per_user = new_data[:rate_limit_per_user] || new_data['rate_limit_per_user'] || @rate_limit_per_user
+    end
+
     private
 
     # For bulk_delete checking
     TWO_WEEKS = 86_400 * 14
 
-    # Deletes a list of messages on this channel using bulk delete
+    # Deletes a list of messages on this channel using bulk delete.
     def bulk_delete(ids, strict = false)
       min_snowflake = IDObject.synthesise(Time.now - TWO_WEEKS)
 
@@ -1514,14 +2038,38 @@ module Discordrb
         message = "Attempted to bulk_delete message #{e} which is too old (min = #{min_snowflake})"
         raise ArgumentError, message if strict
         Discordrb::LOGGER.warn(message)
-        false
+        true
       end
 
       API::Channel.bulk_delete_messages(@bot.token, @id, ids)
-    end
-
-    def update_channel_data
-      API::Channel.update(@bot.token, @id, @name, @topic, @position, @bitrate, @user_limit)
+      ids.size
+    end
+
+    def update_channel_data(new_data)
+      new_nsfw = new_data[:nsfw].is_a?(TrueClass) || new_data[:nsfw].is_a?(FalseClass) ? new_nsfw : @nsfw
+      # send permission_overwrite only when explicitly set
+      overwrites = new_data[:permission_overwrites] ? new_data[:permission_overwrites].map { |_, v| v.to_hash } : nil
+      response = JSON.parse(API::Channel.update(@bot.token, @id,
+                                                new_data[:name] || @name,
+                                                new_data[:topic] || @topic,
+                                                new_data[:position] || @position,
+                                                new_data[:bitrate] || @bitrate,
+                                                new_data[:user_limit] || @user_limit,
+                                                new_nsfw,
+                                                overwrites,
+                                                new_data[:parent_id] || @parent_id,
+                                                new_data[:rate_limit_per_user] || @rate_limit_per_user))
+      update_data(response)
+    end
+
+    def process_permission_overwrites(overwrites)
+      # Populate permission overwrites
+      @permission_overwrites = {}
+      return unless overwrites
+      overwrites.each do |element|
+        id = element['id'].to_i
+        @permission_overwrites[id] = Overwrite.from_hash(element)
+      end
     end
   end
 
@@ -1548,15 +2096,34 @@ module Discordrb
     #   * `:image`
     attr_reader :type
 
-    # @return [EmbedProvider, nil] the provider of the embed object. `nil` is there is not a provider
+    # @return [Time, nil] the timestamp of the embed object. `nil` if there is not a timestamp
+    attr_reader :timestamp
+
+    # @return [String, nil] the color of the embed object. `nil` if there is not a color
+    attr_reader :color
+    alias_method :colour, :color
+
+    # @return [EmbedFooter, nil] the footer of the embed object. `nil` if there is not a footer
+    attr_reader :footer
+
+    # @return [EmbedProvider, nil] the provider of the embed object. `nil` if there is not a provider
     attr_reader :provider
 
-    # @return [EmbedThumbnail, nil] the thumbnail of the embed object. `nil` is there is not a thumbnail
+    # @return [EmbedImage, nil] the image of the embed object. `nil` if there is not an image
+    attr_reader :image
+
+    # @return [EmbedThumbnail, nil] the thumbnail of the embed object. `nil` if there is not a thumbnail
     attr_reader :thumbnail
 
-    # @return [EmbedAuthor, nil] the author of the embed object. `nil` is there is not an author
+    # @return [EmbedVideo, nil] the video of the embed object. `nil` if there is not a video
+    attr_reader :video
+
+    # @return [EmbedAuthor, nil] the author of the embed object. `nil` if there is not an author
     attr_reader :author
 
+    # @return [Array<EmbedField>, nil] the fields of the embed object. `nil` if there are no fields
+    attr_reader :fields
+
     # @!visibility private
     def initialize(data, message)
       @message = message
@@ -1565,9 +2132,91 @@ module Discordrb
       @title = data['title']
       @type = data['type'].to_sym
       @description = data['description']
+      @timestamp = data['timestamp'].nil? ? nil : Time.parse(data['timestamp'])
+      @color = data['color']
+      @footer = data['footer'].nil? ? nil : EmbedFooter.new(data['footer'], self)
+      @image = data['image'].nil? ? nil : EmbedImage.new(data['image'], self)
+      @video = data['video'].nil? ? nil : EmbedVideo.new(data['video'], self)
       @provider = data['provider'].nil? ? nil : EmbedProvider.new(data['provider'], self)
       @thumbnail = data['thumbnail'].nil? ? nil : EmbedThumbnail.new(data['thumbnail'], self)
       @author = data['author'].nil? ? nil : EmbedAuthor.new(data['author'], self)
+      @fields = data['fields'].nil? ? nil : data['fields'].map { |field| EmbedField.new(field, self) }
+    end
+  end
+
+  # An Embed footer for the embed object.
+  class EmbedFooter
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @return [String] the footer text.
+    attr_reader :text
+
+    # @return [String] the URL of the footer icon.
+    attr_reader :icon_url
+
+    # @return [String] the proxied URL of the footer icon.
+    attr_reader :proxy_icon_url
+
+    # @!visibility private
+    def initialize(data, embed)
+      @embed = embed
+
+      @text = data['text']
+      @icon_url = data['icon_url']
+      @proxy_icon_url = data['proxy_icon_url']
+    end
+  end
+
+  # An Embed image for the embed object.
+  class EmbedImage
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @return [String] the source URL of the image.
+    attr_reader :url
+
+    # @return [String] the proxy URL of the image.
+    attr_reader :proxy_url
+
+    # @return [Integer] the width of the image, in pixels.
+    attr_reader :width
+
+    # @return [Integer] the height of the image, in pixels.
+    attr_reader :height
+
+    # @!visibility private
+    def initialize(data, embed)
+      @embed = embed
+
+      @url = data['url']
+      @proxy_url = data['proxy_url']
+      @width = data['width']
+      @height = data['height']
+    end
+  end
+
+  # An Embed video for the embed object
+  class EmbedVideo
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @return [String] the source URL of the video.
+    attr_reader :url
+
+    # @return [Integer] the width of the video, in pixels.
+    attr_reader :width
+
+    # @return [Integer] the height of the video, in pixels.
+    attr_reader :height
+
+    # @!visibility private
+    def initialize(data, embed)
+      @embed = embed
+
+      @url = data['url']
+      @width = data['width']
+      @height = data['height']
     end
   end
 
@@ -1580,7 +2229,7 @@ module Discordrb
     attr_reader :url
 
     # @return [String] the thumbnail's proxy URL - I'm not sure what exactly this does, but I think it has something to
-    #   do with CDNs
+    #   do with CDNs.
     attr_reader :proxy_url
 
     # @return [Integer] the width of this thumbnail file, in pixels.
@@ -1608,7 +2257,7 @@ module Discordrb
     # @return [String] the provider's name.
     attr_reader :name
 
-    # @return [String, nil] the URL of the provider. `nil` is there is no URL
+    # @return [String, nil] the URL of the provider, or `nil` if there is no URL.
     attr_reader :url
 
     # @!visibility private
@@ -1628,20 +2277,52 @@ module Discordrb
     # @return [String] the author's name.
     attr_reader :name
 
-    # @return [String, nil] the URL of the author's website. `nil` is there is no URL
+    # @return [String, nil] the URL of the author's website, or `nil` if there is no URL.
     attr_reader :url
 
+    # @return [String, nil] the icon of the author, or `nil` if there is no icon.
+    attr_reader :icon_url
+
+    # @return [String, nil] the Discord proxy URL, or `nil` if there is no `icon_url`.
+    attr_reader :proxy_icon_url
+
     # @!visibility private
     def initialize(data, embed)
       @embed = embed
 
       @name = data['name']
       @url = data['url']
+      @icon_url = data['icon_url']
+      @proxy_icon_url = data['proxy_icon_url']
     end
   end
 
-  # An attachment to a message
-  class Attachment
+  # An Embed field for the embed object
+  class EmbedField
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @return [String] the field's name.
+    attr_reader :name
+
+    # @return [String] the field's value.
+    attr_reader :value
+
+    # @return [true, false] whether this field is inline.
+    attr_reader :inline
+
+    # @!visibility private
+    def initialize(data, embed)
+      @embed = embed
+
+      @name = data['name']
+      @value = data['value']
+      @inline = data['inline']
+    end
+  end
+
+  # An attachment to a message
+  class Attachment
     include IDObject
 
     # @return [Message] the message this attachment belongs to.
@@ -1651,7 +2332,7 @@ module Discordrb
     attr_reader :url
 
     # @return [String] the attachment's proxy URL - I'm not sure what exactly this does, but I think it has something to
-    #   do with CDNs
+    #   do with CDNs.
     attr_reader :proxy_url
 
     # @return [String] the attachment's filename.
@@ -1660,10 +2341,10 @@ module Discordrb
     # @return [Integer] the attachment's file size in bytes.
     attr_reader :size
 
-    # @return [Integer, nil] the width of an image file, in pixels, or nil if the file is not an image.
+    # @return [Integer, nil] the width of an image file, in pixels, or `nil` if the file is not an image.
     attr_reader :width
 
-    # @return [Integer, nil] the height of an image file, in pixels, or nil if the file is not an image.
+    # @return [Integer, nil] the height of an image file, in pixels, or `nil` if the file is not an image.
     attr_reader :height
 
     # @!visibility private
@@ -1671,6 +2352,7 @@ module Discordrb
       @bot = bot
       @message = message
 
+      @id = data['id'].to_i
       @url = data['url']
       @proxy_url = data['proxy_url']
       @filename = data['filename']
@@ -1724,14 +2406,14 @@ module Discordrb
     # @return [Array<Embed>] the embed objects contained in this message.
     attr_reader :embeds
 
-    # @return [Hash<String, Reaction>] the reaction objects attached to this message keyed by the name of the reaction
+    # @return [Hash<String => Reaction>] the reaction objects attached to this message keyed by the name of the reaction
     attr_reader :reactions
 
     # @return [true, false] whether the message used Text-To-Speech (TTS) or not.
     attr_reader :tts
     alias_method :tts?, :tts
 
-    # @return [String] used for validating a message was sent
+    # @return [String] used for validating a message was sent.
     attr_reader :nonce
 
     # @return [true, false] whether the message was edited or not.
@@ -1747,7 +2429,7 @@ module Discordrb
     attr_reader :pinned
     alias_method :pinned?, :pinned
 
-    # @return [Integer, nil] the webhook ID that sent this message, or nil if it wasn't sent through a webhook.
+    # @return [Integer, nil] the webhook ID that sent this message, or `nil` if it wasn't sent through a webhook.
     attr_reader :webhook_id
 
     # The discriminator that webhook user accounts have.
@@ -1778,7 +2460,7 @@ module Discordrb
 
                     unless member
                       Discordrb::LOGGER.debug("Member with ID #{data['author']['id']} not cached (possibly left the server).")
-                      member = @bot.user(data['author']['id'].to_i)
+                      member = @bot.ensure_user(data['author'])
                     end
 
                     member
@@ -1837,7 +2519,7 @@ module Discordrb
     # Edits this message to have the specified content instead.
     # You can only edit your own messages.
     # @param new_content [String] the new content the message should have.
-    # @param new_embed [Hash, Discordrb::Webhooks::Embed, nil] The new embed the message should have. If nil the message will be changed to have no embed.
+    # @param new_embed [Hash, Discordrb::Webhooks::Embed, nil] The new embed the message should have. If `nil` the message will be changed to have no embed.
     # @return [Message] the resulting message.
     def edit(new_content, new_embed = nil)
       response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content, [], new_embed ? new_embed.to_hash : nil)
@@ -1866,10 +2548,17 @@ module Discordrb
 
     # Add an {Await} for a message with the same user and channel.
     # @see Bot#add_await
+    # @deprecated Will be changed to blocking behavior in v4.0. Use {#await!} instead.
     def await(key, attributes = {}, &block)
       @bot.add_await(key, Discordrb::Events::MessageEvent, { from: @author.id, in: @channel.id }.merge(attributes), &block)
     end
 
+    # Add a blocking {Await} for a message with the same user and channel.
+    # @see Bot#add_await!
+    def await!(attributes = {})
+      @bot.add_await!(Discordrb::Events::MessageEvent, { from: @author.id, in: @channel.id }.merge(attributes))
+    end
+
     # @return [true, false] whether this message was sent by the current {Bot}.
     def from_bot?
       @author && @author.current_bot?
@@ -1884,11 +2573,11 @@ module Discordrb
     # @return [Array<String>] the emoji mentions found in the message
     def scan_for_emoji
       emoji = @content.split
-      emoji = emoji.grep(/<:(?<name>\w+):(?<id>\d+)>?/)
+      emoji = emoji.grep(/<(?<animated>a)?:(?<name>\w+):(?<id>\d+)>?/)
       emoji
     end
 
-    # @return [Array<Emoji>] the emotes that were used/mentioned in this message (Only returns Emoji the bot has access to, else nil).
+    # @return [Array<Emoji>] the emotes that were used/mentioned in this message.
     def emoji
       return if @content.nil?
 
@@ -1899,27 +2588,27 @@ module Discordrb
       @emoji
     end
 
-    # Check if any emoji got used in this message
-    # @return [true, false] whether or not any emoji got used
+    # Check if any emoji were used in this message.
+    # @return [true, false] whether or not any emoji were used
     def emoji?
       emoji = scan_for_emoji
       return true unless emoji.empty?
     end
 
-    # Check if any reactions got used in this message
+    # Check if any reactions were used in this message.
     # @return [true, false] whether or not this message has reactions
     def reactions?
       @reactions.any?
     end
 
-    # Returns the reactions made by the current bot or user
+    # Returns the reactions made by the current bot or user.
     # @return [Array<Reaction>] the reactions
     def my_reactions
-      @reactions.select(&:me)
+      @reactions.values.select(&:me)
     end
 
-    # Reacts to a message
-    # @param [String, #to_reaction] the unicode emoji, Emoji, or GlobalEmoji
+    # Reacts to a message.
+    # @param reaction [String, #to_reaction] the unicode emoji or {Emoji}
     def create_reaction(reaction)
       reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
       API::Channel.create_reaction(@bot.token, @channel.id, @id, reaction)
@@ -1928,8 +2617,10 @@ module Discordrb
 
     alias_method :react, :create_reaction
 
-    # Returns the list of users who reacted with a certain reaction
-    # @param [String, #to_reaction] the unicode emoji, Emoji, or GlobalEmoji
+    # Returns the list of users who reacted with a certain reaction.
+    # @param reaction [String, #to_reaction] the unicode emoji or {Emoji}
+    # @example Get all the users that reacted with a thumbsup.
+    #   thumbs_up_reactions = message.reacted_with("\u{1F44D}")
     # @return [Array<User>] the users who used this reaction
     def reacted_with(reaction)
       reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
@@ -1937,22 +2628,22 @@ module Discordrb
       response.map { |d| User.new(d, @bot) }
     end
 
-    # Deletes a reaction made by a user on this message
-    # @param [User, #resolve_id] the user who used this reaction
-    # @param [String, #to_reaction] the reaction to remove
+    # Deletes a reaction made by a user on this message.
+    # @param user [User, #resolve_id] the user who used this reaction
+    # @param reaction [String, #to_reaction] the reaction to remove
     def delete_reaction(user, reaction)
       reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
       API::Channel.delete_user_reaction(@bot.token, @channel.id, @id, reaction, user.resolve_id)
     end
 
-    # Delete's this clients reaction on this message
-    # @param [String, #to_reaction] the reaction to remove
+    # Deletes this client's reaction on this message.
+    # @param reaction [String, #to_reaction] the reaction to remove
     def delete_own_reaction(reaction)
       reaction = reaction.to_reaction if reaction.respond_to?(:to_reaction)
       API::Channel.delete_own_reaction(@bot.token, @channel.id, @id, reaction)
     end
 
-    # Removes all reactions from this message
+    # Removes all reactions from this message.
     def delete_all_reactions
       API::Channel.delete_all_reactions(@bot.token, @channel.id, @id)
     end
@@ -1963,7 +2654,7 @@ module Discordrb
     end
   end
 
-  # A reaction to a message
+  # A reaction to a message.
   class Reaction
     # @return [Integer] the amount of users who have reacted with this reaction
     attr_reader :count
@@ -1984,6 +2675,13 @@ module Discordrb
       @id = data['emoji']['id'].nil? ? nil : data['emoji']['id'].to_i
       @name = data['emoji']['name']
     end
+
+    # Converts this Reaction into a string that can be sent back to Discord in other reaction endpoints.
+    # If ID is present, it will be rendered into the form of `name:id`.
+    # @return [String] the name of this reaction, including the ID if it is a custom emoji
+    def to_s
+      id.nil? ? name : "#{name}:#{id}"
+    end
   end
 
   # Server emoji
@@ -1999,6 +2697,10 @@ module Discordrb
     # @return [Array<Role>] roles this emoji is active for
     attr_reader :roles
 
+    # @return [true, false] if the emoji is animated
+    attr_reader :animated
+    alias_method :animated?, :animated
+
     def initialize(data, bot, server)
       @bot = bot
       @roles = nil
@@ -2006,13 +2708,14 @@ module Discordrb
       @name = data['name']
       @server = server
       @id = data['id'].nil? ? nil : data['id'].to_i
+      @animated = data['animated']
 
       process_roles(data['roles']) if server
     end
 
     # @return [String] the layout to mention it (or have it used) in a message
     def mention
-      "<:#{@name}:#{@id}>"
+      "<#{'a' if animated}:#{name}:#{id}>"
     end
 
     alias_method :use, :mention
@@ -2020,17 +2723,17 @@ module Discordrb
 
     # @return [String] the layout to use this emoji in a reaction
     def to_reaction
-      "#{@name}:#{@id}"
+      "#{name}:#{id}"
     end
 
     # @return [String] the icon URL of the emoji
     def icon_url
-      API.emoji_icon_url(@id)
+      API.emoji_icon_url(id)
     end
 
     # The inspect method is overwritten to give more useful output
     def inspect
-      "<Emoji name=#{@name} id=#{@id}>"
+      "<Emoji name=#{name} id=#{id} animated=#{animated}>"
     end
 
     # @!visibility private
@@ -2044,61 +2747,6 @@ module Discordrb
     end
   end
 
-  # Emoji that is not tailored to a server
-  class GlobalEmoji
-    include IDObject
-
-    # @return [String] the emoji name
-    attr_reader :name
-
-    # @return [Hash<Integer => Array<Role>>] roles this emoji is active for in every server
-    attr_reader :role_associations
-
-    def initialize(data, bot)
-      @bot = bot
-      @roles = nil
-
-      @name = data.name
-      @id = data.id
-      @role_associations = Hash.new([])
-      @role_associations[data.server.id] = data.roles
-    end
-
-    # @return [String] the layout to mention it (or have it used) in a message
-    def mention
-      "<:#{@name}:#{@id}>"
-    end
-
-    alias_method :use, :mention
-    alias_method :to_s, :mention
-
-    # @return [String] the layout to use this emoji in a reaction
-    def to_reaction
-      "#{@name}:#{@id}"
-    end
-
-    # @return [String] the icon URL of the emoji
-    def icon_url
-      API.emoji_icon_url(@id)
-    end
-
-    # The inspect method is overwritten to give more useful output
-    def inspect
-      "<GlobalEmoji name=#{@name} id=#{@id}>"
-    end
-
-    # @!visibility private
-    def process_roles(roles)
-      new_roles = []
-      return unless roles
-      roles.each do
-        role = server.role(role_id)
-        new_roles << role
-      end
-      new_roles
-    end
-  end
-
   # Basic attributes a server should have
   module ServerAttributes
     # @return [String] this server's name.
@@ -2149,7 +2797,7 @@ module Discordrb
     attr_reader :emoticon
     alias_method :emoticon?, :emoticon
 
-    # @return [String] the integration type (Youtube, Twitch, etc.)
+    # @return [String] the integration type (YouTube, Twitch, etc.)
     attr_reader :type
 
     # @return [true, false] whether the integration is enabled
@@ -2182,7 +2830,7 @@ module Discordrb
       @type = data['type']
       @account = IntegrationAccount.new(data['account'])
       @synced_at = Time.parse(data['synced_at'])
-      @expire_behaviour = [:remove, :kick][data['expire_behavior']]
+      @expire_behaviour = %i[remove kick][data['expire_behavior']]
       @expire_grace_period = data['expire_grace_period']
       @user = @bot.ensure_user(data['user'])
       @role = server.role(data['role_id']) || nil
@@ -2200,8 +2848,8 @@ module Discordrb
     include IDObject
     include ServerAttributes
 
-    # @return [String] the region the server is on (e. g. `amsterdam`).
-    attr_reader :region
+    # @return [String] the ID of the region the server is on (e.g. `amsterdam`).
+    attr_reader :region_id
 
     # @return [Member] The server owner.
     attr_reader :owner
@@ -2212,7 +2860,7 @@ module Discordrb
     # @return [Array<Role>] an array of all the roles created on this server.
     attr_reader :roles
 
-    # @return [Hash<Integer, Emoji>] a hash of all the emoji available on this server.
+    # @return [Hash<Integer => Emoji>] a hash of all the emoji available on this server.
     attr_reader :emoji
     alias_method :emojis, :emoji
 
@@ -2227,15 +2875,9 @@ module Discordrb
     # @return [Integer] the absolute number of members on this server, offline or not.
     attr_reader :member_count
 
-    # @return [Symbol] the verification level of the server (:none = none, :low = 'Must have a verified email on their Discord account', :medium = 'Has to be registered with Discord for at least 5 minutes', :high = 'Has to be a member of this server for at least 10 minutes').
-    attr_reader :verification_level
-
     # @return [Integer] the amount of time after which a voice user gets moved into the AFK channel, in seconds.
     attr_reader :afk_timeout
 
-    # @return [Channel, nil] the AFK voice channel of this server, or nil if none is set
-    attr_reader :afk_channel
-
     # @return [Hash<Integer => VoiceState>] the hash (user ID => voice state) of voice states of members on this server
     attr_reader :voice_states
 
@@ -2244,13 +2886,13 @@ module Discordrb
       @bot = bot
       @owner_id = data['owner_id'].to_i
       @id = data['id'].to_i
+
+      process_channels(data['channels'])
       update_data(data)
 
       @large = data['large']
       @member_count = data['member_count']
-      @verification_level = [:none, :low, :medium, :high][data['verification_level']]
       @splash_id = nil
-      @embed = nil
       @features = data['features'].map { |element| element.downcase.to_sym }
       @members = {}
       @voice_states = {}
@@ -2260,24 +2902,38 @@ module Discordrb
       process_emoji(data['emojis'])
       process_members(data['members'])
       process_presences(data['presences'])
-      process_channels(data['channels'])
       process_voice_states(data['voice_states'])
 
       # Whether this server's members have been chunked (resolved using op 8 and GUILD_MEMBERS_CHUNK) yet
       @chunked = false
       @processed_chunk_members = 0
 
-      # Only get the owner of the server actually exists (i. e. not for ServerDeleteEvent)
+      # Only get the owner of the server actually exists (i.e. not for ServerDeleteEvent)
       @owner = member(@owner_id) if exists
     end
 
-    # @return [Channel] The default channel on this server (usually called #general)
-    def default_channel
-      @bot.channel(@id)
+    # The default channel is the text channel on this server with the highest position
+    # that the bot has Read Messages permission on.
+    # @param send_messages [true, false] whether to additionally consider if the bot has Send Messages permission
+    # @return [Channel, nil] The default channel on this server, or `nil` if there are no channels that the bot can read.
+    def default_channel(send_messages = false)
+      bot_member = member(@bot.profile)
+      text_channels.sort_by { |e| [e.position, e.id] }.find do |e|
+        if send_messages
+          bot_member.can_read_messages?(e) && bot_member.can_send_messages?(e)
+        else
+          bot_member.can_read_messages?(e)
+        end
+      end
     end
 
     alias_method :general_channel, :default_channel
 
+    # @return [Role] The @everyone role on this server
+    def everyone_role
+      role(@id)
+    end
+
     # Gets a role on this server based on its ID.
     # @param id [Integer, String, #resolve_id] The role ID to look for.
     def role(id)
@@ -2294,7 +2950,7 @@ module Discordrb
       return nil unless request
 
       member = @bot.member(self, id)
-      @members[id] = member
+      @members[id] = member unless member.nil?
     rescue
       nil
     end
@@ -2317,19 +2973,92 @@ module Discordrb
       integration.map { |element| Integration.new(element, @bot, self) }
     end
 
+    # @param action [Symbol] The action to only include.
+    # @param user [User, #resolve_id] The user to filter entries to.
+    # @param limit [Integer] The amount of entries to limit it to.
+    # @param before [Entry, #resolve_id] The entry to use to not include all entries after it.
+    # @return [AuditLogs] The server's audit logs.
+    def audit_logs(action: nil, user: nil, limit: 50, before: nil)
+      raise 'Invalid audit log action!' if action && AuditLogs::Actions.key(action).nil?
+      action = AuditLogs::Actions.key(action)
+      user = user.resolve_id if user
+      before = before.resolve_id if before
+      AuditLogs.new(self, @bot, JSON.parse(API::Server.audit_logs(@bot.token, @id, limit, user, action, before)))
+    end
+
     # Cache @embed
     # @note For internal use only
     # @!visibility private
-    def cache_embed
-      @embed ||= JSON.parse(API::Server.resolve(@bot.token, @id))['embed_enabled']
+    def cache_embed_data
+      data = JSON.parse(API::Server.embed(@bot.token, @id))
+      @embed_enabled = data['enabled']
+      @embed_channel_id = data['channel_id']
     end
 
     # @return [true, false] whether or not the server has widget enabled
-    def embed?
-      cache_embed if @embed.nil?
-      @embed
+    def embed_enabled?
+      cache_embed_data if @embed_enabled.nil?
+      @embed_enabled
+    end
+    alias_method :widget_enabled, :embed_enabled?
+    alias_method :widget?, :embed_enabled?
+    alias_method :embed?, :embed_enabled?
+
+    # @return [Channel, nil] the channel the server embed will make an invite for.
+    def embed_channel
+      cache_embed_data if @embed_enabled.nil?
+      @bot.channel(@embed_channel_id) if @embed_channel_id
+    end
+    alias_method :widget_channel, :embed_channel
+
+    # Sets whether this server's embed (widget) is enabled
+    # @param value [true, false]
+    def embed_enabled=(value)
+      modify_embed(value, embed_channel)
     end
 
+    alias_method :widget_enabled=, :embed_enabled=
+
+    # Sets whether this server's embed (widget) is enabled
+    # @param value [true, false]
+    # @param reason [String, nil] the reason to be shown in the audit log for this action
+    def set_embed_enabled(value, reason = nil)
+      modify_embed(value, embed_channel, reason)
+    end
+
+    alias_method :set_widget_enabled, :set_embed_enabled
+
+    # Changes the channel on the server's embed (widget)
+    # @param channel [Channel, String, Integer, #resolve_id] the channel to be referenced by the embed
+    def embed_channel=(channel)
+      modify_embed(embed?, channel)
+    end
+
+    alias_method :widget_channel=, :embed_channel=
+
+    # Changes the channel on the server's embed (widget)
+    # @param channel [Channel, String, Integer, #resolve_id] the channel to be referenced by the embed
+    # @param reason [String, nil] the reason to be shown in the audit log for this action
+    def set_embed_channel(channel, reason = nil)
+      modify_embed(embed?, channel, reason)
+    end
+
+    alias_method :set_widget_channel, :set_embed_channel
+
+    # Changes the channel on the server's embed (widget), and sets whether it is enabled.
+    # @param enabled [true, false] whether the embed (widget) is enabled
+    # @param channel [Channel, String, Integer, #resolve_id] the channel to be referenced by the embed
+    # @param reason [String, nil] the reason to be shown in the audit log for this action
+    def modify_embed(enabled, channel, reason = nil)
+      cache_embed_data if @embed_enabled.nil?
+      channel_id = channel ? channel.resolve_id : @embed_channel_id
+      response = JSON.parse(API::Server.modify_embed(@bot.token, @id, enabled, channel_id, reason))
+      @embed_enabled = response['enabled']
+      @embed_channel_id = response['channel_id']
+    end
+
+    alias_method :modify_widget, :modify_embed
+
     # @param include_idle [true, false] Whether to count idle members as online.
     # @param include_bots [true, false] Whether to include bot accounts in the count.
     # @return [Array<Member>] an array of online members on this server.
@@ -2341,6 +3070,49 @@ module Discordrb
 
     alias_method :online_users, :online_members
 
+    # Adds a member to this guild that has granted this bot's application an OAuth2 access token
+    # with the `guilds.join` scope.
+    # For more information about Discord's OAuth2 implementation, see: https://discordapp.com/developers/docs/topics/oauth2
+    # @note Your bot must be present in this server, and have permission to create instant invites for this to work.
+    # @param user [Integer, User, #resolve_id] the user, or ID of the user to add to this server
+    # @param access_token [String] the OAuth2 Bearer token that has been granted the `guilds.join` scope
+    # @param nick [String] the nickname to give this member upon joining
+    # @param roles [Role, Array<Integer, Role, #resolve_id>] the role (or roles) to give this member upon joining
+    # @param deaf [true, false] whether this member will be server deafened upon joining
+    # @param mute [true, false] whether this member will be server muted upon joining
+    # @return [Member] the created member
+    def add_member_using_token(user, access_token, nick: nil, roles: [], deaf: false, mute: false)
+      user_id = user.resolve_id
+      roles = roles.is_a?(Array) ? roles.map(&:resolve_id) : [roles.resolve_id]
+      response = JSON.parse(API::Server.add_member(@bot.token, @id, user_id, access_token, nick, roles, deaf, mute))
+      add_member Member.new(response, self, @bot)
+    end
+
+    # Returns the amount of members that are candidates for pruning
+    # @param days [Integer] the number of days to consider for inactivity
+    # @return [Integer] number of members to be removed
+    # @raise [ArgumentError] if days is not between 1 and 30 (inclusive)
+    def prune_count(days)
+      raise ArgumentError, 'Days must be between 1 and 30' unless days.between?(1, 30)
+
+      response = JSON.parse API::Server.prune_count(@bot.token, @id, days)
+      response['pruned']
+    end
+
+    # Prunes (kicks) an amount of members for inactivity
+    # @param days [Integer] the number of days to consider for inactivity (between 1 and 30)
+    # @param reason [String] The reason the for the prune.
+    # @return [Integer] the number of members removed at the end of the operation
+    # @raise [ArgumentError] if days is not between 1 and 30 (inclusive)
+    def begin_prune(days, reason = nil)
+      raise ArgumentError, 'Days must be between 1 and 30' unless days.between?(1, 30)
+
+      response = JSON.parse API::Server.begin_prune(@bot.token, @id, days, reason)
+      response['pruned']
+    end
+
+    alias_method :prune, :begin_prune
+
     # @return [Array<Channel>] an array of text channels on this server
     def text_channels
       @channels.select(&:text?)
@@ -2351,11 +3123,21 @@ module Discordrb
       @channels.select(&:voice?)
     end
 
+    # @return [Array<Channel>] an array of category channels on this server
+    def categories
+      @channels.select(&:category?)
+    end
+
+    # @return [Array<Channel>] an array of channels on this server that are not in a category
+    def orphan_channels
+      @channels.reject { |c| c.parent || c.category? }
+    end
+
     # @return [String, nil] the widget URL to the server that displays the amount of online members in a
     #   stylish way. `nil` if the widget is not enabled.
     def widget_url
-      cache_embed if @embed.nil?
-      return nil unless @embed
+      update_data if @embed_enabled.nil?
+      return unless @embed_enabled
       API.widget_url(@id)
     end
 
@@ -2368,8 +3150,8 @@ module Discordrb
     # @return [String, nil] the widget banner URL to the server that displays the amount of online members,
     #   server icon and server name in a stylish way. `nil` if the widget is not enabled.
     def widget_banner_url(style)
-      return nil unless @embed
-      cache_embed if @embed.nil?
+      update_data if @embed_enabled.nil?
+      return unless @embed_enabled
       API.widget_url(@id, style)
     end
 
@@ -2408,12 +3190,23 @@ module Discordrb
       end
     end
 
+    # Updates the positions of all roles on the server
+    # @note For internal use only
+    # @!visibility private
+    def update_role_positions(role_positions)
+      response = JSON.parse(API::Server.update_role_positions(@bot.token, @id, role_positions))
+      response.each do |data|
+        updated_role = Role.new(data, @bot, self)
+        role(updated_role.id).update_from(updated_role)
+      end
+    end
+
     # Adds a member to the member cache.
     # @note For internal use only
     # @!visibility private
     def add_member(member)
-      @members[member.id] = member
       @member_count += 1
+      @members[member.id] = member
     end
 
     # Removes a member from the member cache.
@@ -2466,50 +3259,89 @@ module Discordrb
     end
 
     # Creates a channel on this server with the given name.
+    # @note If parent is provided, permission overwrites have the follow behavior:
+    #
+    #  1. If overwrites is null, the new channel inherits the parent's permissions.
+    #  2. If overwrites is [], the new channel inherits the parent's permissions.
+    #  3. If you supply one or more overwrites, the channel will be created with those permissions and ignore the parents.
+    #
     # @param name [String] Name of the channel to create
-    # @param type [Integer] Type of channel to create (0: text, 2: voice)
+    # @param type [Integer, Symbol] Type of channel to create (0: text, 2: voice, 4: category)
+    # @param topic [String] the topic of this channel, if it will be a text channel
+    # @param bitrate [Integer] the bitrate of this channel, if it will be a voice channel
+    # @param user_limit [Integer] the user limit of this channel, if it will be a voice channel
+    # @param permission_overwrites [Array<Hash>, Array<Overwrite>] permission overwrites for this channel
+    # @param parent [Channel, #resolve_id] parent category for this channel to be created in.
+    # @param nsfw [true, false] whether this channel should be created as nsfw
+    # @param rate_limit_per_user [Integer] how many seconds users need to wait in between messages.
+    # @param reason [String] The reason the for the creation of this channel.
     # @return [Channel] the created channel.
-    # @raise [ArgumentError] if type is not 0 or 2
-    def create_channel(name, type = 0)
-      raise ArgumentError, 'Channel type must be either 0 (text) or 2 (voice)!' unless [0, 2].include?(type)
-      response = API::Server.create_channel(@bot.token, @id, name, type)
+    # @raise [ArgumentError] if type is not 0 (text), 2 (voice), or 4 (category)
+    def create_channel(name, type = 0, topic: nil, bitrate: nil, user_limit: nil, permission_overwrites: nil, parent: nil, nsfw: false, rate_limit_per_user: nil, reason: nil)
+      type = Channel::TYPES[type] if type.is_a?(Symbol)
+      raise ArgumentError, 'Channel type must be either 0 (text), 2 (voice), or 4 (category)!' unless [0, 2, 4].include?(type)
+      permission_overwrites.map! { |e| e.is_a?(Overwrite) ? e.to_hash : e } if permission_overwrites.is_a?(Array)
+      parent_id = parent.respond_to?(:resolve_id) ? parent.resolve_id : nil
+      response = API::Server.create_channel(@bot.token, @id, name, type, topic, bitrate, user_limit, permission_overwrites, parent_id, nsfw, rate_limit_per_user, reason)
       Channel.new(JSON.parse(response), @bot)
     end
 
-    # Creates a role on this server which can then be modified. It will be initialized (on Discord's side)
-    # with the regular role defaults the client uses, i. e. name is "new role", permissions are the default,
-    # colour is the default etc.
+    # Creates a role on this server which can then be modified. It will be initialized
+    # with the regular role defaults the client uses unless specified, i.e. name is "new role",
+    # permissions are the default, colour is the default etc.
+    # @param name [String] Name of the role to create
+    # @param colour [Integer, ColourRGB, #combined] The roles colour
+    # @param hoist [true, false]
+    # @param mentionable [true, false]
+    # @param permissions [Integer, Array<Symbol>, Permissions, #bits] The permissions to write to the new role.
+    # @param reason [String] The reason the for the creation of this role.
     # @return [Role] the created role.
-    def create_role
-      response = API::Server.create_role(@bot.token, @id)
+    def create_role(name: 'new role', colour: 0, hoist: false, mentionable: false, permissions: 104_324_161, reason: nil)
+      colour = colour.respond_to?(:combined) ? colour.combined : colour
+
+      permissions = if permissions.is_a?(Array)
+                      Permissions.bits(permissions)
+                    elsif permissions.respond_to?(:bits)
+                      permissions.bits
+                    else
+                      permissions
+                    end
+
+      response = API::Server.create_role(@bot.token, @id, name, colour, hoist, mentionable, permissions, reason)
+
       role = Role.new(JSON.parse(response), @bot, self)
       @roles << role
       role
     end
 
-    # @return [Array<User>] a list of banned users on this server.
+    # @return [Array<ServerBan>] a list of banned users on this server and the reason they were banned.
     def bans
-      users = JSON.parse(API::Server.bans(@bot.token, @id))
-      users.map { |e| User.new(e['user'], @bot) }
+      response = JSON.parse(API::Server.bans(@bot.token, @id))
+      response.map do |e|
+        ServerBan.new(self, User.new(e['user'], @bot), e['reason'])
+      end
     end
 
     # Bans a user from this server.
     # @param user [User, #resolve_id] The user to ban.
     # @param message_days [Integer] How many days worth of messages sent by the user should be deleted.
-    def ban(user, message_days = 0)
-      API::Server.ban_user(@bot.token, @id, user.resolve_id, message_days)
+    # @param reason [String] The reason the user is being banned.
+    def ban(user, message_days = 0, reason: nil)
+      API::Server.ban_user(@bot.token, @id, user.resolve_id, message_days, reason)
     end
 
     # Unbans a previously banned user from this server.
     # @param user [User, #resolve_id] The user to unban.
-    def unban(user)
-      API::Server.unban_user(@bot.token, @id, user.resolve_id)
+    # @param reason [String] The reason the user is being unbanned.
+    def unban(user, reason = nil)
+      API::Server.unban_user(@bot.token, @id, user.resolve_id, reason)
     end
 
     # Kicks a user from this server.
     # @param user [User, #resolve_id] The user to kick.
-    def kick(user)
-      API::Server.remove_member(@bot.token, @id, user.resolve_id)
+    # @param reason [String] The reason the user is being kicked.
+    def kick(user, reason = nil)
+      API::Server.remove_member(@bot.token, @id, user.resolve_id, reason)
     end
 
     # Forcibly moves a user into a different voice channel. Only works if the bot has the permission needed.
@@ -2524,7 +3356,7 @@ module Discordrb
       API::Server.delete(@bot.token, @id)
     end
 
-    # Leave the server
+    # Leave the server.
     def leave
       API::User.leave_server(@bot.token, @id)
     end
@@ -2541,6 +3373,22 @@ module Discordrb
       update_server_data(name: name)
     end
 
+    # @return [Array<VoiceRegion>] collection of available voice regions to this guild
+    def available_voice_regions
+      return @available_voice_regions if @available_voice_regions
+
+      @available_voice_regions = {}
+
+      data = JSON.parse API::Server.regions(@bot.token, @id)
+      @available_voice_regions = data.map { |e| VoiceRegion.new e }
+    end
+
+    # @return [VoiceRegion, nil] voice region data for this server's region
+    # @note This may return `nil` if this server's voice region is deprecated.
+    def region
+      available_voice_regions.find { |e| e.id == @region_id }
+    end
+
     # Moves the server to another region. This will cause a voice interruption of at most a second.
     # @param region [String] The new region the server should be in.
     def region=(region)
@@ -2553,9 +3401,9 @@ module Discordrb
       if icon.respond_to? :read
         icon_string = 'data:image/jpg;base64,'
         icon_string += Base64.strict_encode64(icon.read)
-        update_server_data(icon: icon_string)
+        update_server_data(icon_id: icon_string)
       else
-        update_server_data(icon: icon)
+        update_server_data(icon_id: icon)
       end
     end
 
@@ -2565,12 +3413,89 @@ module Discordrb
       update_server_data(afk_channel_id: afk_channel.resolve_id)
     end
 
+    # Sets the server's system channel.
+    # @param system_channel [Channel, String, Integer, #resolve_id, nil] The new system channel, or `nil` should it be disabled.
+    def system_channel=(system_channel)
+      update_server_data(system_channel_id: system_channel.resolve_id)
+    end
+
     # Sets the amount of time after which a user gets moved into the AFK channel.
     # @param afk_timeout [Integer] The AFK timeout, in seconds.
     def afk_timeout=(afk_timeout)
       update_server_data(afk_timeout: afk_timeout)
     end
 
+    # A map of possible server verification levels to symbol names
+    VERIFICATION_LEVELS = {
+      none: 0,
+      low: 1,
+      medium: 2,
+      high: 3,
+      very_high: 4
+    }.freeze
+
+    # @return [Symbol] the verification level of the server (:none = none, :low = 'Must have a verified email on their Discord account', :medium = 'Has to be registered with Discord for at least 5 minutes', :high = 'Has to be a member of this server for at least 10 minutes', :very_high = 'Must have a verified phone on their Discord account').
+    def verification_level
+      VERIFICATION_LEVELS.key @verification_level
+    end
+
+    # Sets the verification level of the server
+    # @param level [Integer, Symbol] The verification level from 0-4 or Symbol (see {VERIFICATION_LEVELS})
+    def verification_level=(level)
+      level = VERIFICATION_LEVELS[level] if level.is_a?(Symbol)
+
+      update_server_data(verification_level: level)
+    end
+
+    # A map of possible message notification levels to symbol names
+    NOTIFICATION_LEVELS = {
+      all_messages: 0,
+      only_mentions: 1
+    }.freeze
+
+    # @return [Symbol] the default message notifications settings of the server (:all = 'All messages', :mentions = 'Only @mentions').
+    def default_message_notifications
+      NOTIFICATION_LEVELS.key @default_message_notifications
+    end
+
+    # Sets the default message notification level
+    # @param notification_level [Integer, Symbol] The default message notificiation 0-1 or Symbol (see {NOTIFICATION_LEVELS})
+    def default_message_notifications=(notification_level)
+      notification_level = NOTIFICATION_LEVELS[notification_level] if notification_level.is_a?(Symbol)
+
+      update_server_data(default_message_notifications: notification_level)
+    end
+
+    alias_method :notification_level=, :default_message_notifications=
+
+    # Sets the server splash
+    # @param splash_hash [String] The splash hash
+    def splash=(splash_hash)
+      update_server_data(splash: splash_hash)
+    end
+
+    # A map of possible content filter levels to symbol names
+    FILTER_LEVELS = {
+      disabled: 0,
+      members_without_roles: 1,
+      all_members: 2
+    }.freeze
+
+    # @return [Symbol] the explicit content filter level of the server (:none = 'Don't scan any messages.', :exclude_roles = 'Scan messages for members without a role.', :all = 'Scan messages sent by all members.').
+    def explicit_content_filter
+      FILTER_LEVELS.key @explicit_content_filter
+    end
+
+    alias_method :content_filter_level, :explicit_content_filter
+
+    # Sets the server content filter.
+    # @param filter_level [Integer, Symbol] The content filter from 0-2 or Symbol (see {FILTER_LEVELS})
+    def explicit_content_filter=(filter_level)
+      filter_level = FILTER_LEVELS[filter_level] if filter_level.is_a?(Symbol)
+
+      update_server_data(explicit_content_filter: filter_level)
+    end
+
     # @return [true, false] whether this server has any emoji or not.
     def any_emoji?
       @emoji.any?
@@ -2579,6 +3504,20 @@ module Discordrb
     alias_method :has_emoji?, :any_emoji?
     alias_method :emoji?, :any_emoji?
 
+    # Requests a list of Webhooks on the server.
+    # @return [Array<Webhook>] webhooks on the server.
+    def webhooks
+      webhooks = JSON.parse(API::Server.webhooks(@bot.token, @id))
+      webhooks.map { |webhook| Webhook.new(webhook, @bot) }
+    end
+
+    # Requests a list of Invites to the server.
+    # @return [Array<Invite>] invites to the server.
+    def invites
+      invites = JSON.parse(API::Server.invites(@bot.token, @id))
+      invites.map { |invite| Invite.new(invite, @bot) }
+    end
+
     # Processes a GUILD_MEMBERS_CHUNK packet, specifically the members field
     # @note For internal use only
     # @!visibility private
@@ -2597,23 +3536,39 @@ module Discordrb
       @processed_chunk_members = 0
     end
 
+    # @return [Channel, nil] the AFK voice channel of this server, or `nil` if none is set.
+    def afk_channel
+      @bot.channel(@afk_channel_id) if @afk_channel_id
+    end
+
+    # @return [Channel, nil] the system channel (used for automatic welcome messages) of a server, or `nil` if none is set.
+    def system_channel
+      @bot.channel(@system_channel_id) if @system_channel_id
+    end
+
     # Updates the cached data with new data
     # @note For internal use only
     # @!visibility private
-    def update_data(new_data)
+    def update_data(new_data = nil)
+      new_data ||= JSON.parse(API::Server.resolve(@bot.token, @id))
       @name = new_data[:name] || new_data['name'] || @name
-      @region = new_data[:region] || new_data['region'] || @region
+      @region_id = new_data[:region] || new_data['region'] || @region_id
       @icon_id = new_data[:icon] || new_data['icon'] || @icon_id
-      @afk_timeout = new_data[:afk_timeout] || new_data['afk_timeout'].to_i || @afk_timeout
+      @afk_timeout = new_data[:afk_timeout] || new_data['afk_timeout'] || @afk_timeout
 
-      @afk_channel_id = new_data[:afk_channel_id] || new_data['afk_channel_id'].to_i || @afk_channel.id
+      afk_channel_id = new_data[:afk_channel_id] || new_data['afk_channel_id'] || @afk_channel
+      @afk_channel_id = afk_channel_id.nil? ? nil : afk_channel_id.resolve_id
+      embed_channel_id = new_data[:embed_channel_id] || new_data['embed_channel_id'] || @embed_channel
+      @embed_channel_id = embed_channel_id.nil? ? nil : embed_channel_id.resolve_id
+      system_channel_id = new_data[:system_channel_id] || new_data['system_channel_id'] || @system_channel
+      @system_channel_id = system_channel_id.nil? ? nil : system_channel_id.resolve_id
 
-      begin
-        @afk_channel = @bot.channel(@afk_channel_id, self) if @afk_channel_id.nonzero? && (!@afk_channel || @afk_channel_id != @afk_channel.id)
-      rescue Discordrb::Errors::NoPermission
-        LOGGER.debug("AFK channel #{@afk_channel_id} on server #{@id} is unreachable, setting to nil even though one exists")
-        @afk_channel = nil
-      end
+      @embed_enabled = new_data[:embed_enabled] || new_data['embed_enabled']
+      @splash = new_data[:splash_id] || new_data['splash_id'] || @splash_id
+
+      @verification_level = new_data[:verification_level] || new_data['verification_level'] || @verification_level
+      @explicit_content_filter = new_data[:explicit_content_filter] || new_data['explicit_content_filter'] || @explicit_content_filter
+      @default_message_notifications = new_data[:default_message_notifications] || new_data['default_message_notifications'] || @default_message_notifications
     end
 
     # Adds a channel to this server's cache
@@ -2642,19 +3597,24 @@ module Discordrb
 
     # The inspect method is overwritten to give more useful output
     def inspect
-      "<Server name=#{@name} id=#{@id} large=#{@large} region=#{@region} owner=#{@owner} afk_channel_id=#{@afk_channel_id} afk_timeout=#{@afk_timeout}>"
+      "<Server name=#{@name} id=#{@id} large=#{@large} region=#{@region} owner=#{@owner} afk_channel_id=#{@afk_channel_id} system_channel_id=#{@system_channel_id} afk_timeout=#{@afk_timeout}>"
     end
 
     private
 
     def update_server_data(new_data)
-      API::Server.update(@bot.token, @id,
-                         new_data[:name] || @name,
-                         new_data[:region] || @region,
-                         new_data[:icon_id] || @icon_id,
-                         new_data[:afk_channel_id] || @afk_channel_id,
-                         new_data[:afk_timeout] || @afk_timeout)
-      update_data(new_data)
+      response = JSON.parse(API::Server.update(@bot.token, @id,
+                                               new_data[:name] || @name,
+                                               new_data[:region] || @region_id,
+                                               new_data[:icon_id] || @icon_id,
+                                               new_data[:afk_channel_id] || @afk_channel_id,
+                                               new_data[:afk_timeout] || @afk_timeout,
+                                               new_data[:splash] || @splash,
+                                               new_data[:default_message_notifications] || @default_message_notifications,
+                                               new_data[:verification_level] || @verification_level,
+                                               new_data[:explicit_content_filter] || @explicit_content_filter,
+                                               new_data[:system_channel_id] || @system_channel_id))
+      update_data(response)
     end
 
     def process_roles(roles)
@@ -2721,6 +3681,477 @@ module Discordrb
     end
   end
 
+  # A ban entry on a server
+  class ServerBan
+    # @return [String, nil] the reason the user was banned, if provided
+    attr_reader :reason
+
+    # @return [User] the user that was banned
+    attr_reader :user
+
+    # @return [Server] the server this ban belongs to
+    attr_reader :server
+
+    # @!visibility private
+    def initialize(server, user, reason)
+      @server = server
+      @user = user
+      @reason = reason
+    end
+
+    # Removes this ban on the associated user in the server
+    # @param reason [String] the reason for removing the ban
+    def remove(reason = nil)
+      @server.unban(user, reason)
+    end
+
+    alias_method :unban, :remove
+    alias_method :lift, :remove
+  end
+
+  # A webhook on a server channel
+  class Webhook
+    include IDObject
+
+    # @return [String] the webhook name.
+    attr_reader :name
+
+    # @return [Channel] the channel that the webhook is currently connected to.
+    attr_reader :channel
+
+    # @return [Server] the server that the webhook is currently connected to.
+    attr_reader :server
+
+    # @return [String] the webhook's token.
+    attr_reader :token
+
+    # @return [String] the webhook's avatar id.
+    attr_reader :avatar
+
+    # Gets the user object of the creator of the webhook. May be limited to username, discriminator,
+    # ID and avatar if the bot cannot reach the owner
+    # @return [Member, User, nil] the user object of the owner or nil if the webhook was requested using the token.
+    attr_reader :owner
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @name = data['name']
+      @id = data['id'].to_i
+      @channel = bot.channel(data['channel_id'])
+      @server = @channel.server
+      @token = data['token']
+      @avatar = data['avatar']
+
+      # Will not exist if the data was requested through a webhook token
+      return unless data['user']
+      @owner = @server.member(data['user']['id'].to_i)
+      return if @owner
+      Discordrb::LOGGER.debug("Member with ID #{data['user']['id']} not cached (possibly left the server).")
+      @owner = @bot.ensure_user(data['user'])
+    end
+
+    # Sets the webhook's avatar.
+    # @param avatar [String, #read] The new avatar, in base64-encoded JPG format.
+    def avatar=(avatar)
+      update_webhook(avatar: avatarise(avatar))
+    end
+
+    # Deletes the webhook's avatar.
+    def delete_avatar
+      update_webhook(avatar: nil)
+    end
+
+    # Sets the webhook's channel
+    # @param channel [Channel, String, Integer, #resolve_id] The channel the webhook should use.
+    def channel=(channel)
+      update_webhook(channel_id: channel.resolve_id)
+    end
+
+    # Sets the webhook's name.
+    # @param name [String] The webhook's new name.
+    def name=(name)
+      update_webhook(name: name)
+    end
+
+    # Updates the webhook if you need to edit more than 1 attribute.
+    # @param data [Hash] the data to update.
+    # @option data [String, #read, nil] :avatar The new avatar, in base64-encoded JPG format, or nil to delete the avatar.
+    # @option data [Channel, String, Integer, #resolve_id] :channel The channel the webhook should use.
+    # @option data [String] :name The webhook's new name.
+    # @option data [String] :reason The reason for the webhook changes.
+    def update(data)
+      # Only pass a value for avatar if the key is defined as sending nil will delete the
+      data[:avatar] = avatarise(data[:avatar]) if data.key?(:avatar)
+      data[:channel_id] = data[:channel].resolve_id
+      data.delete(:channel)
+      update_webhook(data)
+    end
+
+    # Deletes the webhook.
+    # @param reason [String] The reason the invite is being deleted.
+    def delete(reason = nil)
+      if token?
+        API::Webhook.token_delete_webhook(@token, @id, reason)
+      else
+        API::Webhook.delete_webhook(@bot.token, @id, reason)
+      end
+    end
+
+    # Utility function to get a webhook's avatar URL.
+    # @return [String] the URL to the avatar image
+    def avatar_url
+      return API::User.default_avatar unless @avatar
+      API::User.avatar_url(@id, @avatar)
+    end
+
+    # The `inspect` method is overwritten to give more useful output.
+    def inspect
+      "<Webhook name=#{@name} id=#{@id}>"
+    end
+
+    # Utility function to know if the webhook was requested through a webhook token, rather than auth.
+    # @return [true, false] whether the webhook was requested by token or not.
+    def token?
+      @owner.nil?
+    end
+
+    private
+
+    def avatarise(avatar)
+      if avatar.respond_to? :read
+        "data:image/jpg;base64,#{Base64.strict_encode64(avatar.read)}"
+      else
+        avatar
+      end
+    end
+
+    def update_internal(data)
+      @name = data['name']
+      @avatar_id = data['avatar']
+      @channel = @bot.channel(data['channel_id'])
+    end
+
+    def update_webhook(new_data)
+      reason = new_data.delete(:reason)
+      data = JSON.parse(if token?
+                          API::Webhook.token_update_webhook(@token, @id, new_data, reason)
+                        else
+                          API::Webhook.update_webhook(@bot.token, @id, new_data, reason)
+                        end)
+      # Only update cache if API call worked
+      update_internal(data) if data['name']
+    end
+  end
+
+  # A server's audit logs
+  class AuditLogs
+    # The numbers associated with the type of action.
+    Actions = {
+      1 => :server_update,
+      10 => :channel_create,
+      11 => :channel_update,
+      12 => :channel_delete,
+      13 => :channel_overwrite_create,
+      14 => :channel_overwrite_update,
+      15 => :channel_overwrite_delete,
+      20 => :member_kick,
+      21 => :member_prune,
+      22 => :member_ban_add,
+      23 => :member_ban_remove,
+      24 => :member_update,
+      25 => :member_role_update,
+      30 => :role_create,
+      31 => :role_update,
+      32 => :role_delete,
+      40 => :invite_create,
+      41 => :invite_update,
+      42 => :invite_delete,
+      50 => :webhook_create,
+      51 => :webhook_update,
+      52 => :webhook_delete,
+      60 => :emoji_create,
+      61 => :emoji_update,
+      62 => :emoji_delete,
+      # 70
+      # 71
+      72 => :message_delete
+    }.freeze
+
+    # @return [Hash<String => User>] the users included in the audit logs.
+    attr_reader :users
+
+    # @return [Hash<String => Webhook>] the webhooks included in the audit logs.
+    attr_reader :webhooks
+
+    # @return [Array<Entry>] the entries listed in the audit logs.
+    attr_reader :entries
+
+    # @!visibility private
+    def initialize(server, bot, data)
+      @bot = bot
+      @server = server
+      @users = {}
+      @webhooks = {}
+      @entries = data['audit_log_entries'].map { |entry| Entry.new(self, @server, @bot, entry) }
+
+      process_users(data['users'])
+      process_webhooks(data['webhooks'])
+    end
+
+    # An entry in a server's audit logs.
+    class Entry
+      include IDObject
+
+      # @return [Symbol] the action that was performed.
+      attr_reader :action
+
+      # @return [Symbol] the type action that was performed. (:create, :delete, :update, :unknown)
+      attr_reader :action_type
+
+      # @return [Symbol] the type of target being performed on. (:server, :channel, :user, :role, :invite, :webhook, :emoji, :unknown)
+      attr_reader :target_type
+
+      # @return [Integer, nil] the amount of messages deleted. Only present if the action is `:message_delete`.
+      attr_reader :count
+      alias_method :amount, :count
+
+      # @return [Integer, nil] the amount of days the members were inactive for. Only present if the action is `:member_prune`.
+      attr_reader :days
+
+      # @return [Integer, nil] the amount of members removed. Only present if the action is `:member_prune`.
+      attr_reader :members_removed
+
+      # @return [String, nil] the reason for this action occuring.
+      attr_reader :reason
+
+      # @return [Hash<String => Change>, RoleChange, nil] the changes from this log, listing the key as the key changed. Will be a RoleChange object if the action is `:member_role_update`. Will be nil if the action is either `:message_delete` or `:member_prune`.
+      attr_reader :changes
+
+      # @!visibility private
+      def initialize(logs, server, bot, data)
+        @bot = bot
+        @id = data['id'].resolve_id
+        @logs = logs
+        @server = server
+        @data = data
+        @action = Actions[data['action_type']]
+        @reason = data['reason']
+        @action_type = AuditLogs.action_type_for(data['action_type'])
+        @target_type = AuditLogs.target_type_for(data['action_type'])
+
+        # Sets the 'changes' variable to a empty hash if there are no special actions.
+        @changes = {} unless @action == :message_delete || @action == :member_prune || @action == :member_role_update
+
+        # Sets the 'changes' variable to a RoleChange class if theres a role update.
+        @changes = RoleChange.new(data['changes'][0], @server) if @action == :member_role_update
+
+        process_changes(data['changes']) unless @action == :member_role_update
+        return unless data.include?('options')
+
+        # Checks and sets variables for special action options.
+        @count = data['options']['count'].to_i unless data['options']['count'].nil?
+        @channel_id = data['options']['channel'].to_i unless data['options']['channel'].nil?
+        @days = data['options']['delete_member_days'].to_i unless data['options']['delete_member_days'].nil?
+        @members_removed = data['options']['members_removed'].to_i unless data['options']['members_removed'].nil?
+      end
+
+      # @return [Server, Channel, Member, User, Role, Invite, Webhook, Emoji, nil] the target being performed on.
+      def target
+        @target ||= process_target(@data['target_id'], @target_type)
+      end
+
+      # @return [Member, User] the user that authored this action. Can be a User object if the user no longer exists in the server.
+      def user
+        @user ||= @server.member(@data['user_id'].to_i) || @bot.user(@data['user_id'].to_i) || @logs.user(@data['user_id'].to_i)
+      end
+      alias_method :author, :user
+
+      # @return [Channel, nil] the amount of messages deleted. Won't be nil if the action is `:message_delete`.
+      def channel
+        return nil unless @channel_id
+        @channel ||= @bot.channel(@channel_id, @server, bot, self)
+      end
+
+      # @!visibility private
+      def process_target(id, type)
+        id = id.resolve_id unless id.nil?
+        case type
+        when :server then @server # Since it won't be anything else
+        when :channel then @bot.channel(id, @server)
+        when :user, :message then @server.member(id) || @bot.user(id) || @logs.user(id)
+        when :role then @server.role(id)
+        when :invite then @bot.invite(@data['changes'].find { |change| change['key'] == 'code' }.values.delete_if { |v| v == 'code' }.first)
+        when :webhook then @server.webhooks.find { |webhook| webhook.id == id } || @logs.webhook(id)
+        when :emoji then @server.emoji[id]
+        end
+      end
+
+      # The inspect method is overwritten to give more useful output
+      def inspect
+        "<AuditLogs::Entry id=#{@id} action=#{@action} reason=#{@reason} action_type=#{@action_type} target_type=#{@target_type} count=#{@count} days=#{@days} members_removed=#{@members_removed}>"
+      end
+
+      # Process action changes
+      # @note For internal use only
+      # @!visibility private
+      def process_changes(changes)
+        return unless changes
+        changes.each do |element|
+          change = Change.new(element, @server, @bot, self)
+          @changes[change.key] = change
+        end
+      end
+    end
+
+    # A change in a audit log entry.
+    class Change
+      # @return [String] the key that was changed.
+      # @note You should check with the Discord API Documentation on what key gives out what value.
+      attr_reader :key
+
+      # @return [String, Integer, true, false, Permissions, Overwrite, nil] the value that was changed from.
+      attr_reader :old
+      alias_method :old_value, :old
+
+      # @return [String, Integer, true, false, Permissions, Overwrite, nil] the value that was changed to.
+      attr_reader :new
+      alias_method :new_value, :new
+
+      # @!visibility private
+      def initialize(data, server, bot, logs)
+        @key = data['key']
+        @old = data['old_value']
+        @new = data['new_value']
+        @server = server
+        @bot = bot
+        @logs = logs
+
+        @old = Permissions.new(@old) if @old && @key == 'permissions'
+        @new = Permissions.new(@new) if @new && @key == 'permissions'
+
+        @old = @old.map { |o| Overwrite.new(o['id'], type: o['type'].to_sym, allow: o['allow'], deny: o['deny']) } if @old && @key == 'permission_overwrites'
+        @new = @new.map { |o| Overwrite.new(o['id'], type: o['type'].to_sym, allow: o['allow'], deny: o['deny']) } if @new && @key == 'permission_overwrites'
+      end
+
+      # @return [Channel, nil] the channel that was previously used in the server widget. Only present if the key for this change is `widget_channel_id`.
+      def old_widget_channel
+        @bot.channel(@old, @server) if @old && @key == 'widget_channel_id'
+      end
+
+      # @return [Channel, nil] the channel that is used in the server widget prior to this change. Only present if the key for this change is `widget_channel_id`.
+      def new_widget_channel
+        @bot.channel(@new, @server) if @new && @key == 'widget_channel_id'
+      end
+
+      # @return [Channel, nil] the channel that was previously used in the server as an AFK channel. Only present if the key for this change is `afk_channel_id`.
+      def old_afk_channel
+        @bot.channel(@old, @server) if @old && @key == 'afk_channel_id'
+      end
+
+      # @return [Channel, nil] the channel that is used in the server as an AFK channel prior to this change. Only present if the key for this change is `afk_channel_id`.
+      def new_afk_channel
+        @bot.channel(@new, @server) if @new && @key == 'afk_channel_id'
+      end
+
+      # @return [Member, User, nil] the member that used to be the owner of the server. Only present if the for key for this change is `owner_id`.
+      def old_owner
+        @server.member(@old) || @bot.user(@old) || @logs.user(@old) if @old && @key == 'owner_id'
+      end
+
+      # @return [Member, User, nil] the member that is now the owner of the server prior to this change. Only present if the key for this change is `owner_id`.
+      def new_owner
+        @server.member(@new) || @bot.user(@new) || @logs.user(@new) if @new && @key == 'owner_id'
+      end
+    end
+
+    # A change that includes roles.
+    class RoleChange
+      # @return [Symbol] what type of change this is: (:add, :remove)
+      attr_reader :type
+
+      # @!visibility private
+      def initialize(data, server)
+        @type = data['key'].delete('$').to_sym
+        @role_id = data['new_value'][0]['id'].to_i
+        @server = server
+      end
+
+      # @return [Role] the role being used.
+      def role
+        @role ||= @server.role(@role_id)
+      end
+    end
+
+    # @return [Entry] the latest entry in the audit logs.
+    def latest
+      @entries.first
+    end
+    alias_method :first, :latest
+
+    # Gets a user in the audit logs data based on user ID
+    # @note This only uses data given by the audit logs request
+    # @param id [#resolve_id] The user ID to look for
+    def user(id)
+      @users[id.resolve_id]
+    end
+
+    # Gets a webhook in the audit logs data based on webhook ID
+    # @note This only uses data given by the audit logs request
+    # @param id [#resolve_id] The webhook ID to look for
+    def webhook(id)
+      @webhooks[id.resolve_id]
+    end
+
+    # Process user objects given by the request
+    # @note For internal use only
+    # @!visibility private
+    def process_users(users)
+      users.each do |element|
+        user = User.new(element, @bot)
+        @users[user.id] = user
+      end
+    end
+
+    # Process webhook objects given by the request
+    # @note For internal use only
+    # @!visibility private
+    def process_webhooks(webhooks)
+      webhooks.each do |element|
+        webhook = Webhook.new(element, @bot)
+        @webhooks[webhook.id] = webhook
+      end
+    end
+
+    # Find the type of target by it's action number
+    # @note For internal use only
+    # @!visibility private
+    def self.target_type_for(action)
+      case action
+      when 1..9 then :server
+      when 10..19 then :channel
+      when 20..29 then :user
+      when 30..39 then :role
+      when 40..49 then :invite
+      when 50..59 then :webhook
+      when 60..69 then :emoji
+      when 70..79 then :message
+      else :unknown
+      end
+    end
+
+    # Find the type of action by its action number
+    # @note For internal use only
+    # @!visibility private
+    def self.action_type_for(action)
+      action = Actions[action]
+      return :create if %i[channel_create channel_overwrite_create member_ban_add role_create invite_create webhook_create emoji_create].include?(action)
+      return :delete if %i[channel_delete channel_overwrite_delete member_kick member_prune member_ban_remove role_delete invite_delete webhook_delete emoji_delete message_delete].include?(action)
+      return :update if %i[server_update channel_update channel_overwrite_update member_update member_role_update role_update invite_update webhook_update emoji_update].include?(action)
+      :unknown
+    end
+  end
+
   # A colour (red, green and blue values). Used for role colours. If you prefer the American spelling, the alias
   # {ColorRGB} is also available.
   class ColourRGB
@@ -2735,15 +4166,27 @@ module Discordrb
 
     # @return [Integer] the colour's RGB values combined into one integer.
     attr_reader :combined
+    alias_method :to_i, :combined
 
     # Make a new colour from the combined value.
-    # @param combined [Integer] The colour's RGB values combined into one integer
+    # @param combined [Integer, String] The colour's RGB values combined into one integer or a hexadecimal string
+    # @example Initialize a with a base 10 integer
+    #   ColourRGB.new(7506394) #=> ColourRGB
+    #   ColourRGB.new(0x7289da) #=> ColourRGB
+    # @example Initialize a with a hexadecimal string
+    #   ColourRGB.new('7289da') #=> ColourRGB
     def initialize(combined)
-      @combined = combined
-      @red = (combined >> 16) & 0xFF
-      @green = (combined >> 8) & 0xFF
-      @blue = combined & 0xFF
+      @combined = combined.is_a?(String) ? combined.to_i(16) : combined
+      @red = (@combined >> 16) & 0xFF
+      @green = (@combined >> 8) & 0xFF
+      @blue = @combined & 0xFF
+    end
+
+    # @return [String] the colour as a hexadecimal.
+    def hex
+      @combined.to_s(16)
     end
+    alias_method :hexadecimal, :hex
   end
 
   # Alias for the class {ColourRGB}