src/Sqlite/Extensions.fs

@@ -2,263 +2,487 @@ namespace BitBadger.Documents.Sqlite
 
 open Microsoft.Data.Sqlite
 
-/// F# extensions for the SqliteConnection type
+/// <summary>F# extensions for the SqliteConnection type</summary>
 [<AutoOpen>]
 module Extensions =
 
     type SqliteConnection with
-        
+
-        /// Execute a query that returns a list of results
+        /// <summary>Execute a query that returns a list of results</summary>
+        /// <param name="query">The query to retrieve the results</param>
+        /// <param name="parameters">Parameters to use for the query</param>
+        /// <param name="mapFunc">The mapping function between the document and the domain item</param>
+        /// <returns>A list of results for the given query</returns>
         member conn.customList<'TDoc> query parameters mapFunc =
             WithConn.Custom.list<'TDoc> query parameters mapFunc conn
 
-        /// Execute a query that returns one or no results
+        /// <summary>Execute a query that returns one or no results</summary>
+        /// <param name="query">The query to retrieve the results</param>
+        /// <param name="parameters">Parameters to use for the query</param>
+        /// <param name="mapFunc">The mapping function between the document and the domain item</param>
+        /// <returns><tt>Some</tt> with the first matching result, or <tt>None</tt> if not found</returns>
         member conn.customSingle<'TDoc> query parameters mapFunc =
             WithConn.Custom.single<'TDoc> query parameters mapFunc conn
-        
+
-        /// Execute a query that does not return a value
+        /// <summary>Execute a query that returns no results</summary>
+        /// <param name="query">The query to retrieve the results</param>
+        /// <param name="parameters">Parameters to use for the query</param>
         member conn.customNonQuery query parameters =
             WithConn.Custom.nonQuery query parameters conn
 
-        /// Execute a query that returns a scalar value
+        /// <summary>Execute a query that returns a scalar value</summary>
+        /// <param name="query">The query to retrieve the value</param>
+        /// <param name="parameters">Parameters to use for the query</param>
+        /// <param name="mapFunc">The mapping function to obtain the value</param>
+        /// <returns>The scalar value for the query</returns>
         member conn.customScalar<'T when 'T: struct> query parameters mapFunc =
             WithConn.Custom.scalar<'T> query parameters mapFunc conn
 
-        /// Create a document table
+        /// <summary>Create a document table</summary>
+        /// <param name="name">The table whose existence should be ensured (may include schema)</param>
         member conn.ensureTable name =
             WithConn.Definition.ensureTable name conn
-        
+
-        /// Create an index on a document table
+        /// <summary>Create an index on field(s) within documents in the specified table</summary>
+        /// <param name="tableName">The table to be indexed (may include schema)</param>
+        /// <param name="indexName">The name of the index to create</param>
+        /// <param name="fields">One or more fields to be indexed</param>
         member conn.ensureFieldIndex tableName indexName fields =
             WithConn.Definition.ensureFieldIndex tableName indexName fields conn
-        
+
-        /// Insert a new document
+        /// <summary>Insert a new document</summary>
+        /// <param name="tableName">The table into which the document should be inserted (may include schema)</param>
+        /// <param name="document">The document to be inserted</param>
         member conn.insert<'TDoc> tableName (document: 'TDoc) =
             WithConn.Document.insert<'TDoc> tableName document conn
 
+        /// <summary>
         /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
+        /// </summary>
+        /// <param name="tableName">The table into which the document should be saved (may include schema)</param>
+        /// <param name="document">The document to be saved</param>
         member conn.save<'TDoc> tableName (document: 'TDoc) =
             WithConn.Document.save tableName document conn
 
-        /// Count all documents in a table
+        /// <summary>Count all documents in a table</summary>
+        /// <param name="tableName">The table in which documents should be counted (may include schema)</param>
+        /// <returns>The count of the documents in the table</returns>
         member conn.countAll tableName =
             WithConn.Count.all tableName conn
-        
+
-        /// Count matching documents using a comparison on JSON fields
+        /// <summary>Count matching documents using JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+        /// <param name="tableName">The table in which documents should be counted (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
+        /// <returns>The count of matching documents in the table</returns>
         member conn.countByFields tableName howMatched fields =
             WithConn.Count.byFields tableName howMatched fields conn
