diff --git a/src/core/pom.xml b/src/core/pom.xml
index 2da4e57..d54de26 100644
--- a/src/core/pom.xml
+++ b/src/core/pom.xml
@@ -106,6 +106,9 @@
                         <goals>
                             <goal>jar</goal>
                         </goals>
+                        <configuration>
+                            <sourcepath>${project.basedir}/src/main/kotlin</sourcepath>
+                        </configuration>
                     </execution>
                 </executions>
             </plugin>
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Count.scala b/src/scala/src/main/scala/Count.scala
similarity index 92%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Count.scala
rename to src/scala/src/main/scala/Count.scala
index a2a1d3c..df5a319 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Count.scala
+++ b/src/scala/src/main/scala/Count.scala
@@ -62,12 +62,12 @@ object Count:
    * Count documents using a JSON containment query (PostgreSQL only)
    *
    * @param tableName The name of the table in which documents should be counted
-   * @param criteria The object for which JSON containment should be checked
-   * @param conn The connection on which the count should be executed
+   * @param criteria  The object for which JSON containment should be checked
+   * @param conn      The connection on which the count should be executed
    * @return A count of the matching documents in the table
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains, conn: Connection): Long =
+  def byContains[A](tableName: String, criteria: A, conn: Connection): Long =
     CoreCount.byContains(tableName, criteria, conn)
 
   /**
@@ -78,7 +78,7 @@ object Count:
    * @return A count of the matching documents in the table
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains): Long =
+  def byContains[A](tableName: String, criteria: A): Long =
     CoreCount.byContains(tableName, criteria)
 
   /**
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Custom.scala b/src/scala/src/main/scala/Custom.scala
similarity index 73%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Custom.scala
rename to src/scala/src/main/scala/Custom.scala
index b59bee2..d946b33 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Custom.scala
+++ b/src/scala/src/main/scala/Custom.scala
@@ -18,9 +18,9 @@ object Custom:
    * @return A list of results for the given query
    * @throws DocumentException If parameters are invalid
    */
