Merge branch 'dev' into fix-use-external-emojis

Discord.Net.sln

@@ -1,6 +1,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.27130.0
+VisualStudioVersion = 15.0.27004.2009
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Discord.Net.Core", "src\Discord.Net.Core\Discord.Net.Core.csproj", "{91E9E7BD-75C9-4E98-84AA-2C271922E5C2}"
 EndProject
@@ -22,7 +22,13 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Discord.Net.Tests", "test\D
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Discord.Net.Webhook", "src\Discord.Net.Webhook\Discord.Net.Webhook.csproj", "{9AFAB80E-D2D3-4EDB-B58C-BACA78D1EA30}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Discord.Net.Analyzers", "src\Discord.Net.Analyzers\Discord.Net.Analyzers.csproj", "{BBA8E7FB-C834-40DC-822F-B112CB7F0140}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Discord.Net.Analyzers", "src\Discord.Net.Analyzers\Discord.Net.Analyzers.csproj", "{BBA8E7FB-C834-40DC-822F-B112CB7F0140}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Samples", "Samples", "{BB59D5B5-E7B0-4BF4-8F82-D14431B2799B}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "01_basic_ping_bot", "samples\01_basic_ping_bot\01_basic_ping_bot.csproj", "{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "02_commands_framework", "samples\02_commands_framework\02_commands_framework.csproj", "{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -130,6 +136,30 @@ Global
 		{BBA8E7FB-C834-40DC-822F-B112CB7F0140}.Release|x64.Build.0 = Release|Any CPU
 		{BBA8E7FB-C834-40DC-822F-B112CB7F0140}.Release|x86.ActiveCfg = Release|Any CPU
 		{BBA8E7FB-C834-40DC-822F-B112CB7F0140}.Release|x86.Build.0 = Release|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Debug|x64.Build.0 = Debug|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Debug|x86.Build.0 = Debug|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Release|x64.ActiveCfg = Release|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Release|x64.Build.0 = Release|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Release|x86.ActiveCfg = Release|Any CPU
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E}.Release|x86.Build.0 = Release|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Debug|x64.Build.0 = Debug|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Debug|x86.Build.0 = Debug|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Release|x64.ActiveCfg = Release|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Release|x64.Build.0 = Release|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Release|x86.ActiveCfg = Release|Any CPU
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -141,6 +171,8 @@ Global
 		{6BDEEC08-417B-459F-9CA3-FF8BAB18CAC7} = {B0657AAE-DCC5-4FBF-8E5D-1FB578CF3012}
 		{9AFAB80E-D2D3-4EDB-B58C-BACA78D1EA30} = {CC3D4B1C-9DE0-448B-8AE7-F3F1F3EC5C3A}
 		{BBA8E7FB-C834-40DC-822F-B112CB7F0140} = {CC3D4B1C-9DE0-448B-8AE7-F3F1F3EC5C3A}
+		{F2FF84FB-F6AD-47E5-9EE5-18206CAE136E} = {BB59D5B5-E7B0-4BF4-8F82-D14431B2799B}
+		{4E1F1F40-B1DD-40C9-A4B1-A2046A4C9C76} = {BB59D5B5-E7B0-4BF4-8F82-D14431B2799B}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {D2404771-EEC8-45F2-9D71-F3373F6C1495}

samples/01_basic_ping_bot/01_basic_ping_bot.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Discord.Net.WebSocket\Discord.Net.WebSocket.csproj" />
+  </ItemGroup>
+
+</Project>

samples/01_basic_ping_bot/Program.cs

@@ -0,0 +1,69 @@
+using System;
+using System.Threading.Tasks;
+using Discord;
+using Discord.WebSocket;
+
+namespace _01_basic_ping_bot
+{
+    // This is a minimal, barebones example of using Discord.Net
+    //
+    // If writing a bot with commands, we recommend using the Discord.Net.Commands
+    // framework, rather than handling commands yourself, like we do in this sample.
+    //
+    // You can find samples of using the command framework:
+    // - Here, under the 02_commands_framework sample
+    // - https://github.com/foxbot/DiscordBotBase - a barebones bot template
+    // - https://github.com/foxbot/patek - a more feature-filled bot, utilizing more aspects of the library
+    class Program
+    {
+        private DiscordSocketClient _client;
+
+        // Discord.Net heavily utilizes TAP for async, so we create
+        // an asynchronous context from the beginning.
+        static void Main(string[] args)
+            => new Program().MainAsync().GetAwaiter().GetResult();
+
+        public async Task MainAsync()
+        {
+            _client = new DiscordSocketClient();
+
+            _client.Log += LogAsync;
+            _client.Ready += ReadyAsync;
+            _client.MessageReceived += MessageReceivedAsync;
+
+            // Tokens should be considered secret data, and never hard-coded.
+            await _client.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("token"));
+            await _client.StartAsync();
+
+            // Block the program until it is closed.
+            await Task.Delay(-1);
+        }
+
+        private Task LogAsync(LogMessage log)
+        {
+            Console.WriteLine(log.ToString());
+            return Task.CompletedTask;
+        }
+
+        // The Ready event indicates that the client has opened a
+        // connection and it is now safe to access the cache.
+        private Task ReadyAsync()
+        {
+            Console.WriteLine($"{_client.CurrentUser} is connected!");
+
+            return Task.CompletedTask;
+        }
+
+        // This is not the recommmended way to write a bot - consider
+        // reading over the Commands Framework sample.
+        private async Task MessageReceivedAsync(SocketMessage message)
+        {
+            // The bot should never respond to itself.
+            if (message.Author.Id == _client.CurrentUser.Id)
+                return;
+
+            if (message.Content == "!ping")
+                await message.Channel.SendMessageAsync("pong!");
+        }
+    }
+}

samples/02_commands_framework/02_commands_framework.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.0-preview1-final" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Discord.Net.Commands\Discord.Net.Commands.csproj" />
+    <ProjectReference Include="..\..\src\Discord.Net.WebSocket\Discord.Net.WebSocket.csproj" />
+  </ItemGroup>
+
+</Project>

samples/02_commands_framework/Modules/PublicModule.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using System.Threading.Tasks;
+using Discord;
+using Discord.Commands;
+using _02_commands_framework.Services;
+
+namespace _02_commands_framework.Modules
+{
+    // Modules must be public and inherit from an IModuleBase
+    public class PublicModule : ModuleBase<SocketCommandContext>
+    {
+        // Dependency Injection will fill this value in for us
+        public PictureService PictureService { get; set; }
+
+        [Command("ping")]
+        [Alias("pong", "hello")]
+        public Task PingAsync()
+            => ReplyAsync("pong!");
+
+        [Command("cat")]
+        public async Task CatAsync()
+        {
+            // Get a stream containing an image of a cat
+            var stream = await PictureService.GetCatPictureAsync();
+            // Streams must be seeked to their beginning before being uploaded!
+            stream.Seek(0, SeekOrigin.Begin);
+            await Context.Channel.SendFileAsync(stream, "cat.png");
+        }
+
+        // Get info on a user, or the user who invoked the command if one is not specified
+        [Command("userinfo")]
+        public async Task UserInfoAsync(IUser user = null)
+        {
+            user = user ?? Context.User;
+
+            await ReplyAsync(user.ToString());
+        }
+
+        // Ban a user
+        [Command("ban")]
+        [RequireContext(ContextType.Guild)]
+        // make sure the user invoking the command can ban
+        [RequireUserPermission(GuildPermission.BanMembers)]
+        // make sure the bot itself can ban
+        [RequireBotPermission(GuildPermission.BanMembers)]
+        public async Task BanUserAsync(IGuildUser user, [Remainder] string reason = null)
+        {
+            await user.Guild.AddBanAsync(user, reason: reason);
+            await ReplyAsync("ok!");
+        }
+
+        // [Remainder] takes the rest of the command's arguments as one argument, rather than splitting every space
+        [Command("echo")]
+        public Task EchoAsync([Remainder] string text)
+            // Insert a ZWSP before the text to prevent triggering other bots!
+            => ReplyAsync('\u200B' + text);
+
+        // 'params' will parse space-separated elements into a list
+        [Command("list")]
+        public Task ListAsync(params string[] objects)
+            => ReplyAsync("You listed: " + string.Join("; ", objects));
+    }
+}

samples/02_commands_framework/Program.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Discord;
+using Discord.WebSocket;
+using Discord.Commands;
+using _02_commands_framework.Services;
+
+namespace _02_commands_framework
+{
+    // This is a minimal example of using Discord.Net's command
+    // framework - by no means does it show everything the framework
+    // is capable of.
+    //
+    // You can find samples of using the command framework:
+    // - Here, under the 02_commands_framework sample
+    // - https://github.com/foxbot/DiscordBotBase - a barebones bot template
+    // - https://github.com/foxbot/patek - a more feature-filled bot, utilizing more aspects of the library
+    class Program
+    {
+        static void Main(string[] args)
+            => new Program().MainAsync().GetAwaiter().GetResult();
+
+        public async Task MainAsync()
+        {
+            var services = ConfigureServices();
+
+            var client = services.GetRequiredService<DiscordSocketClient>();
+
+            client.Log += LogAsync;
+            services.GetRequiredService<CommandService>().Log += LogAsync;
+
+            await client.LoginAsync(TokenType.Bot, Environment.GetEnvironmentVariable("token"));
+            await client.StartAsync();
+
+            await services.GetRequiredService<CommandHandlingService>().InitializeAsync();
+
+            await Task.Delay(-1);
+        }
+
+        private Task LogAsync(LogMessage log)
+        {
+            Console.WriteLine(log.ToString());
+
+            return Task.CompletedTask;
+        }
+
+        private IServiceProvider ConfigureServices()
+        {
+            return new ServiceCollection()
+                .AddSingleton<DiscordSocketClient>()
+                .AddSingleton<CommandService>()
+                .AddSingleton<CommandHandlingService>()
+                .AddSingleton<HttpClient>()
+                .AddSingleton<PictureService>()
+                .BuildServiceProvider();
+        }
+    }
+}

samples/02_commands_framework/Services/CommandHandlingService.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Reflection;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Discord;
+using Discord.Commands;
+using Discord.WebSocket;
+
+namespace _02_commands_framework.Services
+{
+    public class CommandHandlingService
+    {
+        private readonly CommandService _commands;
+        private readonly DiscordSocketClient _discord;
+        private readonly IServiceProvider _services;
+
+        public CommandHandlingService(IServiceProvider services)
+        {
+            _commands = services.GetRequiredService<CommandService>();
+            _discord = services.GetRequiredService<DiscordSocketClient>();
+            _services = services;
+
+            _discord.MessageReceived += MessageReceivedAsync;
+        }
+
+        public async Task InitializeAsync()
+        {
+            await _commands.AddModulesAsync(Assembly.GetEntryAssembly(), _services);
+        }
+
+        public async Task MessageReceivedAsync(SocketMessage rawMessage)
+        {
+            // Ignore system messages, or messages from other bots
+            if (!(rawMessage is SocketUserMessage message)) return;
+            if (message.Source != MessageSource.User) return;
+
+            // This value holds the offset where the prefix ends
+            var argPos = 0;
+            if (!message.HasMentionPrefix(_discord.CurrentUser, ref argPos)) return;
+
+            var context = new SocketCommandContext(_discord, message);
+            var result = await _commands.ExecuteAsync(context, argPos, _services);
+
+            if (result.Error.HasValue &&
+                result.Error.Value != CommandError.UnknownCommand) // it's bad practice to send 'unknown command' errors
+                await context.Channel.SendMessageAsync(result.ToString());
+        }
+    }
+}

samples/02_commands_framework/Services/PictureService.cs

@@ -0,0 +1,20 @@
+using System.IO;
+using System.Net.Http;
+using System.Threading.Tasks;
+
+namespace _02_commands_framework.Services
+{
+    public class PictureService
+    {
+        private readonly HttpClient _http;
+
+        public PictureService(HttpClient http)
+            => _http = http;
+
+        public async Task<Stream> GetCatPictureAsync()
+        {
+            var resp = await _http.GetAsync("https://cataas.com/cat");
+            return await resp.Content.ReadAsStreamAsync();
+        }
+    }
+}

src/Discord.Net.Commands/Attributes/CommandAttribute.cs

@@ -7,6 +7,7 @@ namespace Discord.Commands
     {
         public string Text { get; }
         public RunMode RunMode { get; set; } = RunMode.Default;
+        public bool? IgnoreExtraArgs { get; set; }
 
         public CommandAttribute()
         {

src/Discord.Net.Commands/Builders/CommandBuilder.cs

@@ -1,8 +1,7 @@
-using System;
+using System;
 using System.Linq;
 using System.Threading.Tasks;
 using System.Collections.Generic;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Discord.Commands.Builders
 {
@@ -22,6 +21,7 @@ namespace Discord.Commands.Builders
         public string PrimaryAlias { get; set; }
         public RunMode RunMode { get; set; }
         public int Priority { get; set; }
+        public bool IgnoreExtraArgs { get; set; }
 
         public IReadOnlyList<PreconditionAttribute> Preconditions => _preconditions;
         public IReadOnlyList<ParameterBuilder> Parameters => _parameters;
@@ -140,4 +140,4 @@ namespace Discord.Commands.Builders
             return new CommandInfo(this, info, service);
         }
     }
-}
+}

src/Discord.Net.Commands/Builders/ModuleBuilder.cs

@@ -2,7 +2,6 @@ using System;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 
 namespace Discord.Commands.Builders
 {

src/Discord.Net.Commands/Builders/ModuleClassBuilder.cs

@@ -158,6 +158,7 @@ namespace Discord.Commands
                         builder.AddAliases(command.Text);
                         builder.RunMode = command.RunMode;
                         builder.Name = builder.Name ?? command.Text;
+                        builder.IgnoreExtraArgs = command.IgnoreExtraArgs ?? service._ignoreExtraArgs;
                         break;
                     case NameAttribute name:
                         builder.Name = name.Text;
@@ -291,7 +292,7 @@ namespace Discord.Commands
 
             //We dont have a cached type reader, create one
             reader = ReflectionUtils.CreateObject<TypeReader>(typeReaderType.GetTypeInfo(), service, services);
-            service.AddTypeReader(paramType, reader);
+            service.AddTypeReader(paramType, reader, false);
 
             return reader;
         }

src/Discord.Net.Commands/CommandParser.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Text;
 using System.Threading.Tasks;
@@ -13,8 +14,7 @@ namespace Discord.Commands
             Parameter,
             QuotedParameter
         }
