Add comprehensive XML documentation to domain types

Completes Phase 6 by documenting three key domain types used throughout
the client API.

Documented classes:
- PageRanges: Documented Chrome print format syntax ("1-5,8,11-13")
  and clarified that empty collection means all pages
- ContentItem: Documented all three constructors with use cases
  (byte[] for binary, string for HTML/text, Stream for files)
- ExtraUrlResourceItem: Documented resource injection for URL conversions
  with CSS vs JavaScript distinction

Key improvements:
- CRITICAL: PageRanges.Create() now documents the expected format
- Explained when to use each ContentItem constructor
- Clarified ExtraUrlResourceItem usage for CSS/JS injection
- Added comprehensive exception documentation
- Documented public properties and methods

Users can now understand how to construct and use these types from
IntelliSense without referring to external documentation.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Jaben

src/Gotenberg.Sharp.Api.Client/Domain/Pages/PageRanges.cs

@@ -18,6 +18,12 @@
 
 namespace Gotenberg.Sharp.API.Client.Domain.Pages;
 
+/// <summary>
+/// Represents a specification of which pages to include in a PDF. Supports individual pages and ranges.
+/// </summary>
+/// <remarks>
+/// Format follows Chrome print dialog syntax: "1-5,8,11-13" includes pages 1 through 5, page 8, and pages 11 through 13.
+/// </remarks>
 public sealed class PageRanges : IEquatable<PageRanges>
 {
     private static readonly Regex PageRangePattern =
@@ -28,15 +34,32 @@ private PageRanges(IReadOnlyCollection<int> pages)
         Pages = pages.OrderBy(p => p).ToArray();
     }
 
+    /// <summary>
+    /// Represents all pages (no filtering applied).
+    /// </summary>
     public static PageRanges All { get; } = new(Array.Empty<int>());
 
+    /// <summary>
+    /// Gets the collection of page numbers included in this range. Empty collection means all pages.
+    /// </summary>
     public IReadOnlyCollection<int> Pages { get; }
 
+    /// <summary>
+    /// Determines whether this page range equals another page range.
+    /// </summary>
+    /// <param name="other">The page range to compare with.</param>
+    /// <returns>True if the page ranges are equal.</returns>
     public bool Equals(PageRanges? other)
     {
         return other is not null && Pages.SequenceEqual(other.Pages);
     }
 
+    /// <summary>
+    /// Creates a PageRanges instance from a string specification using Chrome print format.
+    /// </summary>
+    /// <param name="input">Page range string (e.g., "1-5,8,11-13") or null/empty for all pages.</param>
+    /// <returns>A PageRanges instance representing the specified pages.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Thrown when the format is invalid.</exception>
     public static PageRanges Create(string? input)
     {
         if (string.IsNullOrWhiteSpace(input))
@@ -102,16 +125,29 @@ private string GetPageRangeString()
         return string.Join(", ", ranges);
     }
 
+    /// <summary>
+    /// Returns the page range as a string in Chrome print format (e.g., "1-5,8,11-13").
+    /// </summary>
+    /// <returns>Page range string, or empty string for all pages.</returns>
     public override string ToString()
     {
         return GetPageRangeString();
     }
 
+    /// <summary>
+    /// Determines whether this page range equals another object.
+    /// </summary>
+    /// <param name="obj">The object to compare with.</param>
+    /// <returns>True if the objects represent the same page range.</returns>
     public override bool Equals(object? obj)
     {
         return obj is PageRanges other && Pages.SequenceEqual(other.Pages);
     }
 