-        
+
-        /// Determine if a document exists for the given ID
+        /// <summary>Determine if a document exists for the given ID</summary>
+        /// <param name="tableName">The table in which existence should be checked (may include schema)</param>
+        /// <param name="docId">The ID of the document whose existence should be checked</param>
+        /// <returns>True if a document exists, false if not</returns>
         member conn.existsById tableName (docId: 'TKey) =
             WithConn.Exists.byId tableName docId conn
 
-        /// Determine if a document exists using a comparison on JSON fields
+        /// <summary>Determine if a document exists using JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+        /// <param name="tableName">The table in which existence should be checked (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
+        /// <returns>True if any matching documents exist, false if not</returns>
         member conn.existsByFields tableName howMatched fields =
             WithConn.Exists.byFields tableName howMatched fields conn
-        
+
-        /// Retrieve all documents in the given table
+        /// <summary>Retrieve all documents in the given table</summary>
+        /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+        /// <returns>All documents from the given table</returns>
         member conn.findAll<'TDoc> tableName =
             WithConn.Find.all<'TDoc> tableName conn
 
-        /// Retrieve all documents in the given table ordered by the given fields in the document
+        /// <summary>Retrieve all documents in the given table ordered by the given fields in the document</summary>
+        /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+        /// <param name="orderFields">Fields by which the results should be ordered</param>
+        /// <returns>All documents from the given table, ordered by the given fields</returns>
         member conn.findAllOrdered<'TDoc> tableName orderFields =
             WithConn.Find.allOrdered<'TDoc> tableName orderFields conn
 
-        /// Retrieve a document by its ID
+        /// <summary>Retrieve a document by its ID</summary>
+        /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+        /// <param name="docId">The ID of the document to retrieve</param>
+        /// <returns><tt>Some</tt> with the document if found, <tt>None</tt> otherwise</returns>
         member conn.findById<'TKey, 'TDoc> tableName (docId: 'TKey) =
             WithConn.Find.byId<'TKey, 'TDoc> tableName docId conn
-        
+
-        /// Retrieve documents via a comparison on JSON fields
+        /// <summary>Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+        /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
+        /// <returns>All documents matching the given fields</returns>
         member conn.findByFields<'TDoc> tableName howMatched fields =
             WithConn.Find.byFields<'TDoc> tableName howMatched fields conn
-        
+
-        /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document
+        /// <summary>
+        /// Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given fields
+        /// in the document
+        /// </summary>
+        /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="queryFields">The field conditions to match</param>
+        /// <param name="orderFields">Fields by which the results should be ordered</param>
+        /// <returns>All documents matching the given fields, ordered by the other given fields</returns>
         member conn.findByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields =
             WithConn.Find.byFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields conn
-        
+
-        /// Retrieve documents via a comparison on JSON fields, returning only the first result
+        /// <summary>Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+        /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
+        /// <returns><tt>Some</tt> with the first document, or <tt>None</tt> if not found</returns>
         member conn.findFirstByFields<'TDoc> tableName howMatched fields =
             WithConn.Find.firstByFields<'TDoc> tableName howMatched fields conn
-        
+
-        /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document, returning
+        /// <summary>
-        /// only the first result
+        /// Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the
+        /// given fields in the document
+        /// </summary>
+        /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="queryFields">The field conditions to match</param>
+        /// <param name="orderFields">Fields by which the results should be ordered</param>
+        /// <returns>
+        /// <tt>Some</tt> with the first document ordered by the given fields, or <tt>None</tt> if not found
+        /// </returns>
         member conn.findFirstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields =
             WithConn.Find.firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields conn
-        
+
-        /// Update an entire document by its ID
+        /// <summary>Update (replace) an entire document by its ID</summary>
+        /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+        /// <param name="docId">The ID of the document to be updated (replaced)</param>
+        /// <param name="document">The new document</param>
         member conn.updateById tableName (docId: 'TKey) (document: 'TDoc) =
             WithConn.Update.byId tableName docId document conn
-        
+
-        /// Update an entire document by its ID, using the provided function to obtain the ID from the document
+        /// <summary>
+        /// Update (replace) an entire document by its ID, using the provided function to obtain the ID from the
+        /// document
+        /// </summary>
+        /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+        /// <param name="idFunc">The function to obtain the ID of the document</param>
+        /// <param name="document">The new document</param>
         member conn.updateByFunc tableName (idFunc: 'TDoc -> 'TKey) (document: 'TDoc) =
             WithConn.Update.byFunc tableName idFunc document conn
-        
+
-        /// Patch a document by its ID
+        /// <summary>Patch a document by its ID</summary>
+        /// <param name="tableName">The table in which a document should be patched (may include schema)</param>
+        /// <param name="docId">The ID of the document to patch</param>
+        /// <param name="patch">The partial document to patch the existing document</param>
         member conn.patchById tableName (docId: 'TKey) (patch: 'TPatch) =
             WithConn.Patch.byId tableName docId patch conn
-        
+
-        /// Patch documents using a comparison on JSON fields
+        /// <summary>
+        /// Patch documents using a JSON field comparison query in the <tt>WHERE</tt> clause (<tt>-&gt;&gt; =</tt>,
+        /// etc.)
+        /// </summary>
+        /// <param name="tableName">The table in which documents should be patched (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
+        /// <param name="patch">The partial document to patch the existing document</param>
         member conn.patchByFields tableName howMatched fields (patch: 'TPatch) =
             WithConn.Patch.byFields tableName howMatched fields patch conn
-        
+
-        /// Remove fields from a document by the document's ID
+        /// <summary>Remove fields from a document by the document's ID</summary>
+        /// <param name="tableName">The table in which a document should be modified (may include schema)</param>
+        /// <param name="docId">The ID of the document to modify</param>
+        /// <param name="fieldNames">One or more field names to remove from the document</param>
         member conn.removeFieldsById tableName (docId: 'TKey) fieldNames =
             WithConn.RemoveFields.byId tableName docId fieldNames conn
-        
+
-        /// Remove a field from a document via a comparison on JSON fields in the document
+        /// <summary>Remove fields from documents via a comparison on JSON fields in the document</summary>
+        /// <param name="tableName">The table in which documents should be modified (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
+        /// <param name="fieldNames">One or more field names to remove from the matching documents</param>
         member conn.removeFieldsByFields tableName howMatched fields fieldNames =
             WithConn.RemoveFields.byFields tableName howMatched fields fieldNames conn
-        
+
-        /// Delete a document by its ID
+        /// <summary>Delete a document by its ID</summary>
+        /// <param name="tableName">The table in which a document should be deleted (may include schema)</param>
+        /// <param name="docId">The ID of the document to delete</param>
         member conn.deleteById tableName (docId: 'TKey) =
             WithConn.Delete.byId tableName docId conn
 
-        /// Delete documents by matching a comparison on JSON fields
+        /// <summary>Delete documents by matching a JSON field comparison query (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+        /// <param name="tableName">The table in which documents should be deleted (may include schema)</param>
+        /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+        /// <param name="fields">The field conditions to match</param>
         member conn.deleteByFields tableName howMatched fields =
             WithConn.Delete.byFields tableName howMatched fields conn
 
 
 open System.Runtime.CompilerServices
 
-/// C# extensions on the SqliteConnection type
+/// <summary>C# extensions on the SqliteConnection type</summary>
 type SqliteConnectionCSharpExtensions =
-    
+
-    /// Execute a query that returns a list of results
+    /// <summary>Execute a query that returns a list of results</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="query">The query to retrieve the results</param>
+    /// <param name="parameters">Parameters to use for the query</param>
+    /// <param name="mapFunc">The mapping function between the document and the domain item</param>
+    /// <returns>A list of results for the given query</returns>
     [<Extension>]
     static member inline CustomList<'TDoc>(conn, query, parameters, mapFunc: System.Func<SqliteDataReader, 'TDoc>) =
         WithConn.Custom.List<'TDoc>(query, parameters, mapFunc, conn)
 
-    /// Execute a query that returns one or no results
+    /// <summary>Execute a query that returns one or no results</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="query">The query to retrieve the results</param>
+    /// <param name="parameters">Parameters to use for the query</param>
+    /// <param name="mapFunc">The mapping function between the document and the domain item</param>
+    /// <returns>The first matching result, or <tt>null</tt> if not found</returns>
     [<Extension>]
     static member inline CustomSingle<'TDoc when 'TDoc: null and 'TDoc: not struct>(
             conn, query, parameters, mapFunc: System.Func<SqliteDataReader, 'TDoc>) =
         WithConn.Custom.Single<'TDoc>(query, parameters, mapFunc, conn)
-    
+
-    /// Execute a query that does not return a value
+    /// <summary>Execute a query that returns no results</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="query">The query to retrieve the results</param>
+    /// <param name="parameters">Parameters to use for the query</param>
     [<Extension>]
     static member inline CustomNonQuery(conn, query, parameters) =
         WithConn.Custom.nonQuery query parameters conn
 
-    /// Execute a query that returns a scalar value
+    /// <summary>Execute a query that returns a scalar value</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="query">The query to retrieve the value</param>
+    /// <param name="parameters">Parameters to use for the query</param>
+    /// <param name="mapFunc">The mapping function to obtain the value</param>
+    /// <returns>The scalar value for the query</returns>
     [<Extension>]
     static member inline CustomScalar<'T when 'T: struct>(
             conn, query, parameters, mapFunc: System.Func<SqliteDataReader, 'T>) =
         WithConn.Custom.Scalar<'T>(query, parameters, mapFunc, conn)
 
-    /// Create a document table
+    /// <summary>Create a document table</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="name">The table whose existence should be ensured (may include schema)</param>
     [<Extension>]
     static member inline EnsureTable(conn, name) =
         WithConn.Definition.ensureTable name conn
 
-    /// Create an index on one or more fields in a document table
+    /// <summary>Create an index on field(s) within documents in the specified table</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table to be indexed (may include schema)</param>
+    /// <param name="indexName">The name of the index to create</param>
+    /// <param name="fields">One or more fields to be indexed</param>
     [<Extension>]
     static member inline EnsureFieldIndex(conn, tableName, indexName, fields) =
         WithConn.Definition.ensureFieldIndex tableName indexName fields conn
 
-    /// Insert a new document
+    /// <summary>Insert a new document</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table into which the document should be inserted (may include schema)</param>
+    /// <param name="document">The document to be inserted</param>
     [<Extension>]
     static member inline Insert<'TDoc>(conn, tableName, document: 'TDoc) =
         WithConn.Document.insert<'TDoc> tableName document conn
 
-    /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
+    /// <summary>Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table into which the document should be saved (may include schema)</param>
+    /// <param name="document">The document to be saved</param>
     [<Extension>]
     static member inline Save<'TDoc>(conn, tableName, document: 'TDoc) =
         WithConn.Document.save<'TDoc> tableName document conn
 
-    /// Count all documents in a table
+    /// <summary>Count all documents in a table</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which documents should be counted (may include schema)</param>
+    /// <returns>The count of the documents in the table</returns>
     [<Extension>]
     static member inline CountAll(conn, tableName) =
         WithConn.Count.all tableName conn
-    
+
-    /// Count matching documents using a comparison on JSON fields
+    /// <summary>Count matching documents using JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which documents should be counted (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>The count of matching documents in the table</returns>
     [<Extension>]
     static member inline CountByFields(conn, tableName, howMatched, fields) =
         WithConn.Count.byFields tableName howMatched fields conn
-    
+
-    /// Determine if a document exists for the given ID
+    /// <summary>Determine if a document exists for the given ID</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which existence should be checked (may include schema)</param>
+    /// <param name="docId">The ID of the document whose existence should be checked</param>
+    /// <returns>True if a document exists, false if not</returns>
     [<Extension>]
     static member inline ExistsById<'TKey>(conn, tableName, docId: 'TKey) =
         WithConn.Exists.byId tableName docId conn
 
-    /// Determine if a document exists using a comparison on JSON fields
+    /// <summary>Determine if a document exists using JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which existence should be checked (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>True if any matching documents exist, false if not</returns>
     [<Extension>]
     static member inline ExistsByFields(conn, tableName, howMatched, fields) =
         WithConn.Exists.byFields tableName howMatched fields conn
-    
+
-    /// Retrieve all documents in the given table
+    /// <summary>Retrieve all documents in the given table</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <returns>All documents from the given table</returns>
     [<Extension>]
     static member inline FindAll<'TDoc>(conn, tableName) =
         WithConn.Find.All<'TDoc>(tableName, conn)
 
-    /// Retrieve all documents in the given table ordered by the given fields in the document
+    /// <summary>Retrieve all documents in the given table ordered by the given fields in the document</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>All documents from the given table, ordered by the given fields</returns>
     [<Extension>]
     static member inline FindAllOrdered<'TDoc>(conn, tableName, orderFields) =
         WithConn.Find.AllOrdered<'TDoc>(tableName, orderFields, conn)
 
-    /// Retrieve a document by its ID
+    /// <summary>Retrieve a document by its ID</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="docId">The ID of the document to retrieve</param>
+    /// <returns>The document if found, <tt>null</tt> otherwise</returns>
     [<Extension>]
     static member inline FindById<'TKey, 'TDoc when 'TDoc: null and 'TDoc: not struct>(conn, tableName, docId: 'TKey) =
         WithConn.Find.ById<'TKey, 'TDoc>(tableName, docId, conn)
 
-    /// Retrieve documents via a comparison on JSON fields
+    /// <summary>Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>All documents matching the given fields</returns>
     [<Extension>]
     static member inline FindByFields<'TDoc>(conn, tableName, howMatched, fields) =
         WithConn.Find.ByFields<'TDoc>(tableName, howMatched, fields, conn)
-    
+
-    /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document
+    /// <summary>
+    /// Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given fields in
+    /// the document
+    /// </summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="queryFields">The field conditions to match</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>All documents matching the given fields, ordered by the other given fields</returns>
     [<Extension>]
     static member inline FindByFieldsOrdered<'TDoc>(conn, tableName, howMatched, queryFields, orderFields) =
         WithConn.Find.ByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, conn)
-    
+
-    /// Retrieve documents via a comparison on JSON fields, returning only the first result
+    /// <summary>Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>The first document, or <tt>null</tt> if not found</returns>
     [<Extension>]
     static member inline FindFirstByFields<'TDoc when 'TDoc: null and 'TDoc: not struct>(
             conn, tableName, howMatched, fields) =
         WithConn.Find.FirstByFields<'TDoc>(tableName, howMatched, fields, conn)
-    
+
-    /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document, returning only
+    /// <summary>
-    /// the first result
+    /// Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given
+    /// fields in the document
+    /// </summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="queryFields">The field conditions to match</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>The first document ordered by the given fields, or <tt>null</tt> if not found</returns>
     [<Extension>]
     static member inline FindFirstByFieldsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(
             conn, tableName, howMatched, queryFields, orderFields) =
         WithConn.Find.FirstByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, conn)
-    
+
-    /// Update an entire document by its ID
+    /// <summary>Update (replace) an entire document by its ID</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+    /// <param name="docId">The ID of the document to be updated (replaced)</param>
+    /// <param name="document">The new document</param>
     [<Extension>]
     static member inline UpdateById<'TKey, 'TDoc>(conn, tableName, docId: 'TKey, document: 'TDoc) =
         WithConn.Update.byId tableName docId document conn
-    
+
-    /// Update an entire document by its ID, using the provided function to obtain the ID from the document
+    /// <summary>
+    /// Update (replace) an entire document by its ID, using the provided function to obtain the ID from the document
+    /// </summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+    /// <param name="idFunc">The function to obtain the ID of the document</param>
+    /// <param name="document">The new document</param>
     [<Extension>]
-    static member inline UpdateByFunc<'TKey, 'TDoc>(conn, tableName, idFunc: System.Func<'TDoc, 'TKey>, doc: 'TDoc) =
+    static member inline UpdateByFunc<'TKey, 'TDoc>(
-        WithConn.Update.ByFunc(tableName, idFunc, doc, conn)
+            conn, tableName, idFunc: System.Func<'TDoc, 'TKey>, document: 'TDoc) =
-    
+        WithConn.Update.ByFunc(tableName, idFunc, document, conn)
-    /// Patch a document by its ID
+
+    /// <summary>Patch a document by its ID</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which a document should be patched (may include schema)</param>
+    /// <param name="docId">The ID of the document to patch</param>
+    /// <param name="patch">The partial document to patch the existing document</param>
     [<Extension>]
     static member inline PatchById<'TKey, 'TPatch>(conn, tableName, docId: 'TKey, patch: 'TPatch) =
         WithConn.Patch.byId tableName docId patch conn
-    
+
-    /// Patch documents using a comparison on JSON fields
+    /// <summary>
+    /// Patch documents using a JSON field comparison query in the <tt>WHERE</tt> clause (<tt>-&gt;&gt; =</tt>, etc.)
+    /// </summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which documents should be patched (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <param name="patch">The partial document to patch the existing document</param>
     [<Extension>]
     static member inline PatchByFields<'TPatch>(conn, tableName, howMatched, fields, patch: 'TPatch) =
         WithConn.Patch.byFields tableName howMatched fields patch conn
-    
+
-    /// Remove fields from a document by the document's ID
+    /// <summary>Remove fields from a document by the document's ID</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which a document should be modified (may include schema)</param>
+    /// <param name="docId">The ID of the document to modify</param>
+    /// <param name="fieldNames">One or more field names to remove from the document</param>
     [<Extension>]
     static member inline RemoveFieldsById<'TKey>(conn, tableName, docId: 'TKey, fieldNames) =
         WithConn.RemoveFields.byId tableName docId fieldNames conn
-    
+
-    /// Remove fields from documents via a comparison on JSON fields in the document
+    /// <summary>Remove fields from documents via a comparison on JSON fields in the document</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which documents should be modified (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <param name="fieldNames">One or more field names to remove from the matching documents</param>
     [<Extension>]
     static member inline RemoveFieldsByFields(conn, tableName, howMatched, fields, fieldNames) =
         WithConn.RemoveFields.byFields tableName howMatched fields fieldNames conn
-    
+
-    /// Delete a document by its ID
+    /// <summary>Delete a document by its ID</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which a document should be deleted (may include schema)</param>
+    /// <param name="docId">The ID of the document to delete</param>
     [<Extension>]
     static member inline DeleteById<'TKey>(conn, tableName, docId: 'TKey) =
         WithConn.Delete.byId tableName docId conn
