diff --git a/src/Discord.Net.Commands/Attributes/InAttribute.cs b/src/Discord.Net.Commands/Attributes/InAttribute.cs
new file mode 100644
index 000000000..0d4fd9eb0
--- /dev/null
+++ b/src/Discord.Net.Commands/Attributes/InAttribute.cs
@@ -0,0 +1,8 @@
+using System;
+
+namespace Discord.Commands
+{
+    public class InAttribute : Attribute
+    {
+    }
+}
diff --git a/src/Discord.Net.Commands/Attributes/PreconditionAttribute.cs b/src/Discord.Net.Commands/Attributes/PreconditionAttribute.cs
index ae9457b92..90e82607e 100644
--- a/src/Discord.Net.Commands/Attributes/PreconditionAttribute.cs
+++ b/src/Discord.Net.Commands/Attributes/PreconditionAttribute.cs
@@ -6,6 +6,6 @@ namespace Discord.Commands
     [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
     public abstract class PreconditionAttribute : Attribute
     {
-        public abstract Task<PreconditionResult> CheckPermissions(IUserMessage context, Command executingCommand, object moduleInstance);
+        public abstract Task<PreconditionResult> CheckPermissions(CommandContext context, Command executingCommand, object moduleInstance);
     }
 }
diff --git a/src/Discord.Net.Commands/Attributes/Preconditions/RequireContextAttribute.cs b/src/Discord.Net.Commands/Attributes/Preconditions/RequireContextAttribute.cs
index 48ada73d9..c14dbd5bf 100644
--- a/src/Discord.Net.Commands/Attributes/Preconditions/RequireContextAttribute.cs
+++ b/src/Discord.Net.Commands/Attributes/Preconditions/RequireContextAttribute.cs
@@ -21,7 +21,7 @@ namespace Discord.Commands
             Contexts = contexts;
         }
 
-        public override Task<PreconditionResult> CheckPermissions(IUserMessage context, Command executingCommand, object moduleInstance)
+        public override Task<PreconditionResult> CheckPermissions(CommandContext context, Command executingCommand, object moduleInstance)
         {
             bool isValid = false;
 
diff --git a/src/Discord.Net.Commands/Attributes/Preconditions/RequirePermissionAttribute.cs b/src/Discord.Net.Commands/Attributes/Preconditions/RequirePermissionAttribute.cs
index b3215c419..3583836d8 100644
--- a/src/Discord.Net.Commands/Attributes/Preconditions/RequirePermissionAttribute.cs
+++ b/src/Discord.Net.Commands/Attributes/Preconditions/RequirePermissionAttribute.cs
@@ -20,9 +20,9 @@ namespace Discord.Commands
             GuildPermission = null;
         }
         
-        public override Task<PreconditionResult> CheckPermissions(IUserMessage context, Command executingCommand, object moduleInstance)
+        public override Task<PreconditionResult> CheckPermissions(CommandContext context, Command executingCommand, object moduleInstance)
         {
-            var guildUser = context.Author as IGuildUser;
+            var guildUser = context.User as IGuildUser;
 
             if (GuildPermission.HasValue)
             {
diff --git a/src/Discord.Net.Commands/Command.cs b/src/Discord.Net.Commands/Command.cs
index b7b7da401..2b8a46c77 100644
--- a/src/Discord.Net.Commands/Command.cs
+++ b/src/Discord.Net.Commands/Command.cs
@@ -16,7 +16,7 @@ namespace Discord.Commands
         private static readonly ConcurrentDictionary<Type, Func<IEnumerable<object>, object>> _arrayConverters = new ConcurrentDictionary<Type, Func<IEnumerable<object>, object>>();
 
         private readonly object _instance;
-        private readonly Func<IUserMessage, IReadOnlyList<object>, Task> _action;
+        private readonly Func<CommandContext, IReadOnlyList<object>, Task> _action;
 
         public MethodInfo Source { get; }
         public Module Module { get; }
@@ -85,7 +85,7 @@ namespace Discord.Commands
             }
         }
 
-        public async Task<PreconditionResult> CheckPreconditions(IUserMessage context)
+        public async Task<PreconditionResult> CheckPreconditions(CommandContext context)
         {
             foreach (PreconditionAttribute precondition in Module.Preconditions)
             {
@@ -104,7 +104,7 @@ namespace Discord.Commands
             return PreconditionResult.FromSuccess();
         }
 
-        public async Task<ParseResult> Parse(IUserMessage context, SearchResult searchResult, PreconditionResult? preconditionResult = null)
+        public async Task<ParseResult> Parse(CommandContext context, SearchResult searchResult, PreconditionResult? preconditionResult = null)
         {
             if (!searchResult.IsSuccess)
                 return ParseResult.FromError(searchResult);
@@ -125,7 +125,7 @@ namespace Discord.Commands
 
             return await CommandParser.ParseArgs(this, context, input, 0).ConfigureAwait(false);
         }
-        public Task<ExecuteResult> Execute(IUserMessage context, ParseResult parseResult)
+        public Task<ExecuteResult> Execute(CommandContext context, ParseResult parseResult)
         {
             if (!parseResult.IsSuccess)
                 return Task.FromResult(ExecuteResult.FromError(parseResult));
@@ -148,7 +148,7 @@ namespace Discord.Commands
 
             return Execute(context, argList, paramList);
         }
-        public async Task<ExecuteResult> Execute(IUserMessage context, IEnumerable<object> argList, IEnumerable<object> paramList)
+        public async Task<ExecuteResult> Execute(CommandContext context, IEnumerable<object> argList, IEnumerable<object> paramList)
         {
             try
             {
@@ -209,7 +209,7 @@ namespace Discord.Commands
             }
             return paramBuilder.ToImmutable();
         }
-        private Func<IUserMessage, IReadOnlyList<object>, Task> BuildAction(MethodInfo methodInfo)
+        private Func<CommandContext, IReadOnlyList<object>, Task> BuildAction(MethodInfo methodInfo)
         {
             if (methodInfo.ReturnType != typeof(Task))
                 throw new InvalidOperationException("Commands must return a non-generic Task.");
diff --git a/src/Discord.Net.Commands/CommandContext.cs b/src/Discord.Net.Commands/CommandContext.cs
new file mode 100644
index 000000000..c2be3ef59
--- /dev/null
+++ b/src/Discord.Net.Commands/CommandContext.cs
@@ -0,0 +1,18 @@
+namespace Discord.Commands
+{
+    public struct CommandContext
+    {
+        public IGuild Guild { get; }
+        public IMessageChannel Channel { get; }
+        public IUser User { get; }
+        public IUserMessage Message { get; }
+
+        internal CommandContext(IGuild guild, IMessageChannel channel, IUser user, IUserMessage msg)
+        {
+            Guild = guild;
+            Channel = channel;
+            User = user;
+            Message = msg;
+        }
+    }
+}
diff --git a/src/Discord.Net.Commands/CommandParameter.cs b/src/Discord.Net.Commands/CommandParameter.cs
index f074876cf..1edf42bf1 100644
--- a/src/Discord.Net.Commands/CommandParameter.cs
+++ b/src/Discord.Net.Commands/CommandParameter.cs
@@ -32,7 +32,7 @@ namespace Discord.Commands
             DefaultValue = defaultValue;
         }
 
-        public async Task<TypeReaderResult> Parse(IUserMessage context, string input)
+        public async Task<TypeReaderResult> Parse(CommandContext context, string input)
         {
             return await _reader.Read(context, input).ConfigureAwait(false);
         }
diff --git a/src/Discord.Net.Commands/CommandParser.cs b/src/Discord.Net.Commands/CommandParser.cs
index 77e19109a..b87e67aa0 100644
--- a/src/Discord.Net.Commands/CommandParser.cs
+++ b/src/Discord.Net.Commands/CommandParser.cs
@@ -13,7 +13,7 @@ namespace Discord.Commands
             QuotedParameter
         }
         