-        
-        public static async Task<ParseResult> ParseArgsAsync(CommandInfo command, ICommandContext context, bool ignoreExtraArgs, IServiceProvider services, string input, int startPos)
+        public static async Task<ParseResult> ParseArgsAsync(CommandInfo command, ICommandContext context, bool ignoreExtraArgs, IServiceProvider services, string input, int startPos, IReadOnlyDictionary<char, char> aliasMap)
         {
             ParameterInfo curParam = null;
             StringBuilder argBuilder = new StringBuilder(input.Length);
@@ -24,7 +24,27 @@ namespace Discord.Commands
             var argList = ImmutableArray.CreateBuilder<TypeReaderResult>();
             var paramList = ImmutableArray.CreateBuilder<TypeReaderResult>();
             bool isEscaping = false;
-            char c;
+            char c, matchQuote = '\0';
+
+            // local helper functions
+            bool IsOpenQuote(IReadOnlyDictionary<char, char> dict, char ch)
+            {
+                // return if the key is contained in the dictionary if it is populated
+                if (dict.Count != 0)
+                    return dict.ContainsKey(ch);
+                // or otherwise if it is the default double quote
+                return c == '\"';
+            }
+
+            char GetMatch(IReadOnlyDictionary<char, char> dict, char ch)
+            {
+                // get the corresponding value for the key, if it exists
+                // and if the dictionary is populated
+                if (dict.Count != 0 && dict.TryGetValue(c, out var value))
+                    return value;
+                // or get the default pair of the default double quote
+                return '\"';
+            }
 
             for (int curPos = startPos; curPos <= endPos; curPos++)
             {
@@ -74,9 +94,11 @@ namespace Discord.Commands
                             argBuilder.Append(c);
                             continue;
                         }
-                        if (c == '\"')
+                        
+                        if (IsOpenQuote(aliasMap, c))
                         {
                             curPart = ParserPart.QuotedParameter;
+                            matchQuote = GetMatch(aliasMap, c);
                             continue;
                         }
                         curPart = ParserPart.Parameter;
@@ -97,7 +119,7 @@ namespace Discord.Commands
                 }
                 else if (curPart == ParserPart.QuotedParameter)
                 {
-                    if (c == '\"')
+                    if (c == matchQuote)
                     {
                         argString = argBuilder.ToString(); //Remove quotes
                         lastArgEndPos = curPos + 1;
@@ -110,7 +132,7 @@ namespace Discord.Commands
                 {
                     if (curParam == null)
                     {
-                        if (ignoreExtraArgs)
+                        if (command.IgnoreExtraArgs)
                             break;
                         else
                             return ParseResult.FromError(CommandError.BadArgCount, "The input text has too many parameters.");

src/Discord.Net.Commands/CommandService.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -6,7 +6,6 @@ using System.Linq;
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
 using Discord.Commands.Builders;
 using Discord.Logging;
 
@@ -33,6 +32,7 @@ namespace Discord.Commands
         internal readonly RunMode _defaultRunMode;
         internal readonly Logger _cmdLogger;
         internal readonly LogManager _logManager;
+        internal readonly IReadOnlyDictionary<char, char> _quotationMarkAliasMap;
 
         public IEnumerable<ModuleInfo> Modules => _moduleDefs.Select(x => x);
         public IEnumerable<CommandInfo> Commands => _moduleDefs.SelectMany(x => x.Commands);
@@ -46,6 +46,7 @@ namespace Discord.Commands
             _ignoreExtraArgs = config.IgnoreExtraArgs;
             _separatorChar = config.SeparatorChar;
             _defaultRunMode = config.DefaultRunMode;
+            _quotationMarkAliasMap = (config.QuotationMarkAliasMap ?? new Dictionary<char, char>()).ToImmutableDictionary();
             if (_defaultRunMode == RunMode.Default)
                 throw new InvalidOperationException("The default run mode cannot be set to Default.");
 
@@ -66,6 +67,10 @@ namespace Discord.Commands
                 _defaultTypeReaders[typeof(Nullable<>).MakeGenericType(type)] = NullableTypeReader.Create(type, _defaultTypeReaders[type]);
             }
 
+            var tsreader = new TimeSpanTypeReader();
+            _defaultTypeReaders[typeof(TimeSpan)] = tsreader;
+            _defaultTypeReaders[typeof(TimeSpan?)] = NullableTypeReader.Create(typeof(TimeSpan), tsreader);
+
             _defaultTypeReaders[typeof(string)] =
                 new PrimitiveTypeReader<string>((string x, out string y) => { y = x; return true; }, 0);
 
@@ -215,10 +220,11 @@ namespace Discord.Commands
             return true;
         }
 
-        //Type Readers 
+        //Type Readers
         /// <summary>
         /// Adds a custom <see cref="TypeReader"/> to this <see cref="CommandService"/> for the supplied object type. 
         /// If <typeparamref name="T"/> is a <see cref="ValueType"/>, a <see cref="NullableTypeReader{T}"/> will also be added.
+        /// If a default <see cref="TypeReader"/> exists for <typeparamref name="T"/>, a warning will be logged and the default <see cref="TypeReader"/> will be replaced. 
         /// </summary>
         /// <typeparam name="T">The object type to be read by the <see cref="TypeReader"/>.</typeparam>
         /// <param name="reader">An instance of the <see cref="TypeReader"/> to be added.</param>
@@ -226,17 +232,54 @@ namespace Discord.Commands
             => AddTypeReader(typeof(T), reader);
         /// <summary>
         /// Adds a custom <see cref="TypeReader"/> to this <see cref="CommandService"/> for the supplied object type. 
-        /// If <paramref name="type"/> is a <see cref="ValueType"/>, a <see cref="NullableTypeReader{T}"/> for the value type will also be added. 
+        /// If <paramref name="type"/> is a <see cref="ValueType"/>, a <see cref="NullableTypeReader{T}"/> for the value type will also be added.
+        /// If a default <see cref="TypeReader"/> exists for <paramref name="type"/>, a warning will be logged and the default <see cref="TypeReader"/> will be replaced.
         /// </summary>
         /// <param name="type">A <see cref="Type"/> instance for the type to be read.</param>
         /// <param name="reader">An instance of the <see cref="TypeReader"/> to be added.</param>
         public void AddTypeReader(Type type, TypeReader reader)
         {
-            var readers = _typeReaders.GetOrAdd(type, x => new ConcurrentDictionary<Type, TypeReader>());
-            readers[reader.GetType()] = reader;
+            if (_defaultTypeReaders.ContainsKey(type))
+                _ = _cmdLogger.WarningAsync($"The default TypeReader for {type.FullName} was replaced by {reader.GetType().FullName}." +
+                    $"To suppress this message, use AddTypeReader<T>(reader, true).");
+            AddTypeReader(type, reader, true);
+        }
+        /// <summary>
+        /// Adds a custom <see cref="TypeReader"/> to this <see cref="CommandService"/> for the supplied object type. 
+        /// If <typeparamref name="T"/> is a <see cref="ValueType"/>, a <see cref="NullableTypeReader{T}"/> will also be added.
+        /// </summary>
+        /// <typeparam name="T">The object type to be read by the <see cref="TypeReader"/>.</typeparam>
+        /// <param name="reader">An instance of the <see cref="TypeReader"/> to be added.</param>
+        /// <param name="replaceDefault">If <paramref name="reader"/> should replace the default <see cref="TypeReader"/> for <typeparamref name="T"/> if one exists.</param>
+        public void AddTypeReader<T>(TypeReader reader, bool replaceDefault)
+            => AddTypeReader(typeof(T), reader, replaceDefault);
+        /// <summary>
+        /// Adds a custom <see cref="TypeReader"/> to this <see cref="CommandService"/> for the supplied object type. 
+        /// If <paramref name="type"/> is a <see cref="ValueType"/>, a <see cref="NullableTypeReader{T}"/> for the value type will also be added. 
+        /// </summary>
+        /// <param name="type">A <see cref="Type"/> instance for the type to be read.</param>
+        /// <param name="reader">An instance of the <see cref="TypeReader"/> to be added.</param>
+        /// <param name="replaceDefault">If <paramref name="reader"/> should replace the default <see cref="TypeReader"/> for <paramref name="type"/> if one exists.</param>
+        public void AddTypeReader(Type type, TypeReader reader, bool replaceDefault)
+        {
+            if (replaceDefault && _defaultTypeReaders.ContainsKey(type))
+            {
+                _defaultTypeReaders.AddOrUpdate(type, reader, (k, v) => reader);
+                if (type.GetTypeInfo().IsValueType)
+                {
+                    var nullableType = typeof(Nullable<>).MakeGenericType(type);
+                    var nullableReader = NullableTypeReader.Create(type, reader);
+                    _defaultTypeReaders.AddOrUpdate(nullableType, nullableReader, (k, v) => nullableReader);
+                }
+            }
+            else
+            {
+                var readers = _typeReaders.GetOrAdd(type, x => new ConcurrentDictionary<Type, TypeReader>());
+                readers[reader.GetType()] = reader;
 
-            if (type.GetTypeInfo().IsValueType)
-                AddNullableTypeReader(type, reader);
+                if (type.GetTypeInfo().IsValueType)
+                    AddNullableTypeReader(type, reader);
+            }
         }
         internal void AddNullableTypeReader(Type valueType, TypeReader valueTypeReader)
         {
@@ -296,7 +339,6 @@ namespace Discord.Commands
         public async Task<IResult> ExecuteAsync(ICommandContext context, string input, IServiceProvider services, MultiMatchHandling multiMatchHandling = MultiMatchHandling.Exception)
         {
             services = services ?? EmptyServiceProvider.Instance;
-
             var searchResult = Search(context, input);
             if (!searchResult.IsSuccess)
                 return searchResult;

src/Discord.Net.Commands/CommandServiceConfig.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 
 namespace Discord.Commands
 {
@@ -18,13 +19,11 @@ namespace Discord.Commands
         /// <summary> Determines whether RunMode.Sync commands should push exceptions up to the caller. </summary>
         public bool ThrowOnError { get; set; } = true;
 
+        /// <summary> Collection of aliases that can wrap strings for command parsing. 
+        /// represents the opening quotation mark and the value is the corresponding closing mark.</summary>
+        public Dictionary<char, char> QuotationMarkAliasMap { get; set; } = QuotationAliasUtils.GetDefaultAliasMap;
+
         /// <summary> Determines whether extra parameters should be ignored. </summary>
         public bool IgnoreExtraArgs { get; set; } = false;
-
-        ///// <summary> Gets or sets the <see cref="IServiceProvider"/> to use. </summary>
-        //public IServiceProvider ServiceProvider { get; set; } = null;
-
-        ///// <summary> Gets or sets a factory function for the <see cref="IServiceProvider"/> to use. </summary>
-        //public Func<CommandService, IServiceProvider> ServiceProviderFactory { get; set; } = null;
     }
 }

src/Discord.Net.Commands/Info/CommandInfo.cs

@@ -1,4 +1,4 @@
-using Discord.Commands.Builders;
+using Discord.Commands.Builders;
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
@@ -27,6 +27,7 @@ namespace Discord.Commands
         public string Remarks { get; }
         public int Priority { get; }
         public bool HasVarArgs { get; }
+        public bool IgnoreExtraArgs { get; }
         public RunMode RunMode { get; }
 
         public IReadOnlyList<string> Aliases { get; }
@@ -63,6 +64,7 @@ namespace Discord.Commands
 
             Parameters = builder.Parameters.Select(x => x.Build(this)).ToImmutableArray();
             HasVarArgs = builder.Parameters.Count > 0 ? builder.Parameters[builder.Parameters.Count - 1].IsMultiple : false;
+            IgnoreExtraArgs = builder.IgnoreExtraArgs;
 
             _action = builder.Callback;
             _commandService = service;
@@ -119,7 +121,8 @@ namespace Discord.Commands
                 return ParseResult.FromError(preconditionResult);
 
             string input = searchResult.Text.Substring(startIndex);
-            return await CommandParser.ParseArgsAsync(this, context, _commandService._ignoreExtraArgs, services, input, 0).ConfigureAwait(false);
+
+            return await CommandParser.ParseArgsAsync(this, context, _commandService._ignoreExtraArgs, services, input, 0, _commandService._quotationMarkAliasMap).ConfigureAwait(false);
         }
 
         public Task<IResult> ExecuteAsync(ICommandContext context, ParseResult parseResult, IServiceProvider services)
@@ -165,11 +168,11 @@ namespace Discord.Commands
                 switch (RunMode)
                 {
                     case RunMode.Sync: //Always sync
-                        return await ExecuteAsyncInternalAsync(context, args, services).ConfigureAwait(false);
+                        return await ExecuteInternalAsync(context, args, services).ConfigureAwait(false);
                     case RunMode.Async: //Always async
                         var t2 = Task.Run(async () =>
                         {
-                            await ExecuteAsyncInternalAsync(context, args, services).ConfigureAwait(false);
+                            await ExecuteInternalAsync(context, args, services).ConfigureAwait(false);
                         });
                         break;
                 }
@@ -181,7 +184,7 @@ namespace Discord.Commands
             }
         }
 