-    
+
-    /// Delete documents by matching a comparison on JSON fields
+    /// <summary>Delete documents by matching a JSON field comparison query (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="conn">The <tt>SqliteConnection</tt> on which to run the query</param>
+    /// <param name="tableName">The table in which documents should be deleted (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
     [<Extension>]
     static member inline DeleteByFields(conn, tableName, howMatched, fields) =
         WithConn.Delete.byFields tableName howMatched fields conn

src/Sqlite/Library.fs

@@ -838,226 +838,345 @@ module Custom =
         WithConn.Custom.Scalar<'T>(query, parameters, mapFunc, conn)
 
 
-/// Functions to create tables and indexes
+/// <summary>Functions to create tables and indexes</summary>
 [<RequireQualifiedAccess>]
 module Definition =
 
-    /// Create a document table
+    /// <summary>Create a document table</summary>
+    /// <param name="name">The table whose existence should be ensured (may include schema)</param>
     [<CompiledName "EnsureTable">]
     let ensureTable name =
         use conn = Configuration.dbConn ()
         WithConn.Definition.ensureTable name conn
 
-    /// Create an index on a document table
+    /// <summary>Create an index on field(s) within documents in the specified table</summary>
+    /// <param name="tableName">The table to be indexed (may include schema)</param>
+    /// <param name="indexName">The name of the index to create</param>
+    /// <param name="fields">One or more fields to be indexed</param>
     [<CompiledName "EnsureFieldIndex">]
     let ensureFieldIndex tableName indexName fields =
         use conn = Configuration.dbConn ()
         WithConn.Definition.ensureFieldIndex tableName indexName fields conn
 
 
