diff --git a/src/FluentResults/Extensions/EnumerableExtensions.cs b/src/FluentResults/Extensions/EnumerableExtensions.cs
index c041a7d..bd23435 100644
--- a/src/FluentResults/Extensions/EnumerableExtensions.cs
+++ b/src/FluentResults/Extensions/EnumerableExtensions.cs
@@ -3,6 +3,9 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Helpful extensions for IEnumerable
+    /// </summary>
     public static class EnumerableExtensions
     {
         /// <summary>
diff --git a/src/FluentResults/Extensions/ObjectExtensions.cs b/src/FluentResults/Extensions/ObjectExtensions.cs
index 3fa3a48..0828b7a 100644
--- a/src/FluentResults/Extensions/ObjectExtensions.cs
+++ b/src/FluentResults/Extensions/ObjectExtensions.cs
@@ -1,8 +1,16 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Extension methods for object base type
+    /// </summary>
     public static class ObjectExtensions
     {
+        /// <summary>
+        /// Convert value to result
+        /// </summary>
+        /// <typeparam name="TValue">The type of the result's <see cref="Result{TValue}.Value"/></typeparam>
+        /// <param name="value">The value of the result</param>
         public static Result<TValue> ToResult<TValue>(this TValue value)
         {
             return new Result<TValue>()
diff --git a/src/FluentResults/Extensions/ResultExtensions.cs b/src/FluentResults/Extensions/ResultExtensions.cs
index f11dfbe..23ed08a 100644
--- a/src/FluentResults/Extensions/ResultExtensions.cs
+++ b/src/FluentResults/Extensions/ResultExtensions.cs
@@ -3,73 +3,156 @@
 
 namespace FluentResults.Extensions
 {
+    /// <summary>
+    /// Extension methods for Result
+    /// </summary>
     public static class ResultExtensions
     {
+        /// <summary>
+        /// Map all errors of the result via errorMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the errors</param>
         public static async Task<Result> MapErrors(this Task<Result> resultTask, Func<IError, IError> errorMapper)
         {
             var result = await resultTask;
             return result.MapErrors(errorMapper);
         }
 
+        /// <summary>
+        /// Map all errors of the result via errorMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the errors</param>
         public static async ValueTask<Result> MapErrors(this ValueTask<Result> resultTask, Func<IError, IError> errorMapper)
         {
             var result = await resultTask;
             return result.MapErrors(errorMapper);
         }
 
+        /// <summary>
+        /// Map all errors of the result via errorMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the errors</param>
         public static async Task<Result<T>> MapErrors<T>(this Task<Result<T>> resultTask, Func<IError, IError> errorMapper)
         {
             var result = await resultTask;
             return result.MapErrors(errorMapper);
         }
 
+        /// <summary>
+        /// Map all errors of the result via errorMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the errors</param>
         public static async ValueTask<Result<T>> MapErrors<T>(this ValueTask<Result<T>> resultTask, Func<IError, IError> errorMapper)
         {
             var result = await resultTask;
             return result.MapErrors(errorMapper);
         }
 
+        /// <summary>
+        /// Map all successes of the result via successMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the successes</param>
         public static async Task<Result> MapSuccesses(this Task<Result> resultTask, Func<ISuccess, ISuccess> errorMapper)
         {
             var result = await resultTask;
             return result.MapSuccesses(errorMapper);
         }
 
+        /// <summary>
+        /// Map all successes of the result via successMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the successes</param>
         public static async ValueTask<Result> MapSuccesses(this ValueTask<Result> resultTask, Func<ISuccess, ISuccess> errorMapper)
         {
             var result = await resultTask;
             return result.MapSuccesses(errorMapper);
         }
 
+        /// <summary>
+        /// Map all successes of the result via successMapper
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the successes</param>
+        /// </summary>
         public static async Task<Result<T>> MapSuccesses<T>(this Task<Result<T>> resultTask, Func<ISuccess, ISuccess> errorMapper)
         {
             var result = await resultTask;
             return result.MapSuccesses(errorMapper);
         }
 
+        /// <summary>
+        /// Map all successes of the result via successMapper
+        /// </summary>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="errorMapper">Function to transform the successes</param>
         public static async ValueTask<Result<T>> MapSuccesses<T>(this ValueTask<Result<T>> resultTask, Func<ISuccess, ISuccess> errorMapper)
         {
             var result = await resultTask;
             return result.MapSuccesses(errorMapper);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async Task<Result<TNew>> Bind<TOld, TNew>(this Task<Result<TOld>> resultTask, Func<TOld, Task<Result<TNew>>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
-        
+
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async ValueTask<Result<TNew>> Bind<TOld, TNew>(this ValueTask<Result<TOld>> resultTask, Func<TOld, ValueTask<Result<TNew>>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async Task<Result<TNew>> Bind<TOld, TNew>(this Task<Result<TOld>> resultTask, Func<TOld, Result<TNew>> bind)
         {
             var result = await resultTask;
             return result.Bind(bind);
         }
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
 
         public static async ValueTask<Result<TNew>> Bind<TOld, TNew>(this ValueTask<Result<TOld>> resultTask, Func<TOld, Result<TNew>> bind)
         {
@@ -77,72 +160,170 @@ public static async ValueTask<Result<TNew>> Bind<TOld, TNew>(this ValueTask<Resu
             return result.Bind(bind);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async Task<Result> Bind<TOld>(this Task<Result<TOld>> resultTask, Func<TOld, Task<Result>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async Task<Result> Bind<TOld>(this Task<Result<TOld>> resultTask, Func<TOld, Result> bind)
         {
             var result = await resultTask;
             return result.Bind(bind);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async ValueTask<Result> Bind<TOld>(this ValueTask<Result<TOld>> resultTask, Func<TOld, Result> bind)
         {
             var result = await resultTask;
             return result.Bind(bind);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async ValueTask<Result> Bind<TOld>(this ValueTask<Result<TOld>> resultTask, Func<TOld, ValueTask<Result>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
-        
+
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async Task<Result<TNew>> Bind<TNew>(this Task<Result> resultTask, Func<Task<Result<TNew>>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
-        
+
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async ValueTask<Result<TNew>> Bind<TNew>(this ValueTask<Result> resultTask, Func<ValueTask<Result<TNew>>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
-        
+
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async Task<Result> Bind(this Task<Result> resultTask, Func<Task<Result>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
-        
+
+        /// <summary>
+        /// Convert result with value to result with another value that may fail asynchronously.
+        /// </summary>
+        /// <example>
+        /// <code>
+        ///  var bakeryDtoResult = await result.Bind(GetWhichMayFail);
+        /// </code>
+        /// </example>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="bind">Transformation that may fail.</param>
         public static async ValueTask<Result> Bind(this ValueTask<Result> resultTask, Func<ValueTask<Result>> bind)
         {
             var result = await resultTask;
             return await result.Bind(bind);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value. Use valueConverter parameter to specify the value transformation logic.
+        /// </summary>
         public static async Task<Result<TNewValue>> Map<TOldValue, TNewValue>(this Task<Result<TOldValue>> resultTask, Func<TOldValue, TNewValue> valueConverter)
         {
             var result = await resultTask;
             return result.Map(valueConverter);
         }
 
+        /// <summary>
+        /// Convert result with value to result with another value. Use valueConverter parameter to specify the value transformation logic.
+        /// </summary>
         public static async Task<Result<TNewValue>> Map<TOldValue, TNewValue>(this ValueTask<Result<TOldValue>> resultTask, Func<TOldValue, TNewValue> valueConverter)
         {
             var result = await resultTask;
             return result.Map(valueConverter);
         }
 
+        /// <summary>
+        /// Convert result without value to a result containing a value
+        /// </summary>
+        /// <typeparam name="TValue">Type of the value</typeparam>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="value">Value to add to the new result</param>
         public static async Task<Result<TValue>> ToResult<TValue>(this Task<Result> resultTask, TValue value)
         {
             var result = await resultTask;
             return result.ToResult(value);
         }
 
+        /// <summary>
+        /// Convert result without value to a result containing a value
+        /// </summary>
+        /// <typeparam name="TValue">Type of the value</typeparam>
+        /// <param name="resultTask">The current result</param>
+        /// <param name="value">Value to add to the new result</param>
         public static async Task<Result<TValue>> ToResult<TValue>(this ValueTask<Result> resultTask, TValue value)
         {
             var result = await resultTask;
diff --git a/src/FluentResults/Logging/DefaultLogger.cs b/src/FluentResults/Logging/DefaultLogger.cs
index 14c3bde..b149a2e 100644
--- a/src/FluentResults/Logging/DefaultLogger.cs
+++ b/src/FluentResults/Logging/DefaultLogger.cs
@@ -4,13 +4,18 @@
 
 namespace FluentResults
 {
+    /// <summary>
+    /// Default implementation of <see cref="IResultLogger"/> that doesn't log anything
+    /// </summary>
     public class DefaultLogger : IResultLogger
     {
+        /// <inheritdoc/>
         public void Log(string context, string content, ResultBase result, LogLevel logLevel)
         {
 
         }
 
+        /// <inheritdoc/>
         public void Log<TContext>(string content, ResultBase result, LogLevel logLevel)
         {
 
diff --git a/src/FluentResults/Logging/IResultLogger.cs b/src/FluentResults/Logging/IResultLogger.cs
index 377ecf6..b6f3a21 100644
--- a/src/FluentResults/Logging/IResultLogger.cs
+++ b/src/FluentResults/Logging/IResultLogger.cs
@@ -4,9 +4,27 @@
 
 namespace FluentResults
 {
+    /// <summary>
+    /// Logging interface.  Implement this if you want to have custom logging of results
+    /// </summary>
     public interface IResultLogger
     {
+        /// <summary>
+        /// Log result information
+        /// </summary>
+        /// <param name="context">Additional log context</param>
+        /// <param name="content">Content to log</param>
+        /// <param name="result">The result to log</param>
+        /// <param name="logLevel">The <see cref="Microsoft.Extensions.Logging.LogLevel"/></param>
         void Log(string context, string content, ResultBase result, LogLevel logLevel);
+
+        /// <summary>
+        /// Log result information
+        /// </summary>
+        /// <typeparam name="TContext">Additional log context</typeparam>
+        /// <param name="content">Content to log</param>
+        /// <param name="result">The result to log</param>
+        /// <param name="logLevel">The <see cref="Microsoft.Extensions.Logging.LogLevel"/></param>
         void Log<TContext>(string content, ResultBase result, LogLevel logLevel);
     }
 }
\ No newline at end of file
diff --git a/src/FluentResults/Reasons/Error.cs b/src/FluentResults/Reasons/Error.cs
index faca157..98d3294 100644
--- a/src/FluentResults/Reasons/Error.cs
+++ b/src/FluentResults/Reasons/Error.cs
@@ -25,6 +25,9 @@ public class Error : IError
         /// </summary>
         public List<IError> Reasons { get; }
 
+        /// <summary>
+        /// Creates a new instance of <see cref="Error"/>
+        /// </summary>
         protected Error()
         {
             Metadata = new Dictionary<string, object>();
@@ -146,6 +149,9 @@ public Error WithMetadata(Dictionary<string, object> metadata)
             return this;
         }
 
+        /// <summary>
+        /// ToString override
+        /// </summary>
         public override string ToString()
         {
             return new ReasonStringBuilder()
diff --git a/src/FluentResults/Reasons/ExceptionalError.cs b/src/FluentResults/Reasons/ExceptionalError.cs
index 3db4e14..dd63174 100644
--- a/src/FluentResults/Reasons/ExceptionalError.cs
+++ b/src/FluentResults/Reasons/ExceptionalError.cs
@@ -13,16 +13,29 @@ public class ExceptionalError : Error, IExceptionalError
         /// </summary>
         public Exception Exception { get; }
         
+
+        /// <summary>
+        /// Initialize a new instance with an exception
+        /// </summary>
+        /// <param name="exception">The exception</param>
         public ExceptionalError(Exception exception)
             : this(exception.Message, exception)
         { }
 
+        /// <summary>
+        /// Initialize a new instance with a custom message and an exception
+        /// </summary>
+        /// <param name="message">The message</param>
+        /// <param name="exception">The exception</param>
         public ExceptionalError(string message, Exception exception)
             : base(message)
         {
             Exception = exception;
         }
 
+        /// <summary>
+        /// ToString override
+        /// </summary>
         public override string ToString()
         {
             return new ReasonStringBuilder()
diff --git a/src/FluentResults/Reasons/IError.cs b/src/FluentResults/Reasons/IError.cs
index 958205c..e77cf1f 100644
--- a/src/FluentResults/Reasons/IError.cs
+++ b/src/FluentResults/Reasons/IError.cs
@@ -3,6 +3,9 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Definition of an error
+    /// </summary>
     public interface IError : IReason
     {
         /// <summary>
diff --git a/src/FluentResults/Reasons/IExceptionalError.cs b/src/FluentResults/Reasons/IExceptionalError.cs
index 1a9a032..e46e946 100644
--- a/src/FluentResults/Reasons/IExceptionalError.cs
+++ b/src/FluentResults/Reasons/IExceptionalError.cs
@@ -3,8 +3,14 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Definition of an error containing an exception
+    /// </summary>
     public interface IExceptionalError : IError
     {
+        /// <summary>
+        /// The exception
+        /// </summary>
         Exception Exception { get; }
 
     }
diff --git a/src/FluentResults/Reasons/IReason.cs b/src/FluentResults/Reasons/IReason.cs
index 2f033a6..9759e7e 100644
--- a/src/FluentResults/Reasons/IReason.cs
+++ b/src/FluentResults/Reasons/IReason.cs
@@ -3,10 +3,19 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Definition of a reason.  This is also the base of ISuccess and IError
+    /// </summary>
     public interface IReason
     {
+        /// <summary>
+        /// The reason's message
+        /// </summary>
         string Message { get; }
 
+        /// <summary>
+        /// Any metadata added to the reason
+        /// </summary>
         Dictionary<string, object> Metadata { get; }
     }
 }
\ No newline at end of file
diff --git a/src/FluentResults/Reasons/ISuccess.cs b/src/FluentResults/Reasons/ISuccess.cs
index d7ad314..437616b 100644
--- a/src/FluentResults/Reasons/ISuccess.cs
+++ b/src/FluentResults/Reasons/ISuccess.cs
@@ -1,6 +1,9 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Definition of a success
+    /// </summary>
     public interface ISuccess : IReason
     { }
 }
\ No newline at end of file
diff --git a/src/FluentResults/Reasons/ReasonExtensions.cs b/src/FluentResults/Reasons/ReasonExtensions.cs
index 8494b0f..f13d5db 100644
--- a/src/FluentResults/Reasons/ReasonExtensions.cs
+++ b/src/FluentResults/Reasons/ReasonExtensions.cs
@@ -3,8 +3,18 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Extensions for <see cref="IReason"/>
+    /// </summary>
     public static class ReasonExtensions
     {
+        /// <summary>
+        /// Check if a metadata key exists
+        /// </summary>
+        /// <param name="reason">The reason instance</param>
+        /// <param name="key">The metadata key</param>
+        /// <returns>True if the metadata key exists</returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public static bool HasMetadataKey(this IReason reason, string key)
         {
             if(string.IsNullOrEmpty(key))
@@ -13,6 +23,14 @@ public static bool HasMetadataKey(this IReason reason, string key)
             return reason.Metadata.ContainsKey(key);
         }
 
+        /// <summary>
+        /// Check if a metadata key exists and matches the supplied predicate
+        /// </summary>
+        /// <param name="reason">The reason instance</param>
+        /// <param name="key">The metadata key</param>
+        /// <param name="predicate">The predicate to check if the metadata key exists</param>
+        /// <returns>True if the metadata value matches the predicate</returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public static bool HasMetadata(this IReason reason, string key, Func<object, bool> predicate)
         {
             if (string.IsNullOrEmpty(key))
diff --git a/src/FluentResults/Reasons/ReasonStringBuilder.cs b/src/FluentResults/Reasons/ReasonStringBuilder.cs
index 2219be0..608b2da 100644
--- a/src/FluentResults/Reasons/ReasonStringBuilder.cs
+++ b/src/FluentResults/Reasons/ReasonStringBuilder.cs
@@ -5,17 +5,31 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Creates the text to dispay when serializing reason instances
+    /// </summary>
     public class ReasonStringBuilder
     {
         private string _reasonType = string.Empty;
         private readonly List<string> _infos = new List<string>();
          
+        /// <summary>
+        /// Specify the type of reason
+        /// </summary>
+        /// <param name="type">The type of reason</param>
+        /// <returns>Reference to the current Builder</returns>
         public ReasonStringBuilder WithReasonType(Type type)
         {
             _reasonType = type.Name;
             return this;
         }
 
+        /// <summary>
+        /// Add an information label for the given value
+        /// </summary>
+        /// <param name="label">The label to display</param>
+        /// <param name="value">The value the label is for</param>
+        /// <returns>A reference to the current Builder</returns>
         public ReasonStringBuilder WithInfo(string label, string value)
         {
             var infoString = value.ToLabelValueStringOrEmpty(label);
@@ -28,6 +42,10 @@ public ReasonStringBuilder WithInfo(string label, string value)
             return this;
         }
 
+        /// <summary>
+        /// Create the reason string from the current information
+        /// </summary>
+        /// <returns>The reason string</returns>
         public string Build()
         {
             var reasonInfoText = _infos.Any()
diff --git a/src/FluentResults/Reasons/Success.cs b/src/FluentResults/Reasons/Success.cs
index 6a182d3..b4a51dc 100644
--- a/src/FluentResults/Reasons/Success.cs
+++ b/src/FluentResults/Reasons/Success.cs
@@ -18,11 +18,18 @@ public class Success : ISuccess
         /// </summary>
         public Dictionary<string, object> Metadata { get; }
 
+        /// <summary>
+        /// Default constructor
+        /// </summary>
         protected Success()
         {
             Metadata = new Dictionary<string, object>();
         }
 
+        /// <summary>
+        /// Creates a new instance of <see cref="Success"/> and initializes the <see cref="Message"/> property
+        /// </summary>
+        /// <param name="message">The message</param>
         public Success(string message) : this()
         {
             Message = message;
@@ -50,6 +57,10 @@ public Success WithMetadata(Dictionary<string, object> metadata)
             return this;
         }
 
+        /// <summary>
+        /// ToString override
+        /// </summary>
+        /// <returns></returns>
         public override string ToString()
         {
             return new ReasonStringBuilder()
diff --git a/src/FluentResults/Results/Result.cs b/src/FluentResults/Results/Result.cs
index c466ab4..0b03a0b 100644
--- a/src/FluentResults/Results/Result.cs
+++ b/src/FluentResults/Results/Result.cs
@@ -6,8 +6,14 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Implementation of a Result
+    /// </summary>
     public partial class Result : ResultBase<Result>
     {
+        /// <summary>
+        /// Default constructor
+        /// </summary>
         public Result()
         { }
 
@@ -38,6 +44,11 @@ public Result MapSuccesses(Func<ISuccess, ISuccess> successMapper)
                 .WithSuccesses(Successes.Select(successMapper));
         }
 
+        /// <summary>
+        /// Convert result without value to a result containing a value
+        /// </summary>
+        /// <typeparam name="TNewValue">Type of the value</typeparam>
+        /// <param name="newValue">Value to add to the new result</param>
         public Result<TNewValue> ToResult<TNewValue>(TNewValue newValue = default)
         {
             return new Result<TNewValue>()
@@ -186,17 +197,29 @@ public async ValueTask<Result> Bind(Func<ValueTask<Result>> action)
             return result;
         }
         
+        /// <summary>
+        /// Implict conversion from <see cref="Error"/> to a <see cref="Result"/>
+        /// </summary>
+        /// <param name="error">The error</param>
         public static implicit operator Result(Error error)
         {
             return Fail(error);
         }
 
+        /// <summary>
+        /// Implict conversion from <see cref="List{Error}"/> to a <see cref="Result"/>
+        /// </summary>
+        /// <param name="errors">The errors</param>
         public static implicit operator Result(List<Error> errors)
         {
             return Fail(errors);
         }
     }
 
+    /// <summary>
+    /// Definition of a result with a value of type <typeparamref name="TValue"/>
+    /// </summary>
+    /// <typeparam name="TValue">The type of the value</typeparam>
     public interface IResult<out TValue> : IResultBase
     {
         /// <summary>
@@ -210,8 +233,15 @@ public interface IResult<out TValue> : IResultBase
         TValue ValueOrDefault { get; }
     }
 
+    /// <summary>
+    /// A result containing a value of type <typeparamref name="TValue"/>
+    /// </summary>
+    /// <typeparam name="TValue">The type of the value</typeparam>
     public class Result<TValue> : ResultBase<Result<TValue>>, IResult<TValue>
     {
+        /// <summary>
+        /// Default constructor
+        /// </summary>
         public Result()
         { }
 
@@ -452,6 +482,9 @@ public async ValueTask<Result> Bind(Func<TValue, ValueTask<Result>> action)
             return result;
         }
 
+        /// <summary>
+        /// ToString implementation
+        /// </summary>
         public override string ToString()
         {
             var baseString = base.ToString();
@@ -459,16 +492,25 @@ public override string ToString()
             return $"{baseString}, {valueString}";
         }
 
+        /// <summary>
+        /// Implicit conversion from <see cref="Result"/> without a value to <see cref="Result{TValue}"/> having the default value
+        /// </summary>
         public static implicit operator Result<TValue>(Result result)
         {
             return result.ToResult<TValue>(default);
         }
 
+        /// <summary>
+        /// Implicit conversion from <see cref="Result{TValue}"/> having a value to <see cref="Result"/> without a value
+        /// </summary>
         public static implicit operator Result<object>(Result<TValue> result)
         {
             return result.ToResult<object>(value => value);
         }
 
+        /// <summary>
+        /// Implicit conversion of a value to <see cref="Result{TValue}"/>
+        /// </summary>
         public static implicit operator Result<TValue>(TValue value)
         {
             if (value is Result<TValue> r)
@@ -477,11 +519,17 @@ public static implicit operator Result<TValue>(TValue value)
             return Result.Ok(value);
         }
         
+        /// <summary>
+        /// Implicit conversion of an <see cref="Error"/> to <see cref="Result{TValue}"/>
+        /// </summary>
         public static implicit operator Result<TValue>(Error error)
         {
             return Result.Fail(error);
         }
 
+        /// <summary>
+        /// Implicit conversion of a list of <see cref="Error"/> to <see cref="Result{TValue}"/>
+        /// </summary>
         public static implicit operator Result<TValue>(List<Error> errors)
         {
             return Result.Fail(errors);
diff --git a/src/FluentResults/Results/ResultBase.cs b/src/FluentResults/Results/ResultBase.cs
index e0b23df..00ae293 100644
--- a/src/FluentResults/Results/ResultBase.cs
+++ b/src/FluentResults/Results/ResultBase.cs
@@ -6,6 +6,9 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Definition of a ResultBase
+    /// </summary>
     public interface IResultBase
     {
         /// <summary>
@@ -34,6 +37,9 @@ public interface IResultBase
         List<ISuccess> Successes { get; }
     }
 
+    /// <summary>
+    /// Default implementation of <see cref="IResultBase"/>
+    /// </summary>
     public abstract class ResultBase : IResultBase
     {
         /// <summary>
@@ -61,6 +67,9 @@ public abstract class ResultBase : IResultBase
         /// </summary>
         public List<ISuccess> Successes => Reasons.OfType<ISuccess>().ToList();
 
+        /// <summary>
+        /// Default constructor
+        /// </summary>
         protected ResultBase()
         {
             Reasons = new List<IReason>();
@@ -230,6 +239,9 @@ public void Deconstruct(out bool isSuccess, out bool isFailed, out List<IError>
         }
     }
 
+    /// <summary>
+    /// Default implementation of <see cref="IResultBase"/> generics
+    /// </summary>
     public abstract class ResultBase<TResult> : ResultBase
         where TResult : ResultBase<TResult>
 
@@ -318,6 +330,9 @@ public TResult WithSuccess<TSuccess>()
             return WithSuccess(new TSuccess());
         }
 
+        /// <summary>
+        /// Add multiple successes
+        /// </summary>
         public TResult WithSuccesses(IEnumerable<ISuccess> successes)
         {
             foreach (var success in successes)
@@ -442,6 +457,10 @@ public TResult LogIfFailed<TContext>(string content = null, LogLevel logLevel =
             return (TResult)this;
         }
 
+        /// <summary>
+        /// ToString override
+        /// </summary>
+        /// <returns></returns>
         public override string ToString()
         {
             var reasonsString = Reasons.Any()
diff --git a/src/FluentResults/Settings/ResultSettings.cs b/src/FluentResults/Settings/ResultSettings.cs
index 7949d72..fe8ec94 100644
--- a/src/FluentResults/Settings/ResultSettings.cs
+++ b/src/FluentResults/Settings/ResultSettings.cs
@@ -3,16 +3,34 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Settings for creating and handling result elements
+    /// </summary>
     public class ResultSettings
     {
+        /// <summary>
+        /// Set the ResultLogger
+        /// </summary>
         public IResultLogger Logger { get; set; }
 
+        /// <summary>
+        /// Factory to create an IError object.  Used in all scenarios where an error is created within Try methods
+        /// </summary>
         public Func<Exception, IError> DefaultTryCatchHandler { get; set; }
 
+        /// <summary>
+        /// Factory to create an ISuccess object. Used in all scenarios where a success is created within FluentResults. 
+        /// </summary>
         public Func<string, ISuccess> SuccessFactory { get; set; }
 
+        /// <summary>
+        /// Factory to create an IError object. Used in all scenarios where an error is created within FluentResults. 
+        /// </summary>
         public Func<string, IError> ErrorFactory { get; set; }
 
+        /// <summary>
+        /// Factory to create an IExceptionalError object. Used in all scenarios where an exceptional error is created within FluentResults. 
+        /// </summary>
         public Func<string, Exception, IExceptionalError> ExceptionalErrorFactory { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/FluentResults/Settings/ResultSettingsBuilder.cs b/src/FluentResults/Settings/ResultSettingsBuilder.cs
index b5bcfac..30f6702 100644
--- a/src/FluentResults/Settings/ResultSettingsBuilder.cs
+++ b/src/FluentResults/Settings/ResultSettingsBuilder.cs
@@ -3,13 +3,19 @@
 // ReSharper disable once CheckNamespace
 namespace FluentResults
 {
+    /// <summary>
+    /// Builder for <see cref="ResultSettings"/>
+    /// </summary>
     public class ResultSettingsBuilder
     {
         /// <summary>
         /// Set the ResultLogger
         /// </summary>
         public IResultLogger Logger { get; set; }
-        
+
+        /// <summary>
+        /// Factory to create an IError object.  Used in all scenarios where an error is created within Try methods
+        /// </summary>
         public Func<Exception, IError> DefaultTryCatchHandler { get; set; }
 
         /// <summary>
@@ -27,7 +33,9 @@ public class ResultSettingsBuilder
         /// </summary>
         public Func<string, Exception, IExceptionalError> ExceptionalErrorFactory { get; set; }
 
-
+        /// <summary>
+        /// Default constructor that sets default values
+        /// </summary>
         public ResultSettingsBuilder()
         {
             // set defaults
@@ -38,6 +46,10 @@ public ResultSettingsBuilder()
             ExceptionalErrorFactory = (errorMessage, exception) => new ExceptionalError(errorMessage ?? exception.Message, exception);
         }
 
+        /// <summary>
+        /// Create a <see cref="ResultSettings"/> object using the current values
+        /// </summary>
+        /// <returns></returns>
         public ResultSettings Build()
         {
             return new ResultSettings