-        private async Task<IResult> ExecuteAsyncInternalAsync(ICommandContext context, object[] args, IServiceProvider services)
+        private async Task<IResult> ExecuteInternalAsync(ICommandContext context, object[] args, IServiceProvider services)
         {
             await Module.Service._cmdLogger.DebugAsync($"Executing {GetLogText(context)}").ConfigureAwait(false);
             try

src/Discord.Net.Commands/Info/ModuleInfo.cs

@@ -2,7 +2,6 @@ using System;
 using System.Linq;
 using System.Collections.Generic;
 using System.Collections.Immutable;
-using System.Reflection;
 using Discord.Commands.Builders;
 
 namespace Discord.Commands
@@ -23,8 +22,6 @@ namespace Discord.Commands
         public ModuleInfo Parent { get; }
         public bool IsSubmodule => Parent != null;
 
-        //public TypeInfo TypeInfo { get; }
-
         internal ModuleInfo(ModuleBuilder builder, CommandService service, IServiceProvider services, ModuleInfo parent = null)
         {
             Service = service;
@@ -35,8 +32,6 @@ namespace Discord.Commands
             Group = builder.Group;
             Parent = parent;
 
-            //TypeInfo = builder.TypeInfo;
-
             Aliases = BuildAliases(builder, service).ToImmutableArray();
             Commands = builder.Commands.Select(x => x.Build(this, service)).ToImmutableArray();
             Preconditions = BuildPreconditions(builder).ToImmutableArray();

src/Discord.Net.Commands/PrimitiveParsers.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 
@@ -29,7 +29,7 @@ namespace Discord.Commands
             parserBuilder[typeof(decimal)] = (TryParseDelegate<decimal>)decimal.TryParse;
             parserBuilder[typeof(DateTime)] = (TryParseDelegate<DateTime>)DateTime.TryParse;
             parserBuilder[typeof(DateTimeOffset)] = (TryParseDelegate<DateTimeOffset>)DateTimeOffset.TryParse;
-            parserBuilder[typeof(TimeSpan)] = (TryParseDelegate<TimeSpan>)TimeSpan.TryParse;
+            //parserBuilder[typeof(TimeSpan)] = (TryParseDelegate<TimeSpan>)TimeSpan.TryParse;
             parserBuilder[typeof(char)] = (TryParseDelegate<char>)char.TryParse;
             return parserBuilder.ToImmutable();
         }

src/Discord.Net.Commands/Readers/ChannelTypeReader.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace Discord.Commands
 {
-    internal class ChannelTypeReader<T> : TypeReader
+    public class ChannelTypeReader<T> : TypeReader
         where T : class, IChannel
     {
         public override async Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)

src/Discord.Net.Commands/Readers/MessageTypeReader.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using System.Globalization;
 using System.Threading.Tasks;
 
 namespace Discord.Commands
 {
-    internal class MessageTypeReader<T> : TypeReader
+    public class MessageTypeReader<T> : TypeReader
         where T : class, IMessage
     {
         public override async Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)

src/Discord.Net.Commands/Readers/RoleTypeReader.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
@@ -6,7 +6,7 @@ using System.Threading.Tasks;
 
 namespace Discord.Commands
 {
-    internal class RoleTypeReader<T> : TypeReader
+    public class RoleTypeReader<T> : TypeReader
         where T : class, IRole
     {
         public override Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)

src/Discord.Net.Commands/Readers/TimeSpanTypeReader.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Globalization;
+using System.Threading.Tasks;
+
+namespace Discord.Commands
+{
+    internal class TimeSpanTypeReader : TypeReader
+    {
+        private static readonly string[] _formats = new[]
+        {
+            "%d'd'%h'h'%m'm'%s's'", //4d3h2m1s
+            "%d'd'%h'h'%m'm'",      //4d3h2m
+            "%d'd'%h'h'%s's'",      //4d3h  1s
+            "%d'd'%h'h'",           //4d3h
+            "%d'd'%m'm'%s's'",      //4d  2m1s
+            "%d'd'%m'm'",           //4d  2m
+            "%d'd'%s's'",           //4d    1s
+            "%d'd'",                //4d
+            "%h'h'%m'm'%s's'",      //  3h2m1s
+            "%h'h'%m'm'",           //  3h2m
+            "%h'h'%s's'",           //  3h  1s
+            "%h'h'",                //  3h
+            "%m'm'%s's'",           //    2m1s
+            "%m'm'",                //    2m
+            "%s's'",                //      1s
+        };
+
+        public override Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)
+        {
+            return (TimeSpan.TryParseExact(input.ToLowerInvariant(), _formats, CultureInfo.InvariantCulture, out var timeSpan))
+                ? Task.FromResult(TypeReaderResult.FromSuccess(timeSpan))
+                : Task.FromResult(TypeReaderResult.FromError(CommandError.ParseFailed, "Failed to parse TimeSpan"));
+        }
+    }
+}

src/Discord.Net.Commands/Readers/UserTypeReader.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Globalization;
@@ -7,7 +7,7 @@ using System.Threading.Tasks;
 
 namespace Discord.Commands
 {
-    internal class UserTypeReader<T> : TypeReader
+    public class UserTypeReader<T> : TypeReader
         where T : class, IUser
     {
         public override async Task<TypeReaderResult> ReadAsync(ICommandContext context, string input, IServiceProvider services)

src/Discord.Net.Commands/Results/TypeReaderResult.cs

@@ -1,7 +1,8 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Linq;
 
 namespace Discord.Commands
 {
@@ -30,6 +31,9 @@ namespace Discord.Commands
         public string ErrorReason { get; }
 
         public bool IsSuccess => !Error.HasValue;
+        public object BestMatch => IsSuccess
+            ? (Values.Count == 1 ? Values.Single().Value : Values.OrderByDescending(v => v.Score).First().Value)
+            : throw new InvalidOperationException("TypeReaderResult was not successful.");
 
         private TypeReaderResult(IReadOnlyCollection<TypeReaderValue> values, CommandError? error, string errorReason)
         {

src/Discord.Net.Commands/Utilities/QuotationAliasUtils.cs

@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Globalization;
+
+namespace Discord.Commands
+{
+    /// <summary>
+    /// Utility methods for generating matching pairs of unicode quotation marks for CommandServiceConfig
+    /// </summary>
+    internal static class QuotationAliasUtils
+    {
+        /// <summary>
+        /// Generates an IEnumerable of characters representing open-close pairs of
+        /// quotation punctuation.
+        /// </summary>
+        internal static Dictionary<char, char> GetDefaultAliasMap
+        {
+            get
+            {
+                // Output of a gist provided by https://gist.github.com/ufcpp
+                // https://gist.github.com/ufcpp/5b2cf9a9bf7d0b8743714a0b88f7edc5
+                // This was not used for the implementation because of incompatibility with netstandard1.1
+                return new Dictionary<char, char> {
+                    {'\"', '\"' },
+                    {'«', '»' },
+                    {'‘', '’' },
+                    {'“', '”' },
+                    {'„', '‟' },
+                    {'‹', '›' },
+                    {'‚', '‛' },
+                    {'《', '》' },
+                    {'〈', '〉' },
+                    {'「', '」' },
+                    {'『', '』' },
+                    {'〝', '〞' },
+                    {'﹁', '﹂' },
+                    {'﹃', '﹄' },
+                    {'＂', '＂' },
+                    {'＇', '＇' },
+                    {'｢', '｣' },
+                    {'(', ')' },
+                    {'༺', '༻' },
+                    {'༼', '༽' },
+                    {'᚛', '᚜' },
+                    {'⁅', '⁆' },
+                    {'⌈', '⌉' },
+                    {'⌊', '⌋' },
+                    {'❨', '❩' },
+                    {'❪', '❫' },
+                    {'❬', '❭' },
+                    {'❮', '❯' },
+                    {'❰', '❱' },
+                    {'❲', '❳' },
+                    {'❴', '❵' },
+                    {'⟅', '⟆' },
+                    {'⟦', '⟧' },
+                    {'⟨', '⟩' },
+                    {'⟪', '⟫' },
+                    {'⟬', '⟭' },
+                    {'⟮', '⟯' },
+                    {'⦃', '⦄' },
+                    {'⦅', '⦆' },
+                    {'⦇', '⦈' },
+                    {'⦉', '⦊' },
+                    {'⦋', '⦌' },
+                    {'⦍', '⦎' },
+                    {'⦏', '⦐' },
+                    {'⦑', '⦒' },
+                    {'⦓', '⦔' },
+                    {'⦕', '⦖' },
+                    {'⦗', '⦘' },
+                    {'⧘', '⧙' },
+                    {'⧚', '⧛' },
+                    {'⧼', '⧽' },
+                    {'⸂', '⸃' },
+                    {'⸄', '⸅' },
+                    {'⸉', '⸊' },
+                    {'⸌', '⸍' },
+                    {'⸜', '⸝' },
+                    {'⸠', '⸡' },
+                    {'⸢', '⸣' },
+                    {'⸤', '⸥' },
+                    {'⸦', '⸧' },
+                    {'⸨', '⸩' },
+                    {'【', '】'},
+                    {'〔', '〕' },
+                    {'〖', '〗' },
+                    {'〘', '〙' },
+                    {'〚', '〛' }
+                };
+            }
+        }
+    }
+}

src/Discord.Net.Core/CDN.cs

@@ -13,6 +13,10 @@ namespace Discord
             string extension = FormatToExtension(format, avatarId);
             return $"{DiscordConfig.CDNUrl}avatars/{userId}/{avatarId}.{extension}?size={size}";
         }
+        public static string GetDefaultUserAvatarUrl(ushort discriminator)
+        {
+            return $"{DiscordConfig.CDNUrl}embed/avatars/{discriminator % 5}.png";
+        }
         public static string GetGuildIconUrl(ulong guildId, string iconId)
             => iconId != null ? $"{DiscordConfig.CDNUrl}icons/{guildId}/{iconId}.jpg" : null;
         public static string GetGuildSplashUrl(ulong guildId, string splashId)
@@ -30,6 +34,8 @@ namespace Discord
 
         public static string GetSpotifyAlbumArtUrl(string albumArtId)
             => $"https://i.scdn.co/image/{albumArtId}";
+        public static string GetSpotifyDirectUrl(string trackId)
+            => $"https://open.spotify.com/track/{trackId}";
 
         private static string FormatToExtension(ImageFormat format, string imageId)
         {
@@ -37,11 +43,16 @@ namespace Discord
                 format = imageId.StartsWith("a_") ? ImageFormat.Gif : ImageFormat.Png;
             switch (format)
             {
-                case ImageFormat.Gif: return "gif";
-                case ImageFormat.Jpeg: return "jpeg";
-                case ImageFormat.Png: return "png";
-                case ImageFormat.WebP: return "webp";
-                default: throw new ArgumentException(nameof(format));
+                case ImageFormat.Gif:
+                    return "gif";
+                case ImageFormat.Jpeg:
+                    return "jpeg";
+                case ImageFormat.Png:
+                    return "png";
+                case ImageFormat.WebP:
+                    return "webp";
+                default:
+                    throw new ArgumentException(nameof(format));
             }
         }
     }

src/Discord.Net.Core/Discord.Net.Core.csproj

@@ -4,11 +4,12 @@
     <AssemblyName>Discord.Net.Core</AssemblyName>
     <RootNamespace>Discord</RootNamespace>
     <Description>The core components for the Discord.Net library.</Description>
-    <TargetFrameworks>net45;netstandard1.1;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">net45;netstandard1.1;netstandard1.3;netstandard2.0</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.1;netstandard1.3;netstandard2.0</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Newtonsoft.Json" Version="10.0.2" />
     <PackageReference Include="System.Collections.Immutable" Version="1.3.1" />
     <PackageReference Include="System.Interactive.Async" Version="3.1.1" />
   </ItemGroup>
-</Project>
+</Project>

src/Discord.Net.Core/DiscordConfig.cs

@@ -1,13 +1,13 @@
-using System.Reflection;
+using System.Reflection;
 
 namespace Discord
 {
     public class DiscordConfig
     {
-        public const int APIVersion = 6;        
+        public const int APIVersion = 6;
         public static string Version { get; } =
             typeof(DiscordConfig).GetTypeInfo().Assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>()?.InformationalVersion ??
-            typeof(DiscordConfig).GetTypeInfo().Assembly.GetName().Version.ToString(3) ?? 
+            typeof(DiscordConfig).GetTypeInfo().Assembly.GetName().Version.ToString(3) ??
             "Unknown";
 
         public static string UserAgent { get; } = $"DiscordBot (https://github.com/RogueException/Discord.Net, v{Version})";
@@ -20,10 +20,12 @@ namespace Discord
         public const int MaxMessagesPerBatch = 100;
         public const int MaxUsersPerBatch = 1000;
         public const int MaxGuildsPerBatch = 100;
+        public const int MaxUserReactionsPerBatch = 100;
+        public const int MaxAuditLogEntriesPerBatch = 100;
 
         /// <summary> Gets or sets how a request should act in the case of an error, by default. </summary>
         public RetryMode DefaultRetryMode { get; set; } = RetryMode.AlwaysRetry;
-        
+
         /// <summary> Gets or sets the minimum log level severity that will be sent to the Log event. </summary>
         public LogSeverity LogLevel { get; set; } = LogSeverity.Info;
 

src/Discord.Net.Core/Entities/Activities/SpotifyGame.cs

@@ -7,17 +7,20 @@ namespace Discord
     [DebuggerDisplay(@"{DebuggerDisplay,nq}")]
     public class SpotifyGame : Game
     {
-        public IEnumerable<string> Artists { get; internal set; }
-        public string AlbumArt { get; internal set; }
+        public IReadOnlyCollection<string> Artists { get; internal set; }
         public string AlbumTitle { get; internal set; }
         public string TrackTitle { get; internal set; }
-        public string SyncId { get; internal set; }
-        public string SessionId { get; internal set; }
         public TimeSpan? Duration { get; internal set; }
 
+        public string TrackId { get; internal set; }
+        public string SessionId { get; internal set; }
+
+        public string AlbumArtUrl { get; internal set; }
+        public string TrackUrl { get; internal set; }
+
         internal SpotifyGame() { }
 
-        public override string ToString() => Name;
+        public override string ToString() => $"{string.Join(", ", Artists)} - {TrackTitle} ({Duration})";
         private string DebuggerDisplay => $"{Name} (Spotify)";
     }
 }

src/Discord.Net.Core/Entities/AuditLogs/ActionType.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord
+{
+    /// <summary>
+    /// The action type within a <see cref="IAuditLogEntry"/>
+    /// </summary>
+    public enum ActionType
+    {
+        GuildUpdated = 1,
+
+        ChannelCreated = 10,
+        ChannelUpdated = 11,
+        ChannelDeleted = 12,
+
+        OverwriteCreated = 13,
+        OverwriteUpdated = 14,
+        OverwriteDeleted = 15,
+
+        Kick = 20,
+        Prune = 21,
+        Ban = 22,
+        Unban = 23,
+
+        MemberUpdated = 24,
+        MemberRoleUpdated = 25,
+
+        RoleCreated = 30,
+        RoleUpdated = 31,
+        RoleDeleted = 32,
+
+        InviteCreated = 40,
+        InviteUpdated = 41,
+        InviteDeleted = 42,
+
+        WebhookCreated = 50,
+        WebhookUpdated = 51,
+        WebhookDeleted = 52,
+
+        EmojiCreated = 60,
+        EmojiUpdated = 61,
+        EmojiDeleted = 62,
+
+        MessageDeleted = 72
+    }
+}

src/Discord.Net.Core/Entities/AuditLogs/IAuditLogData.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord
+{
+    /// <summary>
+    /// Represents data applied to an <see cref="IAuditLogEntry"/>
+    /// </summary>
+    public interface IAuditLogData
+    { }
+}

src/Discord.Net.Core/Entities/AuditLogs/IAuditLogEntry.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Discord
+{
+    /// <summary>
+    /// Represents an entry in an audit log
+    /// </summary>
+    public interface IAuditLogEntry : IEntity<ulong>
+    {
+        /// <summary>
+        /// The action which occured to create this entry
+        /// </summary>
+        ActionType Action { get; }
+
+        /// <summary>
+        /// The data for this entry. May be <see cref="null"/> if no data was available.
+        /// </summary>
+        IAuditLogData Data { get; }
+
+        /// <summary>
+        /// The user responsible for causing the changes
+        /// </summary>
+        IUser User { get; }
+
+        /// <summary>
+        /// The reason behind the change. May be <see cref="null"/> if no reason was provided.
+        /// </summary>
+        string Reason { get; }
+    }
+}

src/Discord.Net.Core/Entities/Channels/IMessageChannel.cs

@@ -8,7 +8,7 @@ namespace Discord
     public interface IMessageChannel : IChannel
     {
         /// <summary> Sends a message to this message channel. </summary>
-        Task<IUserMessage> SendMessageAsync(string text, bool isTTS = false, Embed embed = null, RequestOptions options = null);
+        Task<IUserMessage> SendMessageAsync(string text = null, bool isTTS = false, Embed embed = null, RequestOptions options = null);
 #if FILESYSTEM
         /// <summary> Sends a file to this text channel, with an optional caption. </summary>
         Task<IUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false, Embed embed = null, RequestOptions options = null);
@@ -30,6 +30,11 @@ namespace Discord
         /// <summary> Gets a collection of pinned messages in this channel. </summary>
         Task<IReadOnlyCollection<IMessage>> GetPinnedMessagesAsync(RequestOptions options = null);
 
+        /// <summary> Deletes a message based on the message ID in this channel. </summary>
+        Task DeleteMessageAsync(ulong messageId, RequestOptions options = null);
+        /// <summary> Deletes a message based on the provided message in this channel. </summary>
+        Task DeleteMessageAsync(IMessage message, RequestOptions options = null);
+
         /// <summary> Broadcasts the "user is typing" message to all users in this channel, lasting 10 seconds. </summary>
         Task TriggerTypingAsync(RequestOptions options = null);
         /// <summary> Continuously broadcasts the "user is typing" message to all users in this channel until the returned object is disposed. </summary>

src/Discord.Net.Core/Entities/Guilds/IGuild.cs

@@ -1,4 +1,4 @@
-using Discord.Audio;
+using Discord.Audio;
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
@@ -66,6 +66,24 @@ namespace Discord
 
         /// <summary> Gets a collection of all users banned on this guild. </summary>
         Task<IReadOnlyCollection<IBan>> GetBansAsync(RequestOptions options = null);
+        /// <summary>
+        ///     Gets a ban object for a banned user.
+        /// </summary>
+        /// <param name="user">The banned user.</param>
+        /// <returns>
+        ///     An awaitable <see cref="Task"/> containing the ban object, which contains the user information and the
+        ///     reason for the ban; <see langword="null"/> if the ban entry cannot be found.
+        /// </returns>
+        Task<IBan> GetBanAsync(IUser user, RequestOptions options = null);
+        /// <summary>
+        ///     Gets a ban object for a banned user.
+        /// </summary>
+        /// <param name="userId">The snowflake identifier for the banned user.</param>
+        /// <returns>
+        ///     An awaitable <see cref="Task"/> containing the ban object, which contains the user information and the
+        ///     reason for the ban; <see langword="null"/> if the ban entry cannot be found.
+        /// </returns>
+        Task<IBan> GetBanAsync(ulong userId, RequestOptions options = null);
         /// <summary> Bans the provided user from this guild and optionally prunes their recent messages. </summary>
         /// <param name="pruneDays">The number of days to remove messages from this user for - must be between [0, 7]</param>
         Task AddBanAsync(IUser user, int pruneDays = 0, string reason = null, RequestOptions options = null);
@@ -91,9 +109,9 @@ namespace Discord
         Task<ITextChannel> GetDefaultChannelAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
         Task<IGuildChannel> GetEmbedChannelAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
         /// <summary> Creates a new text channel. </summary>
-        Task<ITextChannel> CreateTextChannelAsync(string name, RequestOptions options = null);
+        Task<ITextChannel> CreateTextChannelAsync(string name, Action<TextChannelProperties> func = null, RequestOptions options = null);
         /// <summary> Creates a new voice channel. </summary>
-        Task<IVoiceChannel> CreateVoiceChannelAsync(string name, RequestOptions options = null);
+        Task<IVoiceChannel> CreateVoiceChannelAsync(string name, Action<VoiceChannelProperties> func = null, RequestOptions options = null);
         /// <summary> Creates a new channel category. </summary>
         Task<ICategoryChannel> CreateCategoryAsync(string name, RequestOptions options = null);
 
@@ -121,6 +139,10 @@ namespace Discord
         /// <summary> Removes all users from this guild if they have not logged on in a provided number of days or, if simulate is true, returns the number of users that would be removed. </summary>
         Task<int> PruneUsersAsync(int days = 30, bool simulate = false, RequestOptions options = null);
 
+        /// <summary> Gets the specified number of audit log entries for this guild. </summary>
+        Task<IReadOnlyCollection<IAuditLogEntry>> GetAuditLogAsync(int limit = DiscordConfig.MaxAuditLogEntriesPerBatch,
+            CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
+
         /// <summary> Gets the webhook in this guild with the provided id, or null if not found. </summary>
         Task<IWebhook> GetWebhookAsync(ulong id, RequestOptions options = null);
         /// <summary> Gets a collection of all webhooks for this guild. </summary>
@@ -135,4 +157,4 @@ namespace Discord
         /// <summary> Deletes an existing emote from this guild. </summary>
         Task DeleteEmoteAsync(GuildEmote emote, RequestOptions options = null);
     }
-}
+}

src/Discord.Net.Core/Entities/Guilds/IVoiceRegion.cs

@@ -1,4 +1,4 @@
-namespace Discord
+namespace Discord
 {
     public interface IVoiceRegion
     {
@@ -10,9 +10,9 @@
         bool IsVip { get; }
         /// <summary> Returns true if this voice region is the closest to your machine. </summary>
         bool IsOptimal { get; }
-        /// <summary> Gets an example hostname for this voice region. </summary>
-        string SampleHostname { get; }
-        /// <summary> Gets an example port for this voice region. </summary>
-        int SamplePort { get; }
+        /// <summary> Returns true if this is a deprecated voice region (avoid switching to these). </summary>
+        bool IsDeprecated { get; }
+        /// <summary> Returns true if this is a custom voice region (used for events/etc) </summary>
+        bool IsCustom { get; }
     }
-}
+}

src/Discord.Net.Core/Entities/Invites/IInvite.cs

@@ -1,4 +1,4 @@
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 
 namespace Discord
 {
@@ -22,8 +22,9 @@ namespace Discord
         ulong GuildId { get; }
         /// <summary> Gets the name of the guild this invite is linked to. </summary>
         string GuildName { get; }
-
-        /// <summary> Accepts this invite and joins the target guild. This will fail on bot accounts. </summary>
-        Task AcceptAsync(RequestOptions options = null);
+        /// <summary> Gets the approximated count of online members in the guild. </summary>
+        int? PresenceCount { get; }
+        /// <summary> Gets the approximated count of total members in the guild. </summary>
+        int? MemberCount { get; }
     }
 }

src/Discord.Net.Core/Entities/Messages/Embed.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
@@ -57,7 +57,18 @@ namespace Discord
             Fields = fields;
         }
 
-        public int Length => Title?.Length + Author?.Name?.Length + Description?.Length + Footer?.Text?.Length + Fields.Sum(f => f.Name.Length + f.Value.ToString().Length) ?? 0;
+        public int Length
+        {
+            get
+            {
+                int titleLength = Title?.Length ?? 0;
+                int authorLength = Author?.Name?.Length ?? 0;
+                int descriptionLength = Description?.Length ?? 0;
+                int footerLength = Footer?.Text?.Length ?? 0;
+                int fieldSum = Fields.Sum(f => f.Name?.Length + f.Value?.ToString().Length) ?? 0;
+                return titleLength + authorLength + descriptionLength + footerLength + fieldSum;
+            }
+        }
 
         public override string ToString() => Title;
         private string DebuggerDisplay => $"{Title} ({Type})";

src/Discord.Net.Core/Entities/Messages/EmbedBuilder.cs

@@ -1,89 +1,105 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Linq;
 
 namespace Discord
 {
     public class EmbedBuilder
     {
-        private readonly Embed _embed;
+        private string _title;
+        private string _description;
+        private string _url;
+        private EmbedImage? _image;
+        private EmbedThumbnail? _thumbnail;
+        private List<EmbedFieldBuilder> _fields;
 
         public const int MaxFieldCount = 25;
         public const int MaxTitleLength = 256;
         public const int MaxDescriptionLength = 2048;
-        public const int MaxEmbedLength = 6000; // user bot limit is 2000, but we don't validate that here.
+        public const int MaxEmbedLength = 6000;
 
         public EmbedBuilder()
         {
-            _embed = new Embed(EmbedType.Rich);
             Fields = new List<EmbedFieldBuilder>();
         }
 
         public string Title
         {
-            get => _embed.Title;
+            get => _title;
             set
             {
                 if (value?.Length > MaxTitleLength) throw new ArgumentException($"Title length must be less than or equal to {MaxTitleLength}.", nameof(Title));
-                _embed.Title = value;
+                _title = value;
             }
         }
-
         public string Description
         {
-            get => _embed.Description;
+            get => _description;
             set
             {
                 if (value?.Length > MaxDescriptionLength) throw new ArgumentException($"Description length must be less than or equal to {MaxDescriptionLength}.", nameof(Description));
-                _embed.Description = value;
+                _description = value;
             }
         }
 
         public string Url
         {
-            get => _embed.Url;
+            get => _url;
             set
             {
                 if (!value.IsNullOrUri()) throw new ArgumentException("Url must be a well-formed URI", nameof(Url));
-                _embed.Url = value;
+                _url = value;
             }
         }
         public string ThumbnailUrl
         {
-            get => _embed.Thumbnail?.Url;
+            get => _thumbnail?.Url;
             set
             {
                 if (!value.IsNullOrUri()) throw new ArgumentException("Url must be a well-formed URI", nameof(ThumbnailUrl));
-                _embed.Thumbnail = new EmbedThumbnail(value, null, null, null);
+                _thumbnail = new EmbedThumbnail(value, null, null, null);
             }
         }
         public string ImageUrl
         {
-            get => _embed.Image?.Url;
+            get => _image?.Url;
             set
             {
                 if (!value.IsNullOrUri()) throw new ArgumentException("Url must be a well-formed URI", nameof(ImageUrl));
-                _embed.Image = new EmbedImage(value, null, null, null);
+                _image = new EmbedImage(value, null, null, null);
             }
         }
-        public DateTimeOffset? Timestamp { get => _embed.Timestamp; set { _embed.Timestamp = value; } }
-        public Color? Color { get => _embed.Color; set { _embed.Color = value; } }
-
-        public EmbedAuthorBuilder Author { get; set; }
-        public EmbedFooterBuilder Footer { get; set; }
-        private List<EmbedFieldBuilder> _fields;
         public List<EmbedFieldBuilder> Fields
         {
             get => _fields;
             set
             {
-
                 if (value == null) throw new ArgumentNullException("Cannot set an embed builder's fields collection to null", nameof(Fields));
                 if (value.Count > MaxFieldCount) throw new ArgumentException($"Field count must be less than or equal to {MaxFieldCount}.", nameof(Fields));
                 _fields = value;
             }
         }
 
+        public DateTimeOffset? Timestamp { get; set; }
+        public Color? Color { get; set; }
+        public EmbedAuthorBuilder Author { get; set; }
+        public EmbedFooterBuilder Footer { get; set; }
+
+        public int Length
+        {
+            get
+            {
+                int titleLength = Title?.Length ?? 0;
+                int authorLength = Author?.Name?.Length ?? 0;
+                int descriptionLength = Description?.Length ?? 0;
+                int footerLength = Footer?.Text?.Length ?? 0;
+                int fieldSum = Fields.Sum(f => f.Name.Length + f.Value.ToString().Length);
+
+                return titleLength + authorLength + descriptionLength + footerLength + fieldSum;
+            }
+        }
+
         public EmbedBuilder WithTitle(string title)
         {
             Title = title;
@@ -180,7 +196,6 @@ namespace Discord
             AddField(field);
             return this;
         }
-
         public EmbedBuilder AddField(EmbedFieldBuilder field)
         {
             if (Fields.Count >= MaxFieldCount)
@@ -195,63 +210,53 @@ namespace Discord
         {
             var field = new EmbedFieldBuilder();
             action(field);
-            this.AddField(field);
+            AddField(field);
             return this;
         }
 
         public Embed Build()
         {
-            _embed.Footer = Footer?.Build();
-            _embed.Author = Author?.Build();
+            if (Length > MaxEmbedLength)
+                throw new InvalidOperationException($"Total embed length must be less than or equal to {MaxEmbedLength}");
+
             var fields = ImmutableArray.CreateBuilder<EmbedField>(Fields.Count);
             for (int i = 0; i < Fields.Count; i++)
                 fields.Add(Fields[i].Build());
-            _embed.Fields = fields.ToImmutable();
 
-            if (_embed.Length > MaxEmbedLength)
-            {
-                throw new InvalidOperationException($"Total embed length must be less than or equal to {MaxEmbedLength}");
-            }
-
-            return _embed;
+            return new Embed(EmbedType.Rich, Title, Description, Url, Timestamp, Color, _image, null, Author?.Build(), Footer?.Build(), null, _thumbnail, fields.ToImmutable());
         }
     }
 
     public class EmbedFieldBuilder
     {
-        private EmbedField _field;
-
+        private string _name;
+        private string _value;
         public const int MaxFieldNameLength = 256;
         public const int MaxFieldValueLength = 1024;
 
         public string Name
         {
-            get => _field.Name;
+            get => _name;
             set
             {
                 if (string.IsNullOrWhiteSpace(value)) throw new ArgumentException($"Field name must not be null, empty or entirely whitespace.", nameof(Name));
                 if (value.Length > MaxFieldNameLength) throw new ArgumentException($"Field name length must be less than or equal to {MaxFieldNameLength}.", nameof(Name));
-                _field.Name = value;
+                _name = value;
             }
         }
 
         public object Value
         {
-            get => _field.Value;
+            get => _value;
             set
             {
                 var stringValue = value?.ToString();
                 if (string.IsNullOrEmpty(stringValue)) throw new ArgumentException($"Field value must not be null or empty.", nameof(Value));
                 if (stringValue.Length > MaxFieldValueLength) throw new ArgumentException($"Field value length must be less than or equal to {MaxFieldValueLength}.", nameof(Value));
-                _field.Value = stringValue;
+                _value = stringValue;
             }
         }
-        public bool IsInline { get => _field.Inline; set { _field.Inline = value; } }
-
-        public EmbedFieldBuilder()
-        {
-            _field = new EmbedField();
-        }
+        public bool IsInline { get; set; }
 
         public EmbedFieldBuilder WithName(string name)
         {
@@ -270,48 +275,44 @@ namespace Discord
         }
 
         public EmbedField Build()
-            => _field;
+            => new EmbedField(Name, Value.ToString(), IsInline);
     }
 
     public class EmbedAuthorBuilder
     {
-        private EmbedAuthor _author;
-
+        private string _name;
+        private string _url;
+        private string _iconUrl;
         public const int MaxAuthorNameLength = 256;
 
         public string Name
         {
-            get => _author.Name;
+            get => _name;
             set
             {
                 if (value?.Length > MaxAuthorNameLength) throw new ArgumentException($"Author name length must be less than or equal to {MaxAuthorNameLength}.", nameof(Name));
-                _author.Name = value;
+                _name = value;
             }
         }
         public string Url
         {
-            get => _author.Url;
+            get => _url;
             set
             {
                 if (!value.IsNullOrUri()) throw new ArgumentException("Url must be a well-formed URI", nameof(Url));
-                _author.Url = value;
+                _url = value;
             }
         }
         public string IconUrl
         {
-            get => _author.IconUrl;
+            get => _iconUrl;
             set
             {
                 if (!value.IsNullOrUri()) throw new ArgumentException("Url must be a well-formed URI", nameof(IconUrl));
-                _author.IconUrl = value;
+                _iconUrl = value;
             }
         }
 
-        public EmbedAuthorBuilder()
-        {
-            _author = new EmbedAuthor();
-        }
-
         public EmbedAuthorBuilder WithName(string name)
         {
             Name = name;
@@ -329,39 +330,35 @@ namespace Discord
         }
 
         public EmbedAuthor Build()
-            => _author;
+            => new EmbedAuthor(Name, Url, IconUrl, null);
     }
 
     public class EmbedFooterBuilder
     {
-        private EmbedFooter _footer;
+        private string _text;
+        private string _iconUrl;
 
         public const int MaxFooterTextLength = 2048;
 
         public string Text
         {
-            get => _footer.Text;
+            get => _text;
             set
             {
                 if (value?.Length > MaxFooterTextLength) throw new ArgumentException($"Footer text length must be less than or equal to {MaxFooterTextLength}.", nameof(Text));
-                _footer.Text = value;
+                _text = value;
             }
         }
         public string IconUrl
         {
-            get => _footer.IconUrl;
+            get => _iconUrl;
             set
             {
                 if (!value.IsNullOrUri()) throw new ArgumentException("Url must be a well-formed URI", nameof(IconUrl));
-                _footer.IconUrl = value;
+                _iconUrl = value;
             }
         }
 
-        public EmbedFooterBuilder()
-        {
-            _footer = new EmbedFooter();
-        }
-
         public EmbedFooterBuilder WithText(string text)
         {
             Text = text;
@@ -374,6 +371,6 @@ namespace Discord
         }
 
         public EmbedFooter Build()
-            => _footer;
+            => new EmbedFooter(Text, IconUrl, null);
     }
 }

src/Discord.Net.Core/Entities/Messages/IUserMessage.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 
@@ -23,7 +23,7 @@ namespace Discord
         /// <summary> Removes all reactions from this message. </summary>
         Task RemoveAllReactionsAsync(RequestOptions options = null);
         /// <summary>  Gets all users that reacted to a message with a given emote </summary>
-        Task<IReadOnlyCollection<IUser>> GetReactionUsersAsync(IEmote emoji, int limit = 100, ulong? afterUserId = null, RequestOptions options = null);
+        IAsyncEnumerable<IReadOnlyCollection<IUser>> GetReactionUsersAsync(IEmote emoji, int limit, RequestOptions options = null);
 
         /// <summary> Transforms this message's text into a human readable form by resolving its tags. </summary>
         string Resolve(

src/Discord.Net.Core/Entities/Permissions/ChannelPermissions.cs

@@ -12,7 +12,7 @@ namespace Discord
         /// <summary> Gets a ChannelPermissions that grants all permissions for text channels. </summary>
         public static readonly ChannelPermissions Text = new ChannelPermissions(0b01100_0000000_1111111110001_010001);
         /// <summary> Gets a ChannelPermissions that grants all permissions for voice channels. </summary>
-        public static readonly ChannelPermissions Voice = new ChannelPermissions(0b00100_1111110_0000000000000_010001);
+        public static readonly ChannelPermissions Voice = new ChannelPermissions(0b00100_1111110_0000000010000_010001);
         /// <summary> Gets a ChannelPermissions that grants all permissions for category channels. </summary>
         public static readonly ChannelPermissions Category = new ChannelPermissions(0b01100_1111110_1111111110001_010001);
         /// <summary> Gets a ChannelPermissions that grants all permissions for direct message channels. </summary>

src/Discord.Net.Core/Entities/Permissions/GuildPermission.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 
 namespace Discord
 {
@@ -16,7 +16,9 @@ namespace Discord
         // Text
         AddReactions        = 0x00_00_00_40,
         ViewAuditLog        = 0x00_00_00_80,
-        ReadMessages        = 0x00_00_04_00,
+        [Obsolete("Use ViewChannel instead.")]
+        ReadMessages        = ViewChannel,
+        ViewChannel         = 0x00_00_04_00,
         SendMessages        = 0x00_00_08_00,
         SendTTSMessages     = 0x00_00_10_00,
         ManageMessages      = 0x00_00_20_00,

src/Discord.Net.Core/Entities/Permissions/GuildPermissions.cs

@@ -35,7 +35,10 @@ namespace Discord
         public bool ViewAuditLog => Permissions.GetValue(RawValue, GuildPermission.ViewAuditLog);
 
         /// <summary> If True, a user may join channels. </summary>
-        public bool ReadMessages => Permissions.GetValue(RawValue, GuildPermission.ReadMessages);
+        [Obsolete("Use ViewChannel instead.")]
+        public bool ReadMessages => ViewChannel;
+        /// <summary> If True, a user may view channels. </summary>
+        public bool ViewChannel => Permissions.GetValue(RawValue, GuildPermission.ViewChannel);
         /// <summary> If True, a user may send messages. </summary>
         public bool SendMessages => Permissions.GetValue(RawValue, GuildPermission.SendMessages);
         /// <summary> If True, a user may send text-to-speech messages. </summary>

src/Discord.Net.Core/Entities/Roles/Color.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Diagnostics;
+#if NETSTANDARD2_0 || NET45
+using StandardColor = System.Drawing.Color;
+#endif
 
 namespace Discord
 {
@@ -96,7 +99,14 @@ namespace Discord
                 ((uint)(g * 255.0f) << 8) |
                 (uint)(b * 255.0f);
         }
-        
+
+#if NETSTANDARD2_0 || NET45
+        public static implicit operator StandardColor(Color color) =>
+            StandardColor.FromArgb((int)color.RawValue);
+        public static explicit operator Color(StandardColor color) =>
+            new Color((uint)color.ToArgb() << 8 >> 8);
+#endif
+
         public override string ToString() =>
             $"#{Convert.ToString(RawValue, 16)}";
         private string DebuggerDisplay =>

src/Discord.Net.Core/Entities/Users/IUser.cs

@@ -8,6 +8,8 @@ namespace Discord
         string AvatarId { get; }
         /// <summary> Gets the url to this user's avatar. </summary>
         string GetAvatarUrl(ImageFormat format = ImageFormat.Auto, ushort size = 128);
+        /// <summary> Gets the url to this user's default avatar. </summary>
+        string GetDefaultAvatarUrl();
         /// <summary> Gets the per-username unique id for this user. </summary>
         string Discriminator { get; }
         /// <summary> Gets the per-username unique id for this user. </summary>

src/Discord.Net.Core/Entities/Webhooks/WebhookType.cs

@@ -0,0 +1,14 @@
+namespace Discord
+{
+    /// <summary>
+    /// Represents the type of a webhook.
+    /// </summary>
+    /// <remarks>
+    /// This type is currently unused, and is only returned in audit log responses.
+    /// </remarks>
+    public enum WebhookType
+    {
+        /// <summary> An incoming webhook </summary>
+        Incoming = 1
+    }
+}

src/Discord.Net.Core/Extensions/UserExtensions.cs

@@ -9,7 +9,7 @@ namespace Discord
         /// Sends a message to the user via DM.
         /// </summary>
         public static async Task<IUserMessage> SendMessageAsync(this IUser user,
-            string text,
+            string text = null,
             bool isTTS = false,
             Embed embed = null,
             RequestOptions options = null)

src/Discord.Net.Core/IDiscordClient.cs

@@ -27,7 +27,7 @@ namespace Discord
         Task<IReadOnlyCollection<IGuild>> GetGuildsAsync(CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
         Task<IGuild> CreateGuildAsync(string name, IVoiceRegion region, Stream jpegIcon = null, RequestOptions options = null);
         
-        Task<IInvite> GetInviteAsync(string inviteId, RequestOptions options = null);
+        Task<IInvite> GetInviteAsync(string inviteId, bool withCount = false, RequestOptions options = null);
 
         Task<IUser> GetUserAsync(ulong id, CacheMode mode = CacheMode.AllowDownload, RequestOptions options = null);
         Task<IUser> GetUserAsync(string username, string discriminator, RequestOptions options = null);

src/Discord.Net.DebugTools/Discord.Net.DebugTools.csproj

@@ -4,9 +4,10 @@
     <AssemblyName>Discord.Net.DebugTools</AssemblyName>
     <RootNamespace>Discord</RootNamespace>
     <Description>A Discord.Net extension adding some helper classes for diagnosing issues.</Description>
-    <TargetFrameworks>net45;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">net45;netstandard1.3</TargetFrameworks>
+    <TargetFramework Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3</TargetFramework>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Discord.Net.Core\Discord.Net.Core.csproj" />
   </ItemGroup>
-</Project>
+</Project>

src/Discord.Net.Rest/API/Common/AuditLog.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json;
+
+namespace Discord.API
+{
+    internal class AuditLog
+    {
+        [JsonProperty("webhooks")]
+        public Webhook[] Webhooks { get; set; }
+
+        [JsonProperty("users")]
+        public User[] Users { get; set; }
+
+        [JsonProperty("audit_log_entries")]
+        public AuditLogEntry[] Entries { get; set; }
+    }
+}

src/Discord.Net.Rest/API/Common/AuditLogChange.cs

@@ -0,0 +1,17 @@
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace Discord.API
+{
+    internal class AuditLogChange
+    {
+        [JsonProperty("key")]
+        public string ChangedProperty { get; set; }
+
+        [JsonProperty("new_value")]
+        public JToken NewValue { get; set; }
+
+        [JsonProperty("old_value")]
+        public JToken OldValue { get; set; }
+    }
+}

src/Discord.Net.Rest/API/Common/AuditLogEntry.cs

@@ -0,0 +1,26 @@
+using Newtonsoft.Json;
+
+namespace Discord.API
+{
+    internal class AuditLogEntry
+    {
+        [JsonProperty("target_id")]
+        public ulong? TargetId { get; set; }
+        [JsonProperty("user_id")]
+        public ulong UserId { get; set; }
+
+        [JsonProperty("changes")]
+        public AuditLogChange[] Changes { get; set; }
+        [JsonProperty("options")]
+        public AuditLogOptions Options { get; set; }
+
+        [JsonProperty("id")]
+        public ulong Id { get; set; }
+
+        [JsonProperty("action_type")]
+        public ActionType Action { get; set; }
+
+        [JsonProperty("reason")]
+        public string Reason { get; set; }
+    }
+}

src/Discord.Net.Rest/API/Common/AuditLogOptions.cs

@@ -0,0 +1,27 @@
+using Newtonsoft.Json;
+
+namespace Discord.API
+{
+    internal class AuditLogOptions
+    {
+        //Message delete
+        [JsonProperty("count")]
+        public int? MessageDeleteCount { get; set; }
+        [JsonProperty("channel_id")]
+        public ulong? MessageDeleteChannelId { get; set; }
+
+        //Prune
+        [JsonProperty("delete_member_days")]
+        public int? PruneDeleteMemberDays { get; set; }
+        [JsonProperty("members_removed")]
+        public int? PruneMembersRemoved { get; set; }
+
+        //Overwrite Update
+        [JsonProperty("role_name")]
+        public string OverwriteRoleName { get; set; }
+        [JsonProperty("type")]
+        public string OverwriteType { get; set; }
+        [JsonProperty("id")]
+        public ulong? OverwriteTargetId { get; set; }
+    }
+}

src/Discord.Net.Rest/API/Common/Invite.cs

@@ -1,4 +1,4 @@
-#pragma warning disable CS1591
+#pragma warning disable CS1591
 using Newtonsoft.Json;
 
 namespace Discord.API
@@ -11,5 +11,9 @@ namespace Discord.API
         public InviteGuild Guild { get; set; }
         [JsonProperty("channel")]
         public InviteChannel Channel { get; set; }
+        [JsonProperty("approximate_presence_count")]
+        public Optional<int?> PresenceCount { get; set; }
+        [JsonProperty("approximate_member_count")]
+        public Optional<int?> MemberCount { get; set; }
     }
 }

src/Discord.Net.Rest/API/Common/VoiceRegion.cs

@@ -1,4 +1,4 @@
-#pragma warning disable CS1591
+#pragma warning disable CS1591
 using Newtonsoft.Json;
 
 namespace Discord.API
@@ -13,9 +13,9 @@ namespace Discord.API
         public bool IsVip { get; set; }
         [JsonProperty("optimal")]
         public bool IsOptimal { get; set; }
-        [JsonProperty("sample_hostname")]
-        public string SampleHostname { get; set; }
-        [JsonProperty("sample_port")]
-        public int SamplePort { get; set; }
+        [JsonProperty("deprecated")]
+        public bool IsDeprecated { get; set; }
+        [JsonProperty("custom")]
+        public bool IsCustom { get; set; }
     }
 }

src/Discord.Net.Rest/API/Rest/CreateGuildChannelParams.cs

@@ -1,4 +1,4 @@
-#pragma warning disable CS1591
+#pragma warning disable CS1591
 using Newtonsoft.Json;
 
 namespace Discord.API.Rest
@@ -10,9 +10,20 @@ namespace Discord.API.Rest
         public string Name { get; }
         [JsonProperty("type")]
         public ChannelType Type { get; }
+        [JsonProperty("parent_id")]
+        public Optional<ulong?> CategoryId { get; set; }
 
+        //Text channels
+        [JsonProperty("topic")]
+        public Optional<string> Topic { get; set; }
+        [JsonProperty("nsfw")]
+        public Optional<bool> IsNsfw { get; set; }
+
+        //Voice channels
         [JsonProperty("bitrate")]
         public Optional<int> Bitrate { get; set; }
+        [JsonProperty("user_limit")]
+        public Optional<int?> UserLimit { get; set; }
 
         public CreateGuildChannelParams(string name, ChannelType type)
         {

src/Discord.Net.Rest/API/Rest/GetAuditLogsParams.cs

@@ -0,0 +1,8 @@
+namespace Discord.API.Rest
+{
+    class GetAuditLogsParams
+    {
+        public Optional<int> Limit { get; set; }
+        public Optional<ulong> BeforeEntryId { get; set; }
+    }
+}

src/Discord.Net.Rest/API/Rest/GetInviteParams.cs

@@ -0,0 +1,7 @@
+namespace Discord.API.Rest
+{
+    internal class GetInviteParams
+    {
+        public Optional<bool?> WithCounts { get; set; }
+    }
+}

src/Discord.Net.Rest/API/Rest/GetReactionUsersParams.cs

@@ -1,4 +1,4 @@
-namespace Discord.API.Rest
+namespace Discord.API.Rest
 {
     internal class GetReactionUsersParams
     {

src/Discord.Net.Rest/AssemblyInfo.cs

@@ -6,5 +6,17 @@ using System.Runtime.CompilerServices;
 [assembly: InternalsVisibleTo("Discord.Net.Commands")]
 [assembly: InternalsVisibleTo("Discord.Net.Tests")]
 
+[assembly: TypeForwardedTo(typeof(Discord.Embed))]
 [assembly: TypeForwardedTo(typeof(Discord.EmbedBuilder))]
 [assembly: TypeForwardedTo(typeof(Discord.EmbedBuilderExtensions))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedAuthor))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedAuthorBuilder))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedField))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedFieldBuilder))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedFooter))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedFooterBuilder))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedImage))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedProvider))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedThumbnail))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedType))]
