diff --git a/Octokit/Exceptions/ApiException.cs b/Octokit/Exceptions/ApiException.cs
index 9e9150ee..b414a246 100644
--- a/Octokit/Exceptions/ApiException.cs
+++ b/Octokit/Exceptions/ApiException.cs
@@ -6,6 +6,9 @@ using Octokit.Internal;
 
 namespace Octokit
 {
+    /// <summary>
+    /// Represents errors that occur from the GitHub API.
+    /// </summary>
 #if !NETFX_CORE
     [Serializable]
 #endif
@@ -16,25 +19,47 @@ namespace Octokit
         // This needs to be hard-coded for translating GitHub error messages.
         static readonly IJsonSerializer _jsonSerializer = new SimpleJsonSerializer();
 
+        /// <summary>
+        /// Constructs an instance of ApiException
+        /// </summary>
         public ApiException() : this(new ApiResponse<object>())
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiException
+        /// </summary>
+        /// <param name="message">The error message</param>
+        /// <param name="httpStatusCode">The HTTP status code from the response</param>
         public ApiException(string message, HttpStatusCode httpStatusCode)
             : this(new ApiResponse<object> {Body = message, StatusCode = httpStatusCode})
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiException
+        /// </summary>
+        /// <param name="message">The error message</param>
+        /// <param name="innerException">The inner exception</param>
         public ApiException(string message, Exception innerException)
             : this(new ApiResponse<object> { Body = message }, innerException)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
         public ApiException(IResponse response)
             : this(response, null)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
         public ApiException(IResponse response, Exception innerException)
             : base(null, innerException)
         {
@@ -44,6 +69,10 @@ namespace Octokit
             ApiError = GetApiErrorFromExceptionMessage(response);
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiException
+        /// </summary>
+        /// <param name="innerException">The inner exception</param>
         protected ApiException(ApiException innerException)
         {
             Ensure.ArgumentNotNull(innerException, "innerException");
@@ -56,8 +85,14 @@ namespace Octokit
             get { return ApiErrorMessageSafe ?? "An error occurred with this API request"; }
         }
 
+        /// <summary>
+        /// The HTTP status code associated with the repsonse
+        /// </summary>
         public HttpStatusCode StatusCode { get; private set; }
 
+        /// <summary>
+        /// The raw exception payload from the response
+        /// </summary>
         public ApiError ApiError { get; private set; }
 
         static ApiError GetApiErrorFromExceptionMessage(IResponse response)
@@ -82,6 +117,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of ApiException.
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected ApiException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
@@ -98,6 +144,12 @@ namespace Octokit
         }
 #endif
 
+        /// <summary>
+        /// Get the inner error message from the API response
+        /// </summary>
+        /// <remarks>
+        /// Returns null if ApiError is not populated
+        /// </remarks>
         protected string ApiErrorMessageSafe
         {
             get
diff --git a/Octokit/Exceptions/ApiValidationException.cs b/Octokit/Exceptions/ApiValidationException.cs
index 1a8a9028..06e3355e 100644
--- a/Octokit/Exceptions/ApiValidationException.cs
+++ b/Octokit/Exceptions/ApiValidationException.cs
@@ -8,7 +8,7 @@ using Octokit.Internal;
 namespace Octokit
 {
     /// <summary>
-    ///     Represents a validation exception (HTTP STATUS: 422) returned from the API.
+    /// Represents a HTTP 422 - Unprocessable Entity response returned from the API.
     /// </summary>
 #if !NETFX_CORE
     [Serializable]
@@ -17,15 +17,28 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class ApiValidationException : ApiException
     {
-        public ApiValidationException() : base(new ApiResponse<object> { StatusCode = (HttpStatusCode)422})
+        /// <summary>
+        /// Constructs an instance of ApiValidationException
+        /// </summary>
+        public ApiValidationException()
+            : base(new ApiResponse<object> { StatusCode = (HttpStatusCode)422 })
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiValidationException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
         public ApiValidationException(IResponse response)
             : this(response, null)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ApiValidationException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
         public ApiValidationException(IResponse response, Exception innerException)
             : base(response, innerException)
         {
@@ -33,7 +46,12 @@ namespace Octokit
                 "ApiValidationException created with wrong status code");
         }
 
-        protected ApiValidationException(ApiValidationException innerException) : base(innerException)
+        /// <summary>
+        /// Constructs an instance of ApiValidationException
+        /// </summary>
+        /// <param name="innerException">The inner exception</param>
+        protected ApiValidationException(ApiValidationException innerException)
+            : base(innerException)
         {
         }
 
@@ -43,6 +61,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of ApiValidationException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected ApiValidationException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/AuthorizationException.cs b/Octokit/Exceptions/AuthorizationException.cs
index 9ae9804d..a27ab32e 100644
--- a/Octokit/Exceptions/AuthorizationException.cs
+++ b/Octokit/Exceptions/AuthorizationException.cs
@@ -8,7 +8,7 @@ using Octokit.Internal;
 namespace Octokit
 {
     /// <summary>
-    /// Exception thrown when we receive an HttpStatusCode.Unauthorized (HTTP 401) response.
+    /// Represents a HTTP 401 - Unauthorized response returned from the API.
     /// </summary>
 #if !NETFX_CORE
     [Serializable]
@@ -17,15 +17,27 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class AuthorizationException : ApiException
     {
+        /// <summary>
+        /// Constructs an instance of AuthorizationException
+        /// </summary>
         public AuthorizationException() : base(new ApiResponse<object> { StatusCode = HttpStatusCode.Unauthorized })
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of AuthorizationException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
         public AuthorizationException(IResponse response)
             : this(response, null)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of AuthorizationException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
         public AuthorizationException(IResponse response, Exception innerException)
             : base(response, innerException)
         {
@@ -34,6 +46,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of AuthorizationException.
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected AuthorizationException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/ForbiddenException.cs b/Octokit/Exceptions/ForbiddenException.cs
index efc16737..82934238 100644
--- a/Octokit/Exceptions/ForbiddenException.cs
+++ b/Octokit/Exceptions/ForbiddenException.cs
@@ -6,6 +6,9 @@ using System.Runtime.Serialization;
 
 namespace Octokit
 {
+    /// <summary>
+    /// Represents a HTTP 403 - Forbidden response returned from the API.
+    /// </summary>
 #if !NETFX_CORE
     [Serializable]
 #endif
@@ -13,10 +16,19 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class ForbiddenException : ApiException
     {
+        /// <summary>
+        /// Constructs an instance of ForbiddenException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
         public ForbiddenException(IResponse response) : this(response, null)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of ForbiddenException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
         public ForbiddenException(IResponse response, Exception innerException)
             : base(response, innerException)
         {
@@ -30,6 +42,17 @@ namespace Octokit
         }
     
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of ForbiddenException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected ForbiddenException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/LoginAttemptsExceededException.cs b/Octokit/Exceptions/LoginAttemptsExceededException.cs
index 3d76b7dd..de83c864 100644
--- a/Octokit/Exceptions/LoginAttemptsExceededException.cs
+++ b/Octokit/Exceptions/LoginAttemptsExceededException.cs
@@ -4,6 +4,9 @@ using System.Runtime.Serialization;
 
 namespace Octokit
 {
+    /// <summary>
+    /// Represents a "Login Attempts Exceeded" response returned from the API.
+    /// </summary>
 #if !NETFX_CORE
     [Serializable]
 #endif
@@ -11,10 +14,20 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class LoginAttemptsExceededException : ForbiddenException
     {
-        public LoginAttemptsExceededException(IResponse response) : base(response)
+        /// <summary>
+        /// Constructs an instance of LoginAttemptsExceededException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        public LoginAttemptsExceededException(IResponse response)
+            : base(response)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of LoginAttemptsExceededException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
         public LoginAttemptsExceededException(IResponse response, Exception innerException)
             : base(response, innerException)
         {
@@ -26,11 +39,21 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of LoginAttemptsExceededException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected LoginAttemptsExceededException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
         }
 #endif
-
     }
 }
diff --git a/Octokit/Exceptions/NotFoundException.cs b/Octokit/Exceptions/NotFoundException.cs
index 72995802..a8410303 100644
--- a/Octokit/Exceptions/NotFoundException.cs
+++ b/Octokit/Exceptions/NotFoundException.cs
@@ -6,6 +6,9 @@ using System.Runtime.Serialization;
 
 namespace Octokit
 {
+    /// <summary>
+    /// Represents a HTTP 404 - Not Found response returned from the API.
+    /// </summary>
 #if !NETFX_CORE
     [Serializable]
 #endif
@@ -13,17 +16,38 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class NotFoundException : ApiException
     {
+        /// <summary>
+        /// Constructs an instance of NotFoundException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
         public NotFoundException(IResponse response) : this(response, null)
         {
         }
 
-        public NotFoundException(IResponse response, Exception innerException) : base(response, innerException)
+        /// <summary>
+        /// Constructs an instance of NotFoundException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
+        public NotFoundException(IResponse response, Exception innerException)
+            : base(response, innerException)
         {
             Debug.Assert(response != null && response.StatusCode == HttpStatusCode.NotFound,
                 "NotFoundException created with wrong status code");
         }
 
-        #if !NETFX_CORE
+#if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of NotFoundException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected NotFoundException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/PrivateRepositoryQuotaExceededException.cs b/Octokit/Exceptions/PrivateRepositoryQuotaExceededException.cs
index 10bff3cf..1017b5dc 100644
--- a/Octokit/Exceptions/PrivateRepositoryQuotaExceededException.cs
+++ b/Octokit/Exceptions/PrivateRepositoryQuotaExceededException.cs
@@ -1,10 +1,6 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
-using System.Linq;
 using System.Runtime.Serialization;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Octokit
 {
@@ -39,6 +35,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of PrivateRepositoryQuotaExceededException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected PrivateRepositoryQuotaExceededException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/RateLimitExceededException.cs b/Octokit/Exceptions/RateLimitExceededException.cs
index 54a75580..435517da 100644
--- a/Octokit/Exceptions/RateLimitExceededException.cs
+++ b/Octokit/Exceptions/RateLimitExceededException.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.Serialization;
-using Octokit.Internal;
 
 namespace Octokit
 {
@@ -25,10 +24,19 @@ namespace Octokit
     {
         readonly RateLimit _rateLimit;
 
+        /// <summary>
+        /// Constructs an instance of RateLimitExceededException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
         public RateLimitExceededException(IResponse response) : this(response, null)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of RateLimitExceededException
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="innerException">The inner exception</param>
         public RateLimitExceededException(IResponse response, Exception innerException) : base(response, innerException)
         {
             Ensure.ArgumentNotNull(response, "response");
@@ -68,6 +76,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of RateLimitExceededException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected RateLimitExceededException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/RepositoryExistsException.cs b/Octokit/Exceptions/RepositoryExistsException.cs
index 9d19bbdd..3a0de556 100644
--- a/Octokit/Exceptions/RepositoryExistsException.cs
+++ b/Octokit/Exceptions/RepositoryExistsException.cs
@@ -1,11 +1,7 @@
 using System;
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
-using System.Linq;
 using System.Runtime.Serialization;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace Octokit
 {
@@ -19,7 +15,7 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class RepositoryExistsException : ApiValidationException
     {
-        string _message;
+        readonly string _message;
 
         /// <summary>
         /// Constructs an instance of RepositoryExistsException.
@@ -86,6 +82,17 @@ namespace Octokit
         public bool OwnerIsOrganization { get; private set; }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of RepositoryExistsException.
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected RepositoryExistsException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/TwoFactorChallengeFailedException.cs b/Octokit/Exceptions/TwoFactorChallengeFailedException.cs
index 0afa790e..7c67b489 100644
--- a/Octokit/Exceptions/TwoFactorChallengeFailedException.cs
+++ b/Octokit/Exceptions/TwoFactorChallengeFailedException.cs
@@ -7,17 +7,27 @@ using Octokit.Internal;
 namespace Octokit
 {
 #if !NETFX_CORE
+    /// <summary>
+    /// Represents a failed 2FA challenge from the API
+    /// </summary>
     [Serializable]
 #endif
     [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors",
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class TwoFactorChallengeFailedException : AuthorizationException
     {
+        /// <summary>
+        /// Constructs an instance of TwoFactorChallengeFailedException
+        /// </summary>
         public TwoFactorChallengeFailedException() :
             base(new ApiResponse<object> { StatusCode = HttpStatusCode.Unauthorized })
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of TwoFactorChallengeFailedException
+        /// </summary>
+        /// <param name="innerException">The inner exception</param>
         public TwoFactorChallengeFailedException(Exception innerException)
             : base(new ApiResponse<object> { StatusCode = HttpStatusCode.Unauthorized }, innerException)
         {
@@ -29,6 +39,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of TwoFactorChallengeFailedException
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected TwoFactorChallengeFailedException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
diff --git a/Octokit/Exceptions/TwoFactorRequiredException.cs b/Octokit/Exceptions/TwoFactorRequiredException.cs
index 3b4e3384..1763749a 100644
--- a/Octokit/Exceptions/TwoFactorRequiredException.cs
+++ b/Octokit/Exceptions/TwoFactorRequiredException.cs
@@ -7,6 +7,9 @@ using Octokit.Internal;
 
 namespace Octokit
 {
+    /// <summary>
+    /// 
+    /// </summary>
 #if !NETFX_CORE
     [Serializable]
 #endif
@@ -14,15 +17,27 @@ namespace Octokit
         Justification = "These exceptions are specific to the GitHub API and not general purpose exceptions")]
     public class TwoFactorRequiredException : AuthorizationException
     {
+        /// <summary>
+        /// Constructs an instance of TwoFactorRequiredException.
+        /// </summary>
         public TwoFactorRequiredException() : this(TwoFactorType.None)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of TwoFactorRequiredException.
+        /// </summary>
+        /// <param name="twoFactorType">Expected 2FA response type</param>
         public TwoFactorRequiredException(TwoFactorType twoFactorType)
             : this(new ApiResponse<object> { StatusCode = HttpStatusCode.Unauthorized}, twoFactorType)
         {
         }
 
+        /// <summary>
+        /// Constructs an instance of TwoFactorRequiredException.
+        /// </summary>
+        /// <param name="response">The HTTP payload from the server</param>
+        /// <param name="twoFactorType">Expected 2FA response type</param>
         public TwoFactorRequiredException(IResponse response, TwoFactorType twoFactorType) : base(response)
         {
             Debug.Assert(response != null && response.StatusCode == HttpStatusCode.Unauthorized,
@@ -37,6 +52,17 @@ namespace Octokit
         }
 
 #if !NETFX_CORE
+        /// <summary>
+        /// Constructs an instance of TwoFactorRequiredException.
+        /// </summary>
+        /// <param name="info">
+        /// The <see cref="SerializationInfo"/> that holds the
+        /// serialized object data about the exception being thrown.
+        /// </param>
+        /// <param name="context">
+        /// The <see cref="StreamingContext"/> that contains
+        /// contextual information about the source or destination.
+        /// </param>
         protected TwoFactorRequiredException(SerializationInfo info, StreamingContext context)
             : base(info, context)
         {
@@ -51,14 +77,33 @@ namespace Octokit
         }
 #endif
 
+        /// <summary>
+        /// Expected 2FA response type
+        /// </summary>
         public TwoFactorType TwoFactorType { get; private set; }
     }
 
+    /// <summary>
+    /// Methods for receiving 2FA authentication codes
+    /// </summary>
     public enum TwoFactorType
     {
+        /// <summary>
+        /// No method configured
+        /// </summary>
         None,
+        /// <summary>
+        /// Unknown method
+        /// </summary>
         Unknown,
-        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sms")] Sms,
+        /// <summary>
+        /// Receive via SMS
+        /// </summary>
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sms")]
+        Sms,
+        /// <summary>
+        /// Receive via application
+        /// </summary>
         AuthenticatorApp
     }
 }
diff --git a/Octokit/Models/Request/SearchUsersRequest.cs b/Octokit/Models/Request/SearchUsersRequest.cs
index 2fee45c1..e5e6d062 100644
--- a/Octokit/Models/Request/SearchUsersRequest.cs
+++ b/Octokit/Models/Request/SearchUsersRequest.cs
@@ -135,21 +135,45 @@ namespace Octokit
         }
     }
 
+    /// <summary>
+    /// Account Type used to filter search result
+    /// </summary>
     public enum AccountType
     {
+        /// <summary>
+        ///  User account
+        /// </summary>
         User,
+        /// <summary>
+        /// Organization account
+        /// </summary>
         Org
     }
 
+    /// <summary>
+    /// User type to filter search results
+    /// </summary>
     public enum UserInQualifier
     {
+        /// <summary>
+        /// Search by the username
+        /// </summary>
         [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "Username")]
         Username,
+        /// <summary>
+        /// Search by the user's email address
+        /// </summary>
         Email,
+        /// <summary>
+        /// Search by the user's full name
+        /// </summary>
         [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Fullname")]
         Fullname
     }
 
+    /// <summary>
+    /// 
+    /// </summary>
     public enum UsersSearchSort
     {
         Followers,
diff --git a/Octokit/Models/Response/Activity.cs b/Octokit/Models/Response/Activity.cs
index d4b745ac..c6805ef9 100644
--- a/Octokit/Models/Response/Activity.cs
+++ b/Octokit/Models/Response/Activity.cs
@@ -5,6 +5,9 @@ using System.Globalization;
 
 namespace Octokit
 {
+    /// <summary>
+    /// An entry in the activity event stream
+    /// </summary>
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
     public class Activity
     {
diff --git a/Octokit/Models/Response/ApiError.cs b/Octokit/Models/Response/ApiError.cs
index 69204bcf..af23c717 100644
--- a/Octokit/Models/Response/ApiError.cs
+++ b/Octokit/Models/Response/ApiError.cs
@@ -4,6 +4,9 @@ using System.Diagnostics.CodeAnalysis;
 
 namespace Octokit
 {
+    /// <summary>
+    /// Error payload from the API reposnse
+    /// </summary>
 #if !NETFX_CORE
     [Serializable]
 #endif
@@ -20,6 +23,9 @@ namespace Octokit
         public string DocumentationUrl { get; set; }
 
         // TODO: This ought to be an IReadOnlyList<ApiErrorDetail> but we need to add support to SimpleJson for that.
+        /// <summary>
+        /// Additional details about the error
+        /// </summary>
         [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly")]
         public IList<ApiErrorDetail> Errors { get; set; }
     }