-        public static async Task<ParseResult> ParseArgs(Command command, IUserMessage context, string input, int startPos)
+        public static async Task<ParseResult> ParseArgs(Command command, CommandContext context, string input, int startPos)
         {
             CommandParameter curParam = null;
             StringBuilder argBuilder = new StringBuilder(input.Length);
diff --git a/src/Discord.Net.Commands/CommandService.cs b/src/Discord.Net.Commands/CommandService.cs
index 344950e68..8aff5f715 100644
--- a/src/Discord.Net.Commands/CommandService.cs
+++ b/src/Discord.Net.Commands/CommandService.cs
@@ -176,8 +176,8 @@ namespace Discord.Commands
                 return false;
         }
 
-        public SearchResult Search(IUserMessage message, int argPos) => Search(message, message.Content.Substring(argPos));
-        public SearchResult Search(IUserMessage message, string input)
+        public SearchResult Search(CommandContext context, int argPos) => Search(context, context.Message.Content.Substring(argPos));
+        public SearchResult Search(CommandContext context, string input)
         {
             string lowerInput = input.ToLowerInvariant();
             var matches = _map.GetCommands(input).OrderByDescending(x => x.Priority).ToImmutableArray();
@@ -188,18 +188,18 @@ namespace Discord.Commands
                 return SearchResult.FromError(CommandError.UnknownCommand, "Unknown command.");
         }
 
-        public Task<IResult> Execute(IUserMessage message, int argPos, MultiMatchHandling multiMatchHandling = MultiMatchHandling.Exception) 
-            => Execute(message, message.Content.Substring(argPos), multiMatchHandling);
-        public async Task<IResult> Execute(IUserMessage message, string input, MultiMatchHandling multiMatchHandling = MultiMatchHandling.Exception)
+        public Task<IResult> Execute(CommandContext context, int argPos, MultiMatchHandling multiMatchHandling = MultiMatchHandling.Exception) 
+            => Execute(context, context.Message.Content.Substring(argPos), multiMatchHandling);
+        public async Task<IResult> Execute(CommandContext context, string input, MultiMatchHandling multiMatchHandling = MultiMatchHandling.Exception)
         {
-            var searchResult = Search(message, input);
+            var searchResult = Search(context, input);
             if (!searchResult.IsSuccess)
                 return searchResult;
 
             var commands = searchResult.Commands;
             for (int i = commands.Count - 1; i >= 0; i--)
             {
-                var preconditionResult = await commands[i].CheckPreconditions(message);
+                var preconditionResult = await commands[i].CheckPreconditions(context);
                 if (!preconditionResult.IsSuccess)
                 {
                     if (commands.Count == 1)
@@ -208,7 +208,7 @@ namespace Discord.Commands
                         continue;
                 }
 
-                var parseResult = await commands[i].Parse(message, searchResult, preconditionResult);
+                var parseResult = await commands[i].Parse(context, searchResult, preconditionResult);
                 if (!parseResult.IsSuccess)
                 {
                     if (parseResult.Error == CommandError.MultipleMatches)
@@ -233,7 +233,7 @@ namespace Discord.Commands
                     }
                 }
 
-                return await commands[i].Execute(message, parseResult);
+                return await commands[i].Execute(context, parseResult);
             }
             
             return SearchResult.FromError(CommandError.UnknownCommand, "This input does not match any overload.");