+[assembly: TypeForwardedTo(typeof(Discord.EmbedVideo))]

src/Discord.Net.Rest/BaseDiscordClient.cs

@@ -148,7 +148,7 @@ namespace Discord.Rest
         Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync(RequestOptions options)
             => Task.FromResult<IReadOnlyCollection<IConnection>>(ImmutableArray.Create<IConnection>());
 
-        Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, RequestOptions options)
+        Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, bool withCount, RequestOptions options)
             => Task.FromResult<IInvite>(null);
 
         Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode, RequestOptions options)

src/Discord.Net.Rest/ClientHelper.cs

@@ -50,12 +50,16 @@ namespace Discord.Rest
             return models.Select(x => RestConnection.Create(x)).ToImmutableArray();
         }
         
-        public static async Task<RestInvite> GetInviteAsync(BaseDiscordClient client,
-            string inviteId, RequestOptions options)
+        public static async Task<RestInviteMetadata> GetInviteAsync(BaseDiscordClient client,
+            string inviteId, bool withCount, RequestOptions options)
         {
-            var model = await client.ApiClient.GetInviteAsync(inviteId, options).ConfigureAwait(false);
+            var args = new GetInviteParams
+            {
+                WithCounts = withCount
+            };
+            var model = await client.ApiClient.GetInviteAsync(inviteId, args, options).ConfigureAwait(false);
             if (model != null)
-                return RestInvite.Create(client, null, null, model);
+                return RestInviteMetadata.Create(client, null, null, model);
             return null;
         }
         