-/// Document insert/save functions
+/// <summary>Document insert/save functions</summary>
 [<AutoOpen>]
 module Document =
 
-    /// Insert a new document
+    /// <summary>Insert a new document</summary>
+    /// <param name="tableName">The table into which the document should be inserted (may include schema)</param>
+    /// <param name="document">The document to be inserted</param>
     [<CompiledName "Insert">]
     let insert<'TDoc> tableName (document: 'TDoc) =
         use conn = Configuration.dbConn ()
         WithConn.Document.insert tableName document conn
 
-    /// Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
+    /// <summary>Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")</summary>
+    /// <param name="tableName">The table into which the document should be saved (may include schema)</param>
+    /// <param name="document">The document to be saved</param>
     [<CompiledName "Save">]
     let save<'TDoc> tableName (document: 'TDoc) =
         use conn = Configuration.dbConn ()
         WithConn.Document.save tableName document conn
 
 
-/// Commands to count documents
+/// <summary>Commands to count documents</summary>
 [<RequireQualifiedAccess>]
 module Count =
 
-    /// Count all documents in a table
+    /// <summary>Count all documents in a table</summary>
+    /// <param name="tableName">The table in which documents should be counted (may include schema)</param>
+    /// <returns>The count of the documents in the table</returns>
     [<CompiledName "All">]
     let all tableName =
         use conn = Configuration.dbConn ()
         WithConn.Count.all tableName conn
 