diff --git a/src/Discord.Net.Commands/Readers/ChannelTypeReader.cs b/src/Discord.Net.Commands/Readers/ChannelTypeReader.cs
index 463a9de4f..8ace89961 100644
--- a/src/Discord.Net.Commands/Readers/ChannelTypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/ChannelTypeReader.cs
@@ -9,23 +9,21 @@ namespace Discord.Commands
     internal class ChannelTypeReader<T> : TypeReader
         where T : class, IChannel
     {
-        public override async Task<TypeReaderResult> Read(IUserMessage context, string input)
+        public override async Task<TypeReaderResult> Read(CommandContext context, string input)
         {
-            var guild = (context.Channel as IGuildChannel)?.Guild;
-
-            if (guild != null)
+            if (context.Guild != null)
             {
                 var results = new Dictionary<ulong, TypeReaderValue>();
-                var channels = await guild.GetChannelsAsync().ConfigureAwait(false);
+                var channels = await context.Guild.GetChannelsAsync().ConfigureAwait(false);
                 ulong id;
 
                 //By Mention (1.0)
                 if (MentionUtils.TryParseChannel(input, out id))
-                    AddResult(results, await guild.GetChannelAsync(id).ConfigureAwait(false) as T, 1.00f);
+                    AddResult(results, await context.Guild.GetChannelAsync(id).ConfigureAwait(false) as T, 1.00f);
 
                 //By Id (0.9)
                 if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
-                    AddResult(results, await guild.GetChannelAsync(id).ConfigureAwait(false) as T, 0.90f);
+                    AddResult(results, await context.Guild.GetChannelAsync(id).ConfigureAwait(false) as T, 0.90f);
 
                 //By Name (0.7-0.8)
                 foreach (var channel in channels.Where(x => string.Equals(input, x.Name, StringComparison.OrdinalIgnoreCase)))
diff --git a/src/Discord.Net.Commands/Readers/EnumTypeReader.cs b/src/Discord.Net.Commands/Readers/EnumTypeReader.cs
index 54efa8024..dca845704 100644
--- a/src/Discord.Net.Commands/Readers/EnumTypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/EnumTypeReader.cs
@@ -42,7 +42,7 @@ namespace Discord.Commands
             _enumsByValue = byValueBuilder.ToImmutable();
         }
 
-        public override Task<TypeReaderResult> Read(IUserMessage context, string input)
+        public override Task<TypeReaderResult> Read(CommandContext context, string input)
         {
             T baseValue;
             object enumValue;
diff --git a/src/Discord.Net.Commands/Readers/MessageTypeReader.cs b/src/Discord.Net.Commands/Readers/MessageTypeReader.cs
index b509fc025..57bfc21cd 100644
--- a/src/Discord.Net.Commands/Readers/MessageTypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/MessageTypeReader.cs
@@ -6,19 +6,19 @@ namespace Discord.Commands
     internal class MessageTypeReader<T> : TypeReader
         where T : class, IMessage
     {
-        public override Task<TypeReaderResult> Read(IUserMessage context, string input)
+        public override async Task<TypeReaderResult> Read(CommandContext context, string input)
         {
             ulong id;
 
             //By Id (1.0)
             if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
             {
-                var msg = context.Channel.GetCachedMessage(id) as T;
+                var msg = await context.Channel.GetMessageAsync(id, CacheMode.CacheOnly).ConfigureAwait(false) as T;
                 if (msg != null)
-                    return Task.FromResult(TypeReaderResult.FromSuccess(msg));
+                    return TypeReaderResult.FromSuccess(msg);
             }
 
-            return Task.FromResult(TypeReaderResult.FromError(CommandError.ObjectNotFound, "Message not found."));
+            return TypeReaderResult.FromError(CommandError.ObjectNotFound, "Message not found.");
         }
     }
 }
diff --git a/src/Discord.Net.Commands/Readers/RoleTypeReader.cs b/src/Discord.Net.Commands/Readers/RoleTypeReader.cs
index b386aba3c..66b76b7e7 100644
--- a/src/Discord.Net.Commands/Readers/RoleTypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/RoleTypeReader.cs
@@ -9,23 +9,22 @@ namespace Discord.Commands
     internal class RoleTypeReader<T> : TypeReader
         where T : class, IRole
     {
-        public override Task<TypeReaderResult> Read(IUserMessage context, string input)
+        public override Task<TypeReaderResult> Read(CommandContext context, string input)
         {
-            var guild = (context.Channel as IGuildChannel)?.Guild;
             ulong id;
 
-            if (guild != null)
+            if (context.Guild != null)
             {
                 var results = new Dictionary<ulong, TypeReaderValue>();
-                var roles = guild.Roles;
+                var roles = context.Guild.Roles;
 
                 //By Mention (1.0)
                 if (MentionUtils.TryParseRole(input, out id))
-                    AddResult(results, guild.GetRole(id) as T, 1.00f);
+                    AddResult(results, context.Guild.GetRole(id) as T, 1.00f);
 
                 //By Id (0.9)
                 if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
-                     AddResult(results, guild.GetRole(id) as T, 0.90f);
+                     AddResult(results, context.Guild.GetRole(id) as T, 0.90f);
 
                 //By Name (0.7-0.8)
                 foreach (var role in roles.Where(x => string.Equals(input, x.Name, StringComparison.OrdinalIgnoreCase)))
diff --git a/src/Discord.Net.Commands/Readers/SimpleTypeReader.cs b/src/Discord.Net.Commands/Readers/SimpleTypeReader.cs
index 72c729a3b..ad939e59d 100644
--- a/src/Discord.Net.Commands/Readers/SimpleTypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/SimpleTypeReader.cs
@@ -11,7 +11,7 @@ namespace Discord.Commands
             _tryParse = PrimitiveParsers.Get<T>();
         }
 
-        public override Task<TypeReaderResult> Read(IUserMessage context, string input)
+        public override Task<TypeReaderResult> Read(CommandContext context, string input)
         {
             T value;
             if (_tryParse(input, out value))
diff --git a/src/Discord.Net.Commands/Readers/TypeReader.cs b/src/Discord.Net.Commands/Readers/TypeReader.cs
index 4d467ce55..23562cb16 100644
--- a/src/Discord.Net.Commands/Readers/TypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/TypeReader.cs
@@ -4,6 +4,6 @@ namespace Discord.Commands
 {
     public abstract class TypeReader
     {
-        public abstract Task<TypeReaderResult> Read(IUserMessage context, string input);
+        public abstract Task<TypeReaderResult> Read(CommandContext context, string input);
     }
 }
diff --git a/src/Discord.Net.Commands/Readers/UserTypeReader.cs b/src/Discord.Net.Commands/Readers/UserTypeReader.cs
index 46aaa777c..c6416895a 100644
--- a/src/Discord.Net.Commands/Readers/UserTypeReader.cs
+++ b/src/Discord.Net.Commands/Readers/UserTypeReader.cs
@@ -9,22 +9,21 @@ namespace Discord.Commands
     internal class UserTypeReader<T> : TypeReader
         where T : class, IUser
     {
-        public override async Task<TypeReaderResult> Read(IUserMessage context, string input)
+        public override async Task<TypeReaderResult> Read(CommandContext context, string input)
         {
             var results = new Dictionary<ulong, TypeReaderValue>();
-            var guild = (context.Channel as IGuildChannel)?.Guild;
-            IReadOnlyCollection<IUser> channelUsers = await context.Channel.GetUsersAsync().ConfigureAwait(false);
+            IReadOnlyCollection<IUser> channelUsers = (await context.Channel.GetUsersAsync().Flatten().ConfigureAwait(false)).ToArray(); //TODO: must be a better way?
             IReadOnlyCollection<IGuildUser> guildUsers = null;
             ulong id;
 
-            if (guild != null)
-                guildUsers = await guild.GetUsersAsync().ConfigureAwait(false);
+            if (context.Guild != null)
+                guildUsers = await context.Guild.GetUsersAsync().ConfigureAwait(false);
 
             //By Mention (1.0)
             if (MentionUtils.TryParseUser(input, out id))
             {
-                if (guild != null)
-                    AddResult(results, await guild.GetUserAsync(id).ConfigureAwait(false) as T, 1.00f);
+                if (context.Guild != null)
+                    AddResult(results, await context.Guild.GetUserAsync(id).ConfigureAwait(false) as T, 1.00f);
                 else
                     AddResult(results, await context.Channel.GetUserAsync(id).ConfigureAwait(false) as T, 1.00f);
             }
@@ -32,8 +31,8 @@ namespace Discord.Commands
             //By Id (0.9)
             if (ulong.TryParse(input, NumberStyles.None, CultureInfo.InvariantCulture, out id))
             {
-                if (guild != null)
-                    AddResult(results, await guild.GetUserAsync(id).ConfigureAwait(false) as T, 0.90f);
+                if (context.Guild != null)
+                    AddResult(results, await context.Guild.GetUserAsync(id).ConfigureAwait(false) as T, 0.90f);
                 else
                     AddResult(results, await context.Channel.GetUserAsync(id).ConfigureAwait(false) as T, 0.90f);
             }
diff --git a/src/Discord.Net.Commands/project.json b/src/Discord.Net.Commands/project.json
index c0449bf35..8e5d861d8 100644
--- a/src/Discord.Net.Commands/project.json
+++ b/src/Discord.Net.Commands/project.json
@@ -13,18 +13,14 @@
     }
   },
 
-  "buildOptions": {
-    "allowUnsafe": true,
-    "warningsAsErrors": false,
-    "xmlDoc": true
-  },
-
   "configurations": {
     "Release": {
       "buildOptions": {
         "define": [ "RELEASE" ],
         "nowarn": [ "CS1573", "CS1591" ],
-        "optimize": true
+        "optimize": true,
+        "warningsAsErrors": true,
+        "xmlDoc": true
       }
     }
   },
diff --git a/src/Discord.Net.Core/API/DiscordRestApiClient.cs b/src/Discord.Net.Core/API/DiscordRestApiClient.cs
index 5c0aee850..b70ea015b 100644
--- a/src/Discord.Net.Core/API/DiscordRestApiClient.cs
+++ b/src/Discord.Net.Core/API/DiscordRestApiClient.cs
@@ -856,27 +856,6 @@ namespace Discord.API
             }
             catch (HttpException ex) when (ex.StatusCode == HttpStatusCode.NotFound) { return null; }
         }
-        public async Task<User> GetUserAsync(string username, string discriminator, RequestOptions options = null)
-        {
-            Preconditions.NotNullOrEmpty(username, nameof(username));
-            Preconditions.NotNullOrEmpty(discriminator, nameof(discriminator));
-            options = RequestOptions.CreateOrClone(options);
-
-            try
-            {
-                var models = await QueryUsersAsync($"{username}#{discriminator}", 1, options: options).ConfigureAwait(false);
-                return models.FirstOrDefault();
-            }
-            catch (HttpException ex) when (ex.StatusCode == HttpStatusCode.NotFound) { return null; }
-        }
-        public async Task<IReadOnlyCollection<User>> QueryUsersAsync(string query, int limit, RequestOptions options = null)
-        {
-            Preconditions.NotNullOrEmpty(query, nameof(query));
-            Preconditions.AtLeast(limit, 0, nameof(limit));
-            options = RequestOptions.CreateOrClone(options);
-
-            return await SendAsync<IReadOnlyCollection<User>>("GET", $"users?q={Uri.EscapeDataString(query)}&limit={limit}", options: options).ConfigureAwait(false);
-        }
 
         //Current User/DMs
         public async Task<User> GetMyUserAsync(RequestOptions options = null)
diff --git a/src/Discord.Net.Core/Entities/Users/IGuildUser.cs b/src/Discord.Net.Core/Entities/Users/IGuildUser.cs
index 768951c79..72cbabb30 100644
--- a/src/Discord.Net.Core/Entities/Users/IGuildUser.cs
+++ b/src/Discord.Net.Core/Entities/Users/IGuildUser.cs
@@ -12,6 +12,7 @@ namespace Discord
         DateTimeOffset? JoinedAt { get; }
         /// <summary> Gets the nickname for this user. </summary>
         string Nickname { get; }
+        GuildPermissions GuildPermissions { get; }
 
         /// <summary> Gets the id of the guild for this user. </summary>
         ulong GuildId { get; }
diff --git a/src/Discord.Net.Core/IDiscordClient.cs b/src/Discord.Net.Core/IDiscordClient.cs
index 79ca30634..92dc6b7ba 100644
--- a/src/Discord.Net.Core/IDiscordClient.cs
+++ b/src/Discord.Net.Core/IDiscordClient.cs
@@ -19,18 +19,18 @@ namespace Discord
 
         Task<IApplication> GetApplicationInfoAsync();
 
-        Task<IChannel> GetChannelAsync(ulong id);
-        Task<IReadOnlyCollection<IPrivateChannel>> GetPrivateChannelsAsync();
+        Task<IChannel> GetChannelAsync(ulong id, CacheMode mode = CacheMode.AllowDownload);
+        Task<IReadOnlyCollection<IPrivateChannel>> GetPrivateChannelsAsync(CacheMode mode = CacheMode.AllowDownload);
 
         Task<IReadOnlyCollection<IConnection>> GetConnectionsAsync();
 
-        Task<IGuild> GetGuildAsync(ulong id);
-        Task<IReadOnlyCollection<IGuild>> GetGuildsAsync();
+        Task<IGuild> GetGuildAsync(ulong id, CacheMode mode = CacheMode.AllowDownload);
+        Task<IReadOnlyCollection<IGuild>> GetGuildsAsync(CacheMode mode = CacheMode.AllowDownload);
         Task<IGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null);
         
         Task<IInvite> GetInviteAsync(string inviteId);
 
-        Task<IUser> GetUserAsync(ulong id);
+        Task<IUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload);
         Task<IUser> GetUserAsync(string username, string discriminator);
 
         Task<IReadOnlyCollection<IVoiceRegion>> GetVoiceRegionsAsync();
diff --git a/src/Discord.Net.Rest/BaseDiscordClient.cs b/src/Discord.Net.Rest/BaseDiscordClient.cs
index 98d25cba3..62dcfd055 100644
--- a/src/Discord.Net.Rest/BaseDiscordClient.cs
+++ b/src/Discord.Net.Rest/BaseDiscordClient.cs
@@ -129,9 +129,9 @@ namespace Discord.Rest
 
         Task<IApplication> IDiscordClient.GetApplicationInfoAsync() { throw new NotSupportedException(); }
 
-        Task<IChannel> IDiscordClient.GetChannelAsync(ulong id)
+        Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode)
             => Task.FromResult<IChannel>(null);