src/Discord.Net.Rest/Discord.Net.Rest.csproj

@@ -4,7 +4,8 @@
     <AssemblyName>Discord.Net.Rest</AssemblyName>
     <RootNamespace>Discord.Rest</RootNamespace>
     <Description>A core Discord.Net library containing the REST client and models.</Description>
-    <TargetFrameworks>net45;netstandard1.1;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">net45;netstandard1.1;netstandard1.3</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.1;netstandard1.3</TargetFrameworks>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Discord.Net.Core\Discord.Net.Core.csproj" />
@@ -16,4 +17,4 @@
   <ItemGroup Condition=" '$(TargetFramework)' == 'net45' ">
     <Reference Include="System.Net.Http" />
   </ItemGroup>
-</Project>
+</Project>

src/Discord.Net.Rest/DiscordRestApiClient.cs

@@ -618,15 +618,15 @@ namespace Discord.API
             Preconditions.NotNullOrWhitespace(emoji, nameof(emoji));
             Preconditions.NotNull(args, nameof(args));
             Preconditions.GreaterThan(args.Limit, 0, nameof(args.Limit));
-            Preconditions.AtMost(args.Limit, DiscordConfig.MaxUsersPerBatch, nameof(args.Limit));
+            Preconditions.AtMost(args.Limit, DiscordConfig.MaxUserReactionsPerBatch, nameof(args.Limit));
             Preconditions.GreaterThan(args.AfterUserId, 0, nameof(args.AfterUserId));
             options = RequestOptions.CreateOrClone(options);
 
-            int limit = args.Limit.GetValueOrDefault(int.MaxValue);
+            int limit = args.Limit.GetValueOrDefault(DiscordConfig.MaxUserReactionsPerBatch);
             ulong afterUserId = args.AfterUserId.GetValueOrDefault(0);
 
             var ids = new BucketIds(channelId: channelId);
-            Expression<Func<string>> endpoint = () => $"channels/{channelId}/messages/{messageId}/reactions/{emoji}";
+            Expression<Func<string>> endpoint = () => $"channels/{channelId}/messages/{messageId}/reactions/{emoji}?limit={limit}&after={afterUserId}";
             return await SendAsync<IReadOnlyCollection<User>>("GET", endpoint, ids, options: options).ConfigureAwait(false);
         }
         public async Task AckMessageAsync(ulong channelId, ulong messageId, RequestOptions options = null)
@@ -800,6 +800,15 @@ namespace Discord.API
             var ids = new BucketIds(guildId: guildId);
             return await SendAsync<IReadOnlyCollection<Ban>>("GET", () => $"guilds/{guildId}/bans", ids, options: options).ConfigureAwait(false);
         }
+        public async Task<Ban> GetGuildBanAsync(ulong guildId, ulong userId, RequestOptions options)
+        {
+            Preconditions.NotEqual(userId, 0, nameof(userId));
+            Preconditions.NotEqual(guildId, 0, nameof(guildId));
+            options = RequestOptions.CreateOrClone(options);
+
+            var ids = new BucketIds(guildId: guildId);
+            return await SendAsync<Ban>("GET", () => $"guilds/{guildId}/bans/{userId}", ids, options: options).ConfigureAwait(false);
+        }
         public async Task CreateGuildBanAsync(ulong guildId, ulong userId, CreateGuildBanParams args, RequestOptions options = null)
         {
             Preconditions.NotEqual(guildId, 0, nameof(guildId));
@@ -897,7 +906,7 @@ namespace Discord.API
         }
 
         //Guild Invites
-        public async Task<Invite> GetInviteAsync(string inviteId, RequestOptions options = null)
+        public async Task<InviteMetadata> GetInviteAsync(string inviteId, GetInviteParams args, RequestOptions options = null)
         {
             Preconditions.NotNullOrEmpty(inviteId, nameof(inviteId));
             options = RequestOptions.CreateOrClone(options);
@@ -910,9 +919,11 @@ namespace Discord.API
             if (index >= 0)
                 inviteId = inviteId.Substring(index + 1);
 
+            var withCounts = args.WithCounts.GetValueOrDefault(false);
+
             try
             {
-                return await SendAsync<Invite>("GET", () => $"invites/{inviteId}", new BucketIds(), options: options).ConfigureAwait(false);
+                return await SendAsync<InviteMetadata>("GET", () => $"invites/{inviteId}?with_counts={withCounts}", new BucketIds(), options: options).ConfigureAwait(false);
             }
             catch (HttpException ex) when (ex.HttpCode == HttpStatusCode.NotFound) { return null; }
         }