-    /// Count matching documents using a comparison on JSON fields
+    /// <summary>Count matching documents using JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table in which documents should be counted (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>The count of matching documents in the table</returns>
     [<CompiledName "ByFields">]
     let byFields tableName howMatched fields =
         use conn = Configuration.dbConn ()
         WithConn.Count.byFields tableName howMatched fields conn
 
 
-/// Commands to determine if documents exist
+/// <summary>Commands to determine if documents exist</summary>
 [<RequireQualifiedAccess>]
 module Exists =
 
-    /// Determine if a document exists for the given ID
+    /// <summary>Determine if a document exists for the given ID</summary>
+    /// <param name="tableName">The table in which existence should be checked (may include schema)</param>
+    /// <param name="docId">The ID of the document whose existence should be checked</param>
+    /// <returns>True if a document exists, false if not</returns>
     [<CompiledName "ById">]
     let byId tableName (docId: 'TKey) =
         use conn = Configuration.dbConn ()
         WithConn.Exists.byId tableName docId conn
 
-    /// Determine if a document exists using a comparison on JSON fields
+    /// <summary>Determine if a document exists using JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table in which existence should be checked (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>True if any matching documents exist, false if not</returns>
     [<CompiledName "ByFields">]
     let byFields tableName howMatched fields =
         use conn = Configuration.dbConn ()
         WithConn.Exists.byFields tableName howMatched fields conn
 
 
-/// Commands to determine if documents exist
+/// <summary>Commands to retrieve documents</summary>
 [<RequireQualifiedAccess>]
 module Find =
 
-    /// Retrieve all documents in the given table
+    /// <summary>Retrieve all documents in the given table</summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <returns>All documents from the given table</returns>
     [<CompiledName "FSharpAll">]
     let all<'TDoc> tableName =
         use conn = Configuration.dbConn ()
         WithConn.Find.all<'TDoc> tableName conn
 
-    /// Retrieve all documents in the given table
+    /// <summary>Retrieve all documents in the given table</summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <returns>All documents from the given table</returns>
     let All<'TDoc> tableName =
         use conn = Configuration.dbConn ()
         WithConn.Find.All<'TDoc>(tableName, conn)
 
-    /// Retrieve all documents in the given table ordered by the given fields in the document
+    /// <summary>Retrieve all documents in the given table ordered by the given fields in the document</summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>All documents from the given table, ordered by the given fields</returns>
     [<CompiledName "FSharpAllOrdered">]
     let allOrdered<'TDoc> tableName orderFields =
         use conn = Configuration.dbConn ()
         WithConn.Find.allOrdered<'TDoc> tableName orderFields conn
 
-    /// Retrieve all documents in the given table ordered by the given fields in the document
+    /// <summary>Retrieve all documents in the given table ordered by the given fields in the document</summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>All documents from the given table, ordered by the given fields</returns>
     let AllOrdered<'TDoc> tableName orderFields =
         use conn = Configuration.dbConn ()
         WithConn.Find.AllOrdered<'TDoc>(tableName, orderFields, conn)
 
-    /// Retrieve a document by its ID (returns None if not found)
+    /// <summary>Retrieve a document by its ID</summary>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="docId">The ID of the document to retrieve</param>
+    /// <returns><tt>Some</tt> with the document if found, <tt>None</tt> otherwise</returns>
     [<CompiledName "FSharpById">]
     let byId<'TKey, 'TDoc> tableName docId =
         use conn = Configuration.dbConn ()
         WithConn.Find.byId<'TKey, 'TDoc> tableName docId conn
 
-    /// Retrieve a document by its ID (returns null if not found)
+    /// <summary>Retrieve a document by its ID</summary>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="docId">The ID of the document to retrieve</param>
+    /// <returns>The document if found, <tt>null</tt> otherwise</returns>
     let ById<'TKey, 'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, docId) =
         use conn = Configuration.dbConn ()
         WithConn.Find.ById<'TKey, 'TDoc>(tableName, docId, conn)
 
