discordrb 2.1.3 → 3.0.0

data/lib/discordrb/data.rb

@@ -4,7 +4,12 @@
 
 require 'ostruct'
 require 'discordrb/permissions'
+require 'discordrb/errors'
 require 'discordrb/api'
+require 'discordrb/api/channel'
+require 'discordrb/api/server'
+require 'discordrb/api/invite'
+require 'discordrb/api/user'
 require 'discordrb/events/message'
 require 'time'
 require 'base64'
@@ -49,7 +54,7 @@ module Discordrb
 
     # If it's still larger than the character limit (none was smaller than it) split it into slices with the length
     # being the character limit, otherwise just return an array with one element
-    ideal_ary = (ideal.length > CHARACTER_LIMIT) ? ideal.chars.each_slice(CHARACTER_LIMIT).map(&:join) : [ideal]
+    ideal_ary = ideal.length > CHARACTER_LIMIT ? ideal.chars.each_slice(CHARACTER_LIMIT).map(&:join) : [ideal]
 
     # Slice off the ideal part and strip newlines
     rest = msg[ideal.length..-1].strip
@@ -117,7 +122,7 @@ module Discordrb
     # Utility function to get a user's avatar URL.
     # @return [String] the URL to the avatar image.
     def avatar_url
-      API.avatar_url(@id, @avatar_id)
+      API::User.avatar_url(@id, @avatar_id)
     end
   end
 
@@ -164,10 +169,20 @@ module Discordrb
         channel.send_message(content)
       else
         # If no message was specified, return the PM channel
-        @bot.private_channel(@id)
+        @bot.pm_channel(@id)
       end
     end
 
+    alias_method :dm, :pm
+
+    # Send the user a file.
+    # @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.
+    def send_file(file, caption = nil)
+      pm.send_file(file, caption: caption)
+    end
+
     # Set the user's name
     # @note for internal use only
     # @!visibility private
@@ -208,24 +223,54 @@ module Discordrb
     end
   end
 
-  # Mixin for the attributes members and private members should have
-  module MemberAttributes
-    # @return [true, false] whether this member is muted server-wide.
-    attr_reader :mute
-    alias_method :muted?, :mute
+  # OAuth Application information
+  class Application
+    include IDObject
 
-    # @return [true, false] whether this member is deafened server-wide.
-    attr_reader :deaf
-    alias_method :deafened?, :deaf
+    # @return [String] the application name
+    attr_reader :name
 
-    # @return [true, false] whether this member has muted themselves.
-    attr_reader :self_mute
-    alias_method :self_muted?, :self_mute
+    # @return [String] the application description
+    attr_reader :description
 
-    # @return [true, false] whether this member has deafened themselves.
-    attr_reader :self_deaf
-    alias_method :self_deafened?, :self_deaf
+    # @return [Array<String>] the applications 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.
+    # @return [User] the user object of the owner
+    attr_reader :owner
+
+    def initialize(data, bot)
+      @bot = bot
+
+      @name = data['name']
+      @id = data['id'].to_i
+      @description = data['description']
+      @icon_id = data['icon']
+      @rpc_origins = data['rpc_origins']
+      @flags = data['flags']
+      @owner = @bot.ensure_user(data['owner'])
+    end
 
+    # Utility function to get a application's icon URL.
+    # @return [String, nil] the URL to the icon image (nil if no iamge is set).
+    def icon_url
+      return nil if @icon_id.nil?
+      API.app_icon_url(@id, @icon_id)
+    end
+
+    # The inspect method is overwritten to give more useful output
+    def inspect
+      "<Application name=#{@name} id=#{@id}>"
+    end
+  end
+
+  # Mixin for the attributes members and private members should have
+  module MemberAttributes
     # @return [Time] when this member joined the server.
     attr_reader :joined_at
 
@@ -238,9 +283,6 @@ module Discordrb
 
     # @return [Server] the server this member is on.
     attr_reader :server
-
-    # @return [Channel] the voice channel the user is in.
-    attr_reader :voice_channel
   end
 
   # Mixin to calculate resulting permissions from overrides etc.
@@ -258,7 +300,7 @@ module Discordrb
       # (Coincidentally, Manage Permissions is the same permission as Manage Roles, and a
       # Manage Permissions deny overwrite will override Manage Roles, so we can just check for
       # Manage Roles once and call it a day.)
-      return true if defined_permission?(:manage_roles, channel)
+      return true if defined_permission?(:administrator, channel)
 
       # Otherwise, defer to defined_permission
       defined_permission?(action, channel)
@@ -289,6 +331,8 @@ module Discordrb
       end
     end
 
+    alias_method :can_administrate?, :can_administrator?
+
     private
 
     def defined_role_permission?(action, channel)
@@ -327,9 +371,77 @@ module Discordrb
     end
   end
 
+  # A voice state represents the state of a member's connection to a voice channel. It includes data like the voice
+  # channel the member is connected to and mute/deaf flags.
+  class VoiceState
+    # @return [Integer] the ID of the user whose voice state is represented by this object.
+    attr_reader :user_id
+
+    # @return [true, false] whether this voice state's member is muted server-wide.
+    attr_reader :mute
+
+    # @return [true, false] whether this voice state's member is deafened server-wide.
+    attr_reader :deaf
+
+    # @return [true, false] whether this voice state's member has muted themselves.
+    attr_reader :self_mute
+
+    # @return [true, false] whether this voice state's member has deafened themselves.
+    attr_reader :self_deaf
+
+    # @return [Channel] the voice channel this voice state's member is in.
+    attr_reader :voice_channel
+
+    # @!visibility private
+    def initialize(user_id)
+      @user_id = user_id
+    end
+
+    # Update this voice state with new data from Discord
+    # @note For internal use only.
+    # @!visibility private
+    def update(channel, mute, deaf, self_mute, self_deaf)
+      @voice_channel = channel
+      @mute = mute
+      @deaf = deaf
+      @self_mute = self_mute
+      @self_deaf = self_deaf
+    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.
   class Member < DelegateClass(User)