-        Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync()
+        Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode)
             => Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(ImmutableArray.Create<IPrivateChannel>());
 
         Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync()
@@ -140,13 +140,13 @@ namespace Discord.Rest
         Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId)
             => Task.FromResult<IInvite>(null);
 
-        Task<IGuild> IDiscordClient.GetGuildAsync(ulong id)
+        Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode)
             => Task.FromResult<IGuild>(null);
-        Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync()
+        Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode)
             => Task.FromResult<IReadOnlyCollection<IGuild>>(ImmutableArray.Create<IGuild>());
         Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon) { throw new NotSupportedException(); }
 
-        Task<IUser> IDiscordClient.GetUserAsync(ulong id)
+        Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode)
             => Task.FromResult<IUser>(null);
         Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator)
             => Task.FromResult<IUser>(null);
diff --git a/src/Discord.Net.Rest/ClientHelper.cs b/src/Discord.Net.Rest/ClientHelper.cs
index 02ccb2c5b..f1c619e02 100644
--- a/src/Discord.Net.Rest/ClientHelper.cs
+++ b/src/Discord.Net.Rest/ClientHelper.cs
@@ -94,12 +94,12 @@ namespace Discord.Rest
                 return RestUser.Create(client, model);
             return null;
         }
-        public static async Task<RestUser> GetUserAsync(BaseDiscordClient client,
-            string username, string discriminator)
+        public static async Task<RestGuildUser> GetGuildUserAsync(BaseDiscordClient client,
+            ulong guildId, ulong id)
         {
-            var model = await client.ApiClient.GetUserAsync(username, discriminator).ConfigureAwait(false);
+            var model = await client.ApiClient.GetGuildMemberAsync(guildId, id).ConfigureAwait(false);
             if (model != null)
-                return RestUser.Create(client, model);
+                return RestGuildUser.Create(client, new RestGuild(client, guildId), model);
             return null;
         }
 