-    /// Retrieve documents via a comparison on JSON fields
+    /// <summary>Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>All documents matching the given fields</returns>
     [<CompiledName "FSharpByFields">]
     let byFields<'TDoc> tableName howMatched fields =
         use conn = Configuration.dbConn ()
         WithConn.Find.byFields<'TDoc> tableName howMatched fields conn
 
-    /// Retrieve documents via a comparison on JSON fields
+    /// <summary>Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>All documents matching the given fields</returns>
     let ByFields<'TDoc>(tableName, howMatched, fields) =
         use conn = Configuration.dbConn ()
         WithConn.Find.ByFields<'TDoc>(tableName, howMatched, fields, conn)
 
-    /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document
+    /// <summary>
+    /// Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given fields in
+    /// the document
+    /// </summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="queryFields">The field conditions to match</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>All documents matching the given fields, ordered by the other given fields</returns>
     [<CompiledName "FSharpByFieldsOrdered">]
     let byFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields =
         use conn = Configuration.dbConn ()
         WithConn.Find.byFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields conn
 
-    /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document
+    /// <summary>
+    /// Retrieve documents matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given fields in
+    /// the document
+    /// </summary>
+    /// <param name="tableName">The table from which documents should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="queryFields">The field conditions to match</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>All documents matching the given fields, ordered by the other given fields</returns>
     let ByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields) =
         use conn = Configuration.dbConn ()
         WithConn.Find.ByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, conn)
 