+    # @return [true, false] whether this member is muted server-wide.
+    def mute
+      voice_state_attribute(:mute)
+    end
+
+    # @return [true, false] whether this member is deafened server-wide.
+    def deaf
+      voice_state_attribute(:deaf)
+    end
+
+    # @return [true, false] whether this member has muted themselves.
+    def self_mute
+      voice_state_attribute(:self_mute)
+    end
+
+    # @return [true, false] whether this member has deafened themselves.
+    def self_deaf
+      voice_state_attribute(:self_deaf)
+    end
+
+    # @return [Channel] the voice channel this member is in.
+    def voice_channel
+      voice_state_attribute(:voice_channel)
+    end
+
+    alias_method :muted?, :mute
+    alias_method :deafened?, :deaf
+    alias_method :self_muted?, :self_mute
+    alias_method :self_deafened?, :self_deaf
+
     include MemberAttributes
 
     # @!visibility private
@@ -347,9 +459,6 @@ module Discordrb
       update_roles(data['roles'])
 
       @nick = data['nick']
-
-      @deaf = data['deaf']
-      @mute = data['mute']
       @joined_at = data['joined_at'] ? Time.parse(data['joined_at']) : nil
     end
 
@@ -365,6 +474,25 @@ module Discordrb
       @roles.any? { |e| e.id == role }
     end
 
+    # Bulk sets a member's roles.
+    # @param role [Role, Array<Role>] The role(s) to set.
+    def roles=(role)
+      role_ids = role_id_array(role)
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: role_ids)
+    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.
+    def modify_roles(add, remove)
+      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)
+    end
+
     # Adds one or more roles to this member.
     # @param role [Role, Array<Role>] The role(s) to add.
     def add_role(role)
@@ -372,7 +500,7 @@ module Discordrb
       old_role_ids = @roles.map(&:id)
       new_role_ids = (old_role_ids + role_ids).uniq
 
-      API.update_user_roles(@bot.token, @server.id, @user.id, new_role_ids)
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids)
     end
 
     # Removes one or more roles from this member.
@@ -382,7 +510,27 @@ module Discordrb
       role_ids = role_id_array(role)
       new_role_ids = old_role_ids.reject { |i| role_ids.include?(i) }
 
-      API.update_user_roles(@bot.token, @server.id, @user.id, new_role_ids)
+      API::Server.update_member(@bot.token, @server.id, @user.id, roles: new_role_ids)
+    end
+
+    # Server deafens this member.
+    def server_deafen
+      API::Server.update_member(@bot.token, @server.id, @user.id, deaf: true)
+    end
+
+    # Server undeafens this member.
+    def server_undeafen
+      API::Server.update_member(@bot.token, @server.id, @user.id, deaf: false)
+    end
+
+    # Server mutes this member.
+    def server_mute
+      API::Server.update_member(@bot.token, @server.id, @user.id, mute: true)
+    end
+
+    # Server unmutes this member.
+    def server_unmute
+      API::Server.update_member(@bot.token, @server.id, @user.id, mute: false)
     end
 
     # Sets or resets this member's nickname. Requires the Change Nickname permission for the bot itself and Manage
@@ -392,7 +540,11 @@ module Discordrb
       # Discord uses the empty string to signify 'no nickname' so we convert nil into that
       nick ||= ''
 
-      API.change_nickname(@bot.token, @server.id, @user.id, nick)
+      if @user.current_bot?
+        API::User.change_own_nickname(@bot.token, @server.id, nick)
+      else
+        API.change_nickname(@bot.token, @server.id, @user.id, nick)
+      end
     end
 
     alias_method :nickname=, :nick=
@@ -418,17 +570,6 @@ module Discordrb
       @nick = nick
     end
 
-    # Update this member's voice state
-    # @note For internal use only.
-    # @!visibility private
-    def update_voice_state(channel, mute, deaf, self_mute, self_deaf)
-      @voice_channel = channel
-      @mute = mute
-      @deaf = deaf
-      @self_mute = self_mute
-      @self_deaf = self_deaf
-    end
-
     include PermissionCalculator
 
     # Overwriting inspect for debug purposes
@@ -446,6 +587,12 @@ module Discordrb
         [role.resolve_id]
       end
     end
+
+    # Utility method to get data out of this member's voice state
+    def voice_state_attribute(name)
+      voice_state = @server.voice_states[@user.id]
+      voice_state.send name if voice_state
+    end
   end
 
   # Recipients are members on private channels - they exist for completeness purposes, but all
@@ -479,13 +626,11 @@ module Discordrb
     end
   end
 
-  # This class is a special variant of User that represents the bot's user profile (things like email addresses and the avatar).
+  # This class is a special variant of User that represents the bot's user profile (things like own username and the avatar).
   # It can be accessed using {Bot#profile}.
   class Profile < User
-    def initialize(data, bot, email, password)
+    def initialize(data, bot)
       super(data, bot)
-      @email = email
-      @password = password
     end
 
     # Whether or not the user is the bot. The Profile can only ever be the bot user, so this always returns true.
@@ -500,22 +645,11 @@ module Discordrb
       update_profile_data(username: username)
     end
 
-    # Sets the bot's email address. If you use this method, make sure that the login email in the script matches this
-    # one afterwards, so the bot doesn't have any trouble logging in in the future.
-    # @param email [String] The new email address.
-    def email=(email)
-      update_profile_data(email: email)
-    end
-
-    # Changes the bot's password. This will invalidate all tokens so you will have to relog the bot.
-    # @param password [String] The new password.
-    def password=(password)
-      update_profile_data(new_password: password)
-    end
+    alias_method :name=, :username=
 
     # Changes the bot's avatar.
     # @param avatar [String, #read] A JPG file to be used as the avatar, either
-    #  something readable (e. g. File) 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
@@ -533,26 +667,22 @@ module Discordrb
     # @note For internal use only.
     # @!visibility private
     def update_data(new_data)
-      @email = new_data[:email] || @email
-      @password = new_data[:new_password] || @password
       @username = new_data[:username] || @username
       @avatar_id = new_data[:avatar_id] || @avatar_id
     end
 
     # The inspect method is overwritten to give more useful output
     def inspect
-      "<Profile email=#{@email} user=#{super}>"
+      "<Profile user=#{super}>"
     end
 
     private
 
     def update_profile_data(new_data)