diff --git a/src/Discord.Net.Rest/DiscordRestClient.cs b/src/Discord.Net.Rest/DiscordRestClient.cs
index 6fa954116..2e9ff861c 100644
--- a/src/Discord.Net.Rest/DiscordRestClient.cs
+++ b/src/Discord.Net.Rest/DiscordRestClient.cs
@@ -1,5 +1,6 @@
 using Discord.Net.Queue;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.IO;
 using System.Threading.Tasks;
 
@@ -60,8 +61,8 @@ namespace Discord.Rest
         public Task<RestUser> GetUserAsync(ulong id)
             => ClientHelper.GetUserAsync(this, id);
         /// <inheritdoc />
-        public Task<RestUser> GetUserAsync(string username, string discriminator)
-            => ClientHelper.GetUserAsync(this, username, discriminator);
+        public Task<RestGuildUser> GetGuildUserAsync(ulong guildId, ulong id)
+            => ClientHelper.GetGuildUserAsync(this, guildId, id);
 
         /// <inheritdoc />
         public Task<IReadOnlyCollection<RestVoiceRegion>> GetVoiceRegionsAsync()
@@ -74,10 +75,20 @@ namespace Discord.Rest
         async Task<IApplication> IDiscordClient.GetApplicationInfoAsync()
             => await GetApplicationInfoAsync().ConfigureAwait(false);
 
-        async Task<IChannel> IDiscordClient.GetChannelAsync(ulong id)
-            => await GetChannelAsync(id);
-        async Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync()
-            => await GetPrivateChannelsAsync();
+        async Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode)
+        {
+            if (mode == CacheMode.AllowDownload)
+                return await GetChannelAsync(id);
+            else
+                return null;
+        }
+        async Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode)
+        {
+            if (mode == CacheMode.AllowDownload)
+                return await GetPrivateChannelsAsync();
+            else
+                return ImmutableArray.Create<IPrivateChannel>();
+        }
 
         async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync()
             => await GetConnectionsAsync().ConfigureAwait(false);
@@ -85,17 +96,30 @@ namespace Discord.Rest
         async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId)
             => await GetInviteAsync(inviteId).ConfigureAwait(false);
 
-        async Task<IGuild> IDiscordClient.GetGuildAsync(ulong id)
-            => await GetGuildAsync(id).ConfigureAwait(false);
-        async Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync()
-            => await GetGuildsAsync().ConfigureAwait(false);
+        async Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode)
+        {
+            if (mode == CacheMode.AllowDownload)
+                return await GetGuildAsync(id).ConfigureAwait(false);
+            else
+                return null;
+        }
+        async Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode)
+        {
+            if (mode == CacheMode.AllowDownload)
+                return await GetGuildsAsync().ConfigureAwait(false);
+            else
+                return ImmutableArray.Create<IGuild>();
+        }
         async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon)
             => await CreateGuildAsync(name, region, jpegIcon).ConfigureAwait(false);
 