-    /// Retrieve documents via a comparison on JSON fields, returning only the first result
+    /// <summary>Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns><tt>Some</tt> with the first document, or <tt>None</tt> if not found</returns>
     [<CompiledName "FSharpFirstByFields">]
     let firstByFields<'TDoc> tableName howMatched fields =
         use conn = Configuration.dbConn ()
         WithConn.Find.firstByFields<'TDoc> tableName howMatched fields conn
 
-    /// Retrieve documents via a comparison on JSON fields, returning only the first result
+    /// <summary>Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <returns>The first document, or <tt>null</tt> if not found</returns>
     let FirstByFields<'TDoc when 'TDoc: null and 'TDoc: not struct>(tableName, howMatched, fields) =
         use conn = Configuration.dbConn ()
         WithConn.Find.FirstByFields<'TDoc>(tableName, howMatched, fields, conn)
 
-    /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document, returning only
+    /// <summary>
-    /// the first result
+    /// Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given
+    /// fields in the document
+    /// </summary>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="queryFields">The field conditions to match</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>
+    /// <tt>Some</tt> with the first document ordered by the given fields, or <tt>None</tt> if not found
+    /// </returns>
     [<CompiledName "FSharpFirstByFieldsOrdered">]
     let firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields =
         use conn = Configuration.dbConn ()
         WithConn.Find.firstByFieldsOrdered<'TDoc> tableName howMatched queryFields orderFields conn
 
-    /// Retrieve documents via a comparison on JSON fields ordered by the given fields in the document, returning only
+    /// <summary>
-    /// the first result
+    /// Retrieve the first document matching JSON field comparisons (<tt>-&gt;&gt; =</tt>, etc.) ordered by the given
+    /// fields in the document
+    /// </summary>
+    /// <param name="tableName">The table from which a document should be retrieved (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="queryFields">The field conditions to match</param>
+    /// <param name="orderFields">Fields by which the results should be ordered</param>
+    /// <returns>The first document ordered by the given fields, or <tt>null</tt> if not found</returns>
     let FirstByFieldsOrdered<'TDoc when 'TDoc: null and 'TDoc: not struct>(
             tableName, howMatched, queryFields, orderFields) =
         use conn = Configuration.dbConn ()
         WithConn.Find.FirstByFieldsOrdered<'TDoc>(tableName, howMatched, queryFields, orderFields, conn)
 
 
-/// Commands to update documents
+/// <summary>Commands to update documents</summary>
 [<RequireQualifiedAccess>]
 module Update =
 
-    /// Update an entire document by its ID
+    /// <summary>Update (replace) an entire document by its ID</summary>
+    /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+    /// <param name="docId">The ID of the document to be updated (replaced)</param>
+    /// <param name="document">The new document</param>
     [<CompiledName "ById">]
     let byId tableName (docId: 'TKey) (document: 'TDoc) =
         use conn = Configuration.dbConn ()
         WithConn.Update.byId tableName docId document conn
 