@@ -950,13 +961,6 @@ namespace Discord.API
             
             return await SendAsync<Invite>("DELETE", () => $"invites/{inviteId}", new BucketIds(), options: options).ConfigureAwait(false);
         }
-        public async Task AcceptInviteAsync(string inviteId, RequestOptions options = null)
-        {
-            Preconditions.NotNullOrEmpty(inviteId, nameof(inviteId));
-            options = RequestOptions.CreateOrClone(options);
-            
-            await SendAsync("POST", () => $"invites/{inviteId}", new BucketIds(), options: options).ConfigureAwait(false);
-        }
 
         //Guild Members
         public async Task<GuildMember> GetGuildMemberAsync(ulong guildId, ulong userId, RequestOptions options = null)
@@ -1202,6 +1206,26 @@ namespace Discord.API
             return await SendAsync<IReadOnlyCollection<VoiceRegion>>("GET", () => $"guilds/{guildId}/regions", ids, options: options).ConfigureAwait(false);
         }
 
+        //Audit logs
+        public async Task<AuditLog> GetAuditLogsAsync(ulong guildId, GetAuditLogsParams args, RequestOptions options = null)
+        {
+            Preconditions.NotEqual(guildId, 0, nameof(guildId));
+            Preconditions.NotNull(args, nameof(args));
+            options = RequestOptions.CreateOrClone(options);
+
+            int limit = args.Limit.GetValueOrDefault(int.MaxValue);
+
+            var ids = new BucketIds(guildId: guildId);
+            Expression<Func<string>> endpoint;
+
+            if (args.BeforeEntryId.IsSpecified)
+                endpoint = () => $"guilds/{guildId}/audit-logs?limit={limit}&before={args.BeforeEntryId.Value}";
+            else
+                endpoint = () => $"guilds/{guildId}/audit-logs?limit={limit}";
+
+            return await SendAsync<AuditLog>("GET", endpoint, ids, options: options).ConfigureAwait(false);
+        }
+
         //Webhooks
         public async Task<Webhook> CreateWebhookAsync(ulong channelId, CreateWebhookParams args, RequestOptions options = null)
         {

src/Discord.Net.Rest/DiscordRestClient.cs

@@ -56,8 +56,8 @@ namespace Discord.Rest
             => ClientHelper.GetConnectionsAsync(this, options);
 
         /// <inheritdoc />
-        public Task<RestInvite> GetInviteAsync(string inviteId, RequestOptions options = null)
-            => ClientHelper.GetInviteAsync(this, inviteId, options);
+        public Task<RestInviteMetadata> GetInviteAsync(string inviteId, bool withCount = false, RequestOptions options = null)
+            => ClientHelper.GetInviteAsync(this, inviteId, withCount, options);
 
         /// <inheritdoc />
         public Task<RestGuild> GetGuildAsync(ulong id, RequestOptions options = null)
@@ -131,8 +131,8 @@ namespace Discord.Rest
         async Task<IReadOnlyCollection<IConnection>> IDiscordClient.GetConnectionsAsync(RequestOptions options)
             => await GetConnectionsAsync(options).ConfigureAwait(false);
 
-        async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, RequestOptions options)
-            => await GetInviteAsync(inviteId, options).ConfigureAwait(false);
+        async Task<IInvite> IDiscordClient.GetInviteAsync(string inviteId, bool withCount, RequestOptions options)
+            => await GetInviteAsync(inviteId, withCount, options).ConfigureAwait(false);
 
         async Task<IGuild> IDiscordClient.GetGuildAsync(ulong id, CacheMode mode, RequestOptions options)
         {

src/Discord.Net.Rest/Entities/AuditLogs/AuditLogHelper.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    internal static class AuditLogHelper
+    {
+        private static readonly Dictionary<ActionType, Func<BaseDiscordClient, Model, EntryModel, IAuditLogData>> CreateMapping
+            = new Dictionary<ActionType, Func<BaseDiscordClient, Model, EntryModel, IAuditLogData>>()
+        {
+            [ActionType.GuildUpdated] = GuildUpdateAuditLogData.Create,
+
+            [ActionType.ChannelCreated] = ChannelCreateAuditLogData.Create,
+            [ActionType.ChannelUpdated] = ChannelUpdateAuditLogData.Create,
+            [ActionType.ChannelDeleted] = ChannelDeleteAuditLogData.Create,
+
+            [ActionType.OverwriteCreated] = OverwriteCreateAuditLogData.Create,
+            [ActionType.OverwriteUpdated] = OverwriteUpdateAuditLogData.Create,
+            [ActionType.OverwriteDeleted] = OverwriteDeleteAuditLogData.Create,
+
+            [ActionType.Kick] = KickAuditLogData.Create,
+            [ActionType.Prune] = PruneAuditLogData.Create,
+            [ActionType.Ban] = BanAuditLogData.Create,
+            [ActionType.Unban] = UnbanAuditLogData.Create,
+            [ActionType.MemberUpdated] = MemberUpdateAuditLogData.Create,
+            [ActionType.MemberRoleUpdated] = MemberRoleAuditLogData.Create,
+
+            [ActionType.RoleCreated] = RoleCreateAuditLogData.Create,
+            [ActionType.RoleUpdated] = RoleUpdateAuditLogData.Create,
+            [ActionType.RoleDeleted] = RoleDeleteAuditLogData.Create,
+
+            [ActionType.InviteCreated] = InviteCreateAuditLogData.Create,
+            [ActionType.InviteUpdated] = InviteUpdateAuditLogData.Create,
+            [ActionType.InviteDeleted] = InviteDeleteAuditLogData.Create,
+
+            [ActionType.WebhookCreated] = WebhookCreateAuditLogData.Create,
+            [ActionType.WebhookUpdated] = WebhookUpdateAuditLogData.Create,
+            [ActionType.WebhookDeleted] = WebhookDeleteAuditLogData.Create,
+
+            [ActionType.EmojiCreated] = EmoteCreateAuditLogData.Create,
+            [ActionType.EmojiUpdated] = EmoteUpdateAuditLogData.Create,
+            [ActionType.EmojiDeleted] = EmoteDeleteAuditLogData.Create,
+
+            [ActionType.MessageDeleted] = MessageDeleteAuditLogData.Create,
+        };
+
+        public static IAuditLogData CreateData(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            if (CreateMapping.TryGetValue(entry.Action, out var func))
+                return func(discord, log, entry);
+
+            return null;
+        }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/BanAuditLogData.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class BanAuditLogData : IAuditLogData
+    {
+        private BanAuditLogData(IUser user)
+        {
+            Target = user;
+        }
+
+        internal static BanAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
+            return new BanAuditLogData(RestUser.Create(discord, userInfo));
+        }
+
+        public IUser Target { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ChannelCreateAuditLogData.cs

@@ -0,0 +1,52 @@
+using Newtonsoft.Json.Linq;
+using System.Collections.Generic;
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class ChannelCreateAuditLogData : IAuditLogData
+    {
+        private ChannelCreateAuditLogData(ulong id, string name, ChannelType type, IReadOnlyCollection<Overwrite> overwrites)
+        {
+            ChannelId = id;
+            ChannelName = name;
+            ChannelType = type;
+            Overwrites = overwrites;
+        }
+
+        internal static ChannelCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+            var overwrites = new List<Overwrite>();
+
+            var overwritesModel = changes.FirstOrDefault(x => x.ChangedProperty == "permission_overwrites");
+            var typeModel = changes.FirstOrDefault(x => x.ChangedProperty == "type");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+
+            var type = typeModel.NewValue.ToObject<ChannelType>();
+            var name = nameModel.NewValue.ToObject<string>();
+
+            foreach (var overwrite in overwritesModel.NewValue)
+            {
+                var deny = overwrite.Value<ulong>("deny");
+                var _type = overwrite.Value<string>("type");
+                var id = overwrite.Value<ulong>("id");
+                var allow = overwrite.Value<ulong>("allow");
+
+                PermissionTarget permType = _type == "member" ? PermissionTarget.User : PermissionTarget.Role;
+
+                overwrites.Add(new Overwrite(id, permType, new OverwritePermissions(allow, deny)));
+            }
+
+            return new ChannelCreateAuditLogData(entry.TargetId.Value, name, type, overwrites.ToReadOnlyCollection());
+        }
+
+        public ulong ChannelId { get; }
+        public string ChannelName { get; }
+        public ChannelType ChannelType { get; }
+        public IReadOnlyCollection<Overwrite> Overwrites { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ChannelDeleteAuditLogData.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class ChannelDeleteAuditLogData : IAuditLogData
+    {
+        private ChannelDeleteAuditLogData(ulong id, string name, ChannelType type, IReadOnlyCollection<Overwrite> overwrites)
+        {
+            ChannelId = id;
+            ChannelName = name;
+            ChannelType = type;
+            Overwrites = overwrites;
+        }
+
+        internal static ChannelDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var overwritesModel = changes.FirstOrDefault(x => x.ChangedProperty == "permission_overwrites");
+            var typeModel = changes.FirstOrDefault(x => x.ChangedProperty == "type");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+
+            var overwrites = overwritesModel.OldValue.ToObject<API.Overwrite[]>()
+                .Select(x => new Overwrite(x.TargetId, x.TargetType, new OverwritePermissions(x.Allow, x.Deny)))
+                .ToList();
+            var type = typeModel.OldValue.ToObject<ChannelType>();
+            var name = nameModel.OldValue.ToObject<string>();
+            var id = entry.TargetId.Value;
+
+            return new ChannelDeleteAuditLogData(id, name, type, overwrites.ToReadOnlyCollection());
+        }
+
+        public ulong ChannelId { get; }
+        public string ChannelName { get; }
+        public ChannelType ChannelType { get; }
+        public IReadOnlyCollection<Overwrite> Overwrites { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ChannelInfo.cs

@@ -0,0 +1,18 @@
+namespace Discord.Rest
+{
+    public struct ChannelInfo
+    {
+        internal ChannelInfo(string name, string topic, int? bitrate, int? limit)
+        {
+            Name = name;
+            Topic = topic;
+            Bitrate = bitrate;
+            UserLimit = limit;
+        }
+
+        public string Name { get; }
+        public string Topic { get; }
+        public int? Bitrate { get; }
+        public int? UserLimit { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/ChannelUpdateAuditLogData.cs

@@ -0,0 +1,45 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class ChannelUpdateAuditLogData : IAuditLogData
+    {
+        private ChannelUpdateAuditLogData(ulong id, ChannelInfo before, ChannelInfo after)
+        {
+            ChannelId = id;
+            Before = before;
+            After = after;
+        }
+
+        internal static ChannelUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var topicModel = changes.FirstOrDefault(x => x.ChangedProperty == "topic");
+            var bitrateModel = changes.FirstOrDefault(x => x.ChangedProperty == "bitrate");
+            var userLimitModel = changes.FirstOrDefault(x => x.ChangedProperty == "user_limit");
+
+            string oldName = nameModel?.OldValue?.ToObject<string>(),
+                newName = nameModel?.NewValue?.ToObject<string>();
+            string oldTopic = topicModel?.OldValue?.ToObject<string>(),
+                newTopic = topicModel?.NewValue?.ToObject<string>();
+            int? oldBitrate = bitrateModel?.OldValue?.ToObject<int>(),
+                newBitrate = bitrateModel?.NewValue?.ToObject<int>();
+            int? oldLimit = userLimitModel?.OldValue?.ToObject<int>(),
+                newLimit = userLimitModel?.NewValue?.ToObject<int>();
+
+            var before = new ChannelInfo(oldName, oldTopic, oldBitrate, oldLimit);
+            var after = new ChannelInfo(newName, newTopic, newBitrate, newLimit);
+
+            return new ChannelUpdateAuditLogData(entry.TargetId.Value, before, after);
+        }
+
+        public ulong ChannelId { get; }
+        public ChannelInfo Before { get; set; }
+        public ChannelInfo After { get; set; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/EmoteCreateAuditLogData.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class EmoteCreateAuditLogData : IAuditLogData
+    {
+        private EmoteCreateAuditLogData(ulong id, string name)
+        {
+            EmoteId = id;
+            Name = name;
+        }
+
+        internal static EmoteCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var change = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "name");
+
+            var emoteName = change.NewValue?.ToObject<string>();
+            return new EmoteCreateAuditLogData(entry.TargetId.Value, emoteName);
+        }
+
+        public ulong EmoteId { get; }
+        public string Name { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/EmoteDeleteAuditLogData.cs

@@ -0,0 +1,28 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class EmoteDeleteAuditLogData : IAuditLogData
+    {
+        private EmoteDeleteAuditLogData(ulong id, string name)
+        {
+            EmoteId = id;
+            Name = name;
+        }
+
+        internal static EmoteDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var change = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "name");
+
+            var emoteName = change.OldValue?.ToObject<string>();
+
+            return new EmoteDeleteAuditLogData(entry.TargetId.Value, emoteName);
+        }
+
+        public ulong EmoteId { get; }
+        public string Name { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/EmoteUpdateAuditLogData.cs

@@ -0,0 +1,31 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class EmoteUpdateAuditLogData : IAuditLogData
+    {
+        private EmoteUpdateAuditLogData(ulong id, string oldName, string newName)
+        {
+            EmoteId = id;
+            OldName = oldName;
+            NewName = newName;
+        }
+
+        internal static EmoteUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var change = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "name");
+
+            var newName = change.NewValue?.ToObject<string>();
+            var oldName = change.OldValue?.ToObject<string>();
+
+            return new EmoteUpdateAuditLogData(entry.TargetId.Value, oldName, newName);
+        }
+
+        public ulong EmoteId { get; }
+        public string NewName { get; }
+        public string OldName { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/GuildInfo.cs

@@ -0,0 +1,32 @@
+namespace Discord.Rest
+{
+    public struct GuildInfo
+    {
+        internal GuildInfo(int? afkTimeout, DefaultMessageNotifications? defaultNotifs,
+            ulong? afkChannel, string name, string region, string icon,
+            VerificationLevel? verification, IUser owner, MfaLevel? mfa, int? filter)
+        {
+            AfkTimeout = afkTimeout;
+            DefaultMessageNotifications = defaultNotifs;
+            AfkChannelId = afkChannel;
+            Name = name;
+            RegionId = region;
+            IconHash = icon;
+            VerificationLevel = verification;
+            Owner = owner;
+            MfaLevel = mfa;
+            ContentFilterLevel = filter;
+        }
+
+        public int? AfkTimeout { get; }
+        public DefaultMessageNotifications? DefaultMessageNotifications { get; }
+        public ulong? AfkChannelId { get; }
+        public string Name { get; }
+        public string RegionId { get; }
+        public string IconHash { get; }
+        public VerificationLevel? VerificationLevel { get; }
+        public IUser Owner { get; }
+        public MfaLevel? MfaLevel { get; }
+        public int? ContentFilterLevel { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/GuildUpdateAuditLogData.cs

@@ -0,0 +1,79 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class GuildUpdateAuditLogData : IAuditLogData
+    {
+        private GuildUpdateAuditLogData(GuildInfo before, GuildInfo after)
+        {
+            Before = before;
+            After = after;
+        }
+
+        internal static GuildUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var afkTimeoutModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var defaultMessageNotificationsModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var afkChannelModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var regionIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var iconHashModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var verificationLevelModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var ownerIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var mfaLevelModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+            var contentFilterModel = changes.FirstOrDefault(x => x.ChangedProperty == "afk_timeout");
+
+            int? oldAfkTimeout = afkTimeoutModel?.OldValue?.ToObject<int>(),
+                newAfkTimeout = afkTimeoutModel?.NewValue?.ToObject<int>();
+            DefaultMessageNotifications? oldDefaultMessageNotifications = defaultMessageNotificationsModel?.OldValue?.ToObject<DefaultMessageNotifications>(),
+                newDefaultMessageNotifications = defaultMessageNotificationsModel?.NewValue?.ToObject<DefaultMessageNotifications>();
+            ulong? oldAfkChannelId = afkChannelModel?.OldValue?.ToObject<ulong>(),
+                newAfkChannelId = afkChannelModel?.NewValue?.ToObject<ulong>();
+            string oldName = nameModel?.OldValue?.ToObject<string>(),
+                newName = nameModel?.NewValue?.ToObject<string>();
+            string oldRegionId = regionIdModel?.OldValue?.ToObject<string>(),
+                newRegionId = regionIdModel?.NewValue?.ToObject<string>();
+            string oldIconHash = iconHashModel?.OldValue?.ToObject<string>(),
+                newIconHash = iconHashModel?.NewValue?.ToObject<string>();
+            VerificationLevel? oldVerificationLevel = verificationLevelModel?.OldValue?.ToObject<VerificationLevel>(),
+                newVerificationLevel = verificationLevelModel?.NewValue?.ToObject<VerificationLevel>();
+            ulong? oldOwnerId = ownerIdModel?.OldValue?.ToObject<ulong>(),
+                newOwnerId = ownerIdModel?.NewValue?.ToObject<ulong>();
+            MfaLevel? oldMfaLevel = mfaLevelModel?.OldValue?.ToObject<MfaLevel>(),
+                newMfaLevel = mfaLevelModel?.NewValue?.ToObject<MfaLevel>();
+            int? oldContentFilter = contentFilterModel?.OldValue?.ToObject<int>(),
+                newContentFilter = contentFilterModel?.NewValue?.ToObject<int>();
+
+            IUser oldOwner = null;
+            if (oldOwnerId != null)
+            {
+                var oldOwnerInfo = log.Users.FirstOrDefault(x => x.Id == oldOwnerId.Value);
+                oldOwner = RestUser.Create(discord, oldOwnerInfo);
+            }
+
+            IUser newOwner = null;
+            if (newOwnerId != null)
+            {
+                var newOwnerInfo = log.Users.FirstOrDefault(x => x.Id == newOwnerId.Value);
+                newOwner = RestUser.Create(discord, newOwnerInfo);
+            }
+
+            var before = new GuildInfo(oldAfkTimeout, oldDefaultMessageNotifications,
+                oldAfkChannelId, oldName, oldRegionId, oldIconHash, oldVerificationLevel, oldOwner,
+                oldMfaLevel, oldContentFilter);
+            var after = new GuildInfo(newAfkTimeout, newDefaultMessageNotifications,
+                newAfkChannelId, newName, newRegionId, newIconHash, newVerificationLevel, newOwner,
+                newMfaLevel, newContentFilter);
+
+            return new GuildUpdateAuditLogData(before, after);
+        }
+
+        public GuildInfo Before { get; }
+        public GuildInfo After { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/InviteCreateAuditLogData.cs

@@ -0,0 +1,55 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class InviteCreateAuditLogData : IAuditLogData
+    {
+        private InviteCreateAuditLogData(int maxAge, string code, bool temporary, IUser inviter, ulong channelId, int uses, int maxUses)
+        {
+            MaxAge = maxAge;
+            Code = code;
+            Temporary = temporary;
+            Creator = inviter;
+            ChannelId = channelId;
+            Uses = uses;
+            MaxUses = maxUses;
+        }
+
+        internal static InviteCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var maxAgeModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_age");
+            var codeModel = changes.FirstOrDefault(x => x.ChangedProperty == "code");
+            var temporaryModel = changes.FirstOrDefault(x => x.ChangedProperty == "temporary");
+            var inviterIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "inviter_id");
+            var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
+            var usesModel = changes.FirstOrDefault(x => x.ChangedProperty == "uses");
+            var maxUsesModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_uses");
+
+            var maxAge = maxAgeModel.NewValue.ToObject<int>();
+            var code = codeModel.NewValue.ToObject<string>();
+            var temporary = temporaryModel.NewValue.ToObject<bool>();
+            var inviterId = inviterIdModel.NewValue.ToObject<ulong>();
+            var channelId = channelIdModel.NewValue.ToObject<ulong>();
+            var uses = usesModel.NewValue.ToObject<int>();
+            var maxUses = maxUsesModel.NewValue.ToObject<int>();
+
+            var inviterInfo = log.Users.FirstOrDefault(x => x.Id == inviterId);
+            var inviter = RestUser.Create(discord, inviterInfo);
+
+            return new InviteCreateAuditLogData(maxAge, code, temporary, inviter, channelId, uses, maxUses);
+        }
+
+        public int MaxAge { get; }
+        public string Code { get; }
+        public bool Temporary { get; }
+        public IUser Creator { get; }
+        public ulong ChannelId { get; }
+        public int Uses { get; }
+        public int MaxUses { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/InviteDeleteAuditLogData.cs

@@ -0,0 +1,55 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class InviteDeleteAuditLogData : IAuditLogData
+    {
+        private InviteDeleteAuditLogData(int maxAge, string code, bool temporary, IUser inviter, ulong channelId, int uses, int maxUses)
+        {
+            MaxAge = maxAge;
+            Code = code;
+            Temporary = temporary;
+            Creator = inviter;
+            ChannelId = channelId;
+            Uses = uses;
+            MaxUses = maxUses;
+        }
+
+        internal static InviteDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var maxAgeModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_age");
+            var codeModel = changes.FirstOrDefault(x => x.ChangedProperty == "code");
+            var temporaryModel = changes.FirstOrDefault(x => x.ChangedProperty == "temporary");
+            var inviterIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "inviter_id");
+            var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
+            var usesModel = changes.FirstOrDefault(x => x.ChangedProperty == "uses");
+            var maxUsesModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_uses");
+
+            var maxAge = maxAgeModel.OldValue.ToObject<int>();
+            var code = codeModel.OldValue.ToObject<string>();
+            var temporary = temporaryModel.OldValue.ToObject<bool>();
+            var inviterId = inviterIdModel.OldValue.ToObject<ulong>();
+            var channelId = channelIdModel.OldValue.ToObject<ulong>();
+            var uses = usesModel.OldValue.ToObject<int>();
+            var maxUses = maxUsesModel.OldValue.ToObject<int>();
+
+            var inviterInfo = log.Users.FirstOrDefault(x => x.Id == inviterId);
+            var inviter = RestUser.Create(discord, inviterInfo);
+
+            return new InviteDeleteAuditLogData(maxAge, code, temporary, inviter, channelId, uses, maxUses);
+        }
+
+        public int MaxAge { get; }
+        public string Code { get; }
+        public bool Temporary { get; }
+        public IUser Creator { get; }
+        public ulong ChannelId { get; }
+        public int Uses { get; }
+        public int MaxUses { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/InviteInfo.cs

@@ -0,0 +1,20 @@
+namespace Discord.Rest
+{
+    public struct InviteInfo
+    {
+        internal InviteInfo(int? maxAge, string code, bool? temporary, ulong? channelId, int? maxUses)
+        {
+            MaxAge = maxAge;
+            Code = code;
+            Temporary = temporary;
+            ChannelId = channelId;
+            MaxUses = maxUses;
+        }
+
+        public int? MaxAge { get; }
+        public string Code { get; }
+        public bool? Temporary { get; }
+        public ulong? ChannelId { get; }
+        public int? MaxUses { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/InviteUpdateAuditLogData.cs

@@ -0,0 +1,46 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class InviteUpdateAuditLogData : IAuditLogData
+    {
+        private InviteUpdateAuditLogData(InviteInfo before, InviteInfo after)
+        {
+            Before = before;
+            After = after;
+        }
+
+        internal static InviteUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var maxAgeModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_age");
+            var codeModel = changes.FirstOrDefault(x => x.ChangedProperty == "code");
+            var temporaryModel = changes.FirstOrDefault(x => x.ChangedProperty == "temporary");
+            var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
+            var maxUsesModel = changes.FirstOrDefault(x => x.ChangedProperty == "max_uses");
+
+            int? oldMaxAge = maxAgeModel?.OldValue?.ToObject<int>(),
+                newMaxAge = maxAgeModel?.NewValue?.ToObject<int>();
+            string oldCode = codeModel?.OldValue?.ToObject<string>(),
+                newCode = codeModel?.NewValue?.ToObject<string>();
+            bool? oldTemporary = temporaryModel?.OldValue?.ToObject<bool>(),
+                newTemporary = temporaryModel?.NewValue?.ToObject<bool>();
+            ulong? oldChannelId = channelIdModel?.OldValue?.ToObject<ulong>(),
+                newChannelId = channelIdModel?.NewValue?.ToObject<ulong>();
+            int? oldMaxUses = maxUsesModel?.OldValue?.ToObject<int>(),
+                newMaxUses = maxUsesModel?.NewValue?.ToObject<int>();
+
+            var before = new InviteInfo(oldMaxAge, oldCode, oldTemporary, oldChannelId, oldMaxUses);
+            var after = new InviteInfo(newMaxAge, newCode, newTemporary, newChannelId, newMaxUses);
+
+            return new InviteUpdateAuditLogData(before, after);
+        }
+
+        public InviteInfo Before { get; }
+        public InviteInfo After { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/KickAuditLogData.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class KickAuditLogData : IAuditLogData
+    {
+        private KickAuditLogData(RestUser user)
+        {
+            Target = user;
+        }
+
+        internal static KickAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
+            return new KickAuditLogData(RestUser.Create(discord, userInfo));
+        }
+
+        public IUser Target { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/MemberRoleAuditLogData.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class MemberRoleAuditLogData : IAuditLogData
+    {
+        private MemberRoleAuditLogData(IReadOnlyCollection<RoleInfo> roles, IUser target)
+        {
+            Roles = roles;
+            Target = target;
+        }
+
+        internal static MemberRoleAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var roleInfos = changes.SelectMany(x => x.NewValue.ToObject<API.Role[]>(),
+                (model, role) => new { model.ChangedProperty, Role = role })
+                .Select(x => new RoleInfo(x.Role.Name, x.Role.Id, x.ChangedProperty == "$add"))
+                .ToList();
+
+            var userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
+            var user = RestUser.Create(discord, userInfo);
+
+            return new MemberRoleAuditLogData(roleInfos.ToReadOnlyCollection(), user);
+        }
+
+        public IReadOnlyCollection<RoleInfo> Roles { get; }
+        public IUser Target { get; }
+
+        public struct RoleInfo
+        {
+            internal RoleInfo(string name, ulong roleId, bool added)
+            {
+                Name = name;
+                RoleId = roleId;
+                Added = added;
+            }
+
+            public string Name { get; }
+            public ulong RoleId { get; }
+            public bool Added { get; }
+        }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/MemberUpdateAuditLogData.cs

@@ -0,0 +1,35 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+using ChangeModel = Discord.API.AuditLogChange;
+
+namespace Discord.Rest
+{
+    public class MemberUpdateAuditLogData : IAuditLogData
+    {
+        private MemberUpdateAuditLogData(IUser target, string newNick, string oldNick)
+        {
+            Target = target;
+            NewNick = newNick;
+            OldNick = oldNick;
+        }
+
+        internal static MemberUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes.FirstOrDefault(x => x.ChangedProperty == "nick");
+
+            var newNick = changes.NewValue?.ToObject<string>();
+            var oldNick = changes.OldValue?.ToObject<string>();
+
+            var targetInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
+            var user = RestUser.Create(discord, targetInfo);
+
+            return new MemberUpdateAuditLogData(user, newNick, oldNick);
+        }
+
+        public IUser Target { get; }
+        public string NewNick { get; }
+        public string OldNick { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/MessageDeleteAuditLogData.cs

@@ -0,0 +1,22 @@
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class MessageDeleteAuditLogData : IAuditLogData
+    {
+        private MessageDeleteAuditLogData(ulong channelId, int count)
+        {
+            ChannelId = channelId;
+            MessageCount = count;
+        }
+
+        internal static MessageDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            return new MessageDeleteAuditLogData(entry.Options.MessageDeleteChannelId.Value, entry.Options.MessageDeleteCount.Value);
+        }
+
+        public int MessageCount { get; }
+        public ulong ChannelId { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/OverwriteCreateAuditLogData.cs

@@ -0,0 +1,37 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class OverwriteCreateAuditLogData : IAuditLogData
+    {
+        private OverwriteCreateAuditLogData(Overwrite overwrite)
+        {
+            Overwrite = overwrite;
+        }
+
+        internal static OverwriteCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var denyModel = changes.FirstOrDefault(x => x.ChangedProperty == "deny");
+            var allowModel = changes.FirstOrDefault(x => x.ChangedProperty == "allow");
+
+            var deny = denyModel.NewValue.ToObject<ulong>();
+            var allow = allowModel.NewValue.ToObject<ulong>();
+
+            var permissions = new OverwritePermissions(allow, deny);
+
+            var id = entry.Options.OverwriteTargetId.Value;
+            var type = entry.Options.OverwriteType;
+
+            PermissionTarget target = type == "member" ? PermissionTarget.User : PermissionTarget.Role;
+
+            return new OverwriteCreateAuditLogData(new Overwrite(id, target, permissions));
+        }
+
+        public Overwrite Overwrite { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/OverwriteDeleteAuditLogData.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+using ChangeModel = Discord.API.AuditLogChange;
+using OptionModel = Discord.API.AuditLogOptions;
+
+namespace Discord.Rest
+{
+    public class OverwriteDeleteAuditLogData : IAuditLogData
+    {
+        private OverwriteDeleteAuditLogData(Overwrite deletedOverwrite)
+        {
+            Overwrite = deletedOverwrite;
+        }
+
+        internal static OverwriteDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var denyModel = changes.FirstOrDefault(x => x.ChangedProperty == "deny");
+            var typeModel = changes.FirstOrDefault(x => x.ChangedProperty == "type");
+            var idModel = changes.FirstOrDefault(x => x.ChangedProperty == "id");
+            var allowModel = changes.FirstOrDefault(x => x.ChangedProperty == "allow");
+
+            var deny = denyModel.OldValue.ToObject<ulong>();
+            var type = typeModel.OldValue.ToObject<string>();
+            var id = idModel.OldValue.ToObject<ulong>();
+            var allow = allowModel.OldValue.ToObject<ulong>();
+
+            PermissionTarget target = type == "member" ? PermissionTarget.User : PermissionTarget.Role;
+
+            return new OverwriteDeleteAuditLogData(new Overwrite(id, target, new OverwritePermissions(allow, deny)));
+        }
+
+        public Overwrite Overwrite { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/OverwriteUpdateAuditLogData.cs

@@ -0,0 +1,44 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class OverwriteUpdateAuditLogData : IAuditLogData
+    {
+        private OverwriteUpdateAuditLogData(OverwritePermissions before, OverwritePermissions after, ulong targetId, PermissionTarget targetType)
+        {
+            OldPermissions = before;
+            NewPermissions = after;
+            OverwriteTargetId = targetId;
+            OverwriteType = targetType;
+        }
+
+        internal static OverwriteUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var denyModel = changes.FirstOrDefault(x => x.ChangedProperty == "deny");
+            var allowModel = changes.FirstOrDefault(x => x.ChangedProperty == "allow");
+
+            var beforeAllow = allowModel?.OldValue?.ToObject<ulong>();
+            var afterAllow = allowModel?.NewValue?.ToObject<ulong>();
+            var beforeDeny = denyModel?.OldValue?.ToObject<ulong>();
+            var afterDeny = denyModel?.OldValue?.ToObject<ulong>();
+
+            var beforePermissions = new OverwritePermissions(beforeAllow ?? 0, beforeDeny ?? 0);
+            var afterPermissions = new OverwritePermissions(afterAllow ?? 0, afterDeny ?? 0);
+
+            PermissionTarget target = entry.Options.OverwriteType == "member" ? PermissionTarget.User : PermissionTarget.Role;
+
+            return new OverwriteUpdateAuditLogData(beforePermissions, afterPermissions, entry.Options.OverwriteTargetId.Value, target);
+        }
+
+        public OverwritePermissions OldPermissions { get; }
+        public OverwritePermissions NewPermissions { get; }
+
+        public ulong OverwriteTargetId { get; }
+        public PermissionTarget OverwriteType { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/PruneAuditLogData.cs

@@ -0,0 +1,22 @@
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class PruneAuditLogData : IAuditLogData
+    {
+        private PruneAuditLogData(int pruneDays, int membersRemoved)
+        {
+            PruneDays = pruneDays;
+            MembersRemoved = membersRemoved;
+        }
+
+        internal static PruneAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            return new PruneAuditLogData(entry.Options.PruneDeleteMemberDays.Value, entry.Options.PruneMembersRemoved.Value);
+        }
+
+        public int PruneDays { get; }
+        public int MembersRemoved { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/RoleCreateAuditLogData.cs

@@ -0,0 +1,47 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class RoleCreateAuditLogData : IAuditLogData
+    {
+        private RoleCreateAuditLogData(ulong id, RoleInfo props)
+        {
+            RoleId = id;
+            Properties = props;
+        }
+
+        internal static RoleCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var colorModel = changes.FirstOrDefault(x => x.ChangedProperty == "color");
+            var mentionableModel = changes.FirstOrDefault(x => x.ChangedProperty == "mentionable");
+            var hoistModel = changes.FirstOrDefault(x => x.ChangedProperty == "hoist");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var permissionsModel = changes.FirstOrDefault(x => x.ChangedProperty == "permissions");
+
+            uint? colorRaw = colorModel?.NewValue?.ToObject<uint>();
+            bool? mentionable = mentionableModel?.NewValue?.ToObject<bool>();
+            bool? hoist = hoistModel?.NewValue?.ToObject<bool>();
+            string name = nameModel?.NewValue?.ToObject<string>();
+            ulong? permissionsRaw = permissionsModel?.NewValue?.ToObject<ulong>();
+
+            Color? color = null;
+            GuildPermissions? permissions = null;
+
+            if (colorRaw.HasValue)
+                color = new Color(colorRaw.Value);
+            if (permissionsRaw.HasValue)
+                permissions = new GuildPermissions(permissionsRaw.Value);
+
+            return new RoleCreateAuditLogData(entry.TargetId.Value,
+                new RoleInfo(color, mentionable, hoist, name, permissions));
+        }
+
+        public ulong RoleId { get; }
+        public RoleInfo Properties { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/RoleDeleteAuditLogData.cs

@@ -0,0 +1,47 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class RoleDeleteAuditLogData : IAuditLogData
+    {
+        private RoleDeleteAuditLogData(ulong id, RoleInfo props)
+        {
+            RoleId = id;
+            Properties = props;
+        }
+
+        internal static RoleDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var colorModel = changes.FirstOrDefault(x => x.ChangedProperty == "color");
+            var mentionableModel = changes.FirstOrDefault(x => x.ChangedProperty == "mentionable");
+            var hoistModel = changes.FirstOrDefault(x => x.ChangedProperty == "hoist");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var permissionsModel = changes.FirstOrDefault(x => x.ChangedProperty == "permissions");
+
+            uint? colorRaw = colorModel?.OldValue?.ToObject<uint>();
+            bool? mentionable = mentionableModel?.OldValue?.ToObject<bool>();
+            bool? hoist = hoistModel?.OldValue?.ToObject<bool>();
+            string name = nameModel?.OldValue?.ToObject<string>();
+            ulong? permissionsRaw = permissionsModel?.OldValue?.ToObject<ulong>();
+
+            Color? color = null;
+            GuildPermissions? permissions = null;
+
+            if (colorRaw.HasValue)
+                color = new Color(colorRaw.Value);
+            if (permissionsRaw.HasValue)
+                permissions = new GuildPermissions(permissionsRaw.Value);
+
+            return new RoleDeleteAuditLogData(entry.TargetId.Value,
+                new RoleInfo(color, mentionable, hoist, name, permissions));
+        }
+
+        public ulong RoleId { get; }
+        public RoleInfo Properties { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/RoleInfo.cs

@@ -0,0 +1,21 @@
+namespace Discord.Rest
+{
+    public struct RoleInfo
+        {
+            internal RoleInfo(Color? color, bool? mentionable, bool? hoist, string name,
+                GuildPermissions? permissions)
+            {
+                Color = color;
+                Mentionable = mentionable;
+                Hoist = hoist;
+                Name = name;
+                Permissions = permissions;
+            }
+
+            public Color? Color { get; }
+            public bool? Mentionable { get; }
+            public bool? Hoist { get; }
+            public string Name { get; }
+            public GuildPermissions? Permissions { get; }
+        }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/RoleUpdateAuditLogData.cs

@@ -0,0 +1,62 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class RoleUpdateAuditLogData : IAuditLogData
+    {
+        private RoleUpdateAuditLogData(ulong id, RoleInfo oldProps, RoleInfo newProps)
+        {
+            RoleId = id;
+            Before = oldProps;
+            After = newProps;
+        }
+
+        internal static RoleUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var colorModel = changes.FirstOrDefault(x => x.ChangedProperty == "color");
+            var mentionableModel = changes.FirstOrDefault(x => x.ChangedProperty == "mentionable");
+            var hoistModel = changes.FirstOrDefault(x => x.ChangedProperty == "hoist");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var permissionsModel = changes.FirstOrDefault(x => x.ChangedProperty == "permissions");
+
+            uint? oldColorRaw = colorModel?.OldValue?.ToObject<uint>(),
+                newColorRaw = colorModel?.NewValue?.ToObject<uint>();
+            bool? oldMentionable = mentionableModel?.OldValue?.ToObject<bool>(),
+                newMentionable = mentionableModel?.NewValue?.ToObject<bool>();
+            bool? oldHoist = hoistModel?.OldValue?.ToObject<bool>(),
+                newHoist = hoistModel?.NewValue?.ToObject<bool>();
+            string oldName = nameModel?.OldValue?.ToObject<string>(),
+                newName = nameModel?.NewValue?.ToObject<string>();
+            ulong? oldPermissionsRaw = permissionsModel?.OldValue?.ToObject<ulong>(),
+                newPermissionsRaw = permissionsModel?.OldValue?.ToObject<ulong>();
+
+            Color? oldColor = null,
+                newColor = null;
+            GuildPermissions? oldPermissions = null,
+                newPermissions = null;
+
+            if (oldColorRaw.HasValue)
+                oldColor = new Color(oldColorRaw.Value);
+            if (newColorRaw.HasValue)
+                newColor = new Color(newColorRaw.Value);
+            if (oldPermissionsRaw.HasValue)
+                oldPermissions = new GuildPermissions(oldPermissionsRaw.Value);
+            if (newPermissionsRaw.HasValue)
+                newPermissions = new GuildPermissions(newPermissionsRaw.Value);
+
+            var oldProps = new RoleInfo(oldColor, oldMentionable, oldHoist, oldName, oldPermissions);
+            var newProps = new RoleInfo(newColor, newMentionable, newHoist, newName, newPermissions);
+
+            return new RoleUpdateAuditLogData(entry.TargetId.Value, oldProps, newProps);
+        }
+
+        public ulong RoleId { get; }
+        public RoleInfo Before { get; }
+        public RoleInfo After { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/UnbanAuditLogData.cs

@@ -0,0 +1,23 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class UnbanAuditLogData : IAuditLogData
+    {
+        private UnbanAuditLogData(IUser user)
+        {
+            Target = user;
+        }
+
+        internal static UnbanAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var userInfo = log.Users.FirstOrDefault(x => x.Id == entry.TargetId);
+            return new UnbanAuditLogData(RestUser.Create(discord, userInfo));
+        }
+
+        public IUser Target { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/WebhookCreateAuditLogData.cs

@@ -0,0 +1,44 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class WebhookCreateAuditLogData : IAuditLogData
+    {
+        private WebhookCreateAuditLogData(IWebhook webhook, WebhookType type, string name, ulong channelId)
+        {
+            Webhook = webhook;
+            Name = name;
+            Type = type;
+            ChannelId = channelId;
+        }
+
+        internal static WebhookCreateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
+            var typeModel = changes.FirstOrDefault(x => x.ChangedProperty == "type");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+
+            var channelId = channelIdModel.NewValue.ToObject<ulong>();
+            var type = typeModel.NewValue.ToObject<WebhookType>();
+            var name = nameModel.NewValue.ToObject<string>();
+
+            var webhookInfo = log.Webhooks?.FirstOrDefault(x => x.Id == entry.TargetId);
+            var webhook = RestWebhook.Create(discord, (IGuild)null, webhookInfo);
+
+            return new WebhookCreateAuditLogData(webhook, type, name, channelId);
+        }
+
+        //Corresponds to the *current* data
+        public IWebhook Webhook { get; }
+
+        //Corresponds to the *audit log* data
+        public WebhookType Type { get; }
+        public string Name { get; }
+        public ulong ChannelId { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/WebhookDeleteAuditLogData.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class WebhookDeleteAuditLogData : IAuditLogData
+    {
+        private WebhookDeleteAuditLogData(ulong id, ulong channel, WebhookType type, string name, string avatar)
+        {
+            WebhookId = id;
+            ChannelId = channel;
+            Name = name;
+            Type = type;
+            Avatar = avatar;
+        }
+
+        internal static WebhookDeleteAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
+            var typeModel = changes.FirstOrDefault(x => x.ChangedProperty == "type");
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var avatarHashModel = changes.FirstOrDefault(x => x.ChangedProperty == "avatar_hash");
+
+            var channelId = channelIdModel.OldValue.ToObject<ulong>();
+            var type = typeModel.OldValue.ToObject<WebhookType>();
+            var name = nameModel.OldValue.ToObject<string>();
+            var avatarHash = avatarHashModel?.OldValue?.ToObject<string>();
+
+            return new WebhookDeleteAuditLogData(entry.TargetId.Value, channelId, type, name, avatarHash);
+        }
+
+        public ulong WebhookId { get; }
+        public ulong ChannelId { get; }
+        public WebhookType Type { get; }
+        public string Name { get; }
+        public string Avatar { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/WebhookInfo.cs

@@ -0,0 +1,16 @@
+namespace Discord.Rest
+{
+    public struct WebhookInfo
+    {
+        internal WebhookInfo(string name, ulong? channelId, string avatar)
+        {
+            Name = name;
+            ChannelId = channelId;
+            Avatar = avatar;
+        }
+
+        public string Name { get; }
+        public ulong? ChannelId { get; }
+        public string Avatar { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/DataTypes/WebhookUpdateAuditLogData.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class WebhookUpdateAuditLogData : IAuditLogData
+    {
+        private WebhookUpdateAuditLogData(IWebhook webhook, WebhookInfo before, WebhookInfo after)
+        {
+            Webhook = webhook;
+            Before = before;
+            After = after;
+        }
+
+        internal static WebhookUpdateAuditLogData Create(BaseDiscordClient discord, Model log, EntryModel entry)
+        {
+            var changes = entry.Changes;
+
+            var nameModel = changes.FirstOrDefault(x => x.ChangedProperty == "name");
+            var channelIdModel = changes.FirstOrDefault(x => x.ChangedProperty == "channel_id");
+            var avatarHashModel = changes.FirstOrDefault(x => x.ChangedProperty == "avatar_hash");
+
+            var oldName = nameModel?.OldValue?.ToObject<string>();
+            var oldChannelId = channelIdModel?.OldValue?.ToObject<ulong>();
+            var oldAvatar = avatarHashModel?.OldValue?.ToObject<string>();
+            var before = new WebhookInfo(oldName, oldChannelId, oldAvatar);
+
+            var newName = nameModel?.NewValue?.ToObject<string>();
+            var newChannelId = channelIdModel?.NewValue?.ToObject<ulong>();
+            var newAvatar = avatarHashModel?.NewValue?.ToObject<string>();
+            var after = new WebhookInfo(newName, newChannelId, newAvatar);
+
+            var webhookInfo = log.Webhooks?.FirstOrDefault(x => x.Id == entry.TargetId);
+            var webhook = RestWebhook.Create(discord, (IGuild)null, webhookInfo);
+
+            return new WebhookUpdateAuditLogData(webhook, before, after);
+        }
+
+        //Again, the *current* data
+        public IWebhook Webhook { get; }
+
+        //And the *audit log* data
+        public WebhookInfo Before { get; }
+        public WebhookInfo After { get; }
+    }
+}

src/Discord.Net.Rest/Entities/AuditLogs/RestAuditLogEntry.cs

@@ -0,0 +1,38 @@
+using System.Linq;
+
+using Model = Discord.API.AuditLog;
+using EntryModel = Discord.API.AuditLogEntry;
+
+namespace Discord.Rest
+{
+    public class RestAuditLogEntry : RestEntity<ulong>, IAuditLogEntry
+    {
+        private RestAuditLogEntry(BaseDiscordClient discord, Model fullLog, EntryModel model, IUser user)
+            : base(discord, model.Id)
+        {
+            Action = model.Action;
+            Data = AuditLogHelper.CreateData(discord, fullLog, model);
+            User = user;
+            Reason = model.Reason;
+        }
+
+        internal static RestAuditLogEntry Create(BaseDiscordClient discord, Model fullLog, EntryModel model)
+        {
+            var userInfo = fullLog.Users.FirstOrDefault(x => x.Id == model.UserId);
+            IUser user = null;
+            if (userInfo != null)
+                user = RestUser.Create(discord, userInfo);
+
+            return new RestAuditLogEntry(discord, fullLog, model, user);
+        }
+
+        /// <inheritdoc/>
+        public ActionType Action { get; }
+        /// <inheritdoc/>
+        public IAuditLogData Data { get; }
+        /// <inheritdoc/>
+        public IUser User { get; }
+        /// <inheritdoc/>
+        public string Reason { get; }
+    }
+}

src/Discord.Net.Rest/Entities/Channels/ChannelHelper.cs

@@ -185,6 +185,10 @@ namespace Discord.Rest
             return RestUserMessage.Create(client, channel, client.CurrentUser, model);
         }
 
+        public static Task DeleteMessageAsync(IMessageChannel channel, ulong messageId, BaseDiscordClient client,
+            RequestOptions options)
+            => MessageHelper.DeleteAsync(channel.Id, messageId, client, options);
+
         public static async Task DeleteMessagesAsync(ITextChannel channel, BaseDiscordClient client,
             IEnumerable<ulong> messageIds, RequestOptions options)
         {

src/Discord.Net.Rest/Entities/Channels/IRestMessageChannel.cs

@@ -7,7 +7,7 @@ namespace Discord.Rest
     public interface IRestMessageChannel : IMessageChannel
     {
         /// <summary> Sends a message to this message channel. </summary>
-        new Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false, Embed embed = null, RequestOptions options = null);
+        new Task<RestUserMessage> SendMessageAsync(string text = null, bool isTTS = false, Embed embed = null, RequestOptions options = null);
 #if FILESYSTEM
         /// <summary> Sends a file to this text channel, with an optional caption. </summary>
         new Task<RestUserMessage> SendFileAsync(string filePath, string text = null, bool isTTS = false, Embed embed = null, RequestOptions options = null);

src/Discord.Net.Rest/Entities/Channels/RestDMChannel.cs

@@ -63,7 +63,7 @@ namespace Discord.Rest
         public Task<IReadOnlyCollection<RestMessage>> GetPinnedMessagesAsync(RequestOptions options = null)
             => ChannelHelper.GetPinnedMessagesAsync(this, Discord, options);
 
-        public Task<RestUserMessage> SendMessageAsync(string text, bool isTTS = false, Embed embed = null, RequestOptions options = null)
+        public Task<RestUserMessage> SendMessageAsync(string text = null, bool isTTS = false, Embed embed = null, RequestOptions options = null)
             => ChannelHelper.SendMessageAsync(this, Discord, text, isTTS, embed, options);
 #if FILESYSTEM
         public Task<RestUserMessage> SendFileAsync(string filePath, string text, bool isTTS = false, Embed embed = null, RequestOptions options = null)
@@ -72,6 +72,11 @@ namespace Discord.Rest
         public Task<RestUserMessage> SendFileAsync(Stream stream, string filename, string text, bool isTTS = false, Embed embed = null, RequestOptions options = null)
             => ChannelHelper.SendFileAsync(this, Discord, stream, filename, text, isTTS, embed, options);
 
+        public Task DeleteMessageAsync(ulong messageId, RequestOptions options = null)
+            => ChannelHelper.DeleteMessageAsync(this, messageId, Discord, options);
+        public Task DeleteMessageAsync(IMessage message, RequestOptions options = null)
+            => ChannelHelper.DeleteMessageAsync(this, message.Id, Discord, options);
+
         public Task TriggerTypingAsync(RequestOptions options = null)
             => ChannelHelper.TriggerTypingAsync(this, Discord, options);
         public IDisposable EnterTypingState(RequestOptions options = null)