-      API.update_user(@bot.token,
-                      new_data[:email] || @email,
-                      @password,
-                      new_data[:username] || @username,
-                      new_data[:avatar],
-                      new_data[:new_password] || nil)
+      API::User.update_profile(@bot.token,
+                               nil, nil,
+                               new_data[:username] || @username,
+                               new_data.key?(:avatar) ? new_data[:avatar] : @avatar_id)
       update_data(new_data)
     end
   end
@@ -576,9 +706,11 @@ module Discordrb
 
     # @return [ColourRGB] the role colour
     attr_reader :colour
-
     alias_method :color, :colour
 
+    # @return [Integer] the position of this role in the hierarchy
+    attr_reader :position
+
     # This class is used internally as a wrapper to a Role object that allows easy writing of permission data.
     class RoleWriter
       # @!visibility private
@@ -602,6 +734,8 @@ module Discordrb
       @name = data['name']
       @id = data['id'].to_i
 
+      @position = data['position']
+
       @hoist = data['hoist']
       @mentionable = data['mentionable']
 
@@ -613,6 +747,14 @@ module Discordrb
       "<@&#{@id}>"
     end
 
+    # @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 }
+    end
+
+    alias_method :users, :members
+
     # Updates the data cache from another Role object
     # @note For internal use only
     # @!visibility private
@@ -621,6 +763,7 @@ module Discordrb
       @name = other.name
       @hoist = other.hoist
       @colour = other.colour
+      @position = other.position
     end
 
     # Updates the data cache from a hash containing data
@@ -645,6 +788,12 @@ module Discordrb
       update_role_data(hoist: hoist)
     end
 
+    # Changes whether or not this role can be mentioned
+    # @param mentionable [true, false] The value it should be changed to
+    def mentionable=(mentionable)
+      update_role_data(mentionable: mentionable)
+    end
+
     # Sets the role colour to something new
     # @param colour [ColourRGB] The new colour
     def colour=(colour)
@@ -653,9 +802,16 @@ module Discordrb
 
     alias_method :color=, :colour=
 
-    # Changes the internal packed permissions
-    # @note For internal use only
-    # @!visibility private
+    # Changes this role's permissions to a fixed bitfield. This allows setting multiple permissions at once with just
+    # one API call.
+    #
+    # Information on how this bitfield is structured can be found at
+    # https://discordapp.com/developers/docs/topics/permissions.
+    # @example Remove all permissions from a role
+    #   role.packed = 0
+    # @param packed [Integer] A bitfield with the desired permissions value.
+    # @param update_perms [true, false] Whether the internal data should also be updated. This should always be true
+    #   when calling externally.
     def packed=(packed, update_perms = true)
       update_role_data(permissions: packed)
       @permissions.bits = packed if update_perms
@@ -663,7 +819,7 @@ module Discordrb
 
     # Delets this role. This cannot be undone without recreating the role!
     def delete
-      API.delete_role(@bot.token, @server.id, @id)
+      API::Server.delete_role(@bot.token, @server.id, @id)
       @server.delete_role(@id)
     end
 
@@ -675,11 +831,12 @@ module Discordrb
     private
 
     def update_role_data(new_data)
-      API.update_role(@bot.token, @server.id, @id,
-                      new_data[:name] || @name,
-                      (new_data[:colour] || @colour).combined,
-                      new_data[:hoist].nil? ? false : !@hoist.nil?,
-                      new_data[:permissions] || @permissions.bits)
+      API::Server.update_role(@bot.token, @server.id, @id,
+                              new_data[:name] || @name,
+                              (new_data[:colour] || @colour).combined,
+                              new_data[:hoist].nil? ? @hoist : new_data[:hoist],
+                              new_data[:mentionable].nil? ? @mentionable : new_data[:mentionable],
+                              new_data[:permissions] || @permissions.bits)
       update_data(new_data)
     end
   end
@@ -691,7 +848,7 @@ module Discordrb
     # @return [String] this channel's name.
     attr_reader :name
 
-    # @return [String] this channel's type (text or voice)
+    # @return [Integer] this channel's type (0: text, 1: private, 2: voice, 3: group).
     attr_reader :type
 
     # @!visibility private
@@ -735,29 +892,23 @@ module Discordrb
 
     # @return [Integer] the amount of uses left on this invite.
     attr_reader :uses
+    alias_method :max_uses, :uses
 
     # @return [User, nil] the user that made this invite. May also be nil if the user can't be determined.
     attr_reader :inviter
+    alias_method :user, :inviter
 
     # @return [true, false] whether or not this invite is temporary.
     attr_reader :temporary
+    alias_method :temporary?, :temporary
 
     # @return [true, false] whether this invite is still valid.
     attr_reader :revoked
-
-    # @return [true, false] whether this invite is in xkcd format (i. e. "Human readable" in the invite settings)
-    attr_reader :xkcd
+    alias_method :revoked?, :revoked
 
     # @return [String] this invite's code
     attr_reader :code
 
-    alias_method :max_uses, :uses
-    alias_method :user, :inviter
-
-    alias_method :temporary?, :temporary
-    alias_method :revoked?, :revoked
-    alias_method :xkcd?, :xkcd
-
     # @!visibility private
     def initialize(data, bot)
       @bot = bot
@@ -768,7 +919,6 @@ module Discordrb
       @inviter = data['inviter'] ? (@bot.user(data['inviter']['id'].to_i) || User.new(data['inviter'], bot)) : nil
       @temporary = data['temporary']
       @revoked = data['revoked']
-      @xkcd = data['xkcdpass']
 
       @code = data['code']
     end
@@ -780,14 +930,14 @@ module Discordrb
 
     # Deletes this invite
     def delete
-      API.delete_invite(@bot.token, @code)
+      API::Invite.delete(@bot.token, @code)
     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} xkcd=#{@xkcd}>"
+      "<Invite code=#{@code} channel=#{@channel} uses=#{@uses} temporary=#{@temporary} revoked=#{@revoked}>"
     end
 
     # Creates an invite URL.
@@ -798,14 +948,6 @@ module Discordrb
 
   # A Discord channel, including data like the topic
   class Channel