-        async Task<IUser> IDiscordClient.GetUserAsync(ulong id)
-            => await GetUserAsync(id).ConfigureAwait(false);
-        async Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator)
-            => await GetUserAsync(username, discriminator).ConfigureAwait(false);
+        async Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode)
+        {
+            if (mode == CacheMode.AllowDownload)
+                return await GetUserAsync(id).ConfigureAwait(false);
+            else
+                return null;
+        }
 
         async Task<IReadOnlyCollection<IVoiceRegion>> IDiscordClient.GetVoiceRegionsAsync()
             => await GetVoiceRegionsAsync().ConfigureAwait(false);
diff --git a/src/Discord.Net.Rest/Entities/Channels/ChannelHelper.cs b/src/Discord.Net.Rest/Entities/Channels/ChannelHelper.cs
index 0022c79d9..5a14c7ee4 100644
--- a/src/Discord.Net.Rest/Entities/Channels/ChannelHelper.cs
+++ b/src/Discord.Net.Rest/Entities/Channels/ChannelHelper.cs
@@ -163,19 +163,19 @@ namespace Discord.Rest
         }
 
         //Users
-        public static async Task<RestGuildUser> GetUserAsync(IGuildChannel channel, BaseDiscordClient client,
+        public static async Task<RestGuildUser> GetUserAsync(IGuildChannel channel, IGuild guild, BaseDiscordClient client,
             ulong id)
         {
             var model = await client.ApiClient.GetGuildMemberAsync(channel.GuildId, id);
             if (model == null)
                 return null;
-            var user = RestGuildUser.Create(client, model);
+            var user = RestGuildUser.Create(client, guild, model);
             if (!user.GetPermissions(channel).ReadMessages)
                 return null;
 
             return user;
         }
-        public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuildChannel channel, BaseDiscordClient client,
+        public static IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync(IGuildChannel channel, IGuild guild, BaseDiscordClient client,
             ulong? froUserId = null, uint? limit = DiscordConfig.MaxUsersPerBatch)
         {
             return new PagedAsyncEnumerable<RestGuildUser>(
@@ -188,8 +188,11 @@ namespace Discord.Rest
                     };
                     if (info.Position != null)
                         args.AfterUserId = info.Position.Value;
-                    var models = await client.ApiClient.GetGuildMembersAsync(channel.GuildId, args);
-                    return models.Select(x => RestGuildUser.Create(client, x)).ToImmutableArray(); ;
+                    var models = await guild.Discord.ApiClient.GetGuildMembersAsync(guild.Id, args);
+                    return models
+                        .Select(x => RestGuildUser.Create(client, guild, x))
+                        .Where(x => x.GetPermissions(channel).ReadMessages)
+                        .ToImmutableArray();
                 },
                 nextPage: (info, lastPage) =>
                 {
diff --git a/src/Discord.Net.Rest/Entities/Channels/RestGuildChannel.cs b/src/Discord.Net.Rest/Entities/Channels/RestGuildChannel.cs
index 7d7547713..4c0b92403 100644
--- a/src/Discord.Net.Rest/Entities/Channels/RestGuildChannel.cs
+++ b/src/Discord.Net.Rest/Entities/Channels/RestGuildChannel.cs
@@ -16,24 +16,25 @@ namespace Discord.Rest
 
         public IReadOnlyCollection<Overwrite> PermissionOverwrites => _overwrites;
 
-        public ulong GuildId { get; }
+        internal IGuild Guild { get; }
+        public ulong GuildId => Guild.Id;
 
         public string Name { get; private set; }
         public int Position { get; private set; }
 
-        internal RestGuildChannel(BaseDiscordClient discord, ulong id, ulong guildId)
+        internal RestGuildChannel(BaseDiscordClient discord, IGuild guild, ulong id)
             : base(discord, id)
         {
-            GuildId = guildId;
+            Guild = guild;
         }
-        internal new static RestGuildChannel Create(BaseDiscordClient discord, Model model)
+        internal static RestGuildChannel Create(BaseDiscordClient discord, IGuild guild, Model model)
         {
             switch (model.Type)
             {
                 case ChannelType.Text:
-                    return RestTextChannel.Create(discord, model);
+                    return RestTextChannel.Create(discord, guild, model);
                 case ChannelType.Voice:
-                    return RestVoiceChannel.Create(discord, model);
+                    return RestVoiceChannel.Create(discord, guild, model);
                 default:
                     throw new InvalidOperationException("Unknown guild channel type");
             }
diff --git a/src/Discord.Net.Rest/Entities/Channels/RestTextChannel.cs b/src/Discord.Net.Rest/Entities/Channels/RestTextChannel.cs
index 3e660b53b..3dccc2e2b 100644
--- a/src/Discord.Net.Rest/Entities/Channels/RestTextChannel.cs
+++ b/src/Discord.Net.Rest/Entities/Channels/RestTextChannel.cs
@@ -17,13 +17,13 @@ namespace Discord.Rest
 
         public string Mention => MentionUtils.MentionChannel(Id);
 
-        internal RestTextChannel(BaseDiscordClient discord, ulong id, ulong guildId)
-            : base(discord, id, guildId)
+        internal RestTextChannel(BaseDiscordClient discord, IGuild guild, ulong id)
+            : base(discord, guild, id)
         {
         }
-        internal new static RestTextChannel Create(BaseDiscordClient discord, Model model)
+        internal new static RestTextChannel Create(BaseDiscordClient discord, IGuild guild, Model model)
         {
-            var entity = new RestTextChannel(discord, model.Id, model.GuildId.Value);
+            var entity = new RestTextChannel(discord, guild, model.Id);
             entity.Update(model);
             return entity;
         }
@@ -39,9 +39,9 @@ namespace Discord.Rest
             => ChannelHelper.ModifyAsync(this, Discord, func);
 
         public Task<RestGuildUser> GetUserAsync(ulong id)
-            => ChannelHelper.GetUserAsync(this, Discord, id);
+            => ChannelHelper.GetUserAsync(this, Guild, Discord, id);
         public IAsyncEnumerable<IReadOnlyCollection<RestGuildUser>> GetUsersAsync()
-            => ChannelHelper.GetUsersAsync(this, Discord);
+            => ChannelHelper.GetUsersAsync(this, Guild, Discord);
 
         public Task<RestMessage> GetMessageAsync(ulong id)
             => ChannelHelper.GetMessageAsync(this, Discord, id);
diff --git a/src/Discord.Net.Rest/Entities/Channels/RestVoiceChannel.cs b/src/Discord.Net.Rest/Entities/Channels/RestVoiceChannel.cs
index 1ff7c3075..3f59c4b0e 100644
--- a/src/Discord.Net.Rest/Entities/Channels/RestVoiceChannel.cs
+++ b/src/Discord.Net.Rest/Entities/Channels/RestVoiceChannel.cs
@@ -16,13 +16,13 @@ namespace Discord.Rest
         public int Bitrate { get; private set; }
         public int UserLimit { get; private set; }
 
-        internal RestVoiceChannel(BaseDiscordClient discord, ulong id, ulong guildId)
-            : base(discord, id, guildId)
+        internal RestVoiceChannel(BaseDiscordClient discord, IGuild guild, ulong id)
+            : base(discord, guild, id)
         {
         }
-        internal new static RestVoiceChannel Create(BaseDiscordClient discord, Model model)
+        internal new static RestVoiceChannel Create(BaseDiscordClient discord, IGuild guild, Model model)
         {
-            var entity = new RestVoiceChannel(discord, model.Id, model.GuildId.Value);
+            var entity = new RestVoiceChannel(discord, guild, model.Id);
             entity.Update(model);
             return entity;
         }
diff --git a/src/Discord.Net.Rest/Entities/Guilds/GuildHelper.cs b/src/Discord.Net.Rest/Entities/Guilds/GuildHelper.cs
index d3fdf01d3..f3ab36258 100644
--- a/src/Discord.Net.Rest/Entities/Guilds/GuildHelper.cs
+++ b/src/Discord.Net.Rest/Entities/Guilds/GuildHelper.cs
@@ -81,13 +81,13 @@ namespace Discord.Rest
         {
             var model = await client.ApiClient.GetChannelAsync(guild.Id, id).ConfigureAwait(false);
             if (model != null)
-                return RestGuildChannel.Create(client, model);
+                return RestGuildChannel.Create(client, guild, model);
             return null;
         }
         public static async Task<IReadOnlyCollection<RestGuildChannel>> GetChannelsAsync(IGuild guild, BaseDiscordClient client)
         {
             var models = await client.ApiClient.GetGuildChannelsAsync(guild.Id).ConfigureAwait(false);
-            return models.Select(x => RestGuildChannel.Create(client, x)).ToImmutableArray();
+            return models.Select(x => RestGuildChannel.Create(client, guild, x)).ToImmutableArray();
         }
         public static async Task<RestTextChannel> CreateTextChannelAsync(IGuild guild, BaseDiscordClient client,
             string name)
@@ -96,7 +96,7 @@ namespace Discord.Rest
 
             var args = new CreateGuildChannelParams(name, ChannelType.Text);
             var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args).ConfigureAwait(false);
-            return RestTextChannel.Create(client, model);
+            return RestTextChannel.Create(client, guild, model);
         }
         public static async Task<RestVoiceChannel> CreateVoiceChannelAsync(IGuild guild, BaseDiscordClient client,
             string name)
@@ -105,7 +105,7 @@ namespace Discord.Rest
 
             var args = new CreateGuildChannelParams(name, ChannelType.Voice);
             var model = await client.ApiClient.CreateGuildChannelAsync(guild.Id, args).ConfigureAwait(false);
-            return RestVoiceChannel.Create(client, model);
+            return RestVoiceChannel.Create(client, guild, model);
         }
 
         //Integrations