-    /// Update an entire document by its ID, using the provided function to obtain the ID from the document
+    /// <summary>
+    /// Update (replace) an entire document by its ID, using the provided function to obtain the ID from the document
+    /// </summary>
+    /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+    /// <param name="idFunc">The function to obtain the ID of the document</param>
+    /// <param name="document">The new document</param>
     [<CompiledName "FSharpByFunc">]
     let byFunc tableName (idFunc: 'TDoc -> 'TKey) (document: 'TDoc) =
         use conn = Configuration.dbConn ()
         WithConn.Update.byFunc tableName idFunc document conn
 
-    /// Update an entire document by its ID, using the provided function to obtain the ID from the document
+    /// <summary>
+    /// Update (replace) an entire document by its ID, using the provided function to obtain the ID from the document
+    /// </summary>
+    /// <param name="tableName">The table in which a document should be updated (may include schema)</param>
+    /// <param name="idFunc">The function to obtain the ID of the document</param>
+    /// <param name="document">The new document</param>
     let ByFunc(tableName, idFunc: System.Func<'TDoc, 'TKey>, document: 'TDoc) =
         use conn = Configuration.dbConn ()
         WithConn.Update.ByFunc(tableName, idFunc, document, conn)
 
 
-/// Commands to patch (partially update) documents
+/// <summary>Commands to patch (partially update) documents</summary>
 [<RequireQualifiedAccess>]
 module Patch =
 
-    /// Patch a document by its ID
+    /// <summary>Patch a document by its ID</summary>
+    /// <param name="tableName">The table in which a document should be patched (may include schema)</param>
+    /// <param name="docId">The ID of the document to patch</param>
+    /// <param name="patch">The partial document to patch the existing document</param>
     [<CompiledName "ById">]
     let byId tableName (docId: 'TKey) (patch: 'TPatch) =
         use conn = Configuration.dbConn ()
         WithConn.Patch.byId tableName docId patch conn
 
-    /// Patch documents using a comparison on JSON fields in the WHERE clause
+    /// <summary>
+    /// Patch documents using a JSON field comparison query in the <tt>WHERE</tt> clause (<tt>-&gt;&gt; =</tt>, etc.)
+    /// </summary>
+    /// <param name="tableName">The table in which documents should be patched (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <param name="patch">The partial document to patch the existing document</param>
     [<CompiledName "ByFields">]
     let byFields tableName howMatched fields (patch: 'TPatch) =
         use conn = Configuration.dbConn ()
         WithConn.Patch.byFields tableName howMatched fields patch conn
 
 
-/// Commands to remove fields from documents
+/// <summary>Commands to remove fields from documents</summary>
 [<RequireQualifiedAccess>]
 module RemoveFields =
 
-    /// Remove fields from a document by the document's ID
+    /// <summary>Remove fields from a document by the document's ID</summary>
+    /// <param name="tableName">The table in which a document should be modified (may include schema)</param>
+    /// <param name="docId">The ID of the document to modify</param>
+    /// <param name="fieldNames">One or more field names to remove from the document</param>
     [<CompiledName "ById">]
     let byId tableName (docId: 'TKey) fieldNames =
         use conn = Configuration.dbConn ()
         WithConn.RemoveFields.byId tableName docId fieldNames conn
 
-    /// Remove field from documents via a comparison on JSON fields in the document
+    /// <summary>Remove fields from documents via a comparison on JSON fields in the document</summary>
+    /// <param name="tableName">The table in which documents should be modified (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
+    /// <param name="fieldNames">One or more field names to remove from the matching documents</param>
     [<CompiledName "ByFields">]
     let byFields tableName howMatched fields fieldNames =
         use conn = Configuration.dbConn ()
         WithConn.RemoveFields.byFields tableName howMatched fields fieldNames conn
 
 
-/// Commands to delete documents
+/// <summary>Commands to delete documents</summary>
 [<RequireQualifiedAccess>]
 module Delete =
 
-    /// Delete a document by its ID
+    /// <summary>Delete a document by its ID</summary>
+    /// <param name="tableName">The table in which a document should be deleted (may include schema)</param>
+    /// <param name="docId">The ID of the document to delete</param>
     [<CompiledName "ById">]
     let byId tableName (docId: 'TKey) =
         use conn = Configuration.dbConn ()
         WithConn.Delete.byId tableName docId conn
 
-    /// Delete documents by matching a comparison on JSON fields
+    /// <summary>Delete documents by matching a JSON field comparison query (<tt>-&gt;&gt; =</tt>, etc.)</summary>
+    /// <param name="tableName">The table in which documents should be deleted (may include schema)</param>
+    /// <param name="howMatched">Whether to match any or all of the field conditions</param>
+    /// <param name="fields">The field conditions to match</param>
     [<CompiledName "ByFields">]
     let byFields tableName howMatched fields =
         use conn = Configuration.dbConn ()