-    # The type string that stands for a text channel
-    # @see Channel#type
-    TEXT_TYPE = 'text'.freeze
-
-    # The type string that stands for a voice channel
-    # @see Channel#type
-    VOICE_TYPE = 'voice'.freeze
-
     include IDObject
 
     # @return [String] this channel's name.
@@ -814,15 +956,25 @@ module Discordrb
     # @return [Server, nil] the server this channel is on. If this channel is a PM channel, it will be nil.
     attr_reader :server
 
-    # @return [String] the type of this channel (currently either 'text' or 'voice')
+    # @return [Integer] the type of this channel (0: text, 1: private, 2: voice, 3: group)
     attr_reader :type
 
-    # @return [Recipient, nil] the recipient of the private messages, or nil if this is not a PM channel
-    attr_reader :recipient
+    # @return [Integer, nil] the id of the owner of the group channel or nil if this is not a group channel.
+    attr_reader :owner_id
+
+    # @return [Array<Recipient>, nil] the array of recipients of the private messages, or nil if this is not a Private channel
+    attr_reader :recipients
 
     # @return [String] the channel's topic
     attr_reader :topic
 
+    # @return [Integer] the bitrate (in bps) of the channel
+    attr_reader :bitrate
+
+    # @return [Integer] the amount of users that can be in the channel. `0` means it is unlimited.
+    attr_reader :user_limit
+    alias_method :limit, :user_limit
+
     # @return [Integer] the channel's position on the channel list
     attr_reader :position
 
@@ -831,9 +983,9 @@ module Discordrb
     # @return [Hash<Integer => OpenStruct>] the channel's permission overwrites
     attr_reader :permission_overwrites
 
-    # @return [true, false] whether or not this channel is a PM channel.
+    # @return [true, false] whether or not this channel is a PM or group channel.
     def private?
-      @server.nil?
+      pm? || group?
     end
 
     # @return [String] a string that will mention the channel as a clickable link on Discord.
@@ -841,23 +993,38 @@ module Discordrb
       "<##{@id}>"
     end
 
+    # @return [Recipient, nil] the recipient of the private messages, or nil if this is not a PM channel
+    def recipient
+      @recipients.first if pm?
+    end
+
     # @!visibility private
     def initialize(data, bot, server = nil)
       @bot = bot
-
-      # data is a sometimes a Hash and othertimes an array of Hashes, you only want the last one if it's an array
+      # 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 = data[-1] if data.is_a?(Array)
 
       @id = data['id'].to_i
-      @type = data['type'] || TEXT_TYPE
+      @type = data['type'] || 0
       @topic = data['topic']
+      @bitrate = data['bitrate']
+      @user_limit = data['user_limit']
       @position = data['position']
 
-      @is_private = data['is_private']
-      if @is_private
-        recipient_user = bot.ensure_user(data['recipient'])
-        @recipient = Recipient.new(recipient_user, self, bot)
-        @name = @recipient.username
+      if private?
+        @recipients = []
+        if data['recipients']
+          data['recipients'].each do |recipient|
+            recipient_user = bot.ensure_user(recipient)
+            @recipients << Recipient.new(recipient_user, self, bot)
+          end
+        end
+        if pm?
+          @name = @recipients.first.username
+        else
+          @name = data['name']
+          @owner_id = data['owner_id']
+        end
       else
         @name = data['name']
         @server = if server
@@ -882,12 +1049,22 @@ module Discordrb
 
     # @return [true, false] whether or not this channel is a text channel
     def text?
-      @type == TEXT_TYPE
+      @type.zero?
     end
 
-    # @return [true, false] whether or not this channel is a voice channel
+    # @return [true, false] whether or not this channel is a PM channel.
+    def pm?
+      @type == 1
+    end
+
+    # @return [true, false] whether or not this channel is a voice channel.
     def voice?
-      @type == VOICE_TYPE
+      @type == 2
+    end
+
+    # @return [true, false] whether or not this channel is a group channel.
+    def group?
+      @type == 3
     end
 
     # Sends a message to this channel.
@@ -898,6 +1075,16 @@ module Discordrb
       @bot.send_message(@id, content, tts, @server && @server.id)
     end
 
+    alias_method :send, :send_message
+
+    # Sends a temporary 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 timeout [Float] The amount of time in seconds after which the message sent will be deleted.
+    # @param tts [true, false] Whether or not this message should be sent using Discord text-to-speech.
+    def send_temporary_message(content, timeout, tts = false)
+      @bot.send_temporary_message(@id, content, timeout, tts, @server && @server.id)
+    end
+
     # Sends multiple messages to a channel
     # @param content [Array<String>] The messages to send.
     def send_multiple(content)
@@ -912,13 +1099,15 @@ module Discordrb
 
     # Sends a file to this channel. If it is an image, it will be embedded.
     # @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)
-    def send_file(file)
-      @bot.send_file(@id, file)
+    # @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.
+    def send_file(file, caption: nil, tts: false)
+      @bot.send_file(@id, file, caption: caption, tts: tts)
     end
 
     # Permanently deletes this channel
     def delete
-      API.delete_channel(@bot.token, @id)
+      API::Channel.delete(@bot.token, @id)
     end
 
     # Sets this channel's name. The name must be alphanumeric with dashes, unless this is a voice channel (then there are no limitations)
@@ -931,10 +1120,29 @@ module Discordrb
     # 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
     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
+    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
+    end
+
+    alias_method :limit=, :user_limit=
+
     # Sets this channel's position in the list.
     # @param position [Integer] The new position.
     def position=(position)
@@ -962,11 +1170,15 @@ module Discordrb
       allow_bits = allow.respond_to?(:bits) ? allow.bits : allow
       deny_bits = deny.respond_to?(:bits) ? deny.bits : deny
 
-      if thing.is_a? User
-        API.update_user_overrides(@bot.token, @id, thing.id, allow_bits, deny_bits)
-      elsif thing.is_a? Role
-        API.update_role_overrides(@bot.token, @id, thing.id, allow_bits, deny_bits)
-      end
+      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
+
+      API::Channel.update_permission(@bot.token, @id, thing.id, allow_bits, deny_bits, type)
     end
 
     # Updates the cached data from another channel.