@@ -155,7 +155,7 @@ namespace Discord.Rest
         {
             var model = await client.ApiClient.GetGuildMemberAsync(guild.Id, id).ConfigureAwait(false);
             if (model != null)
-                return RestGuildUser.Create(client, model);
+                return RestGuildUser.Create(client, guild, model);
             return null;
         }
         public static async Task<RestGuildUser> GetCurrentUserAsync(IGuild guild, BaseDiscordClient client)
@@ -166,7 +166,7 @@ namespace Discord.Rest
         {
             var args = new GetGuildMembersParams();
             var models = await client.ApiClient.GetGuildMembersAsync(guild.Id, args).ConfigureAwait(false);
-            return models.Select(x => RestGuildUser.Create(client, x)).ToImmutableArray();
+            return models.Select(x => RestGuildUser.Create(client, guild, x)).ToImmutableArray();
         }
         public static async Task<int> PruneUsersAsync(IGuild guild, BaseDiscordClient client,
             int days = 30, bool simulate = false)
diff --git a/src/Discord.Net.Rest/Entities/Guilds/RestGuild.cs b/src/Discord.Net.Rest/Entities/Guilds/RestGuild.cs
index 19af50ec3..4c2407968 100644
--- a/src/Discord.Net.Rest/Entities/Guilds/RestGuild.cs
+++ b/src/Discord.Net.Rest/Entities/Guilds/RestGuild.cs
@@ -30,6 +30,7 @@ namespace Discord.Rest
         public string VoiceRegionId { get; private set; }
         public string IconId { get; private set; }
         public string SplashId { get; private set; }
+        internal bool Available { get; private set; }
 
         public ulong DefaultChannelId => Id;
         public string IconUrl => API.CDN.GetGuildIconUrl(Id, IconId);
@@ -87,6 +88,8 @@ namespace Discord.Rest
                     roles[model.Roles[i].Id] = RestRole.Create(Discord, model.Roles[i]);
             }
             _roles = roles.ToImmutable();
+
+            Available = true;
         }
 
         //General
@@ -169,7 +172,7 @@ namespace Discord.Rest
             => GuildHelper.PruneUsersAsync(this, Discord, days, simulate);
 
         //IGuild
-        bool IGuild.Available => true;
+        bool IGuild.Available => Available;
         IAudioClient IGuild.AudioClient => null;
         IRole IGuild.EveryoneRole => EveryoneRole;
         IReadOnlyCollection<IRole> IGuild.Roles => Roles;