+    /// <summary>
+    /// Returns a hash code for this page range.
+    /// </summary>
+    /// <returns>A hash code based on the included pages.</returns>
     public override int GetHashCode()
     {
         return Pages.Aggregate(0, (hash, page) => hash ^ page.GetHashCode());

src/Gotenberg.Sharp.Api.Client/Domain/Requests/Facets/ContentItem.cs

@@ -17,6 +17,10 @@
 
 namespace Gotenberg.Sharp.API.Client.Domain.Requests.Facets
 {
+    /// <summary>
+    /// Represents content for PDF conversion requests. Supports content from strings, byte arrays, or streams.
+    /// Used for HTML, Markdown, headers, footers, and file assets.
+    /// </summary>
     public sealed class ContentItem
     {
         readonly Func<HttpContent> _getHttpContent;
@@ -26,25 +30,44 @@ public sealed class ContentItem
             _getHttpContent = getHttpContent;
         }
 
+        /// <summary>
+        /// Creates content from a byte array. Use for binary files like images, PDFs, or Office documents.
+        /// </summary>
+        /// <param name="bytes">The content as bytes.</param>
+        /// <exception cref="ArgumentNullException">Thrown when bytes is null.</exception>
         public ContentItem(byte[] bytes)
             : this(() => new ByteArrayContent(bytes))
         {
             if (bytes == null) throw new ArgumentNullException(nameof(bytes));
         }
 
+        /// <summary>
+        /// Creates content from a string. Use for HTML, Markdown, or text content.
+        /// </summary>
+        /// <param name="str">The content as a string.</param>
+        /// <exception cref="ArgumentOutOfRangeException">Thrown when string is null or empty.</exception>
         public ContentItem(string str)
             : this(() => new StringContent(str))
         {
             if (str.IsNotSet())
                 throw new ArgumentOutOfRangeException(nameof(str), "Must not be null or empty");
         }
 
+        /// <summary>
+        /// Creates content from a stream. Use when loading content from files or network sources.
+        /// </summary>
+        /// <param name="stream">The content stream.</param>
+        /// <exception cref="ArgumentNullException">Thrown when stream is null.</exception>
         public ContentItem(Stream stream)
             : this(() => new StreamContent(stream))
         {
             if (stream == null) throw new ArgumentNullException(nameof(stream));
         }
 
+        /// <summary>
+        /// Converts this content item to HttpContent for transmission to Gotenberg.
+        /// </summary>
+        /// <returns>HttpContent representing this content item.</returns>
         public HttpContent ToHttpContentItem()
         {
             return _getHttpContent();

src/Gotenberg.Sharp.Api.Client/Domain/Requests/Facets/UrlExtras/ExtraUrlResourceItem.cs

@@ -21,17 +21,34 @@ namespace Gotenberg.Sharp.API.Client.Domain.Requests.Facets.UrlExtras;
 
 using urlConstants = Constants.Gotenberg.Chromium.Routes.Url;
 
+/// <summary>
+/// Represents an external resource (CSS stylesheet or JavaScript file) to inject into URL-based PDF conversions.
+/// </summary>
 public class ExtraUrlResourceItem
 {
     const string LinkFieldName = urlConstants.ExtraLinkTags;
 
     const string ScriptFieldName = urlConstants.ExtraScriptTags;
 
+    /// <summary>
+    /// Creates an extra resource item from a URL string.
+    /// </summary>
+    /// <param name="url">Absolute URL of the CSS or JavaScript resource.</param>
+    /// <param name="itemType">Type of resource (LinkTag for CSS, ScriptTag for JavaScript).</param>
+    /// <exception cref="InvalidOperationException">Thrown when URL is not absolute.</exception>
     public ExtraUrlResourceItem(string url, ExtraUrlResourceType itemType)
         : this(new Uri(url), itemType)
     {
     }
 
+    /// <summary>
+    /// Creates an extra resource item from a URI.
+    /// </summary>
+    /// <param name="url">Absolute URI of the CSS or JavaScript resource.</param>
+    /// <param name="itemType">Type of resource (LinkTag for CSS, ScriptTag for JavaScript).</param>
+    /// <exception cref="ArgumentNullException">Thrown when URL is null.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when URL is not absolute.</exception>
+    /// <exception cref="InvalidEnumArgumentException">Thrown when itemType is not valid.</exception>
     public ExtraUrlResourceItem(Uri url, ExtraUrlResourceType itemType)
     {
         Url = url ?? throw new ArgumentNullException(nameof(url));
@@ -44,10 +61,14 @@ public ExtraUrlResourceItem(Uri url, ExtraUrlResourceType itemType)
             itemType == ExtraUrlResourceType.LinkTag ? LinkFieldName : ScriptFieldName;
     }
 
-    
+    /// <summary>
+    /// Gets the URL of the resource to inject.
+    /// </summary>
     public Uri Url { get; }
 
-    
+    /// <summary>
+    /// Gets the type of resource (LinkTag for CSS, ScriptTag for JavaScript).
+    /// </summary>
     public ExtraUrlResourceType ItemType { get; }
 
     internal string FormDataFieldName { get; }