@@ -975,20 +1187,17 @@ module Discordrb
     def update_from(other)
       @topic = other.topic
       @name = other.name
-      @recipient = other.recipient
       @permission_overwrites = other.permission_overwrites
     end
 
-    # The list of users currently in this channel. This is mostly useful for a voice channel, for a text channel it will
-    # just return the users on the server that are online.
+    # The list of users currently in this channel. For a voice channel, it will return all the members currently
+    # in that channel. For a text channel, it will return all online members that have permission to read it.
     # @return [Array<Member>] the users in this channel
     def users
-      if @type == 'text'
-        @server.members.select { |u| u.status != :offline }
-      else
-        @server.members.select do |user|
-          user.voice_channel.id == @id if user.voice_channel
-        end
+      if text?
+        @server.online_members(include_idle: true).select { |u| u.can_read_messages? self }
+      elsif voice?
+        @server.voice_states.map { |id, voice_state| @server.member(id) if !voice_state.voice_channel.nil? && voice_state.voice_channel.id == @id }.compact
       end
     end
 
@@ -1001,18 +1210,45 @@ module Discordrb
     #   as soon as possible with the specified amount.
     # @return [Array<Message>] the retrieved messages.
     def history(amount, before_id = nil, after_id = nil)
-      logs = API.channel_log(@bot.token, @id, amount, before_id, after_id)
+      logs = API::Channel.messages(@bot.token, @id, amount, before_id, after_id)
       JSON.parse(logs).map { |message| Message.new(message, @bot) }
     end
 
+    # 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)
+      JSON.parse(logs).map { |message| message['id'] }
+    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.
+    def load_message(message_id)
+      response = API::Channel.message(@bot.token, @id, message_id)
+      return Message.new(JSON.parse(response), @bot)
+    rescue RestClient::ResourceNotFound
+      return nil
+    end
+
+    alias_method :message, :load_message
+
+    # Requests all pinned messages of a channel.
+    # @return [Array<Message>] the received messages.
+    def pins
+      msgs = API::Channel.pinned_messages(@bot.token, @id)
+      JSON.parse(msgs).map { |msg| Message.new(msg, @bot) }
+    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)
     # @raise [ArgumentError] if the amount of messages is not a value between 2 and 100
     def prune(amount)
       raise ArgumentError, 'Can only prune between 2 and 100 messages!' unless amount.between?(2, 100)
 
-      messages = history(amount).map(&:id)
-      API.bulk_delete(@bot.token, @id, messages)
+      messages = history_ids(amount)
+      API::Channel.bulk_delete_messages(@bot.token, @id, messages)
     end
 
     # Updates the cached permission overwrites
@@ -1033,33 +1269,214 @@ module Discordrb
     # @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 xkcd [true, false] Whether or not the invite should be human-readable.
     # @return [Invite] the created invite.
-    def make_invite(max_age = 0, max_uses = 0, temporary = false, xkcd = false)
-      response = API.create_invite(@bot.token, @id, max_age, max_uses, temporary, xkcd)
+    def make_invite(max_age = 0, max_uses = 0, temporary = false)
+      response = API::Channel.create_invite(@bot.token, @id, max_age, max_uses, temporary)
       Invite.new(JSON.parse(response), @bot)
     end
 
+    alias_method :invite, :make_invite
+
     # 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)
     def start_typing
-      API.start_typing(@bot.token, @id)
+      API::Channel.start_typing(@bot.token, @id)
     end
 
-    alias_method :send, :send_message
-    alias_method :message, :send_message
-    alias_method :invite, :make_invite
+    # 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).
+    # @return [Channel] the created channel.
+    def create_group(user_ids)
+      raise 'Attempted to create group channel on a non-pm channel!' unless pm?
+      response = API::Channel.create_group(@bot.token, @id, user_ids.shift)
+      channel = Channel.new(JSON.parse(response), @bot)
+      channel.add_group_users(user_ids)
+    end
+
+    # 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)
+      raise 'Attempted to add a user to a non-group channel!' unless group?
+      user_ids = [user_ids] unless user_ids.is_a? Array
+      user_ids.each do |user_id|
+        API::Channel.add_group_user(@bot.token, @id, user_id.resolve_id)
+      end
+      self
+    end
+
+    alias_method :add_group_user, :add_group_users
+
+    # Removes a user from a group channel.
+    # @param user_ids [Array<#resolve_id>, #resolve_id] User ID or array of user IDs to remove from the group channel.
+    # @return [Channel] the group channel.
+    def remove_group_users(user_ids)
+      raise 'Attempted to remove a user from a non-group channel!' unless group?
+      user_ids = [user_ids] unless user_ids.is_a? Array
+      user_ids.each do |user_id|
+        API::Channel.remove_group_user(@bot.token, @id, user_id.resolve_id)
+      end
+      self
+    end
+
+    alias_method :remove_group_user, :remove_group_users
+
+    # Leaves the group
+    def leave_group
+      raise 'Attempted to leave a non-group channel!' unless group?
+      API::Channel.leave_group(@bot.token, @id)
+    end
+
+    alias_method :leave, :leave_group
 
     # The 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
 
+    # Adds a recipient to a group channel.
+    # @param recipient [Recipient] the recipient to add to the group
+    # @raise [ArgumentError] if tried to add a non-recipient
+    # @note For internal use only
+    # @!visibility private
+    def add_recipient(recipient)
+      raise 'Tried to add recipient to a non-group channel' unless group?
+      raise ArgumentError, 'Tried to add a non-recipient to a group' unless recipient.is_a?(Recipient)
+      @recipients << recipient
+    end
+
+    # Removes a recipient from a group channel.
+    # @param recipient [Recipient] the recipient to remove from the group
+    # @raise [ArgumentError] if tried to remove a non-recipient
+    # @note For internal use only
+    # @!visibility private
+    def remove_recipient(recipient)
+      raise 'Tried to add recipient to a non-group channel' unless group?
+      raise ArgumentError, 'Tried to remove a non-recipient from a group' unless recipient.is_a?(Recipient)
+      @recipients.delete(recipient)
+    end
+
     private
 
     def update_channel_data