diff --git a/src/Discord.Net.Rest/Entities/Users/RestGuildUser.cs b/src/Discord.Net.Rest/Entities/Users/RestGuildUser.cs
index 2fe25b416..dd6056f41 100644
--- a/src/Discord.Net.Rest/Entities/Users/RestGuildUser.cs
+++ b/src/Discord.Net.Rest/Entities/Users/RestGuildUser.cs
@@ -15,19 +15,30 @@ namespace Discord.Rest
         private ImmutableArray<ulong> _roleIds;
 
         public string Nickname { get; private set; }
-        public ulong GuildId { get; private set; }
+        internal IGuild Guild { get; private set; }
 
+        public ulong GuildId => Guild.Id;
+        public GuildPermissions GuildPermissions
+        {
+            get
+            {
+                if (!Guild.Available)
+                    throw new InvalidOperationException("Resolving permissions requires the parent guild to be downloaded.");
+                return new GuildPermissions(Permissions.ResolveGuild(Guild, this));
+            }
+        }
         public IReadOnlyCollection<ulong> RoleIds => _roleIds;
         
         public DateTimeOffset? JoinedAt => DateTimeUtils.FromTicks(_joinedAtTicks);
 
-        internal RestGuildUser(BaseDiscordClient discord, ulong id)
+        internal RestGuildUser(BaseDiscordClient discord, IGuild guild, ulong id)
             : base(discord, id)
         {
+            Guild = guild;
         }
-        internal static RestGuildUser Create(BaseDiscordClient discord, Model model)
+        internal static RestGuildUser Create(BaseDiscordClient discord, IGuild guild, Model model)
         {
-            var entity = new RestGuildUser(discord, model.User.Id);
+            var entity = new RestGuildUser(discord, guild, model.User.Id);
             entity.Update(model);
             return entity;
         }
@@ -41,7 +52,7 @@ namespace Discord.Rest
         private void UpdateRoles(ulong[] roleIds)
         {
             var roles = ImmutableArray.CreateBuilder<ulong>(roleIds.Length + 1);
-            roles.Add(GuildId);
+            roles.Add(Guild.Id);
             for (int i = 0; i < roleIds.Length; i++)
                 roles.Add(roleIds[i]);
             _roleIds = roles.ToImmutable();
@@ -56,12 +67,10 @@ namespace Discord.Rest
 
         public ChannelPermissions GetPermissions(IGuildChannel channel)
         {
-            throw new NotImplementedException(); //TODO: Impl
+            var guildPerms = GuildPermissions;
+            return new ChannelPermissions(Permissions.ResolveChannel(Guild, this, channel, guildPerms.RawValue));
         }
 
-        //IGuildUser
-        IReadOnlyCollection<ulong> IGuildUser.RoleIds => RoleIds;
-
         //IVoiceState
         bool IVoiceState.IsDeafened => false;
         bool IVoiceState.IsMuted => false;
diff --git a/src/Discord.Net.WebSocket/DiscordSocketClient.cs b/src/Discord.Net.WebSocket/DiscordSocketClient.cs
index 03831818a..a6576160b 100644
--- a/src/Discord.Net.WebSocket/DiscordSocketClient.cs
+++ b/src/Discord.Net.WebSocket/DiscordSocketClient.cs
@@ -1612,9 +1612,9 @@ namespace Discord.WebSocket
         async Task<IApplication> IDiscordClient.GetApplicationInfoAsync()
             => await GetApplicationInfoAsync().ConfigureAwait(false);
 
-        Task<IChannel> IDiscordClient.GetChannelAsync(ulong id)
+        Task<IChannel> IDiscordClient.GetChannelAsync(ulong id, CacheMode mode)
             => Task.FromResult<IChannel>(GetChannel(id));
-        Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync()
+        Task<IReadOnlyCollection<IPrivateChannel>> IDiscordClient.GetPrivateChannelsAsync(CacheMode mode)
             => Task.FromResult<IReadOnlyCollection<IPrivateChannel>>(PrivateChannels);
 
         async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync()
@@ -1623,14 +1623,14 @@ namespace Discord.WebSocket
         async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId)
             => await GetInviteAsync(inviteId);
 
-        Task<IGuild> IDiscordClient.GetGuildAsync(ulong id)
+        Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode)
             => Task.FromResult<IGuild>(GetGuild(id));
-        Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync()
+        Task<IReadOnlyCollection<IGuild>> IDiscordClient.GetGuildsAsync(CacheMode mode)
             => Task.FromResult<IReadOnlyCollection<IGuild>>(Guilds);
         async Task<IGuild> IDiscordClient.CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon)
             => await CreateGuildAsync(name, region, jpegIcon);
 
-        Task<IUser> IDiscordClient.GetUserAsync(ulong id)
+        Task<IUser> IDiscordClient.GetUserAsync(ulong id, CacheMode mode)
             => Task.FromResult<IUser>(GetUser(id));
         Task<IUser> IDiscordClient.GetUserAsync(string username, string discriminator)
             => Task.FromResult<IUser>(GetUser(username, discriminator));
diff --git a/src/Discord.Net.WebSocket/Entities/Users/SocketGuildUser.cs b/src/Discord.Net.WebSocket/Entities/Users/SocketGuildUser.cs
index f73b10a2e..01d473a00 100644
--- a/src/Discord.Net.WebSocket/Entities/Users/SocketGuildUser.cs
+++ b/src/Discord.Net.WebSocket/Entities/Users/SocketGuildUser.cs
@@ -23,6 +23,7 @@ namespace Discord.WebSocket
         public override ushort DiscriminatorValue { get { return GlobalUser.DiscriminatorValue; } internal set { GlobalUser.DiscriminatorValue = value; } }
         public override string AvatarId { get { return GlobalUser.AvatarId; } internal set { GlobalUser.AvatarId = value; } }
         internal override SocketPresence Presence { get { return GlobalUser.Presence; } set { GlobalUser.Presence = value; } }
+        public GuildPermissions GuildPermissions => new GuildPermissions(Permissions.ResolveGuild(Guild, this));
         public IReadOnlyCollection<ulong> RoleIds => _roleIds;
 
         public SocketVoiceState? VoiceState => Guild.GetVoiceState(Id);