-  def list[TDoc](query: String, parameters: Seq[Parameter[?]], conn: Connection,
-                 mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Using(Parameters.apply(conn, query, parameters)) { stmt => Results.toCustomList[TDoc](stmt, mapFunc) }.get
+  def list[Doc](query: String, parameters: Seq[Parameter[?]], conn: Connection,
+                mapFunc: (ResultSet, ClassTag[Doc]) => Doc)(using tag: ClassTag[Doc]): List[Doc] =
+    Using(Parameters.apply(conn, query, parameters)) { stmt => Results.toCustomList[Doc](stmt, mapFunc) }.get
 
   /**
    * Execute a query that returns a list of results
@@ -31,8 +31,8 @@ object Custom:
    * @return A list of results for the given query
    * @throws DocumentException If parameters are invalid
    */
-  def list[TDoc](query: String, conn: Connection,
-                 mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
+  def list[Doc](query: String, conn: Connection, mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+               (using tag: ClassTag[Doc]): List[Doc] =
     list(query, List(), conn, mapFunc)
 
   /**
@@ -44,9 +44,9 @@ object Custom:
    * @return A list of results for the given query
    * @throws DocumentException If parameters are invalid
    */
-  def list[TDoc](query: String, parameters: Seq[Parameter[?]],
-                 mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Using(Configuration.dbConn()) { conn => list[TDoc](query, parameters, conn, mapFunc) }.get
+  def list[Doc](query: String, parameters: Seq[Parameter[?]], mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+               (using tag: ClassTag[Doc]): List[Doc] =
+    Using(Configuration.dbConn()) { conn => list[Doc](query, parameters, conn, mapFunc) }.get
 
   /**
    * Execute a query that returns a list of results (creates connection)
@@ -56,8 +56,7 @@ object Custom:
    * @return A list of results for the given query
    * @throws DocumentException If parameters are invalid
    */
-  def list[TDoc](query: String,
-                 mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
+  def list[Doc](query: String, mapFunc: (ResultSet, ClassTag[Doc]) => Doc)(using tag: ClassTag[Doc]): List[Doc] =
     list(query, List(), mapFunc)
 
   /**
@@ -70,9 +69,9 @@ object Custom:
    * @return An `Option` value, with the document if one matches the query
    * @throws DocumentException If parameters are invalid
    */
-  def single[TDoc](query: String, parameters: Seq[Parameter[?]], conn: Connection,
-                   mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    list[TDoc](s"$query LIMIT 1", parameters, conn, mapFunc).headOption
+  def single[Doc](query: String, parameters: Seq[Parameter[?]], conn: Connection,
+                  mapFunc: (ResultSet, ClassTag[Doc]) => Doc)(using tag: ClassTag[Doc]): Option[Doc] =
+    list[Doc](s"$query LIMIT 1", parameters, conn, mapFunc).headOption
 
   /**
    * Execute a query that returns one or no results
@@ -83,9 +82,9 @@ object Custom:
    * @return An `Option` value, with the document if one matches the query
    * @throws DocumentException If parameters are invalid
    */
-  def single[TDoc](query: String, conn: Connection,
-                   mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    list[TDoc](s"$query LIMIT 1", List(), conn, mapFunc).headOption
+  def single[Doc](query: String, conn: Connection, mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                 (using tag: ClassTag[Doc]): Option[Doc] =
+    list[Doc](s"$query LIMIT 1", List(), conn, mapFunc).headOption
 
   /**
    * Execute a query that returns one or no results (creates connection)
@@ -96,9 +95,9 @@ object Custom:
    * @return An `Option` value, with the document if one matches the query
    * @throws DocumentException If parameters are invalid
    */
-  def single[TDoc](query: String, parameters: Seq[Parameter[?]],
-                   mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Using(Configuration.dbConn()) { conn => single[TDoc](query, parameters, conn, mapFunc) }.get
+  def single[Doc](query: String, parameters: Seq[Parameter[?]], mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                 (using tag: ClassTag[Doc]): Option[Doc] =
+    Using(Configuration.dbConn()) { conn => single[Doc](query, parameters, conn, mapFunc) }.get
 
   /**
    * Execute a query that returns one or no results (creates connection)
@@ -108,9 +107,8 @@ object Custom:
    * @return An `Option` value, with the document if one matches the query
    * @throws DocumentException If parameters are invalid
    */
-  def single[TDoc](query: String,
-                   mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    single[TDoc](query, List(), mapFunc)
+  def single[Doc](query: String, mapFunc: (ResultSet, ClassTag[Doc]) => Doc)(using tag: ClassTag[Doc]): Option[Doc] =
+    single[Doc](query, List(), mapFunc)
 
   /**
    * Execute a query that returns no results
@@ -162,8 +160,8 @@ object Custom:
    * @return The scalar value from the query
    * @throws DocumentException If parameters are invalid
    */
-  def scalar[T](query: String, parameters: Seq[Parameter[?]], conn: Connection,
-                mapFunc: (ResultSet, ClassTag[T]) => T)(implicit tag: ClassTag[T]): T =
+  def scalar[A](query: String, parameters: Seq[Parameter[?]], conn: Connection, mapFunc: (ResultSet, ClassTag[A]) => A)
+               (using tag: ClassTag[A]): A =
     Using(Parameters.apply(conn, query, parameters)) { stmt =>
       Using(stmt.executeQuery()) { rs =>
         rs.next()
@@ -180,9 +178,8 @@ object Custom:
    * @return The scalar value from the query
    * @throws DocumentException If parameters are invalid
    */
-  def scalar[T](query: String, conn: Connection,
-                mapFunc: (ResultSet, ClassTag[T]) => T)(implicit tag: ClassTag[T]): T =
-    scalar[T](query, List(), conn, mapFunc)
+  def scalar[A](query: String, conn: Connection, mapFunc: (ResultSet, ClassTag[A]) => A)(using tag: ClassTag[A]): A =
+    scalar[A](query, List(), conn, mapFunc)
 
   /**
    * Execute a query that returns a scalar result (creates connection)
@@ -193,9 +190,9 @@ object Custom:
    * @return The scalar value from the query
    * @throws DocumentException If parameters are invalid
    */
-  def scalar[T](query: String, parameters: Seq[Parameter[?]],
-                mapFunc: (ResultSet, ClassTag[T]) => T)(implicit tag: ClassTag[T]): T =
-    Using(Configuration.dbConn()) { conn => scalar[T](query, parameters, conn, mapFunc) }.get
+  def scalar[A](query: String, parameters: Seq[Parameter[?]], mapFunc: (ResultSet, ClassTag[A]) => A)
+               (using tag: ClassTag[A]): A =
+    Using(Configuration.dbConn()) { conn => scalar[A](query, parameters, conn, mapFunc) }.get
 
   /**
    * Execute a query that returns a scalar result (creates connection)
@@ -205,6 +202,5 @@ object Custom:
    * @return The scalar value from the query
    * @throws DocumentException If parameters are invalid
    */
-  def scalar[T](query: String,
-                mapFunc: (ResultSet, ClassTag[T]) => T)(implicit tag: ClassTag[T]): T =
-    scalar[T](query, List(), mapFunc)
+  def scalar[A](query: String, mapFunc: (ResultSet, ClassTag[A]) => A)(using tag: ClassTag[A]): A =
+    scalar[A](query, List(), mapFunc)
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Definition.scala b/src/scala/src/main/scala/Definition.scala
similarity index 100%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Definition.scala
rename to src/scala/src/main/scala/Definition.scala
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Delete.scala b/src/scala/src/main/scala/Delete.scala
similarity index 91%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Delete.scala
rename to src/scala/src/main/scala/Delete.scala
index 19729af..bd67103 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Delete.scala
+++ b/src/scala/src/main/scala/Delete.scala
@@ -19,7 +19,7 @@ object Delete:
    * @param conn      The connection on which the deletion should be executed
    * @throws DocumentException If no dialect has been configured
    */
-  def byId[TKey](tableName: String, docId: TKey, conn: Connection): Unit =
+  def byId[Key](tableName: String, docId: Key, conn: Connection): Unit =
     CoreDelete.byId(tableName, docId, conn)
 
   /**
@@ -29,7 +29,7 @@ object Delete:
   * @param docId     The ID of the document to be deleted
   * @throws DocumentException If no connection string has been set
   */
-  def byId[TKey](tableName: String, docId: TKey): Unit =
+  def byId[Key](tableName: String, docId: Key): Unit =
     CoreDelete.byId(tableName, docId)
 
   /**
@@ -63,7 +63,7 @@ object Delete:
    * @param conn      The connection on which the deletion should be executed
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains, conn: Connection): Unit =
+  def byContains[A](tableName: String, criteria: A, conn: Connection): Unit =
     CoreDelete.byContains(tableName, criteria, conn)
 
   /**
@@ -73,7 +73,7 @@ object Delete:
    * @param criteria  The object for which JSON containment should be checked
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains): Unit =
+  def byContains[A](tableName: String, criteria: A): Unit =
     CoreDelete.byContains(tableName, criteria)
 
   /**
@@ -91,7 +91,7 @@ object Delete:
   * Delete documents using a JSON Path match query (PostgreSQL only; creates connection)
   *
   * @param tableName The name of the table from which documents should be deleted
-  * @param path The JSON path comparison to match
+  * @param path      The JSON path comparison to match
   * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
   */
   def byJsonPath(tableName: String, path: String): Unit =
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Document.scala b/src/scala/src/main/scala/Document.scala
similarity index 71%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Document.scala
rename to src/scala/src/main/scala/Document.scala
index ca23662..cab75fe 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Document.scala
+++ b/src/scala/src/main/scala/Document.scala
@@ -14,7 +14,7 @@ object Document:
    * @param conn      The connection on which the query should be executed
    * @throws DocumentException If IDs are misconfigured, or if the database command fails
    */
-  def insert[TDoc](tableName: String, document: TDoc, conn: Connection): Unit =
+  def insert[Doc](tableName: String, document: Doc, conn: Connection): Unit =
     CoreDocument.insert(tableName, document, conn)
 
   /**
@@ -24,49 +24,49 @@ object Document:
    * @param document  The document to be inserted
    * @throws DocumentException If IDs are misconfigured, or if the database command fails
    */
-  def insert[TDoc](tableName: String, document: TDoc): Unit =
+  def insert[Doc](tableName: String, document: Doc): Unit =
     CoreDocument.insert(tableName, document)
 
   /**
    * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
    *
    * @param tableName The table in which the document should be saved (may include schema)
-   * @param document The document to be saved
-   * @param conn The connection on which the query should be executed
+   * @param document  The document to be saved
+   * @param conn      The connection on which the query should be executed
    * @throws DocumentException If the database command fails
    */
-  def save[TDoc](tableName: String, document: TDoc, conn: Connection): Unit =
+  def save[Doc](tableName: String, document: Doc, conn: Connection): Unit =
     CoreDocument.save(tableName, document, conn)
 
   /**
    * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert"; creates connection)
    *
    * @param tableName The table in which the document should be saved (may include schema)
-   * @param document The document to be saved
+   * @param document  The document to be saved
    * @throws DocumentException If the database command fails
    */
-  def save[TDoc](tableName: String, document: TDoc): Unit =
+  def save[Doc](tableName: String, document: Doc): Unit =
     CoreDocument.save(tableName, document)
 
   /**
    * Update (replace) a document by its ID
    *
    * @param tableName The table in which the document should be replaced (may include schema)
-   * @param docId The ID of the document to be replaced
-   * @param document The document to be replaced
-   * @param conn The connection on which the query should be executed
+   * @param docId     The ID of the document to be replaced
+   * @param document  The document to be replaced
+   * @param conn      The connection on which the query should be executed
    * @throws DocumentException If no dialect has been configured, or if the database command fails
    */
-  def update[TKey, TDoc](tableName: String, docId: TKey, document: TDoc, conn: Connection): Unit =
+  def update[Key, Doc](tableName: String, docId: Key, document: Doc, conn: Connection): Unit =
     CoreDocument.update(tableName, docId, document, conn)
 
   /**
    * Update (replace) a document by its ID (creates connection)
    *
    * @param tableName The table in which the document should be replaced (may include schema)
-   * @param docId The ID of the document to be replaced
-   * @param document The document to be replaced
+   * @param docId     The ID of the document to be replaced
+   * @param document  The document to be replaced
    * @throws DocumentException If no dialect has been configured, or if the database command fails
    */
-  def update[TKey, TDoc](tableName: String, docId: TKey, document: TDoc): Unit =
+  def update[Key, Doc](tableName: String, docId: Key, document: Doc): Unit =
     CoreDocument.update(tableName, docId, document)
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Exists.scala b/src/scala/src/main/scala/Exists.scala
similarity index 92%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Exists.scala
rename to src/scala/src/main/scala/Exists.scala
index 90883f0..ef1c4fb 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Exists.scala
+++ b/src/scala/src/main/scala/Exists.scala
@@ -20,7 +20,7 @@ object Exists:
    * @return True if the document exists, false if not
    * @throws DocumentException If no dialect has been configured
    */
-  def byId[TKey](tableName: String, docId: TKey, conn: Connection): Boolean =
+  def byId[Key](tableName: String, docId: Key, conn: Connection): Boolean =
     CoreExists.byId(tableName, docId, conn)
 
   /**
@@ -31,7 +31,7 @@ object Exists:
    * @return True if the document exists, false if not
    * @throws DocumentException If no connection string has been set
    */
-  def byId[TKey](tableName: String, docId: TKey): Boolean =
+  def byId[Key](tableName: String, docId: Key): Boolean =
     CoreExists.byId(tableName, docId)
 
   /**
@@ -68,7 +68,7 @@ object Exists:
    * @return True if any matching documents exist, false if not
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains, conn: Connection): Boolean =
+  def byContains[A](tableName: String, criteria: A, conn: Connection): Boolean =
     CoreExists.byContains(tableName, criteria, conn)
 
   /**
@@ -79,7 +79,7 @@ object Exists:
    * @return True if any matching documents exist, false if not
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains): Boolean =
+  def byContains[A](tableName: String, criteria: A): Boolean =
     CoreExists.byContains(tableName, criteria)
 
   /**
@@ -98,7 +98,7 @@ object Exists:
    * Determine document existence using a JSON Path match query (PostgreSQL only; creates connection)
    *
    * @param tableName The name of the table in which document existence should be checked
-   * @param path The JSON path comparison to match
+   * @param path      The JSON path comparison to match
    * @return True if any matching documents exist, false if not
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Find.scala b/src/scala/src/main/scala/Find.scala
similarity index 67%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Find.scala
rename to src/scala/src/main/scala/Find.scala
index eb6534f..4335be7 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Find.scala
+++ b/src/scala/src/main/scala/Find.scala
@@ -22,8 +22,8 @@ object Find:
    * @return A list of documents from the given table
    * @throws DocumentException If query execution fails
    */
-  def all[TDoc](tableName: String, orderBy: Seq[Field[?]], conn: Connection)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Custom.list[TDoc](FindQuery.all(tableName) + QueryUtils.orderBy(orderBy.asJava), conn, Results.fromData)
+  def all[Doc](tableName: String, orderBy: Seq[Field[?]], conn: Connection)(using tag: ClassTag[Doc]): List[Doc] =
+    Custom.list[Doc](FindQuery.all(tableName) + QueryUtils.orderBy(orderBy.asJava), conn, Results.fromData)
 
   /**
    * Retrieve all documents in the given table, ordering results by the optional given fields
@@ -33,43 +33,43 @@ object Find:
    * @return A list of documents from the given table
    * @throws DocumentException If query execution fails
    */
-  def all[TDoc](tableName: String, conn: Connection)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    all[TDoc](tableName, List(), conn)
+  def all[Doc](tableName: String, conn: Connection)(using tag: ClassTag[Doc]): List[Doc] =
+    all[Doc](tableName, List(), conn)
     
   /**
    * Retrieve all documents in the given table (creates connection)
    *
    * @param tableName The table from which documents should be retrieved
-   * @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
    * @return A list of documents from the given table
    * @throws DocumentException If no connection string has been set, or if query execution fails
    */
-  def all[TDoc](tableName: String, orderBy: Seq[Field[?]] = List())(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Using(Configuration.dbConn()) { conn => all[TDoc](tableName, orderBy, conn) }.get
+  def all[Doc](tableName: String, orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
+    Using(Configuration.dbConn()) { conn => all[Doc](tableName, orderBy, conn) }.get
 
   /**
    * Retrieve a document by its ID
    *
    * @param tableName The table from which the document should be retrieved
-   * @param docId The ID of the document to retrieve
-   * @param conn The connection over which documents should be retrieved
+   * @param docId     The ID of the document to retrieve
+   * @param conn      The connection over which documents should be retrieved
    * @return An `Option` with the document if it is found
    * @throws DocumentException If no dialect has been configured
    */
-  def byId[TKey, TDoc](tableName: String, docId: TKey, conn: Connection)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Custom.single[TDoc](FindQuery.byId(tableName, docId),
+  def byId[Key, Doc](tableName: String, docId: Key, conn: Connection)(using tag: ClassTag[Doc]): Option[Doc] =
+    Custom.single[Doc](FindQuery.byId(tableName, docId),
       Parameters.addFields(Field.equal(Configuration.idField, docId, ":id") :: Nil).toSeq, conn, Results.fromData)
 
   /**
    * Retrieve a document by its ID (creates connection
    *
    * @param tableName The table from which the document should be retrieved
-   * @param docId The ID of the document to retrieve
+   * @param docId     The ID of the document to retrieve
    * @return An `Option` with the document if it is found
    * @throws DocumentException If no connection string has been set
    */
-  def byId[TKey, TDoc](tableName: String, docId: TKey)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Using(Configuration.dbConn()) { conn => byId[TKey, TDoc](tableName, docId, conn) }.get
+  def byId[Key, Doc](tableName: String, docId: Key)(using tag: ClassTag[Doc]): Option[Doc] =
+    Using(Configuration.dbConn()) { conn => byId[Key, Doc](tableName, docId, conn) }.get
 
   /**
    * Retrieve documents using a field comparison, ordering results by the given fields
@@ -82,10 +82,10 @@ object Find:
    * @return A list of documents matching the field comparison
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def byFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], orderBy: Seq[Field[?]],
-                     conn: Connection)(implicit tag: ClassTag[TDoc]): List[TDoc] =
+  def byFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], orderBy: Seq[Field[?]],
+                    conn: Connection)(using tag: ClassTag[Doc]): List[Doc] =
     val named = Parameters.nameFields(fields)
-    Custom.list[TDoc](
+    Custom.list[Doc](
       FindQuery.byFields(tableName, named.asJava, howMatched.orNull) + QueryUtils.orderBy(orderBy.asJava),
       Parameters.addFields(named).toSeq, conn, Results.fromData)
 
@@ -99,9 +99,9 @@ object Find:
    * @return A list of documents matching the field comparison
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def byFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], conn: Connection)
-                    (implicit tag: ClassTag[TDoc]): List[TDoc] =
-    byFields[TDoc](tableName, fields, howMatched, List(), conn)
+  def byFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], conn: Connection)
+                   (using tag: ClassTag[Doc]): List[Doc] =
+    byFields[Doc](tableName, fields, howMatched, List(), conn)
 
   /**
    * Retrieve documents using a field comparison, ordering results by the given fields
@@ -113,9 +113,9 @@ object Find:
    * @return A list of documents matching the field comparison
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def byFields[TDoc](tableName: String, fields: Seq[Field[?]], orderBy: Seq[Field[?]], conn: Connection)
-                    (implicit tag: ClassTag[TDoc]): List[TDoc] =
-    byFields[TDoc](tableName, fields, None, orderBy, conn)
+  def byFields[Doc](tableName: String, fields: Seq[Field[?]], orderBy: Seq[Field[?]], conn: Connection)
+                   (using tag: ClassTag[Doc]): List[Doc] =
+    byFields[Doc](tableName, fields, None, orderBy, conn)
 
   /**
    * Retrieve documents using a field comparison, ordering results by the given fields (creates connection)
@@ -127,9 +127,9 @@ object Find:
    * @return A list of documents matching the field comparison
    * @throws DocumentException If no connection string has been set, or if parameters are invalid
    */
-  def byFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
-                     orderBy: Seq[Field[?]] = List())(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Using(Configuration.dbConn()) { conn => byFields[TDoc](tableName, fields, howMatched, orderBy, conn) }.get
+  def byFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
+                    orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
+    Using(Configuration.dbConn()) { conn => byFields[Doc](tableName, fields, howMatched, orderBy, conn) }.get
 
   /**
    * Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only)
@@ -141,9 +141,9 @@ object Find:
    * @return A list of documents matching the JSON containment query
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TDoc, TContains](tableName: String, criteria: TContains, orderBy: Seq[Field[?]],
-                                  conn: Connection)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Custom.list[TDoc](FindQuery.byContains(tableName) + QueryUtils.orderBy(orderBy.asJava),
+  def byContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]], conn: Connection)
+                        (using tag: ClassTag[Doc]): List[Doc] =
+    Custom.list[Doc](FindQuery.byContains(tableName) + QueryUtils.orderBy(orderBy.asJava),
       Parameters.json(":criteria", criteria) :: Nil, conn, Results.fromData)
 
   /**
@@ -155,9 +155,8 @@ object Find:
    * @return A list of documents matching the JSON containment query
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TDoc, TContains](tableName: String, criteria: TContains, conn: Connection)
-                                 (implicit tag: ClassTag[TDoc]): List[TDoc] =
-    byContains[TDoc, TContains](tableName, criteria, List(), conn)
+  def byContains[Doc, A](tableName: String, criteria: A, conn: Connection)(using tag: ClassTag[Doc]): List[Doc] =
+    byContains[Doc, A](tableName, criteria, List(), conn)
 
   /**
    * Retrieve documents using a JSON containment query, ordering results by the given fields (PostgreSQL only; creates
@@ -169,9 +168,9 @@ object Find:
    * @return A list of documents matching the JSON containment query
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byContains[TDoc, TContains](tableName: String, criteria: TContains, orderBy: Seq[Field[?]] = List())
-                                 (implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Using(Configuration.dbConn()) { conn => byContains[TDoc, TContains](tableName, criteria, orderBy, conn) }.get
+  def byContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
+                        (using tag: ClassTag[Doc]): List[Doc] =
+    Using(Configuration.dbConn()) { conn => byContains[Doc, A](tableName, criteria, orderBy, conn) }.get
 
   /**
    * Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only)
@@ -183,9 +182,9 @@ object Find:
    * @return A list of documents matching the JSON Path match query
    * @throws DocumentException If called on a SQLite connection
    */
-  def byJsonPath[TDoc](tableName: String, path: String, orderBy: Seq[Field[?]], conn: Connection)
-                      (implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Custom.list[TDoc](FindQuery.byJsonPath(tableName) + QueryUtils.orderBy(orderBy.asJava),
+  def byJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]], conn: Connection)
+                     (using tag: ClassTag[Doc]): List[Doc] =
+    Custom.list[Doc](FindQuery.byJsonPath(tableName) + QueryUtils.orderBy(orderBy.asJava),
       Parameter(":path", ParameterType.STRING, path) :: Nil, conn, Results.fromData)
 
   /**
@@ -197,8 +196,8 @@ object Find:
    * @return A list of documents matching the JSON Path match query
    * @throws DocumentException If called on a SQLite connection
    */
-  def byJsonPath[TDoc](tableName: String, path: String, conn: Connection)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-    byJsonPath[TDoc](tableName, path, List(), conn)
+  def byJsonPath[Doc](tableName: String, path: String, conn: Connection)(using tag: ClassTag[Doc]): List[Doc] =
+    byJsonPath[Doc](tableName, path, List(), conn)
 
   /**
    * Retrieve documents using a JSON Path match query, ordering results by the given fields (PostgreSQL only; creates
@@ -210,9 +209,9 @@ object Find:
    * @return A list of documents matching the JSON Path match query
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byJsonPath[TDoc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
-                      (implicit tag: ClassTag[TDoc]): List[TDoc] =
-    Using(Configuration.dbConn()) { conn => byJsonPath[TDoc](tableName, path, orderBy, conn) }.get
+  def byJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
+                     (using tag: ClassTag[Doc]): List[Doc] =
+    Using(Configuration.dbConn()) { conn => byJsonPath[Doc](tableName, path, orderBy, conn) }.get
 
   /**
    * Retrieve the first document using a field comparison and ordering fields
@@ -225,10 +224,10 @@ object Find:
    * @return An `Option` with the first document matching the field comparison if found
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def firstByFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch],
-                          orderBy: Seq[Field[?]], conn: Connection)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
+  def firstByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch],
+                         orderBy: Seq[Field[?]], conn: Connection)(using tag: ClassTag[Doc]): Option[Doc] =
     val named = Parameters.nameFields(fields)
-    Custom.single[TDoc](
+    Custom.single[Doc](
       FindQuery.byFields(tableName, named.asJava, howMatched.orNull) + QueryUtils.orderBy(orderBy.asJava),
       Parameters.addFields(named).toSeq, conn, Results.fromData)
 
@@ -242,9 +241,9 @@ object Find:
    * @return An `Option` with the first document matching the field comparison if found
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def firstByFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], conn: Connection)
-                         (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    firstByFields[TDoc](tableName, fields, howMatched, List(), conn)
+  def firstByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch], conn: Connection)
+                        (using tag: ClassTag[Doc]): Option[Doc] =
+    firstByFields[Doc](tableName, fields, howMatched, List(), conn)
 
   /**
    * Retrieve the first document using a field comparison and ordering fields
@@ -256,9 +255,9 @@ object Find:
    * @return An `Option` with the first document matching the field comparison if found
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def firstByFields[TDoc](tableName: String, fields: Seq[Field[?]], orderBy: Seq[Field[?]], conn: Connection)
-                         (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    firstByFields[TDoc](tableName, fields, None, orderBy, conn)
+  def firstByFields[Doc](tableName: String, fields: Seq[Field[?]], orderBy: Seq[Field[?]], conn: Connection)
+                        (using tag: ClassTag[Doc]): Option[Doc] =
+    firstByFields[Doc](tableName, fields, None, orderBy, conn)
 
   /**
    * Retrieve the first document using a field comparison
@@ -269,9 +268,9 @@ object Find:
    * @return An `Option` with the first document matching the field comparison if found
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def firstByFields[TDoc](tableName: String, fields: Seq[Field[?]], conn: Connection)
-                         (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    firstByFields[TDoc](tableName, fields, None, List(), conn)
+  def firstByFields[Doc](tableName: String, fields: Seq[Field[?]], conn: Connection)
+                        (using tag: ClassTag[Doc]): Option[Doc] =
+    firstByFields[Doc](tableName, fields, None, List(), conn)
 
   /**
    * Retrieve the first document using a field comparison and optional ordering fields (creates connection)
@@ -283,9 +282,9 @@ object Find:
    * @return An `Option` with the first document matching the field comparison if found
    * @throws DocumentException If no connection string has been set, or if parameters are invalid
    */
-  def firstByFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
-                          orderBy: Seq[Field[?]] = List())(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Using(Configuration.dbConn()) { conn => firstByFields[TDoc](tableName, fields, howMatched, orderBy, conn) }.get
+  def firstByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
+                         orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): Option[Doc] =
+    Using(Configuration.dbConn()) { conn => firstByFields[Doc](tableName, fields, howMatched, orderBy, conn) }.get
 
   /**
    * Retrieve the first document using a JSON containment query and ordering fields (PostgreSQL only)
@@ -297,9 +296,9 @@ object Find:
    * @return An `Option` with the first document matching the JSON containment query if found
    * @throws DocumentException If called on a SQLite connection
    */
-  def firstByContains[TDoc, TContains](tableName: String, criteria: TContains, orderBy: Seq[Field[?]],
-                                       conn: Connection)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Custom.single[TDoc](FindQuery.byContains(tableName) + QueryUtils.orderBy(orderBy.asJava),
+  def firstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]], conn: Connection)
+                             (using tag: ClassTag[Doc]): Option[Doc] =
+    Custom.single[Doc](FindQuery.byContains(tableName) + QueryUtils.orderBy(orderBy.asJava),
       Parameters.json(":criteria", criteria) :: Nil, conn, Results.fromData)
 
   /**
@@ -311,9 +310,8 @@ object Find:
    * @return An `Option` with the first document matching the JSON containment query if found
    * @throws DocumentException If called on a SQLite connection
    */
-  def firstByContains[TDoc, TContains](tableName: String, criteria: TContains, conn: Connection)
-                                      (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    firstByContains[TDoc, TContains](tableName, criteria, List(), conn)
+  def firstByContains[Doc, A](tableName: String, criteria: A, conn: Connection)(using tag: ClassTag[Doc]): Option[Doc] =
+    firstByContains[Doc, A](tableName, criteria, List(), conn)
 
   /**
    * Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only; creates
@@ -325,23 +323,23 @@ object Find:
    * @return An `Option` with the first document matching the JSON containment query if found
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def firstByContains[TDoc, TContains](tableName: String, criteria: TContains, orderBy: Seq[Field[?]] = List())
-                                      (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Using(Configuration.dbConn()) { conn => firstByContains[TDoc, TContains](tableName, criteria, orderBy, conn) }.get
+  def firstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
+                             (using tag: ClassTag[Doc]): Option[Doc] =
+    Using(Configuration.dbConn()) { conn => firstByContains[Doc, A](tableName, criteria, orderBy, conn) }.get
 
   /**
    * Retrieve the first document using a JSON Path match query and ordering fields (PostgreSQL only)
    *
    * @param tableName The table from which documents should be retrieved
-   * @param path The JSON path comparison to match
-   * @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
-   * @param conn The connection over which documents should be retrieved
+   * @param path      The JSON path comparison to match
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @param conn      The connection over which documents should be retrieved
    * @return An `Optional` item, with the first document matching the JSON Path match query if found
    * @throws DocumentException If called on a SQLite connection
    */
-  def firstByJsonPath[TDoc](tableName: String, path: String, orderBy: Seq[Field[?]], conn: Connection)
-                           (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Custom.single[TDoc](FindQuery.byJsonPath(tableName) + QueryUtils.orderBy(orderBy.asJava),
+  def firstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]], conn: Connection)
+                          (using tag: ClassTag[Doc]): Option[Doc] =
+    Custom.single[Doc](FindQuery.byJsonPath(tableName) + QueryUtils.orderBy(orderBy.asJava),
       Parameter(":path", ParameterType.STRING, path) :: Nil, conn, Results.fromData)
 
   /**
@@ -353,20 +351,19 @@ object Find:
    * @return An `Option` with the first document matching the JSON Path match query if found
    * @throws DocumentException If called on a SQLite connection
    */
-  def firstByJsonPath[TDoc](tableName: String, path: String, conn: Connection)
-                           (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    firstByJsonPath[TDoc](tableName, path, List(), conn)
+  def firstByJsonPath[Doc](tableName: String, path: String, conn: Connection)(using tag: ClassTag[Doc]): Option[Doc] =
+    firstByJsonPath[Doc](tableName, path, List(), conn)
 
   /**
    * Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only; creates
    * connection)
    *
    * @param tableName The table from which documents should be retrieved
-   * @param path The JSON path comparison to match
-   * @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @param path      The JSON path comparison to match
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
    * @return An `Optional` item, with the first document matching the JSON Path match query if found
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def firstByJsonPath[TDoc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
-                           (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-    Using(Configuration.dbConn()) { conn => firstByJsonPath[TDoc](tableName, path, orderBy, conn) }.get
+  def firstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
+                          (using tag: ClassTag[Doc]): Option[Doc] =
+    Using(Configuration.dbConn()) { conn => firstByJsonPath[Doc](tableName, path, orderBy, conn) }.get
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Parameters.scala b/src/scala/src/main/scala/Parameters.scala
similarity index 90%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Parameters.scala
rename to src/scala/src/main/scala/Parameters.scala
index 02b2d5d..2499863 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Parameters.scala
+++ b/src/scala/src/main/scala/Parameters.scala
@@ -38,13 +38,13 @@ object Parameters:
    * @param value The object to be encoded as JSON
    * @return A parameter with the value encoded
    */
-  def json[T](name: String, value: T): Parameter[String] =
+  def json[A](name: String, value: A): Parameter[String] =
     CoreParameters.json(name, value)
 
   /**
    * Add field parameters to the given set of parameters
    *
-   * @param fields The fields being compared in the query
+   * @param fields   The fields being compared in the query
    * @param existing Any existing parameters for the query (optional, defaults to empty collection)
    * @return A collection of parameters for the query
    */
@@ -56,7 +56,7 @@ object Parameters:
   /**
    * Replace the parameter names in the query with question marks
    *
-   * @param query The query with named placeholders
+   * @param query      The query with named placeholders
    * @param parameters The parameters for the query
    * @return The query, with name parameters changed to `?`s
    */
@@ -66,8 +66,8 @@ object Parameters:
   /**
    * Apply the given parameters to the given query, returning a prepared statement
    *
-   * @param conn The active JDBC connection
-   * @param query The query
+   * @param conn       The active JDBC connection
+   * @param query      The query
    * @param parameters The parameters for the query
    * @return A `PreparedStatement` with the parameter names replaced with `?` and parameter values bound
    * @throws DocumentException If parameter names are invalid or number value types are invalid
@@ -78,7 +78,7 @@ object Parameters:
   /**
    * Create parameters for field names to be removed from a document
    *
-   * @param names The names of the fields to be removed
+   * @param names         The names of the fields to be removed
    * @param parameterName The parameter name to use for the query
    * @return A list of parameters to use for building the query
    * @throws DocumentException If the dialect has not been set
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Patch.scala b/src/scala/src/main/scala/Patch.scala
similarity index 83%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Patch.scala
rename to src/scala/src/main/scala/Patch.scala
index b53bb83..e90e150 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Patch.scala
+++ b/src/scala/src/main/scala/Patch.scala
@@ -20,7 +20,7 @@ object Patch:
    * @param conn      The connection on which the update should be executed
    * @throws DocumentException If no dialect has been configured
    */
-  def byId[TKey, TPatch](tableName: String, docId: TKey, patch: TPatch, conn: Connection): Unit =
+  def byId[Key, Patch](tableName: String, docId: Key, patch: Patch, conn: Connection): Unit =
     CorePatch.byId(tableName, docId, patch, conn)
 
   /**
@@ -31,7 +31,7 @@ object Patch:
    * @param patch     The object whose properties should be replaced in the document
    * @throws DocumentException If no connection string has been set
    */
-  def byId[TKey, TPatch](tableName: String, docId: TKey, patch: TPatch) =
+  def byId[Key, Patch](tableName: String, docId: Key, patch: Patch): Unit =
     CorePatch.byId(tableName, docId, patch)
 
   /**
@@ -44,8 +44,8 @@ object Patch:
    * @param conn       The connection on which the update should be executed
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def byFields[TPatch](tableName: String, fields: Seq[Field[?]], patch: TPatch, howMatched: Option[FieldMatch],
-                       conn: Connection): Unit =
+  def byFields[Patch](tableName: String, fields: Seq[Field[?]], patch: Patch, howMatched: Option[FieldMatch],
+                  conn: Connection): Unit =
     CorePatch.byFields(tableName, fields.asJava, patch, howMatched.orNull, conn)
 
   /**
@@ -57,7 +57,7 @@ object Patch:
    * @param conn      The connection on which the update should be executed
    * @throws DocumentException If no dialect has been configured, or if parameters are invalid
    */
-  def byFields[TPatch](tableName: String, fields: Seq[Field[?]], patch: TPatch, conn: Connection): Unit =
+  def byFields[Patch](tableName: String, fields: Seq[Field[?]], patch: Patch, conn: Connection): Unit =
     byFields(tableName, fields, patch, None, conn)
 
   /**
@@ -69,8 +69,8 @@ object Patch:
    * @param howMatched How the fields should be matched
    * @throws DocumentException If no connection string has been set, or if parameters are invalid
    */
-  def byFields[TPatch](tableName: String, fields: Seq[Field[?]], patch: TPatch,
-                       howMatched: Option[FieldMatch] = None): Unit =
+  def byFields[Patch](tableName: String, fields: Seq[Field[?]], patch: Patch,
+                      howMatched: Option[FieldMatch] = None): Unit =
     CorePatch.byFields(tableName, fields.asJava, patch, howMatched.orNull)
 
   /**
@@ -82,7 +82,7 @@ object Patch:
    * @param conn      The connection on which the update should be executed
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TContains, TPatch](tableName: String, criteria: TContains, patch: TPatch, conn: Connection): Unit =
+  def byContains[A, Patch](tableName: String, criteria: A, patch: Patch, conn: Connection): Unit =
     CorePatch.byContains(tableName, criteria, patch, conn)
 
   /**
@@ -93,7 +93,7 @@ object Patch:
    * @param patch     The object whose properties should be replaced in the document
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byContains[TContains, TPatch](tableName: String, criteria: TContains, patch: TPatch): Unit =
+  def byContains[A, Patch](tableName: String, criteria: A, patch: Patch): Unit =
     CorePatch.byContains(tableName, criteria, patch)
 
   /**
@@ -105,7 +105,7 @@ object Patch:
    * @param conn      The connection on which the update should be executed
    * @throws DocumentException If called on a SQLite connection
    */
-  def byJsonPath[TPatch](tableName: String, path: String, patch: TPatch, conn: Connection): Unit =
+  def byJsonPath[Patch](tableName: String, path: String, patch: Patch, conn: Connection): Unit =
     CorePatch.byJsonPath(tableName, path, patch, conn)
 
   /**
@@ -116,5 +116,5 @@ object Patch:
    * @param patch     The object whose properties should be replaced in the document
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byJsonPath[TPatch](tableName: String, path: String, patch: TPatch): Unit =
+  def byJsonPath[Patch](tableName: String, path: String, patch: Patch): Unit =
     CorePatch.byJsonPath(tableName, path, patch)
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/RemoveFields.scala b/src/scala/src/main/scala/RemoveFields.scala
similarity index 93%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/RemoveFields.scala
rename to src/scala/src/main/scala/RemoveFields.scala
index 2701553..a605b7f 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/RemoveFields.scala
+++ b/src/scala/src/main/scala/RemoveFields.scala
@@ -20,7 +20,7 @@ object RemoveFields:
    * @param conn      The connection on which the update should be executed
    * @throws DocumentException If no dialect has been configured
    */
-  def byId[TKey](tableName: String, docId: TKey, toRemove: Seq[String], conn: Connection): Unit =
+  def byId[Key](tableName: String, docId: Key, toRemove: Seq[String], conn: Connection): Unit =
     CoreRemoveFields.byId(tableName, docId, toRemove.asJava, conn)
 
   /**
@@ -31,7 +31,7 @@ object RemoveFields:
    * @param toRemove  The names of the fields to be removed
    * @throws DocumentException If no connection string has been set
    */
-  def byId[TKey](tableName: String, docId: TKey, toRemove: Seq[String]): Unit =
+  def byId[Key](tableName: String, docId: Key, toRemove: Seq[String]): Unit =
     CoreRemoveFields.byId(tableName, docId, toRemove.asJava)
 
   /**
@@ -82,7 +82,7 @@ object RemoveFields:
    * @param conn      The connection on which the update should be executed
    * @throws DocumentException If called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains, toRemove: Seq[String], conn: Connection): Unit =
+  def byContains[A](tableName: String, criteria: A, toRemove: Seq[String], conn: Connection): Unit =
     CoreRemoveFields.byContains(tableName, criteria, toRemove.asJava, conn)
 
   /**
@@ -93,7 +93,7 @@ object RemoveFields:
    * @param toRemove  The names of the fields to be removed
    * @throws DocumentException If no connection string has been set, or if called on a SQLite connection
    */
-  def byContains[TContains](tableName: String, criteria: TContains, toRemove: Seq[String]): Unit =
+  def byContains[A](tableName: String, criteria: A, toRemove: Seq[String]): Unit =
     CoreRemoveFields.byContains(tableName, criteria, toRemove.asJava)
 
   /**
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Results.scala b/src/scala/src/main/scala/Results.scala
similarity index 82%
rename from src/scala/src/main/scala/solutions/bitbadger/documents/scala/Results.scala
rename to src/scala/src/main/scala/Results.scala
index bab76e4..18de0c1 100644
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/Results.scala
+++ b/src/scala/src/main/scala/Results.scala
@@ -21,8 +21,8 @@ object Results:
    * @param ignored The class tag (placeholder used for signature; implicit tag used for serialization)
    * @return The constructed domain item
    */
-  def fromDocument[TDoc](field: String, rs: ResultSet, ignored: ClassTag[TDoc])(implicit tag: ClassTag[TDoc]): TDoc =
-    CoreResults.fromDocument(field, rs, tag.runtimeClass.asInstanceOf[Class[TDoc]])
+  def fromDocument[Doc](field: String, rs: ResultSet, ignored: ClassTag[Doc])(using tag: ClassTag[Doc]): Doc =
+    CoreResults.fromDocument(field, rs, tag.runtimeClass.asInstanceOf[Class[Doc]])
 
   /**
    * Create a domain item from a document
@@ -31,21 +31,21 @@ object Results:
    * @param ignored The class tag (placeholder used for signature; implicit tag used for serialization)
    * @return The constructed domain item
    */
-  def fromData[TDoc](rs: ResultSet, ignored: ClassTag[TDoc])(implicit tag: ClassTag[TDoc]): TDoc =
-    fromDocument[TDoc]("data", rs, tag)
+  def fromData[Doc](rs: ResultSet, ignored: ClassTag[Doc])(using tag: ClassTag[Doc]): Doc =
+    fromDocument[Doc]("data", rs, tag)
 
   /**
    * Create a list of items for the results of the given command, using the specified mapping function
    *
-   * @param stmt The prepared statement to execute
+   * @param stmt    The prepared statement to execute
    * @param mapFunc The mapping function from data reader to domain class instance
    * @return A list of items from the query's result
    * @throws DocumentException If there is a problem executing the query (unchecked)
    */
-  def toCustomList[TDoc](stmt: PreparedStatement,
-                         mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
+  def toCustomList[Doc](stmt: PreparedStatement,mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                       (using tag: ClassTag[Doc]): List[Doc] =
     try
-      val buffer = ListBuffer[TDoc]()
+      val buffer = ListBuffer[Doc]()
       Using(stmt.executeQuery()) { rs =>
         while (rs.next()) {
           buffer.append(mapFunc(rs, tag))
diff --git a/src/scala/src/main/scala/extensions/package.scala b/src/scala/src/main/scala/extensions/package.scala
new file mode 100644
index 0000000..c7c4dd6
--- /dev/null
+++ b/src/scala/src/main/scala/extensions/package.scala
@@ -0,0 +1,497 @@
+package solutions.bitbadger.documents.scala.extensions
+
+import solutions.bitbadger.documents.{DocumentIndex, Field, FieldMatch, Parameter}
+import solutions.bitbadger.documents.scala.*
+
+import java.sql.{Connection, ResultSet}
+import scala.reflect.ClassTag
+
+extension (conn: Connection)
+
+  // ~~~ CUSTOM QUERIES ~~~
+
+  /**
+   * Execute a query that returns a list of results
+   *
+   * @param query      The query to retrieve the results
+   * @param parameters Parameters to use for the query
+   * @param mapFunc    The mapping function between the document and the domain item
+   * @return A list of results for the given query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customList[Doc](query: String, parameters: Seq[Parameter[?]], mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                     (using tag: ClassTag[Doc]): List[Doc] =
+    Custom.list[Doc](query, parameters, conn, mapFunc)
+
+  /**
+   * Execute a query that returns a list of results
+   *
+   * @param query   The query to retrieve the results
+   * @param mapFunc The mapping function between the document and the domain item
+   * @return A list of results for the given query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customList[Doc](query: String, mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                     (using tag: ClassTag[Doc]): List[Doc] =
+    Custom.list[Doc](query, conn, mapFunc)
+
+  /**
+   * Execute a query that returns one or no results
+   *
+   * @param query      The query to retrieve the results
+   * @param parameters Parameters to use for the query
+   * @param mapFunc    The mapping function between the document and the domain item
+   * @return An optional document, filled if one matches the query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customSingle[Doc](query: String, parameters: Seq[Parameter[?]], mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                       (using tag: ClassTag[Doc]): Option[Doc] =
+    Custom.single[Doc](query, parameters, conn, mapFunc)
+
+  /**
+   * Execute a query that returns one or no results
+   *
+   * @param query   The query to retrieve the results
+   * @param mapFunc The mapping function between the document and the domain item
+   * @return An optional document, filled if one matches the query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customSingle[Doc](query: String, mapFunc: (ResultSet, ClassTag[Doc]) => Doc)
+                       (using tag: ClassTag[Doc]): Option[Doc] =
+    Custom.single[Doc](query, conn, mapFunc)
+
+  /**
+   * Execute a query that returns no results
+   *
+   * @param query      The query to retrieve the results
+   * @param parameters Parameters to use for the query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customNonQuery(query: String, parameters: Seq[Parameter[?]] = List()): Unit =
+    Custom.nonQuery(query, parameters, conn)
+
+  /**
+   * Execute a query that returns a scalar result
+   *
+   * @param query      The query to retrieve the result
+   * @param parameters Parameters to use for the query
+   * @param mapFunc    The mapping function between the document and the domain item
+   * @return The scalar value from the query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customScalar[A](query: String, parameters: Seq[Parameter[?]], mapFunc: (ResultSet, ClassTag[A]) => A)
+                     (using tag: ClassTag[A]): A =
+    Custom.scalar[A](query, parameters, conn, mapFunc)
+
+  /**
+   * Execute a query that returns a scalar result
+   *
+   * @param query   The query to retrieve the result
+   * @param mapFunc The mapping function between the document and the domain item
+   * @return The scalar value from the query
+   * @throws DocumentException If parameters are invalid
+   */
+  def customScalar[A](query: String, mapFunc: (ResultSet, ClassTag[A]) => A)(using tag: ClassTag[A]): A =
+    Custom.scalar[A](query, conn, mapFunc)
+
+  // ~~~ DEFINITION QUERIES ~~~
+
+  /**
+   * Create a document table if necessary
+   *
+   * @param tableName The table whose existence should be ensured (may include schema)
+   * @throws DocumentException If the dialect is not configured
+   */
+  def ensureTable(tableName: String): Unit =
+    Definition.ensureTable(tableName, conn)
+
+  /**
+   * Create an index on field(s) within documents in the specified table if necessary
+   *
+   * @param tableName The table to be indexed (may include schema)
+   * @param indexName The name of the index to create
+   * @param fields    One or more fields to be indexed<
+   * @throws DocumentException If any dependent process does
+   */
+  def ensureFieldIndex(tableName: String, indexName: String, fields: Seq[String]): Unit =
+    Definition.ensureFieldIndex(tableName, indexName, fields, conn)
+
+  /**
+   * Create a document index on a table (PostgreSQL only)
+   *
+   * @param tableName The table to be indexed (may include schema)
+   * @param indexType The type of index to ensure
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def ensureDocumentIndex(tableName: String, indexType: DocumentIndex): Unit =
+    Definition.ensureDocumentIndex (tableName, indexType, conn)
+
+  // ~~~ DOCUMENT MANIPULATION QUERIES ~~~
+
+  /**
+   * Insert a new document
+   *
+   * @param tableName The table into which the document should be inserted (may include schema)
+   * @param document  The document to be inserted
+   * @throws DocumentException If IDs are misconfigured, or if the database command fails
+   */
+  def insert[Doc](tableName: String, document: Doc): Unit =
+    Document.insert(tableName, document, conn)
+
+  /**
+   * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
+   *
+   * @param tableName The table in which the document should be saved (may include schema)
+   * @param document  The document to be saved
+   * @throws DocumentException If the database command fails
+   */
+  def save[Doc](tableName: String, document: Doc): Unit =
+    Document.save(tableName, document, conn)
+
+  /**
+   * Update (replace) a document by its ID
+   *
+   * @param tableName The table in which the document should be replaced (may include schema)
+   * @param docId     The ID of the document to be replaced
+   * @param document  The document to be replaced
+   * @throws DocumentException If no dialect has been configured, or if the database command fails
+   */
+  def update[Key, Doc](tableName: String, docId: Key, document: Doc): Unit =
+    Document.update(tableName, docId, document, conn)
+
+  // ~~~ DOCUMENT COUNT QUERIES ~~~
+
+  /**
+   * Count all documents in the table
+   *
+   * @param tableName The name of the table in which documents should be counted
+   * @return A count of the documents in the table
+   * @throws DocumentException If any dependent process does
+   */
+  def countAll(tableName: String): Long =
+    Count.all(tableName, conn)
+
+  /**
+   * Count documents using a field comparison
+   *
+   * @param tableName  The name of the table in which documents should be counted
+   * @param fields     The fields which should be compared
+   * @param howMatched How the fields should be matched (optional, default `ALL`)
+   * @return A count of the matching documents in the table
+   * @throws DocumentException If the dialect has not been configured
+   */
+  def countByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None): Long =
+    Count.byFields(tableName, fields, howMatched, conn)
+
+  /**
+   * Count documents using a JSON containment query (PostgreSQL only)
+   *
+   * @param tableName The name of the table in which documents should be counted
+   * @param criteria  The object for which JSON containment should be checked
+   * @return A count of the matching documents in the table
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def countByContains[A](tableName: String, criteria: A): Long =
+    Count.byContains(tableName, criteria, conn)
+
+  /**
+   * Count documents using a JSON Path match query (PostgreSQL only)
+   *
+   * @param tableName The name of the table in which documents should be counted
+   * @param path      The JSON path comparison to match
+   * @return A count of the matching documents in the table
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def countByJsonPath(tableName: String, path: String): Long =
+    Count.byJsonPath(tableName, path, conn)
+
+  // ~~~ DOCUMENT EXISTENCE QUERIES ~~~
+
+  /**
+   * Determine a document's existence by its ID
+   *
+   * @param tableName The name of the table in which document existence should be checked
+   * @param docId     The ID of the document to be checked
+   * @return True if the document exists, false if not
+   * @throws DocumentException If no dialect has been configured
+   */
+  def existsById[Key](tableName: String, docId: Key): Boolean =
+    Exists.byId(tableName, docId, conn)
+
+  /**
+   * Determine document existence using a field comparison
+   *
+   * @param tableName  The name of the table in which document existence should be checked
+   * @param fields     The fields which should be compared
+   * @param howMatched How the fields should be matched
+   * @return True if any matching documents exist, false if not
+   * @throws DocumentException If no dialect has been configured, or if parameters are invalid
+   */
+  def existsByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None): Boolean =
+    Exists.byFields(tableName, fields, howMatched, conn)
+
+  /**
+   * Determine document existence using a JSON containment query (PostgreSQL only)
+   *
+   * @param tableName The name of the table in which document existence should be checked
+   * @param criteria  The object for which JSON containment should be checked
+   * @return True if any matching documents exist, false if not
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def existsByContains[A](tableName: String, criteria: A): Boolean =
+    Exists.byContains(tableName, criteria, conn)
+
+  /**
+   * Determine document existence using a JSON Path match query (PostgreSQL only)
+   *
+   * @param tableName The name of the table in which document existence should be checked
+   * @param path      The JSON path comparison to match
+   * @return True if any matching documents exist, false if not
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def existsByJsonPath(tableName: String, path: String): Boolean =
+    Exists.byJsonPath(tableName, path, conn)
+
+  // ~~~ DOCUMENT RETRIEVAL QUERIES ~~~
+
+  /**
+   * Retrieve all documents in the given table, ordering results by the optional given fields
+   *
+   * @param tableName The table from which documents should be retrieved
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return A list of documents from the given table
+   * @throws DocumentException If query execution fails
+   */
+  def findAll[Doc](tableName: String, orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
+    Find.all[Doc](tableName, orderBy, conn)
+
+  /**
+   * Retrieve a document by its ID
+   *
+   * @param tableName The table from which the document should be retrieved
+   * @param docId     The ID of the document to retrieve
+   * @return The document if it is found, `None` otherwise
+   * @throws DocumentException If no dialect has been configured
+   */
+  def findById[Key, Doc](tableName: String, docId: Key)(using tag: ClassTag[Doc]): Option[Doc] =
+    Find.byId[Key, Doc](tableName, docId, conn)
+
+  /**
+   * Retrieve documents using a field comparison, ordering results by the optional given fields
+   *
+   * @param tableName  The table from which the document should be retrieved
+   * @param fields     The fields which should be compared
+   * @param howMatched How the fields should be matched
+   * @param orderBy    Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return A list of documents matching the field comparison
+   * @throws DocumentException If no dialect has been configured, or if parameters are invalid
+   */
+  def findByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
+                        orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): List[Doc] =
+    Find.byFields[Doc](tableName, fields, howMatched, orderBy, conn)
+
+  /**
+   * Retrieve documents using a JSON containment query, ordering results by the optional given fields (PostgreSQL
+   * only)
+   *
+   * @param tableName The name of the table in which document existence should be checked
+   * @param criteria  The object for which JSON containment should be checked
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return A list of documents matching the JSON containment query
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def findByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
+                            (using tag: ClassTag[Doc]): List[Doc] =
+    Find.byContains[Doc, A](tableName, criteria, orderBy, conn)
+
+  /**
+   * Retrieve documents using a JSON Path match query, ordering results by the optional given fields (PostgreSQL only)
+   *
+   * @param tableName The table from which documents should be retrieved
+   * @param path      The JSON path comparison to match
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return A list of documents matching the JSON Path match query
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def findByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
+                         (using tag: ClassTag[Doc]): List[Doc] =
+    Find.byJsonPath[Doc](tableName, path, orderBy, conn)
+
+  /**
+   * Retrieve the first document using a field comparison and optional ordering fields
+   *
+   * @param tableName  The table from which documents should be retrieved
+   * @param fields     The fields which should be compared
+   * @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
+   * @param orderBy    Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return The first document matching the field comparison, or `None` if no matches are found
+   * @throws DocumentException If no dialect has been configured, or if parameters are invalid
+   */
+  def findFirstByFields[Doc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
+                             orderBy: Seq[Field[?]] = List())(using tag: ClassTag[Doc]): Option[Doc] =
+    Find.firstByFields[Doc](tableName, fields, howMatched, orderBy, conn)
+
+  /**
+   * Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only)
+   *
+   * @param tableName The table from which documents should be retrieved
+   * @param criteria  The object for which JSON containment should be checked
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return The first document matching the JSON containment query, or `None` if no matches are found
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def findFirstByContains[Doc, A](tableName: String, criteria: A, orderBy: Seq[Field[?]] = List())
+                                 (using tag: ClassTag[Doc]): Option[Doc] =
+    Find.firstByContains[Doc, A](tableName, criteria, orderBy, conn)
+
+  /**
+   * Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only)
+   *
+   * @param tableName The table from which documents should be retrieved
+   * @param path      The JSON path comparison to match
+   * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
+   * @return The first document matching the JSON Path match query, or `None` if no matches are found
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def findFirstByJsonPath[Doc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
+                              (using tag: ClassTag[Doc]): Option[Doc] =
+    Find.firstByJsonPath[Doc](tableName, path, orderBy, conn)
+
+  // ~~~ DOCUMENT PATCH (PARTIAL UPDATE) QUERIES ~~~
+
+  /**
+   * Patch a document by its ID
+   *
+   * @param tableName The name of the table in which a document should be patched
+   * @param docId     The ID of the document to be patched
+   * @param patch     The object whose properties should be replaced in the document
+   * @throws DocumentException If no dialect has been configured
+   */
+  def patchById[Key, Patch](tableName: String, docId: Key, patch: Patch): Unit =
+    Patch.byId(tableName, docId, patch, conn)
+
+  /**
+   * Patch documents using a field comparison
+   *
+   * @param tableName  The name of the table in which documents should be patched
+   * @param fields     The fields which should be compared
+   * @param patch      The object whose properties should be replaced in the document
+   * @param howMatched How the fields should be matched
+   * @throws DocumentException If no dialect has been configured, or if parameters are invalid
+   */
+  def patchByFields[Patch](tableName: String, fields: Seq[Field[?]], patch: Patch,
+                           howMatched: Option[FieldMatch] = None): Unit =
+    Patch.byFields(tableName, fields, patch, howMatched, conn)
+
+  /**
+  * Patch documents using a JSON containment query (PostgreSQL only)
+  *
+  * @param tableName The name of the table in which documents should be patched
+  * @param criteria  The object against which JSON containment should be checked
+  * @param patch     The object whose properties should be replaced in the document
+  * @throws DocumentException If called on a SQLite connection
+  */
+  def patchByContains[A, Patch](tableName: String, criteria: A, patch: Patch): Unit =
+    Patch.byContains(tableName, criteria, patch, conn)
+
+  /**
+   * Patch documents using a JSON Path match query (PostgreSQL only)
+   *
+   * @param tableName The name of the table in which documents should be patched
+   * @param path The JSON path comparison to match
+   * @param patch The object whose properties should be replaced in the document
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def patchByJsonPath[Patch](tableName: String, path: String, patch: Patch): Unit =
+    Patch.byJsonPath(tableName, path, patch, conn)
+
+  // ~~~ DOCUMENT FIELD REMOVAL QUERIES ~~~
+
+  /**
+   * Remove fields from a document by its ID
+   *
+   * @param tableName The name of the table in which the document's fields should be removed
+   * @param docId     The ID of the document to have fields removed
+   * @param toRemove  The names of the fields to be removed
+   * @throws DocumentException If no dialect has been configured
+   */
+  def removeFieldsById[Key](tableName: String, docId: Key, toRemove: Seq[String]): Unit =
+    RemoveFields.byId(tableName, docId, toRemove, conn)
+
+  /**
+   * Remove fields from documents using a field comparison
+   *
+   * @param tableName  The name of the table in which document fields should be removed
+   * @param fields     The fields which should be compared
+   * @param toRemove   The names of the fields to be removed
+   * @param howMatched How the fields should be matched
+   * @throws DocumentException If no dialect has been configured, or if parameters are invalid
+   */
+  def removeFieldsByFields(tableName: String, fields: Seq[Field[?]], toRemove: Seq[String],
+                           howMatched: Option[FieldMatch] = None): Unit =
+    RemoveFields.byFields(tableName, fields, toRemove, howMatched, conn)
+
+  /**
+   * Remove fields from documents using a JSON containment query (PostgreSQL only)
+   *
+   * @param tableName The name of the table in which document fields should be removed
+   * @param criteria  The object against which JSON containment should be checked
+   * @param toRemove  The names of the fields to be removed
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def removeFieldsByContains[A](tableName: String, criteria: A, toRemove: Seq[String]): Unit =
+    RemoveFields.byContains(tableName, criteria, toRemove, conn)
+
+  /**
+  * Remove fields from documents using a JSON Path match query (PostgreSQL only)
+  *
+  * @param tableName The name of the table in which document fields should be removed
+  * @param path      The JSON path comparison to match
+  * @param toRemove  The names of the fields to be removed
+  * @throws DocumentException If called on a SQLite connection
+  */
+  def removeFieldsByJsonPath(tableName: String, path: String, toRemove: Seq[String]): Unit =
+    RemoveFields.byJsonPath(tableName, path, toRemove, conn)
+
+  // ~~~ DOCUMENT DELETION QUERIES ~~~
+
+  /**
+   * Delete a document by its ID
+   *
+   * @param tableName The name of the table from which documents should be deleted
+   * @param docId     The ID of the document to be deleted
+   * @throws DocumentException If no dialect has been configured
+   */
+  def deleteById[Key](tableName: String, docId: Key): Unit =
+    Delete.byId(tableName, docId, conn)
+
+  /**
+   * Delete documents using a field comparison
+   *
+   * @param tableName  The name of the table from which documents should be deleted
+   * @param fields     The fields which should be compared
+   * @param howMatched How the fields should be matched
+   * @throws DocumentException If no dialect has been configured, or if parameters are invalid
+   */
+  def deleteByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None): Unit =
+    Delete.byFields(tableName, fields, howMatched, conn)
+
+  /**
+   * Delete documents using a JSON containment query (PostgreSQL only)
+   *
+   * @param tableName The name of the table from which documents should be deleted
+   * @param criteria  The object for which JSON containment should be checked
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def deleteByContains[A](tableName: String, criteria: A): Unit =
+    Delete.byContains(tableName, criteria, conn)
+
+  /**
+   * Delete documents using a JSON Path match query (PostgreSQL only)
+   *
+   * @param tableName The name of the table from which documents should be deleted
+   * @param path      The JSON path comparison to match
+   * @throws DocumentException If called on a SQLite connection
+   */
+  def deleteByJsonPath(tableName: String, path: String): Unit =
+    Delete.byJsonPath(tableName, path, conn)
diff --git a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/extensions/package.scala b/src/scala/src/main/scala/solutions/bitbadger/documents/scala/extensions/package.scala
deleted file mode 100644
index 142fd26..0000000
--- a/src/scala/src/main/scala/solutions/bitbadger/documents/scala/extensions/package.scala
+++ /dev/null
@@ -1,499 +0,0 @@
-package solutions.bitbadger.documents.scala
-
-import solutions.bitbadger.documents.{DocumentIndex, Field, FieldMatch, Parameter}
-
-import java.sql.{Connection, ResultSet}
-import scala.reflect.ClassTag
-
-package object extensions:
-
-  extension (conn: Connection)
-
-    // ~~~ CUSTOM QUERIES ~~~
-
-    /**
-     * Execute a query that returns a list of results
-     *
-     * @param query      The query to retrieve the results
-     * @param parameters Parameters to use for the query
-     * @param mapFunc    The mapping function between the document and the domain item
-     * @return A list of results for the given query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customList[TDoc](query: String, parameters: Seq[Parameter[?]],
-                         mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-      Custom.list[TDoc](query, parameters, conn, mapFunc)
-
-    /**
-     * Execute a query that returns a list of results
-     *
-     * @param query   The query to retrieve the results
-     * @param mapFunc The mapping function between the document and the domain item
-     * @return A list of results for the given query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customList[TDoc](query: String,
-                         mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): List[TDoc] =
-      Custom.list[TDoc](query, conn, mapFunc)
-
-    /**
-     * Execute a query that returns one or no results
-     *
-     * @param query      The query to retrieve the results
-     * @param parameters Parameters to use for the query
-     * @param mapFunc    The mapping function between the document and the domain item
-     * @return An optional document, filled if one matches the query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customSingle[TDoc](query: String, parameters: Seq[Parameter[?]],
-                           mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-      Custom.single[TDoc](query, parameters, conn, mapFunc)
-
-    /**
-     * Execute a query that returns one or no results
-     *
-     * @param query   The query to retrieve the results
-     * @param mapFunc The mapping function between the document and the domain item
-     * @return An optional document, filled if one matches the query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customSingle[TDoc](query: String,
-                           mapFunc: (ResultSet, ClassTag[TDoc]) => TDoc)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-      Custom.single[TDoc](query, conn, mapFunc)
-
-    /**
-     * Execute a query that returns no results
-     *
-     * @param query      The query to retrieve the results
-     * @param parameters Parameters to use for the query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customNonQuery(query: String, parameters: Seq[Parameter[?]] = List()): Unit =
-      Custom.nonQuery(query, parameters, conn)
-
-    /**
-     * Execute a query that returns a scalar result
-     *
-     * @param query      The query to retrieve the result
-     * @param parameters Parameters to use for the query
-     * @param mapFunc    The mapping function between the document and the domain item
-     * @return The scalar value from the query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customScalar[T](query: String, parameters: Seq[Parameter[?]],
-                        mapFunc: (ResultSet, ClassTag[T]) => T)(implicit tag: ClassTag[T]): T =
-      Custom.scalar[T](query, parameters, conn, mapFunc)
-
-    /**
-     * Execute a query that returns a scalar result
-     *
-     * @param query   The query to retrieve the result
-     * @param mapFunc The mapping function between the document and the domain item
-     * @return The scalar value from the query
-     * @throws DocumentException If parameters are invalid
-     */
-    def customScalar[T](query: String,
-                        mapFunc: (ResultSet, ClassTag[T]) => T)(implicit tag: ClassTag[T]): T =
-      Custom.scalar[T](query, conn, mapFunc)
-
-    // ~~~ DEFINITION QUERIES ~~~
-
-    /**
-     * Create a document table if necessary
-     *
-     * @param tableName The table whose existence should be ensured (may include schema)
-     * @throws DocumentException If the dialect is not configured
-     */
-    def ensureTable(tableName: String): Unit =
-      Definition.ensureTable(tableName, conn)
-
-    /**
-     * Create an index on field(s) within documents in the specified table if necessary
-     *
-     * @param tableName The table to be indexed (may include schema)
-     * @param indexName The name of the index to create
-     * @param fields    One or more fields to be indexed<
-     * @throws DocumentException If any dependent process does
-     */
-    def ensureFieldIndex(tableName: String, indexName: String, fields: Seq[String]): Unit =
-      Definition.ensureFieldIndex(tableName, indexName, fields, conn)
-
-    /**
-     * Create a document index on a table (PostgreSQL only)
-     *
-     * @param tableName The table to be indexed (may include schema)
-     * @param indexType The type of index to ensure
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def ensureDocumentIndex(tableName: String, indexType: DocumentIndex): Unit =
-      Definition.ensureDocumentIndex (tableName, indexType, conn)
-
-    // ~~~ DOCUMENT MANIPULATION QUERIES ~~~
-
-    /**
-     * Insert a new document
-     *
-     * @param tableName The table into which the document should be inserted (may include schema)
-     * @param document  The document to be inserted
-     * @throws DocumentException If IDs are misconfigured, or if the database command fails
-     */
-    def insert[TDoc](tableName: String, document: TDoc): Unit =
-      Document.insert(tableName, document, conn)
-
-    /**
-     * Save a document, inserting it if it does not exist and updating it if it does (AKA "upsert")
-     *
-     * @param tableName The table in which the document should be saved (may include schema)
-     * @param document  The document to be saved
-     * @throws DocumentException If the database command fails
-     */
-    def save[TDoc](tableName: String, document: TDoc): Unit =
-      Document.save(tableName, document, conn)
-
-    /**
-     * Update (replace) a document by its ID
-     *
-     * @param tableName The table in which the document should be replaced (may include schema)
-     * @param docId     The ID of the document to be replaced
-     * @param document  The document to be replaced
-     * @throws DocumentException If no dialect has been configured, or if the database command fails
-     */
-    def update[TKey, TDoc](tableName: String, docId: TKey, document: TDoc): Unit =
-      Document.update(tableName, docId, document, conn)
-
-    // ~~~ DOCUMENT COUNT QUERIES ~~~
-
-    /**
-     * Count all documents in the table
-     *
-     * @param tableName The name of the table in which documents should be counted
-     * @return A count of the documents in the table
-     * @throws DocumentException If any dependent process does
-     */
-    def countAll(tableName: String): Long =
-      Count.all(tableName, conn)
-
-    /**
-     * Count documents using a field comparison
-     *
-     * @param tableName  The name of the table in which documents should be counted
-     * @param fields     The fields which should be compared
-     * @param howMatched How the fields should be matched (optional, default `ALL`)
-     * @return A count of the matching documents in the table
-     * @throws DocumentException If the dialect has not been configured
-     */
-    def countByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None): Long =
-      Count.byFields(tableName, fields, howMatched, conn)
-
-    /**
-     * Count documents using a JSON containment query (PostgreSQL only)
-     *
-     * @param tableName The name of the table in which documents should be counted
-     * @param criteria  The object for which JSON containment should be checked
-     * @return A count of the matching documents in the table
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def countByContains[TContains](tableName: String, criteria: TContains): Long =
-      Count.byContains(tableName, criteria, conn)
-
-    /**
-     * Count documents using a JSON Path match query (PostgreSQL only)
-     *
-     * @param tableName The name of the table in which documents should be counted
-     * @param path      The JSON path comparison to match
-     * @return A count of the matching documents in the table
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def countByJsonPath(tableName: String, path: String): Long =
-      Count.byJsonPath(tableName, path, conn)
-
-    // ~~~ DOCUMENT EXISTENCE QUERIES ~~~
-
-    /**
-     * Determine a document's existence by its ID
-     *
-     * @param tableName The name of the table in which document existence should be checked
-     * @param docId     The ID of the document to be checked
-     * @return True if the document exists, false if not
-     * @throws DocumentException If no dialect has been configured
-     */
-    def existsById[TKey](tableName: String, docId: TKey): Boolean =
-      Exists.byId(tableName, docId, conn)
-
-    /**
-     * Determine document existence using a field comparison
-     *
-     * @param tableName  The name of the table in which document existence should be checked
-     * @param fields     The fields which should be compared
-     * @param howMatched How the fields should be matched
-     * @return True if any matching documents exist, false if not
-     * @throws DocumentException If no dialect has been configured, or if parameters are invalid
-     */
-    def existsByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None): Boolean =
-      Exists.byFields(tableName, fields, howMatched, conn)
-
-    /**
-     * Determine document existence using a JSON containment query (PostgreSQL only)
-     *
-     * @param tableName The name of the table in which document existence should be checked
-     * @param criteria  The object for which JSON containment should be checked
-     * @return True if any matching documents exist, false if not
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def existsByContains[TContains](tableName: String, criteria: TContains): Boolean =
-      Exists.byContains(tableName, criteria, conn)
-
-    /**
-     * Determine document existence using a JSON Path match query (PostgreSQL only)
-     *
-     * @param tableName The name of the table in which document existence should be checked
-     * @param path      The JSON path comparison to match
-     * @return True if any matching documents exist, false if not
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def existsByJsonPath(tableName: String, path: String): Boolean =
-      Exists.byJsonPath(tableName, path, conn)
-
-    // ~~~ DOCUMENT RETRIEVAL QUERIES ~~~
-
-    /**
-     * Retrieve all documents in the given table, ordering results by the optional given fields
-     *
-     * @param tableName The table from which documents should be retrieved
-     * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return A list of documents from the given table
-     * @throws DocumentException If query execution fails
-     */
-    def findAll[TDoc](tableName: String, orderBy: Seq[Field[?]] = List())(implicit tag: ClassTag[TDoc]): List[TDoc] =
-      Find.all[TDoc](tableName, orderBy, conn)
-
-    /**
-     * Retrieve a document by its ID
-     *
-     * @param tableName The table from which the document should be retrieved
-     * @param docId     The ID of the document to retrieve
-     * @return The document if it is found, `None` otherwise
-     * @throws DocumentException If no dialect has been configured
-     */
-    def findById[TKey, TDoc](tableName: String, docId: TKey)(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-      Find.byId[TKey, TDoc](tableName, docId, conn)
-
-    /**
-     * Retrieve documents using a field comparison, ordering results by the optional given fields
-     *
-     * @param tableName  The table from which the document should be retrieved
-     * @param fields     The fields which should be compared
-     * @param howMatched How the fields should be matched
-     * @param orderBy    Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return A list of documents matching the field comparison
-     * @throws DocumentException If no dialect has been configured, or if parameters are invalid
-     */
-    def findByFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
-                           orderBy: Seq[Field[?]] = List())(implicit tag: ClassTag[TDoc]): List[TDoc] =
-      Find.byFields[TDoc](tableName, fields, howMatched, orderBy, conn)
-
-    /**
-     * Retrieve documents using a JSON containment query, ordering results by the optional given fields (PostgreSQL
-     * only)
-     *
-     * @param tableName The name of the table in which document existence should be checked
-     * @param criteria  The object for which JSON containment should be checked
-     * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return A list of documents matching the JSON containment query
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def findByContains[TDoc, TContains](tableName: String, criteria: TContains, orderBy: Seq[Field[?]] = List())
-                                       (implicit tag: ClassTag[TDoc]): List[TDoc] =
-      Find.byContains[TDoc, TContains](tableName, criteria, orderBy, conn)
-
-    /**
-     * Retrieve documents using a JSON Path match query, ordering results by the optional given fields (PostgreSQL only)
-     *
-     * @param tableName The table from which documents should be retrieved
-     * @param path      The JSON path comparison to match
-     * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return A list of documents matching the JSON Path match query
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def findByJsonPath[TDoc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
-                            (implicit tag: ClassTag[TDoc]): List[TDoc] =
-      Find.byJsonPath[TDoc](tableName, path, orderBy, conn)
-
-    /**
-     * Retrieve the first document using a field comparison and optional ordering fields
-     *
-     * @param tableName  The table from which documents should be retrieved
-     * @param fields     The fields which should be compared
-     * @param howMatched How the fields should be matched (optional, defaults to `FieldMatch.ALL`)
-     * @param orderBy    Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return The first document matching the field comparison, or `None` if no matches are found
-     * @throws DocumentException If no dialect has been configured, or if parameters are invalid
-     */
-    def findFirstByFields[TDoc](tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None,
-                                orderBy: Seq[Field[?]] = List())(implicit tag: ClassTag[TDoc]): Option[TDoc] =
-      Find.firstByFields[TDoc](tableName, fields, howMatched, orderBy, conn)
-
-    /**
-     * Retrieve the first document using a JSON containment query and optional ordering fields (PostgreSQL only)
-     *
-     * @param tableName The table from which documents should be retrieved
-     * @param criteria  The object for which JSON containment should be checked
-     * @param orderBy   Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return The first document matching the JSON containment query, or `None` if no matches are found
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def findFirstByContains[TDoc, TContains](tableName: String, criteria: TContains, orderBy: Seq[Field[?]] = List())
-                                            (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-      Find.firstByContains[TDoc, TContains](tableName, criteria, orderBy, conn)
-
-    /**
-     * Retrieve the first document using a JSON Path match query and optional ordering fields (PostgreSQL only)
-     *
-     * @param tableName The table from which documents should be retrieved
-     * @param path The JSON path comparison to match
-     * @param orderBy Fields by which the query should be ordered (optional, defaults to no ordering)
-     * @return The first document matching the JSON Path match query, or `None` if no matches are found
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def findFirstByJsonPath[TDoc](tableName: String, path: String, orderBy: Seq[Field[?]] = List())
-                                 (implicit tag: ClassTag[TDoc]): Option[TDoc] =
-      Find.firstByJsonPath[TDoc](tableName, path, orderBy, conn)
-
-    // ~~~ DOCUMENT PATCH (PARTIAL UPDATE) QUERIES ~~~
-
-    /**
-     * Patch a document by its ID
-     *
-     * @param tableName The name of the table in which a document should be patched
-     * @param docId     The ID of the document to be patched
-     * @param patch     The object whose properties should be replaced in the document
-     * @throws DocumentException If no dialect has been configured
-     */
-    def patchById[TKey, TPatch](tableName: String, docId: TKey, patch: TPatch): Unit =
-      Patch.byId(tableName, docId, patch, conn)
-
-    /**
-     * Patch documents using a field comparison
-     *
-     * @param tableName  The name of the table in which documents should be patched
-     * @param fields     The fields which should be compared
-     * @param patch      The object whose properties should be replaced in the document
-     * @param howMatched How the fields should be matched
-     * @throws DocumentException If no dialect has been configured, or if parameters are invalid
-     */
-    def patchByFields[TPatch](tableName: String, fields: Seq[Field[?]], patch: TPatch,
-                              howMatched: Option[FieldMatch] = None): Unit =
-      Patch.byFields(tableName, fields, patch, howMatched, conn)
-
-    /**
-    * Patch documents using a JSON containment query (PostgreSQL only)
-    *
-    * @param tableName The name of the table in which documents should be patched
-    * @param criteria  The object against which JSON containment should be checked
-    * @param patch     The object whose properties should be replaced in the document
-    * @throws DocumentException If called on a SQLite connection
-    */
-    def patchByContains[TContains, TPatch](tableName: String, criteria: TContains, patch: TPatch): Unit =
-      Patch.byContains(tableName, criteria, patch, conn)
-
-    /**
-     * Patch documents using a JSON Path match query (PostgreSQL only)
-     *
-     * @param tableName The name of the table in which documents should be patched
-     * @param path The JSON path comparison to match
-     * @param patch The object whose properties should be replaced in the document
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def patchByJsonPath[TPatch](tableName: String, path: String, patch: TPatch): Unit =
-      Patch.byJsonPath(tableName, path, patch, conn)
-
-    // ~~~ DOCUMENT FIELD REMOVAL QUERIES ~~~
-
-    /**
-     * Remove fields from a document by its ID
-     *
-     * @param tableName The name of the table in which the document's fields should be removed
-     * @param docId     The ID of the document to have fields removed
-     * @param toRemove  The names of the fields to be removed
-     * @throws DocumentException If no dialect has been configured
-     */
-    def removeFieldsById[TKey](tableName: String, docId: TKey, toRemove: Seq[String]): Unit =
-      RemoveFields.byId(tableName, docId, toRemove, conn)
-
-    /**
-     * Remove fields from documents using a field comparison
-     *
-     * @param tableName  The name of the table in which document fields should be removed
-     * @param fields     The fields which should be compared
-     * @param toRemove   The names of the fields to be removed
-     * @param howMatched How the fields should be matched
-     * @throws DocumentException If no dialect has been configured, or if parameters are invalid
-     */
-    def removeFieldsByFields(tableName: String, fields: Seq[Field[?]], toRemove: Seq[String],
-                             howMatched: Option[FieldMatch] = None): Unit =
-      RemoveFields.byFields(tableName, fields, toRemove, howMatched, conn)
-
-    /**
-     * Remove fields from documents using a JSON containment query (PostgreSQL only)
-     *
-     * @param tableName The name of the table in which document fields should be removed
-     * @param criteria  The object against which JSON containment should be checked
-     * @param toRemove  The names of the fields to be removed
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def removeFieldsByContains[TContains](tableName: String, criteria: TContains, toRemove: Seq[String]): Unit =
-      RemoveFields.byContains(tableName, criteria, toRemove, conn)
-
-    /**
-    * Remove fields from documents using a JSON Path match query (PostgreSQL only)
-    *
-    * @param tableName The name of the table in which document fields should be removed
-    * @param path      The JSON path comparison to match
-    * @param toRemove  The names of the fields to be removed
-    * @throws DocumentException If called on a SQLite connection
-    */
-    def removeFieldsByJsonPath(tableName: String, path: String, toRemove: Seq[String]): Unit =
-      RemoveFields.byJsonPath(tableName, path, toRemove, conn)
-
-    // ~~~ DOCUMENT DELETION QUERIES ~~~
-
-    /**
-     * Delete a document by its ID
-     *
-     * @param tableName The name of the table from which documents should be deleted
-     * @param docId     The ID of the document to be deleted
-     * @throws DocumentException If no dialect has been configured
-     */
-    def deleteById[TKey](tableName: String, docId: TKey): Unit =
-      Delete.byId(tableName, docId, conn)
-
-    /**
-     * Delete documents using a field comparison
-     *
-     * @param tableName  The name of the table from which documents should be deleted
-     * @param fields     The fields which should be compared
-     * @param howMatched How the fields should be matched
-     * @throws DocumentException If no dialect has been configured, or if parameters are invalid
-     */
-    def deleteByFields(tableName: String, fields: Seq[Field[?]], howMatched: Option[FieldMatch] = None): Unit =
-      Delete.byFields(tableName, fields, howMatched, conn)
-
-    /**
-     * Delete documents using a JSON containment query (PostgreSQL only)
-     *
-     * @param tableName The name of the table from which documents should be deleted
-     * @param criteria  The object for which JSON containment should be checked
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def deleteByContains[TContains](tableName: String, criteria: TContains): Unit =
-      Delete.byContains(tableName, criteria, conn)
-
-    /**
-     * Delete documents using a JSON Path match query (PostgreSQL only)
-     *
-     * @param tableName The name of the table from which documents should be deleted
-     * @param path      The JSON path comparison to match
-     * @throws DocumentException If called on a SQLite connection
-     */
-    def deleteByJsonPath(tableName: String, path: String): Unit =
-      Delete.byJsonPath(tableName, path, conn)
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/AutoIdTest.scala b/src/scala/src/test/scala/AutoIdTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/AutoIdTest.scala
rename to src/scala/src/test/scala/AutoIdTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ByteIdClass.scala b/src/scala/src/test/scala/ByteIdClass.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ByteIdClass.scala
rename to src/scala/src/test/scala/ByteIdClass.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ConfigurationTest.scala b/src/scala/src/test/scala/ConfigurationTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ConfigurationTest.scala
rename to src/scala/src/test/scala/ConfigurationTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/CountQueryTest.scala b/src/scala/src/test/scala/CountQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/CountQueryTest.scala
rename to src/scala/src/test/scala/CountQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DefinitionQueryTest.scala b/src/scala/src/test/scala/DefinitionQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DefinitionQueryTest.scala
rename to src/scala/src/test/scala/DefinitionQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DeleteQueryTest.scala b/src/scala/src/test/scala/DeleteQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DeleteQueryTest.scala
rename to src/scala/src/test/scala/DeleteQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DialectTest.scala b/src/scala/src/test/scala/DialectTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DialectTest.scala
rename to src/scala/src/test/scala/DialectTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DocumentIndexTest.scala b/src/scala/src/test/scala/DocumentIndexTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DocumentIndexTest.scala
rename to src/scala/src/test/scala/DocumentIndexTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DocumentQueryTest.scala b/src/scala/src/test/scala/DocumentQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/DocumentQueryTest.scala
rename to src/scala/src/test/scala/DocumentQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ExistsQueryTest.scala b/src/scala/src/test/scala/ExistsQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ExistsQueryTest.scala
rename to src/scala/src/test/scala/ExistsQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/FieldMatchTest.scala b/src/scala/src/test/scala/FieldMatchTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/FieldMatchTest.scala
rename to src/scala/src/test/scala/FieldMatchTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/FieldTest.scala b/src/scala/src/test/scala/FieldTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/FieldTest.scala
rename to src/scala/src/test/scala/FieldTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/FindQueryTest.scala b/src/scala/src/test/scala/FindQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/FindQueryTest.scala
rename to src/scala/src/test/scala/FindQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ForceDialect.scala b/src/scala/src/test/scala/ForceDialect.scala
similarity index 83%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ForceDialect.scala
rename to src/scala/src/test/scala/ForceDialect.scala
index 7665d26..d233bd9 100644
--- a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ForceDialect.scala
+++ b/src/scala/src/test/scala/ForceDialect.scala
@@ -7,11 +7,11 @@ import solutions.bitbadger.documents.Configuration
  */
 object ForceDialect:
 
-  def postgres (): Unit =
+  def postgres(): Unit =
     Configuration.setConnectionString(":postgresql:")
 
-  def sqlite (): Unit =
+  def sqlite(): Unit =
     Configuration.setConnectionString(":sqlite:")
 
-  def none (): Unit =
+  def none(): Unit =
     Configuration.setConnectionString(null)
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/IntIdClass.scala b/src/scala/src/test/scala/IntIdClass.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/IntIdClass.scala
rename to src/scala/src/test/scala/IntIdClass.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/LongIdClass.scala b/src/scala/src/test/scala/LongIdClass.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/LongIdClass.scala
rename to src/scala/src/test/scala/LongIdClass.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/OpTest.scala b/src/scala/src/test/scala/OpTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/OpTest.scala
rename to src/scala/src/test/scala/OpTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ParameterNameTest.scala b/src/scala/src/test/scala/ParameterNameTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ParameterNameTest.scala
rename to src/scala/src/test/scala/ParameterNameTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ParameterTest.scala b/src/scala/src/test/scala/ParameterTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ParameterTest.scala
rename to src/scala/src/test/scala/ParameterTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ParametersTest.scala b/src/scala/src/test/scala/ParametersTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ParametersTest.scala
rename to src/scala/src/test/scala/ParametersTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/PatchQueryTest.scala b/src/scala/src/test/scala/PatchQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/PatchQueryTest.scala
rename to src/scala/src/test/scala/PatchQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/QueryUtilsTest.scala b/src/scala/src/test/scala/QueryUtilsTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/QueryUtilsTest.scala
rename to src/scala/src/test/scala/QueryUtilsTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/RemoveFieldsQueryTest.scala b/src/scala/src/test/scala/RemoveFieldsQueryTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/RemoveFieldsQueryTest.scala
rename to src/scala/src/test/scala/RemoveFieldsQueryTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ShortIdClass.scala b/src/scala/src/test/scala/ShortIdClass.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/ShortIdClass.scala
rename to src/scala/src/test/scala/ShortIdClass.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/StringIdClass.scala b/src/scala/src/test/scala/StringIdClass.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/StringIdClass.scala
rename to src/scala/src/test/scala/StringIdClass.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/WhereTest.scala b/src/scala/src/test/scala/WhereTest.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/WhereTest.scala
rename to src/scala/src/test/scala/WhereTest.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/ArrayDocument.scala b/src/scala/src/test/scala/integration/ArrayDocument.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/ArrayDocument.scala
rename to src/scala/src/test/scala/integration/ArrayDocument.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/CountFunctions.scala b/src/scala/src/test/scala/integration/CountFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/CountFunctions.scala
rename to src/scala/src/test/scala/integration/CountFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/CustomFunctions.scala b/src/scala/src/test/scala/integration/CustomFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/CustomFunctions.scala
rename to src/scala/src/test/scala/integration/CustomFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/DefinitionFunctions.scala b/src/scala/src/test/scala/integration/DefinitionFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/DefinitionFunctions.scala
rename to src/scala/src/test/scala/integration/DefinitionFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/DeleteFunctions.scala b/src/scala/src/test/scala/integration/DeleteFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/DeleteFunctions.scala
rename to src/scala/src/test/scala/integration/DeleteFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/DocumentFunctions.scala b/src/scala/src/test/scala/integration/DocumentFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/DocumentFunctions.scala
rename to src/scala/src/test/scala/integration/DocumentFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/ExistsFunctions.scala b/src/scala/src/test/scala/integration/ExistsFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/ExistsFunctions.scala
rename to src/scala/src/test/scala/integration/ExistsFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/FindFunctions.scala b/src/scala/src/test/scala/integration/FindFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/FindFunctions.scala
rename to src/scala/src/test/scala/integration/FindFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/JacksonDocumentSerializer.scala b/src/scala/src/test/scala/integration/JacksonDocumentSerializer.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/JacksonDocumentSerializer.scala
rename to src/scala/src/test/scala/integration/JacksonDocumentSerializer.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/JsonDocument.scala b/src/scala/src/test/scala/integration/JsonDocument.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/JsonDocument.scala
rename to src/scala/src/test/scala/integration/JsonDocument.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/NumIdDocument.scala b/src/scala/src/test/scala/integration/NumIdDocument.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/NumIdDocument.scala
rename to src/scala/src/test/scala/integration/NumIdDocument.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PatchFunctions.scala b/src/scala/src/test/scala/integration/PatchFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PatchFunctions.scala
rename to src/scala/src/test/scala/integration/PatchFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PgDB.scala b/src/scala/src/test/scala/integration/PgDB.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PgDB.scala
rename to src/scala/src/test/scala/integration/PgDB.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLCountIT.scala b/src/scala/src/test/scala/integration/PostgreSQLCountIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLCountIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLCountIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLCustomIT.scala b/src/scala/src/test/scala/integration/PostgreSQLCustomIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLCustomIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLCustomIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLDefinitionIT.scala b/src/scala/src/test/scala/integration/PostgreSQLDefinitionIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLDefinitionIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLDefinitionIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLDeleteIT.scala b/src/scala/src/test/scala/integration/PostgreSQLDeleteIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLDeleteIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLDeleteIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLDocumentIT.scala b/src/scala/src/test/scala/integration/PostgreSQLDocumentIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLDocumentIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLDocumentIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLExistsIT.scala b/src/scala/src/test/scala/integration/PostgreSQLExistsIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLExistsIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLExistsIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLFindIT.scala b/src/scala/src/test/scala/integration/PostgreSQLFindIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLFindIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLFindIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLPatchIT.scala b/src/scala/src/test/scala/integration/PostgreSQLPatchIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLPatchIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLPatchIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLRemoveFieldsIT.scala b/src/scala/src/test/scala/integration/PostgreSQLRemoveFieldsIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/PostgreSQLRemoveFieldsIT.scala
rename to src/scala/src/test/scala/integration/PostgreSQLRemoveFieldsIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/RemoveFieldsFunctions.scala b/src/scala/src/test/scala/integration/RemoveFieldsFunctions.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/RemoveFieldsFunctions.scala
rename to src/scala/src/test/scala/integration/RemoveFieldsFunctions.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteCountIT.scala b/src/scala/src/test/scala/integration/SQLiteCountIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteCountIT.scala
rename to src/scala/src/test/scala/integration/SQLiteCountIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteCustomIT.scala b/src/scala/src/test/scala/integration/SQLiteCustomIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteCustomIT.scala
rename to src/scala/src/test/scala/integration/SQLiteCustomIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDB.scala b/src/scala/src/test/scala/integration/SQLiteDB.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDB.scala
rename to src/scala/src/test/scala/integration/SQLiteDB.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDefinitionIT.scala b/src/scala/src/test/scala/integration/SQLiteDefinitionIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDefinitionIT.scala
rename to src/scala/src/test/scala/integration/SQLiteDefinitionIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDeleteIT.scala b/src/scala/src/test/scala/integration/SQLiteDeleteIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDeleteIT.scala
rename to src/scala/src/test/scala/integration/SQLiteDeleteIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDocumentIT.scala b/src/scala/src/test/scala/integration/SQLiteDocumentIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteDocumentIT.scala
rename to src/scala/src/test/scala/integration/SQLiteDocumentIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteExistsIT.scala b/src/scala/src/test/scala/integration/SQLiteExistsIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteExistsIT.scala
rename to src/scala/src/test/scala/integration/SQLiteExistsIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteFindIT.scala b/src/scala/src/test/scala/integration/SQLiteFindIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteFindIT.scala
rename to src/scala/src/test/scala/integration/SQLiteFindIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLitePatchIT.scala b/src/scala/src/test/scala/integration/SQLitePatchIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLitePatchIT.scala
rename to src/scala/src/test/scala/integration/SQLitePatchIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteRemoveFieldsIT.scala b/src/scala/src/test/scala/integration/SQLiteRemoveFieldsIT.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SQLiteRemoveFieldsIT.scala
rename to src/scala/src/test/scala/integration/SQLiteRemoveFieldsIT.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SubDocument.scala b/src/scala/src/test/scala/integration/SubDocument.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/SubDocument.scala
rename to src/scala/src/test/scala/integration/SubDocument.scala
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/ThrowawayDatabase.scala b/src/scala/src/test/scala/integration/ThrowawayDatabase.scala
similarity index 100%
rename from src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/integration/ThrowawayDatabase.scala
rename to src/scala/src/test/scala/integration/ThrowawayDatabase.scala
diff --git a/src/scala/src/test/scala/package.scala b/src/scala/src/test/scala/package.scala
new file mode 100644
index 0000000..dc80f93
--- /dev/null
+++ b/src/scala/src/test/scala/package.scala
@@ -0,0 +1,3 @@
+package solutions.bitbadger.documents.scala.tests
+
+def TEST_TABLE = "test_table"
diff --git a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/package.scala b/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/package.scala
deleted file mode 100644
index 8992837..0000000
--- a/src/scala/src/test/scala/solutions/bitbadger/documents/scala/tests/package.scala
+++ /dev/null
@@ -1,6 +0,0 @@
-package solutions.bitbadger.documents.scala
-
-package object tests {
-
-  def TEST_TABLE = "test_table"
-}
\ No newline at end of file