-      API.update_channel(@bot.token, @id, @name, @topic, @position)
+      API.update_channel(@bot.token, @id, @name, @topic, @position, @bitrate, @user_limit)
+    end
+  end
+
+  # An Embed object that is contained in a message
+  # A freshly generated embed object will not appear in a message object
+  # unless grabbed from its ID in a channel.
+  class Embed
+    # @return [Message] the message this embed object is contained in.
+    attr_reader :message
+
+    # @return [String] the URL this embed object is based on.
+    attr_reader :url
+
+    # @return [String, nil] the title of the embed object. `nil` if there is not a title
+    attr_reader :title
+
+    # @return [String, nil] the description of the embed object. `nil` if there is not a description
+    attr_reader :description
+
+    # @return [Symbol] the type of the embed object. Possible types are:
+    #
+    #   * `:link`
+    #   * `:video`
+    #   * `:image`
+    attr_reader :type
+
+    # @return [EmbedProvider, nil] the provider of the embed object. `nil` is there is not a provider
+    attr_reader :provider
+
+    # @return [EmbedThumbnail, nil] the thumbnail of the embed object. `nil` is there is not a thumbnail
+    attr_reader :thumbnail
+
+    # @return [EmbedAuthor, nil] the author of the embed object. `nil` is there is not an author
+    attr_reader :author
+
+    # @!visibility private
+    def initialize(data, message)
+      @message = message
+
+      @url = data['url']
+      @title = data['title']
+      @type = data['type'].to_sym
+      @description = data['description']
+      @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)
+    end
+  end
+
+  # An Embed thumbnail for the embed object
+  class EmbedThumbnail
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @return [String] the CDN URL this thumbnail can be downloaded at.
+    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
+    attr_reader :proxy_url
+
+    # @return [Integer] the width of this thumbnail file, in pixels.
+    attr_reader :width
+
+    # @return [Integer] the height of this thumbnail file, 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 provider for the embed object
+  class EmbedProvider
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @return [String] the provider's name.
+    attr_reader :name
+
+    # @return [String, nil] the URL of the provider. `nil` is there is no URL
+    attr_reader :url
+
+    # @!visibility private
+    def initialize(data, embed)
+      @embed = embed
+
+      @name = data['name']
+      @url = data['url']
+    end
+  end
+
+  # An Embed author for the embed object
+  class EmbedAuthor
+    # @return [Embed] the embed object this is based on.
+    attr_reader :embed
+
+    # @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
+    attr_reader :url
+
+    # @!visibility private
+    def initialize(data, embed)
+      @embed = embed
+
+      @name = data['name']
+      @url = data['url']
     end
   end
 
@@ -1116,9 +1533,13 @@ module Discordrb
 
     # @return [String] the content of this message.
     attr_reader :content
+    alias_method :text, :content
+    alias_method :to_s, :content
 
     # @return [Member] the user that sent this message.
     attr_reader :author
+    alias_method :user, :author
+    alias_method :writer, :author
 
     # @return [Channel] the channel in which this message was sent.
     attr_reader :channel
@@ -1126,6 +1547,10 @@ module Discordrb
     # @return [Time] the timestamp at which this message was sent.
     attr_reader :timestamp
 
+    # @return [Time] the timestamp at which this message was edited. `nil` if the message was never edited.
+    attr_reader :edited_timestamp
+    alias_method :edit_timestamp, :edited_timestamp
+
     # @return [Array<User>] the users that were mentioned in this message.
     attr_reader :mentions
 
@@ -1135,15 +1560,38 @@ module Discordrb
     # @return [Array<Attachment>] the files attached to this message.
     attr_reader :attachments
 
-    alias_method :user, :author
-    alias_method :text, :content
-    alias_method :to_s, :content
+    # @return [Array<Embed>] the embed objects contained in this message.
+    attr_reader :embeds
+
+    # @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
+    attr_reader :nonce
+
+    # @return [true, false] whether the message was edited or not.
+    attr_reader :edited
+    alias_method :edited?, :edited
+
+    # @return [true, false] whether the message mentioned everyone or not.
+    attr_reader :mention_everyone
+    alias_method :mention_everyone?, :mention_everyone
+    alias_method :mentions_everyone?, :mention_everyone
+
+    # @return [true, false] whether the message is pinned or not.
+    attr_reader :pinned
+    alias_method :pinned?, :pinned
 
     # @!visibility private
     def initialize(data, bot)
       @bot = bot
       @content = data['content']
       @channel = bot.channel(data['channel_id'].to_i)
+      @pinned = data['pinned']
+      @tts = data['tts']
+      @nonce = data['nonce']
+      @mention_everyone = data['mention_everyone']
 
       @author = if data['author']
                   if @channel.private?
@@ -1151,13 +1599,15 @@ module Discordrb
                     # directly because the bot may also send messages to the channel
                     Recipient.new(bot.user(data['author']['id'].to_i), @channel, bot)
                   else
-                    member = @channel.server.member(data['author']['id'].to_i, false)
+                    member = @channel.server.member(data['author']['id'].to_i)
                     Discordrb::LOGGER.warn("Member with ID #{data['author']['id']} not cached even though it should be.") unless member
                     member
                   end
                 end
 
       @timestamp = Time.parse(data['timestamp']) if data['timestamp']
+      @edited_timestamp = data['edited_timestamp'].nil? ? nil : Time.parse(data['edited_timestamp'])
+      @edited = !@edited_timestamp.nil?
       @id = data['id'].to_i
 
       @mentions = []
@@ -1169,7 +1619,7 @@ module Discordrb
       @role_mentions = []
 
       # Role mentions can only happen on public servers so make sure we only parse them there
-      unless @channel.private?
+      if @channel.text?
         data['mention_roles'].each do |element|
           @role_mentions << @channel.server.role(element.to_i)
         end if data['mention_roles']
@@ -1177,6 +1627,9 @@ module Discordrb
 
       @attachments = []
       @attachments = data['attachments'].map { |e| Attachment.new(e, self, @bot) } if data['attachments']
+
+      @embeds = []
+      @embeds = data['embeds'].map { |e| Embed.new(e, self) } if data['embeds']
     end
 
     # Replies to this message with the specified content.
@@ -1189,13 +1642,27 @@ module Discordrb
     # @param new_content [String] the new content the message should have.
     # @return [Message] the resulting message.
     def edit(new_content)
-      response = API.edit_message(@bot.token, @channel.id, @id, new_content)
+      response = API::Channel.edit_message(@bot.token, @channel.id, @id, new_content)
       Message.new(JSON.parse(response), @bot)
     end
 
     # Deletes this message.
     def delete
-      API.delete_message(@bot.token, @channel.id, @id)
+      API::Channel.delete_message(@bot.token, @channel.id, @id)
+      nil
+    end
+
+    # Pins this message
+    def pin
+      API::Channel.pin_message(@bot.token, @channel.id, @id)
+      @pinned = true
+      nil
+    end
+
+    # Unpins this message
+    def unpin
+      API::Channel.unpin_message(@bot.token, @channel.id, @id)
+      @pinned = false
       nil
     end
 
@@ -1227,10 +1694,91 @@ module Discordrb
     # Utility function to get the URL for the icon image
     # @return [String] the URL to the icon image
     def icon_url
+      return nil unless @icon_id
       API.icon_url(@id, @icon_id)
     end
   end
 
+  # Integration Account
+  class IntegrationAccount
+    # @return [String] this accounts's name.
+    attr_reader :name
+
+    # @return [Integer] this account's ID.
+    attr_reader :id
+
+    def initialize(data)
+      @name = data['name']
+      @id = data['id'].to_i
+    end
+  end
+
+  # Server integration
+  class Integration
+    include IDObject
+
+    # @return [String] the integration name
+    attr_reader :name
+
+    # @return [Server] the server the integration is linked to
+    attr_reader :server
+
+    # @return [User] the user the integration is linked to
+    attr_reader :user
+
+    # @return [Role, nil] the role that this integration uses for "subscribers"
+    attr_reader :role
+
+    # @return [true, false] whether emoticons are enabled
+    attr_reader :emoticon
+    alias_method :emoticon?, :emoticon
+
+    # @return [String] the integration type (Youtube, Twitch, etc.)
+    attr_reader :type
+
+    # @return [true, false] whether the integration is enabled
+    attr_reader :enabled
+
+    # @return [true, false] whether the integration is syncing
+    attr_reader :syncing
+
+    # @return [IntegrationAccount] the integration account information
+    attr_reader :account
+
+    # @return [Time] the time the integration was synced at
+    attr_reader :synced_at
+
+    # @return [Symbol] the behaviour of expiring subscribers (:remove = Remove User from role; :kick = Kick User from server)
+    attr_reader :expire_behaviour
+    alias_method :expire_behavior, :expire_behaviour
+
+    # @return [Integer] the grace period before subscribers expire (in days)
+    attr_reader :expire_grace_period
+
+    def initialize(data, bot, server)
+      @bot = bot
+
+      @name = data['name']
+      @server = server
+      @id = data['id'].to_i
+      @enabled = data['enabled']
+      @syncing = data['syncing']
+      @type = data['type']
+      @account = IntegrationAccount.new(data['account'])
+      @synced_at = Time.parse(data['synced_at'])
+      @expire_behaviour = [: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
+      @emoticon = data['enable_emoticons']
+    end
+
+    # The inspect method is overwritten to give more useful output
+    def inspect
+      "<Integration name=#{@name} id=#{@id} type=#{@type} enabled=#{@enabled}>"
+    end
+  end
+
   # A server on Discord
   class Server
     include IDObject
@@ -1253,15 +1801,24 @@ module Discordrb
     attr_reader :large
     alias_method :large?, :large
 
+    # @return [Array<Symbol>] the features of the server (eg. "INVITE_SPLASH")
+    attr_reader :features
+
     # @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
+
     # @!visibility private
     def initialize(data, bot, exists = true)
       @bot = bot
@@ -1271,7 +1828,12 @@ module Discordrb
 
       @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 = {}
 
       process_roles(data['roles'])
       process_members(data['members'])
@@ -1308,7 +1870,7 @@ module Discordrb
       return @members[id] if member_cached?(id)
       return nil unless request
 
-      member = @bot.member(@id, id)
+      member = @bot.member(self, id)
       @members[id] = member
     rescue
       nil
@@ -1326,6 +1888,25 @@ module Discordrb
 
     alias_method :users, :members
 
+    # @return [Array<Integration>] an array of all the integrations connected to this server.
+    def integrations
+      integration = JSON.parse(API.server_integrations(@bot.token, @id))
+      integration.map { |element| Integration.new(element, @bot, self) }
+    end
+
+    # Cache @embed
+    # @note For internal use only
+    # @!visibility private
+    def cache_embed
+      @embed = JSON.parse(API.server(@bot.token, @id))['embed_enabled'] if @embed.nil?
+    end
+
+    # @return [true, false] whether or not the server has widget enabled
+    def embed?
+      cache_embed if @embed.nil?
+      @embed
+    end
+
     # @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.
@@ -1347,6 +1928,42 @@ module Discordrb
       @channels.select(&:voice?)
     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
+      API.widget_url(@id)
+    end
+
+    # @param style [Symbol] The style the picture should have. Possible styles are:
+    #   * `:banner1` creates a rectangular image with the server name, member count and icon, a "Powered by Discord" message on the bottom and an arrow on the right.
+    #   * `:banner2` creates a less tall rectangular image that has the same information as `banner1`, but the Discord logo on the right - together with the arrow and separated by a diagonal separator.
+    #   * `:banner3` creates an image similar in size to `banner1`, but it has the arrow in the bottom part, next to the Discord logo and with a "Chat now" text.
+    #   * `:banner4` creates a tall, almost square, image that prominently features the Discord logo at the top and has a "Join my server" in a pill-style button on the bottom. The information about the server is in the same format as the other three `banner` styles.
+    #   * `:shield` creates a very small, long rectangle, of the style you'd find at the top of GitHub `README.md` files. It features a small version of the Discord logo at the left and the member count at the right.
+    # @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?
+      API.widget_url(@id, style)
+    end
+
+    # @return [String] the hexadecimal ID used to identify this server's splash image for their VIP invite page.
+    def splash_id
+      @splash_id = JSON.parse(API.server(@bot.token, @id))['splash'] if @splash_id.nil?
+      @splash_id
+    end
+
+    # @return [String, nil] the splash image URL for the server's VIP invite page.
+    #   `nil` if there is no splash image.
+    def splash_url
+      splash_id if @splash_id.nil?
+      return nil unless @splash_id
+      API.splash_url(@id, @splash_id)
+    end
+
     # Adds a role to the role cache
     # @note For internal use only
     # @!visibility private
@@ -1399,10 +2016,41 @@ module Discordrb
       @members[member.id] = member
     end
 
+    # Updates a member's voice state
+    # @note For internal use only
+    # @!visibility private
+    def update_voice_state(data)
+      user_id = data['user_id'].to_i
+
+      if data['channel_id']
+        unless @voice_states[user_id]
+          # Create a new voice state for the user
+          @voice_states[user_id] = VoiceState.new(user_id)
+        end
+
+        # Update the existing voice state (or the one we just created)
+        channel = @channels_by_id[data['channel_id'].to_i]
+        @voice_states[user_id].update(
+          channel,
+          data['mute'],
+          data['deaf'],
+          data['self_mute'],
+          data['self_deaf']
+        )
+      else
+        # The user is not in a voice channel anymore, so delete its voice state
+        @voice_states.delete(user_id)
+      end
+    end
+
     # Creates a channel on this server with the given name.
+    # @param name [String] Name of the channel to create
+    # @param type [Integer] Type of channel to create (0: text, 2: voice)
     # @return [Channel] the created channel.
-    def create_channel(name, type = 'text')
-      response = API.create_channel(@bot.token, @id, name, type)
+    # @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)
       Channel.new(JSON.parse(response), @bot)
     end
 
@@ -1411,7 +2059,7 @@ module Discordrb
     # colour is the default etc.
     # @return [Role] the created role.
     def create_role
-      response = API.create_role(@bot.token, @id)
+      response = API::Server.create_role(@bot.token, @id)
       role = Role.new(JSON.parse(response), @bot, self)
       @roles << role
       role
@@ -1419,7 +2067,7 @@ module Discordrb
 
     # @return [Array<User>] a list of banned users on this server.
     def bans
-      users = JSON.parse(API.bans(@bot.token, @id))
+      users = JSON.parse(API::Server.bans(@bot.token, @id))
       users.map { |e| User.new(e['user'], @bot) }
     end
 
@@ -1427,42 +2075,42 @@ module Discordrb
     # @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.ban_user(@bot.token, @id, user.resolve_id, message_days)
+      API::Server.ban_user(@bot.token, @id, user.resolve_id, message_days)
     end
 
     # Unbans a previously banned user from this server.
     # @param user [User, #resolve_id] The user to unban.
     def unban(user)
-      API.unban_user(@bot.token, @id, user.resolve_id)
+      API::Server.unban_user(@bot.token, @id, user.resolve_id)
     end
 
     # Kicks a user from this server.
     # @param user [User, #resolve_id] The user to kick.
     def kick(user)
-      API.kick_user(@bot.token, @id, user.resolve_id)
+      API::Server.remove_member(@bot.token, @id, user.resolve_id)
     end
 
     # Forcibly moves a user into a different voice channel. Only works if the bot has the permission needed.
     # @param user [User] The user to move.
     # @param channel [Channel] The voice channel to move into.
     def move(user, channel)
-      API.move_user(@bot.token, @id, user.id, channel.id)
+      API::Server.update_member(@bot.token, @id, user.id, channel_id: channel.id)
     end
 
     # Deletes this server. Be aware that this is permanent and impossible to undo, so be careful!
     def delete
-      API.delete_server(@bot.token, @id)
+      API::Server.delete(@bot.token, @id)
     end
 
     # Leave the server
     def leave
-      API.leave_server(@bot.token, @id)
+      API::User.leave_server(@bot.token, @id)
     end
 
     # Transfers server ownership to another user.
     # @param user [User] The user who should become the new owner.
     def owner=(user)
-      API.transfer_ownership(@bot.token, @id, user.id)
+      API::Server.transfer_ownership(@bot.token, @id, user.id)
     end
 
     # Sets the server's name.
@@ -1529,7 +2177,13 @@ module Discordrb
       @afk_timeout = new_data[:afk_timeout] || new_data['afk_timeout'].to_i || @afk_timeout
 
       @afk_channel_id = new_data[:afk_channel_id] || new_data['afk_channel_id'].to_i || @afk_channel.id
-      @afk_channel = @bot.channel(@afk_channel_id, self) if @afk_channel_id != 0 && (!@afk_channel || @afk_channel_id != @afk_channel.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
     end
 
     # The inspect method is overwritten to give more useful output
@@ -1540,12 +2194,12 @@ module Discordrb
     private
 
     def update_server_data(new_data)
-      API.update_server(@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)
+      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)
     end
 
@@ -1566,17 +2220,6 @@ module Discordrb
       return unless members
       members.each do |element|
         member = Member.new(element, self, @bot)
-        if @members[member.id] && @members[member.id].voice_channel
-          @bot.debug("Preserving voice state of member #{member.id} while chunking")
-          old_member = @members[member.id]
-          member.update_voice_state(
-            old_member.voice_channel,
-            old_member.mute,
-            old_member.deaf,
-            old_member.self_mute,
-            old_member.self_deaf
-          )
-        end
         @members[member.id] = member
       end
     end
@@ -1591,6 +2234,8 @@ module Discordrb
         if user
           user.status = element['status'].to_sym
           user.game = element['game'] ? element['game']['name'] : nil
+        else
+          LOGGER.warn "Rogue presence update! #{element['user']['id']} on #{@id}"
         end
       end
     end
@@ -1610,18 +2255,7 @@ module Discordrb
     def process_voice_states(voice_states)
       return unless voice_states
       voice_states.each do |element|
-        user_id = element['user_id'].to_i
-        member = @members[user_id]
-        next unless member
-        channel_id = element['channel_id'].to_i
-        channel = channel_id ? @channels_by_id[channel_id] : nil
-
-        member.update_voice_state(
-          channel,
-          element['mute'],
-          element['deaf'],
-          element['self_mute'],
-          element['self_deaf'])
+        update_voice_state(element)
       end
     end
   end