Merge branch 'master' into synch-refactor

67 files changed, 1415 insertions, 635 deletions

diff --git a/build.sbt b/build.sbt
index 837a1f0..66c0f7b 100644
--- a/build.sbt
+++ b/build.sbt
@@ -18,8 +18,8 @@ lazy val core = (project in file("."))
     "io.github.cloudify"                %% "spdf"                   % "1.4.0",
     "org.davidbild"                     %% "tristate-core"          % "0.2.0",
     "org.davidbild"                     %% "tristate-play"          % "0.2.0" exclude ("com.typesafe.play", "play-json"),
-    "xyz.driver"                        %% "core"                   % "0.16.7",
-    "xyz.driver"                        %% "domain-model"           % "0.12.26",
+    "xyz.driver"                        %% "core"                   % "1.2.1",
+    "xyz.driver"                        %% "domain-model"           % "0.17.1",
     "ch.qos.logback"                    % "logback-classic"         % "1.1.7",
     "com.fasterxml.jackson.datatype"    % "jackson-datatype-jsr310" % "2.8.4",
     "com.github.spullara.mustache.java" % "scala-extensions-2.11"   % "0.9.4",
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala
index f882441..a56ab9a 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala
@@ -2,8 +2,7 @@ package xyz.driver.pdsuicommon.db
 
 import java.time.{LocalDateTime, ZoneOffset}
 
-import slick.driver.JdbcProfile
-import slick.jdbc.GetResult
+import slick.jdbc.{JdbcProfile, GetResult}
 import xyz.driver.core.database.SlickDal
 import xyz.driver.pdsuicommon.logging._
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SlickQueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SlickQueryBuilder.scala
index ab2757b..0daa84d 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/db/SlickQueryBuilder.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SlickQueryBuilder.scala
@@ -3,8 +3,7 @@ package xyz.driver.pdsuicommon.db
 import java.sql.PreparedStatement
 import java.time.LocalDateTime
 
-import slick.driver.JdbcProfile
-import slick.jdbc.{PositionedParameters, SQLActionBuilder, SetParameter}
+import slick.jdbc.{JdbcProfile, PositionedParameters, SQLActionBuilder, SetParameter}
 import xyz.driver.pdsuicommon.db.Sorting.{Dimension, Sequential}
 import xyz.driver.pdsuicommon.db.SortingOrder.{Ascending, Descending}
 
diff --git a/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala b/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala
index e0adeb8..e46e11c 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParser.scala
@@ -15,10 +15,7 @@ object SearchFilterParser {
   private object BinaryAtomFromTuple {
     def unapply(input: (SearchFilterExpr.Dimension, (String, Any))): Option[SearchFilterExpr.Atom.Binary] = {
       val (dimensionName, (strOperation, value)) = input
-      val updatedValue = value match {
-        case s: String => s.safeTrim
-        case a         => a
-      }
+      val updatedValue                           = trimIfString(value)
 
       parseOperation(strOperation.toLowerCase).map { op =>
         SearchFilterExpr.Atom.Binary(dimensionName, op, updatedValue.asInstanceOf[AnyRef])
@@ -30,15 +27,24 @@ object SearchFilterParser {
     // Compiler warning: unchecked since it is eliminated by erasure, if we user Seq[String]
     def unapply(input: (SearchFilterExpr.Dimension, (String, Seq[_]))): Option[SearchFilterExpr.Atom.NAry] = {
       val (dimensionName, (strOperation, xs)) = input
+      val updatedValues                       = xs.map(trimIfString)
+
       if (strOperation.toLowerCase == "in") {
-        val values = xs.asInstanceOf[Seq[String]].map(_.safeTrim)
-        Some(SearchFilterExpr.Atom.NAry(dimensionName, SearchFilterNAryOperation.In, values))
+        Some(
+          SearchFilterExpr.Atom
+            .NAry(dimensionName, SearchFilterNAryOperation.In, updatedValues.map(_.asInstanceOf[AnyRef])))
       } else {
         None
       }
     }
   }
 
+  private def trimIfString(value: Any) =
+    value match {
+      case s: String => s.safeTrim
+      case a         => a
+    }
+
   private val operationsMapping = {
     import xyz.driver.pdsuicommon.db.SearchFilterBinaryOperation._
 
@@ -96,7 +102,7 @@ object SearchFilterParser {
 
   private val nAryValueParser: Parser[String] = P(CharPred(_ != ',').rep(min = 1).!)
 
-  private val longParser: Parser[Long] = P(CharIn('0' to '9').rep(1).!.map(_.toLong))
+  private val longParser: Parser[Long] = P(CharIn('0' to '9').rep(min = 1).!.map(_.toLong))
 
   private val binaryAtomParser: Parser[SearchFilterExpr.Atom.Binary] = P(
     dimensionParser ~ whitespaceParser ~ (
@@ -109,7 +115,8 @@ object SearchFilterParser {
 
   private val nAryAtomParser: Parser[SearchFilterExpr.Atom.NAry] = P(
     dimensionParser ~ whitespaceParser ~ (
-      naryOperatorParser ~/ whitespaceParser ~/ nAryValueParser.!.rep(min = 1, sep = ",")
+      naryOperatorParser ~ whitespaceParser ~
+        (longParser.rep(min = 1, sep = ",") | nAryValueParser.!.rep(min = 1, sep = ","))
     ) ~ End
   ).map {
     case NAryAtomFromTuple(atom) => atom
diff --git a/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala b/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala
index 6c87858..83c4e6f 100644
--- a/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala
+++ b/src/main/scala/xyz/driver/pdsuicommon/utils/CustomSwaggerJsonFormats.scala
@@ -4,7 +4,7 @@ import java.time.{LocalDate, LocalDateTime}
 
 import io.swagger.models.properties.Property
 import spray.json.JsValue
-import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
+import xyz.driver.pdsuicommon.domain.{LongId, StringId, TextJson, UuidId}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.arm._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.criterion._
@@ -15,25 +15,29 @@ import xyz.driver.pdsuidomain.formats.json.sprayformats.trial._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.trialhistory._
 import xyz.driver.pdsuidomain.formats.json.sprayformats.trialissue._
 import xyz.driver.core.swagger.CustomSwaggerJsonConverter._
+import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue
 import xyz.driver.pdsuidomain.services.CriterionService.RichCriterion
+import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
+
+import scala.collection.immutable
 
 object CustomSwaggerJsonFormats {
 
-  val customCommonProperties = Map[Class[_], Property](
+  val customCommonProperties = immutable.Map[Class[_], Property](
     classOf[LocalDateTime] -> stringProperty(example = Some("2010-12-31'T'18:59:59Z")),
     classOf[LocalDate]     -> stringProperty(example = Some("2010-12-31")),
     classOf[UuidId[_]]     -> stringProperty(example = Some("370b0450-35cb-4aab-ba74-0145be75add5")),
     classOf[StringId[_]]   -> stringProperty(),
     classOf[LongId[_]]     -> stringProperty()
   )
-  val customTrialCurationProperties = Map[Class[_], Property](
+  val customTrialCurationProperties = immutable.Map[Class[_], Property](
     classOf[Trial.Status]        -> stringProperty(),
     classOf[Trial.Condition]     -> stringProperty(),
     classOf[TrialHistory.Action] -> stringProperty(),
     classOf[TrialHistory.State]  -> stringProperty()
   ) ++ customCommonProperties
 
-  val customTrialCurationObjectsExamples = Map[Class[_], JsValue](
+  val customTrialCurationObjectsExamples = immutable.Map[Class[_], JsValue](
     classOf[Trial] -> trialWriter.write(xyz.driver.pdsuidomain.fakes.entities.trialcuration.nextTrial()),
     classOf[Arm]   -> armFormat.write(xyz.driver.pdsuidomain.fakes.entities.trialcuration.nextArm()),
     classOf[TrialHistory] -> trialHistoryFormat.write(
@@ -52,4 +56,72 @@ object CustomSwaggerJsonFormats {
       xyz.driver.pdsuidomain.fakes.entities.trialcuration.nextStudyDesign())
   )
 
+  // records-processing-service
+  object Rep {
+    import xyz.driver.pdsuidomain.fakes.entities.rep
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.document
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.documentissue
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.documenthistory
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.record
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.recordissue
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.recordhistory
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.bridgeuploadqueue
+    import xyz.driver.pdsuidomain.formats.json.sprayformats.extracteddata
+
+    val customRepObjectsExamples = immutable.Map[Class[_], JsValue](
+      classOf[Document] ->
+        document.documentFormat.write(rep.DocumentGen.nextDocument()),
+      classOf[Document.Meta] ->
+        document.documentMetaFormat.write(rep.DocumentGen.nextDocumentMeta()),
+      classOf[TextJson[Document.Meta]] ->
+        document.fullDocumentMetaFormat.write(rep.DocumentGen.nextDocumentMetaJson()),
+      classOf[Document.RequiredType] ->
+        document.requiredTypeFormat.write(rep.DocumentGen.nextDocumentRequiredType()),
+      classOf[Document.Status] ->
+        document.documentStatusFormat.write(rep.DocumentGen.nextDocumentStatus()),
+      classOf[DocumentIssue] ->
+        documentissue.documentIssueFormat.write(rep.DocumentGen.nextDocumentIssue()),
+      classOf[DocumentHistory] ->
+        documenthistory.documentHistoryFormat.write(rep.DocumentGen.nextDocumentHistory()),
+      classOf[DocumentHistory.Action] ->
+        documenthistory.documentActionFormat.write(rep.DocumentGen.nextDocumentHistoryAction()),
+      classOf[DocumentHistory.State] ->
+        documenthistory.documentStateFormat.write(rep.DocumentGen.nextDocumentHistoryState()),
+      classOf[ProviderType] ->
+        record.providerTypeFormat.write(rep.MedicalRecordGen.nextProviderType()),
+      classOf[TextJson[List[MedicalRecord.Meta]]] ->
+        record.recordMetaFormat.write(rep.MedicalRecordGen.nextMedicalRecordMetasJson()),
+      classOf[MedicalRecord] ->
+        record.recordFormat.write(rep.MedicalRecordGen.nextMedicalRecord()),
+      classOf[MedicalRecord.Meta] ->
+        record.recordMetaTypeFormat.write(rep.MedicalRecordGen.nextMedicalRecordMeta()),
+      classOf[MedicalRecord.Status] ->
+        record.recordStatusFormat.write(rep.MedicalRecordGen.nextMedicalRecordStatus()),
+      classOf[MedicalRecordIssue] ->
+        recordissue.recordIssueFormat.write(rep.MedicalRecordGen.nextMedicalRecordIssue()),
+      classOf[MedicalRecordHistory] ->
+        recordhistory.recordHistoryFormat.write(rep.MedicalRecordGen.nextMedicalRecordHistory()),
+      classOf[MedicalRecordHistory.Action] ->
+        recordhistory.recordActionFormat.write(rep.MedicalRecordGen.nextMedicalRecordHistoryAction()),
+      classOf[MedicalRecordHistory.State] ->
+        recordhistory.recordStateFormat.write(rep.MedicalRecordGen.nextMedicalRecordHistoryState()),
+      classOf[BridgeUploadQueue.Item] ->
+        bridgeuploadqueue.queueUploadItemFormat.write(rep.BridgeUploadQueueGen.nextBridgeUploadQueueItem()),
+      classOf[ExtractedData.Meta] ->
+        extracteddata.extractedDataMetaFormat.write(rep.ExtractedDataGen.nextExtractedDataMeta()),
+      classOf[ExtractedData.Meta.Evidence] ->
+        extracteddata.metaEvidenceFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaEvidence()),
+      classOf[ExtractedData.Meta.Keyword] ->
+        extracteddata.metaKeywordFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaKeyword()),
+      classOf[ExtractedData.Meta.TextLayerPosition] ->
+        extracteddata.metaTextLayerPositionFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaTextLayerPosition()),
+      classOf[TextJson[ExtractedData.Meta]] ->
+        extracteddata.fullExtractedDataMetaFormat.write(rep.ExtractedDataGen.nextExtractedDataMetaJson()),
+      classOf[RichExtractedData] ->
+        extracteddata.extractedDataFormat.write(rep.ExtractedDataGen.nextRichExtractedData()),
+      classOf[ExtractedDataLabel] ->
+        extracteddata.extractedDataLabelWriter.write(rep.ExtractedDataGen.nextExtractedDataLabel())
+    )
+  }
+
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Criterion.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Criterion.scala
index 0dfb33f..2432251 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Criterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Criterion.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.entities
 
+import xyz.driver.entities.labels.{Label, LabelCategory}
 import xyz.driver.pdsuicommon.domain.{LongId, StringId}
 import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuidomain.entities.Criterion.Meta.Evidence
@@ -8,9 +9,10 @@ final case class Criterion(id: LongId[Criterion],
                            trialId: StringId[Trial],
                            text: Option[String],
                            isCompound: Boolean,
-                           meta: String) {
+                           meta: String,
+                           inclusion: Option[Boolean]) {
 
-  def isValid(): Boolean = text.nonEmpty && Option(meta).isDefined
+  def isValid: Boolean = text.nonEmpty && Option(meta).isDefined
 }
 
 object Criterion {
@@ -41,7 +43,7 @@ object CriterionArm {
 final case class CriterionLabel(id: LongId[CriterionLabel],
                                 labelId: Option[LongId[Label]],
                                 criterionId: LongId[Criterion],
-                                categoryId: Option[LongId[Category]],
+                                categoryId: Option[LongId[LabelCategory]],
                                 value: Option[Boolean],
                                 isDefining: Boolean)
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
index 839fead..eccb254 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Document.scala
@@ -15,74 +15,195 @@ import xyz.driver.pdsuicommon.validation.Validators.Validator
 import xyz.driver.pdsuidomain.entities.Document.Meta
 
 import scalaz.Equal
+import scalaz.syntax.equal._
+import scalaz.Scalaz.stringInstance
 
-final case class ProviderType(id: LongId[ProviderType], name: String)
+sealed trait ProviderType {
+  val id: LongId[ProviderType]
+  val name: String
+}
 
 object ProviderType {
-  sealed trait ProviderTypeName
-  case object MedicalOncology         extends ProviderTypeName
-  case object Surgery                 extends ProviderTypeName
-  case object Pathology               extends ProviderTypeName
-  case object MolecularPathology      extends ProviderTypeName
-  case object LaboratoryMedicine      extends ProviderTypeName
-  case object Radiology               extends ProviderTypeName
-  case object InterventionalRadiology extends ProviderTypeName
-  case object RadiationOncology       extends ProviderTypeName
-  case object PrimaryCare             extends ProviderTypeName
-  case object Cardiology              extends ProviderTypeName
-  case object Dermatology             extends ProviderTypeName
-  case object Ophthalmology           extends ProviderTypeName
-  case object Gastroenterology        extends ProviderTypeName
-  case object Neurology               extends ProviderTypeName
-  case object Psychiatry              extends ProviderTypeName
-  case object Gynecology              extends ProviderTypeName
-  case object InfectiousDisease       extends ProviderTypeName
-  case object Immunology              extends ProviderTypeName
-  case object Nephrology              extends ProviderTypeName
-  case object Rheumatology            extends ProviderTypeName
-  case object Cytology                extends ProviderTypeName
-  case object Otolaryngology          extends ProviderTypeName
-  case object Anesthesiology          extends ProviderTypeName
-  case object Urology                 extends ProviderTypeName
-  case object PalliativeCare          extends ProviderTypeName
-  case object EmergencyMedicine       extends ProviderTypeName
-  case object SocialWork              extends ProviderTypeName
-  case object NA                      extends ProviderTypeName
-  case object Other                   extends ProviderTypeName
-
-  def fromString(txt: String): Option[ProviderTypeName] = {
-    txt match {
-      case "Medical Oncology"         => Some(MedicalOncology)
-      case "Surgery"                  => Some(Surgery)
-      case "Pathology"                => Some(Pathology)
-      case "Molecular Pathology"      => Some(MolecularPathology)
-      case "LaboratoryMedicine"       => Some(LaboratoryMedicine)
-      case "Radiology"                => Some(Radiology)
-      case "Interventional Radiology" => Some(InterventionalRadiology)
-      case "Radiation Oncology"       => Some(RadiationOncology)
-      case "Primary Care"             => Some(PrimaryCare)
-      case "Cardiology"               => Some(Cardiology)
-      case "Dermatology"              => Some(Dermatology)
-      case "Ophthalmology"            => Some(Ophthalmology)
-      case "Gastroenterology"         => Some(Gastroenterology)
-      case "Neurology"                => Some(Neurology)
-      case "Psychiatry"               => Some(Psychiatry)
-      case "Gynecology"               => Some(Gynecology)
-      case "Infectious Disease"       => Some(InfectiousDisease)
-      case "Immunology"               => Some(Immunology)
-      case "Nephrology"               => Some(Nephrology)
-      case "Rheumatology"             => Some(Rheumatology)
-      case "Cytology"                 => Some(Cytology)
-      case "Otolaryngology"           => Some(Otolaryngology)
-      case "Anesthesiology"           => Some(Anesthesiology)
-      case "Urology"                  => Some(Urology)
-      case "Palliative Care"          => Some(PalliativeCare)
-      case "Emergency Medicine"       => Some(EmergencyMedicine)
-      case "Social Work"              => Some(SocialWork)
-      case "N/A"                      => Some(NA)
-      case "Other"                    => Some(Other)
-      case _                          => None
-    }
+
+  case object MedicalOncology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](1)
+    val name: String             = "Medical Oncology"
+  }
+
+  case object Surgery extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](2)
+    val name: String             = "Surgery"
+  }
+
+  case object Pathology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](3)
+    val name: String             = "Pathology"
+  }
+
+  case object MolecularPathology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](4)
+    val name: String             = "Molecular Pathology"
+  }
+
+  case object LaboratoryMedicine extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](5)
+    val name: String             = "Laboratory Medicine"
+  }
+
+  case object Radiology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](6)
+    val name: String             = "Radiology"
+  }
+
+  case object InterventionalRadiology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](7)
+    val name: String             = "Interventional Radiology"
+  }
+
+  case object RadiationOncology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](8)
+    val name: String             = "Radiation Oncology"
+  }
+
+  case object PrimaryCare extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](9)
+    val name: String             = "Primary Care"
+  }
+
+  case object Cardiology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](10)
+    val name: String             = "Cardiology"
+  }
+
+  case object Dermatology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](11)
+    val name: String             = "Dermatology"
+  }
+
+  case object Ophthalmology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](12)
+    val name: String             = "Ophthalmology"
+  }
+
+  case object Gastroenterology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](13)
+    val name: String             = "Gastroenterology"
+  }
+
+  case object Neurology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](14)
+    val name: String             = "Neurology"
+  }
+
+  case object Psychiatry extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](15)
+    val name: String             = "Psychiatry"
+  }
+
+  case object Gynecology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](16)
+    val name: String             = "Gynecology"
+  }
+
+  case object InfectiousDisease extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](17)
+    val name: String             = "Infectious Disease"
+  }
+
+  case object Immunology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](18)
+    val name: String             = "Immunology"
+  }
+
+  case object Nephrology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](19)
+    val name: String             = "Nephrology"
+  }
+
+  case object Rheumatology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](20)
+    val name: String             = "Rheumatology"
+  }
+
+  case object Cytology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](21)
+    val name: String             = "Cytology"
+  }
+
+  case object Otolaryngology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](22)
+    val name: String             = "Otolaryngology"
+  }
+
+  case object Anesthesiology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](23)
+    val name: String             = "Anesthesiology"
+  }
+
+  case object Urology extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](24)
+    val name: String             = "Urology"
+  }
+
+  case object PalliativeCare extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](25)
+    val name: String             = "Palliative Care"
+  }
+
+  case object EmergencyMedicine extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](26)
+    val name: String             = "Emergency Medicine"
+  }
+
+  case object SocialWork extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](27)
+    val name: String             = "Social Work"
+  }
+
+  case object NA extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](28)
+    val name: String             = "N/A"
+  }
+
+  case object Other extends ProviderType {
+    val id: LongId[ProviderType] = LongId[ProviderType](29)
+    val name: String             = "Other"
+  }
+
+  val All = Seq[ProviderType](
+    MedicalOncology,
+    Surgery,
+    Pathology,
+    MolecularPathology,
+    LaboratoryMedicine,
+    Radiology,
+    InterventionalRadiology,
+    RadiationOncology,
+    PrimaryCare,
+    Cardiology,
+    Dermatology,
+    Ophthalmology,
+    Gastroenterology,
+    Neurology,
+    Psychiatry,
+    Gynecology,
+    InfectiousDisease,
+    Immunology,
+    Nephrology,
+    Rheumatology,
+    Cytology,
+    Otolaryngology,
+    Anesthesiology,
+    Urology,
+    PalliativeCare,
+    EmergencyMedicine,
+    SocialWork,
+    NA,
+    Other
+  )
+
+  def fromString(txt: String): Option[ProviderType] = {
+    All.find(_.name === txt)
   }
 
   implicit def toPhiString(x: ProviderType): PhiString = {
@@ -91,39 +212,90 @@ object ProviderType {
   }
 }
 
-final case class DocumentType(id: LongId[DocumentType], name: String)
+sealed trait DocumentType {
+  val id: LongId[DocumentType]
+  val name: String
+}
 
 object DocumentType {
-  sealed trait DocumentTypeName
-  case object OutpatientPhysicianNote      extends DocumentTypeName
-  case object DischargeNote                extends DocumentTypeName
-  case object LaboratoryReport             extends DocumentTypeName
-  case object MedicationList               extends DocumentTypeName
-  case object HospitalizationNote          extends DocumentTypeName
-  case object PathologyReport              extends DocumentTypeName
-  case object RadiologyReport              extends DocumentTypeName
-  case object OperativeProcedureReport     extends DocumentTypeName
-  case object MedicationAdministration     extends DocumentTypeName
-  case object SocialWorkCaseManagementNote extends DocumentTypeName
-  case object NonPhysicianProviderNote     extends DocumentTypeName
-  case object Administrative               extends DocumentTypeName
-
-  def fromString(txt: String): Option[DocumentTypeName] = {
-    txt match {
-      case "Outpatient Physician Note"        => Some(OutpatientPhysicianNote)
-      case "Discharge Note"                   => Some(DischargeNote)
-      case "Laboratory Report"                => Some(LaboratoryReport)
-      case "Medication List"                  => Some(MedicationList)
-      case "Hospitalization Note"             => Some(HospitalizationNote)
-      case "Pathology Report"                 => Some(PathologyReport)
-      case "Radiology Report"                 => Some(RadiologyReport)
-      case "Operative/Procedure Report"       => Some(OperativeProcedureReport)
-      case "Medication Administration"        => Some(MedicationAdministration)
-      case "Social Work/Case Management Note" => Some(SocialWorkCaseManagementNote)
-      case "Non-physician Provider Note"      => Some(NonPhysicianProviderNote)
-      case "Administrative"                   => Some(Administrative)
-      case _                                  => None
-    }
+
+  case object OutpatientPhysicianNote extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](1)
+    val name: String             = "Outpatient Physician Note"
+  }
+
+  case object DischargeNote extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](2)
+    val name: String             = "Discharge Note"
+  }
+
+  case object LaboratoryReport extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](3)
+    val name: String             = "Laboratory Report"
+  }
+
+  case object MedicationList extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](4)
+    val name: String             = "Medication List"
+  }
+
+  case object HospitalizationNote extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](5)
+    val name: String             = "Hospitalization Note"
+  }
+
+  case object PathologyReport extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](6)
+    val name: String             = "Pathology Report"
+  }
+
+  case object RadiologyReport extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](7)
+    val name: String             = "Radiology Report"
+  }
+
+  case object OperativeProcedureReport extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](8)
+    val name: String             = "Operative/Procedure Report"
+  }
+
+  case object MedicationAdministration extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](9)
+    val name: String             = "Medication Administration"
+  }
+
+  case object SocialWorkCaseManagementNote extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](10)
+    val name: String             = "Social Work/Case Management Note"
+  }
+
+  case object NonPhysicianProviderNote extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](11)
+    val name: String             = "Non-physician Provider Note"
+  }
+
+  case object Administrative extends DocumentType {
+    val id: LongId[DocumentType] = LongId[DocumentType](12)
+    val name: String             = "Administrative"
+  }
+
+  val All = Seq[DocumentType](
+    OutpatientPhysicianNote,
+    DischargeNote,
+    LaboratoryReport,
+    MedicationList,
+    HospitalizationNote,
+    PathologyReport,
+    RadiologyReport,
+    OperativeProcedureReport,
+    MedicationAdministration,
+    SocialWorkCaseManagementNote,
+    NonPhysicianProviderNote,
+    Administrative
+  )
+
+  def fromString(txt: String): Option[DocumentType] = {
+    All.find(_.name === txt)
   }
 
   implicit def equal: Equal[DocumentType] = Equal.equal[DocumentType](_ == _)
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala
index 32258dc..fbd468f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/ExtractedData.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.entities
 
+import xyz.driver.entities.labels.{Label, LabelCategory}
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, TextJson}
 import xyz.driver.pdsuicommon.logging._
 import xyz.driver.pdsuidomain.entities.ExtractedData.Meta
@@ -43,5 +44,5 @@ object ExtractedDataLabel {
 final case class ExtractedDataLabel(id: LongId[ExtractedDataLabel],
                                     dataId: LongId[ExtractedData],
                                     labelId: Option[LongId[Label]],
-                                    categoryId: Option[LongId[Category]],
+                                    categoryId: Option[LongId[LabelCategory]],
                                     value: Option[FuzzyValue])
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Keyword.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Keyword.scala
index 3683efc..a984f92 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Keyword.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/Keyword.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.entities
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuicommon.logging._
 
@@ -17,7 +18,7 @@ final case class KeywordWithLabels(keyword: Keyword, labels: List[Label])
 object KeywordWithLabels {
   implicit def toPhiString(x: KeywordWithLabels): PhiString = {
     import x._
-    phi"KeywordWithLabels(keyword=$keyword, $labels)"
+    phi"KeywordWithLabels(keyword=$keyword, ${Unsafe(labels)}"
   }
 }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala
deleted file mode 100644
index eea39de..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/Label.scala
+++ /dev/null
@@ -1,31 +0,0 @@
-package xyz.driver.pdsuidomain.entities
-
-import xyz.driver.pdsuicommon.domain.LongId
-import xyz.driver.pdsuicommon.logging._
-
-final case class Category(id: LongId[Category], name: String)
-
-object Category {
-  implicit def toPhiString(x: Category): PhiString = {
-    import x._
-    phi"Category(id=$id, name=${Unsafe(name)})"
-  }
-}
-
-final case class Label(id: LongId[Label], categoryId: LongId[Category], name: String, description: String)
-
-object Label {
-  implicit def toPhiString(x: Label): PhiString = {
-    import x._
-    phi"Label($id, categoryId=${Unsafe(categoryId)}, name=${Unsafe(name)}, description=${Unsafe(description)})"
-  }
-}
-
-final case class CategoryWithLabels(category: Category, labels: List[Label])
-
-object CategoryWithLabels {
-  implicit def toPhiString(x: CategoryWithLabels): PhiString = {
-    import x._
-    phi"CategoryWithLabels(category=$category, labels=$labels)"
-  }
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala
index 633a347..d10c7d2 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabel.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.entities
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, UuidId}
 import xyz.driver.pdsuicommon.logging._
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabelEvidenceView.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabelEvidenceView.scala
index 34e3741..3311d96 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabelEvidenceView.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/PatientLabelEvidenceView.scala
@@ -2,6 +2,7 @@ package xyz.driver.pdsuidomain.entities
 
 import java.time.LocalDate
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuicommon.logging._
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/RawPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/RawPatientLabel.scala
index 6114661..689eaa4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/RawPatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/RawPatientLabel.scala
@@ -2,6 +2,7 @@ package xyz.driver.pdsuidomain.entities
 
 import java.time.LocalDate
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, UuidId}
 import xyz.driver.pdsuicommon.logging._
 
@@ -13,8 +14,8 @@ final case class RawPatientLabel(patientId: UuidId[Patient],
                                  disease: String,
                                  documentId: LongId[Document],
                                  requestId: RecordRequestId,
-                                 documentType: String,
-                                 providerType: String,
+                                 documentType: DocumentType,
+                                 providerType: ProviderType,
                                  startDate: LocalDate,
                                  endDate: Option[LocalDate])
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/RawTrialLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/RawTrialLabel.scala
index 9e69c87..bdbc4ea 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/RawTrialLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/RawTrialLabel.scala
@@ -2,6 +2,7 @@ package xyz.driver.pdsuidomain.entities
 
 import java.time.LocalDateTime
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
 import xyz.driver.pdsuicommon.logging._
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/eligibility.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/eligibility.scala
new file mode 100644
index 0000000..1a900ac
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/eligibility.scala
@@ -0,0 +1,63 @@
+package xyz.driver.pdsuidomain.entities
+
+import xyz.driver.core.Id
+import xyz.driver.core.date.Date
+import xyz.driver.entities.assays.AssayType
+import xyz.driver.entities.clinic.{ClinicalRecord, TestOrder}
+import xyz.driver.entities.common.FullName
+import xyz.driver.entities.labels.{Label, LabelValue}
+import xyz.driver.entities.patient.CancerType
+import xyz.driver.entities.process.ProcessStepExecutionStatus
+import xyz.driver.entities.report.Report
+import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialWithLabels
+
+object eligibility {
+
+  sealed trait EvidenceDocument {
+    val documentType: DocumentType
+    val providerType: ProviderType
+    val providerName: Option[String]
+    val date: Option[Date]
+    val isDriverDocument: Boolean
+  }
+
+  final case class MolecularEvidenceDocument(documentType: DocumentType,
+                                             providerType: ProviderType,
+                                             providerName: Option[String],
+                                             date: Option[Date],
+                                             reportId: Id[Report],
+                                             reportType: AssayType,
+                                             isDriverDocument: Boolean = true)
+      extends EvidenceDocument
+
+  final case class ClinicalEvidenceDocument(documentId: Id[ClinicalEvidenceDocument],
+                                            documentType: DocumentType,
+                                            providerType: ProviderType,
+                                            providerName: Option[String],
+                                            date: Option[Date],
+                                            requestId: Id[ClinicalRecord],
+                                            isDriverDocument: Boolean = false)
+      extends EvidenceDocument
+
+  // Some fields are optional because they are not in the backend response
+  final case class Evidence(evidenceId: Option[Id[Evidence]],
+                            evidenceText: String,
+                            labelValue: LabelValue,
+                            document: EvidenceDocument,
+                            isPrimaryValue: Option[Boolean] = None)
+
+  final case class LabelEvidence(label: Label, evidence: Seq[Evidence] = Seq.empty)
+
+  final case class LabelMismatchRank(label: Label,
+                                     score: Int,
+                                     trials: Seq[ExportTrialWithLabels],
+                                     evidence: Seq[Evidence])
+  final case class MismatchRankedLabels(data: Seq[LabelMismatchRank], labelVersion: Int)
+
+  final case class MatchedPatient(patientId: Id[xyz.driver.entities.patient.Patient],
+                                  name: FullName[xyz.driver.entities.patient.Patient],
+                                  birthDate: Date,
+                                  orderId: Id[TestOrder],
+                                  disease: CancerType,
+                                  patientDataStatus: ProcessStepExecutionStatus)
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala
index c69fc09..2edd707 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabel.scala
@@ -1,8 +1,9 @@
 package xyz.driver.pdsuidomain.entities.export.patient
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuicommon.logging._
-import xyz.driver.pdsuidomain.entities.{Label, RawPatientLabel}
+import xyz.driver.pdsuidomain.entities.RawPatientLabel
 
 final case class ExportPatientLabel(id: LongId[Label], evidences: List[ExportPatientLabelEvidence])
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabelEvidenceDocument.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabelEvidenceDocument.scala
index 99912bc..7003615 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabelEvidenceDocument.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/patient/ExportPatientLabelEvidenceDocument.scala
@@ -4,12 +4,12 @@ import java.time.LocalDate
 
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuicommon.logging._
-import xyz.driver.pdsuidomain.entities.{Document, RawPatientLabel, RecordRequestId}
+import xyz.driver.pdsuidomain.entities._
 
 final case class ExportPatientLabelEvidenceDocument(documentId: LongId[Document],
                                                     requestId: RecordRequestId,
-                                                    documentType: String,
-                                                    providerType: String,
+                                                    documentType: DocumentType,
+                                                    providerType: ProviderType,
                                                     date: LocalDate)
 
 object ExportPatientLabelEvidenceDocument extends PhiLogging {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala
index 7bff22c..1f06e0d 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/entities/export/trial/ExportTrialLabelCriterion.scala
@@ -1,8 +1,9 @@
 package xyz.driver.pdsuidomain.entities.export.trial
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuicommon.logging._
-import xyz.driver.pdsuidomain.entities.{Arm, Criterion, Label, RawTrialLabel}
+import xyz.driver.pdsuidomain.entities.{Arm, Criterion, RawTrialLabel}
 
 final case class ExportTrialLabelCriterion(criterionId: LongId[Criterion],
                                            value: Option[Boolean],
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/common.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/common.scala
index b259b07..7318ff6 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/common.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/common.scala
@@ -2,26 +2,28 @@ package xyz.driver.pdsuidomain.fakes.entities
 
 import java.time.{LocalDate, LocalDateTime, LocalTime}
 
-import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
+import xyz.driver.core.generators.{nextDouble, nextOption}
+import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId, UuidId}
 import xyz.driver.pdsuidomain.entities.{Trial, TrialHistory}
+
 import scala.util.Random
 
 object common {
   import xyz.driver.core.generators
 
-  def nextUuidId[T] = UuidId[T](generators.nextUuid())
+  def nextUuidId[T]: UuidId[T] = UuidId[T](generators.nextUuid())
 
-  def nextLongId[T] = LongId[T](generators.nextInt(Int.MaxValue).toLong)
+  def nextLongId[T]: LongId[T] = LongId[T](generators.nextInt(Int.MaxValue).toLong)
 
-  def nextStringId[T] = StringId[T](generators.nextString(maxLength = 20))
+  def nextStringId[T]: StringId[T] = StringId[T](generators.nextString(maxLength = 20))
 
-  def nextTrialStatus = generators.oneOf[Trial.Status](Trial.Status.All)
+  def nextTrialStatus: Trial.Status = generators.oneOf[Trial.Status](Trial.Status.All)
 
-  def nextPreviousTrialStatus = generators.oneOf[Trial.Status](Trial.Status.AllPrevious)
+  def nextPreviousTrialStatus: Trial.Status = generators.oneOf[Trial.Status](Trial.Status.AllPrevious)
 
-  def nextLocalDateTime = LocalDateTime.of(nextLocalDate, LocalTime.MIDNIGHT)
+  def nextLocalDateTime: LocalDateTime = LocalDateTime.of(nextLocalDate, LocalTime.MIDNIGHT)
 
-  def nextLocalDate = LocalDate.of(
+  def nextLocalDate: LocalDate = LocalDate.of(
     1970 + Random.nextInt(68),
     1 + Random.nextInt(12),
     1 + Random.nextInt(28) // all months have at least 28 days
@@ -33,4 +35,27 @@ object common {
 
   def nextTrialState = generators.oneOf[TrialHistory.State](TrialHistory.State.All)
 
+  def genBoundedRange[T](from: T, to: T)(implicit ord: Ordering[T]): (T, T) = {
+    if (ord.compare(from, to) > 0) {
+      to -> from
+    } else {
+      from -> to
+    }
+  }
+
+  def genBoundedRangeOption[T](from: T, to: T)(implicit ord: Ordering[T]): (Option[T], Option[T]) = {
+    val ranges = nextOption(from).map { left =>
+      val range = genBoundedRange(left, to)
+      range._1 -> nextOption(range._2)
+    }
+
+    ranges.map(_._1) -> ranges.flatMap(_._2)
+  }
+
+  def nextFuzzyValue(): FuzzyValue =
+    generators.oneOf[FuzzyValue](FuzzyValue.All)
+
+  def nextStartAndEndPages: (Option[Double], Option[Double]) =
+    genBoundedRangeOption[Double](nextDouble(), nextDouble())
+
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/eligibility.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/eligibility.scala
new file mode 100644
index 0000000..5f3321c
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/eligibility.scala
@@ -0,0 +1,72 @@
+package xyz.driver.pdsuidomain.fakes.entities
+
+import xyz.driver.core.generators
+import xyz.driver.entities.clinic.{ClinicalRecord, TestOrder}
+import xyz.driver.entities.patient.{CancerType, Patient}
+import xyz.driver.entities.report.Report
+import xyz.driver.fakes
+import xyz.driver.pdsuidomain.entities.eligibility._
+
+object eligibility {
+  import xyz.driver.core.generators._
+
+  def nextMolecularEvidenceDocument(): MolecularEvidenceDocument =
+    MolecularEvidenceDocument(
+      documentType = xyz.driver.pdsuidomain.fakes.entities.rep.DocumentGen.nextDocumentType(),
+      providerType = xyz.driver.pdsuidomain.fakes.entities.rep.MedicalRecordGen.nextProviderType(),
+      providerName = nextOption(nextString(100)),
+      date = nextOption(nextDate()),
+      reportId = nextId[Report](),
+      reportType = fakes.entities.assays.nextAssayType(),
+      isDriverDocument = nextBoolean()
+    )
+
+  def nextClinicalEvidenceDocument(): ClinicalEvidenceDocument =
+    ClinicalEvidenceDocument(
+      documentType = xyz.driver.pdsuidomain.fakes.entities.rep.DocumentGen.nextDocumentType(),
+      providerType = xyz.driver.pdsuidomain.fakes.entities.rep.MedicalRecordGen.nextProviderType(),
+      providerName = nextOption(nextString(100)),
+      date = nextOption(nextDate()),
+      documentId = nextId[ClinicalEvidenceDocument](),
+      requestId = nextId[ClinicalRecord](),
+      isDriverDocument = nextBoolean()
+    )
+
+  def nextEvidenceDocument(): EvidenceDocument =
+    oneOf[EvidenceDocument](nextMolecularEvidenceDocument(),
+                            nextClinicalEvidenceDocument(),
+                            nextClinicalEvidenceDocument()) // For more clinical documents
+
+  def nextEvidence(): Evidence =
+    Evidence(
+      evidenceId = Option(nextId[Evidence]()),
+      evidenceText = nextString(100),
+      labelValue = xyz.driver.fakes.entities.labels.nextLabelValue(),
+      nextEvidenceDocument(),
+      isPrimaryValue = nextOption(nextBoolean())
+    )
+
+  def nextLabelEvidence(): LabelEvidence =
+    LabelEvidence(label = fakes.entities.labels.nextLabel(), evidence = Seq.empty)
+
+  def nextLabelMismatchRank(): LabelMismatchRank =
+    LabelMismatchRank(
+      label = fakes.entities.labels.nextLabel(),
+      score = nextInt(100),
+      trials = seqOf(xyz.driver.pdsuidomain.fakes.entities.export.nextExportTrialWithLabels()),
+      evidence = seqOf(nextEvidence())
+    )
+
+  def nextMismatchRankedLabels(): MismatchRankedLabels =
+    MismatchRankedLabels(data = seqOf(nextLabelMismatchRank()), labelVersion = nextInt(100))
+
+  def nextMatchedPatient(): MatchedPatient =
+    MatchedPatient(
+      patientId = nextId[Patient](),
+      name = fakes.entities.common.nextFullName[Patient](),
+      birthDate = nextDate(),
+      orderId = nextId[TestOrder](),
+      disease = generators.oneOf[CancerType](CancerType.Breast, CancerType.Lung, CancerType.Prostate),
+      patientDataStatus = fakes.entities.process.nextProcessStepExecutionStatus()
+    )
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala
new file mode 100644
index 0000000..7f3c410
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/export.scala
@@ -0,0 +1,35 @@
+package xyz.driver.pdsuidomain.fakes.entities
+
+import xyz.driver.entities.labels.Label
+import xyz.driver.pdsuidomain.entities.{Arm, Criterion, Trial}
+import xyz.driver.pdsuidomain.entities.export.trial._
+
+object export {
+  import xyz.driver.core.generators._
+  import common._
+
+  def nextExportTrialArm(): ExportTrialArm =
+    ExportTrialArm(armId = nextLongId[Arm], armName = nextString(100))
+
+  def nextExportTrialLabelCriterion(): ExportTrialLabelCriterion =
+    ExportTrialLabelCriterion(
+      criterionId = nextLongId[Criterion],
+      value = nextOption[Boolean](nextBoolean()),
+      labelId = nextLongId[Label],
+      armIds = setOf(nextLongId[Arm]),
+      criteria = nextString(100),
+      isCompound = nextBoolean(),
+      isDefining = nextBoolean()
+    )
+
+  def nextExportTrialWithLabels(): ExportTrialWithLabels =
+    ExportTrialWithLabels(
+      nctId = nextStringId[Trial],
+      trialId = nextUuidId[Trial],
+      condition = nextString(100),
+      lastReviewed = nextLocalDateTime,
+      labelVersion = nextInt(100).toLong,
+      arms = listOf(nextExportTrialArm()),
+      criteria = listOf(nextExportTrialLabelCriterion())
+    )
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala
new file mode 100644
index 0000000..e7cbd19
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/BridgeUploadQueueGen.scala
@@ -0,0 +1,22 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators.{nextBoolean, nextInt, nextOption, nextString}
+import xyz.driver.pdsuicommon.concurrent.BridgeUploadQueue
+import xyz.driver.pdsuidomain.fakes.entities.common.nextLocalDateTime
+
+object BridgeUploadQueueGen {
+  private val maxAttemptsNumber = 100
+
+  def nextBridgeUploadQueueItem(): BridgeUploadQueue.Item = {
+    BridgeUploadQueue.Item(
+      kind = nextString(),
+      tag = nextString(),
+      created = nextLocalDateTime,
+      attempts = nextInt(maxAttemptsNumber, minValue = 0),
+      nextAttempt = nextLocalDateTime,
+      completed = nextBoolean(),
+      dependencyKind = nextOption(nextString()),
+      dependencyTag = nextOption(nextString())
+    )
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala
new file mode 100644
index 0000000..1ac75ab
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/DocumentGen.scala
@@ -0,0 +1,107 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import java.time.LocalDate
+
+import xyz.driver.core.generators
+import xyz.driver.core.generators.{nextBoolean, nextDouble, nextOption, nextString}
+import xyz.driver.pdsuidomain.fakes.entities.common._
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson, User}
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDate, nextLocalDateTime, nextLongId, nextStringId}
+
+object DocumentGen {
+  implicit private class LocalDateOrdering(localData: LocalDate) extends Ordered[LocalDate] {
+
+    override def compare(that: LocalDate): Int = {
+      this.localData.compareTo(that)
+    }
+  }
+
+  private def nextDates() =
+    genBoundedRangeOption[LocalDate](nextLocalDate, nextLocalDate)
+
+  private def nextStartAndEndPagesOption() =
+    nextStartAndEndPages
+
+  private def nextStartAndEndPage() =
+    genBoundedRange(nextDouble(), nextDouble())
+
+  def nextDocumentStatus(): Document.Status =
+    Document.Status.New
+
+  def nextDocumentRequiredType(): Document.RequiredType =
+    generators.oneOf[Document.RequiredType](Document.RequiredType.All)
+
+  def nextDocumentHistoryState(): DocumentHistory.State =
+    generators.oneOf[DocumentHistory.State](DocumentHistory.State.All)
+
+  def nextDocumentHistoryAction(): DocumentHistory.Action =
+    generators.oneOf[DocumentHistory.Action](DocumentHistory.Action.All)
+
+  def nextDocumentMeta(): Document.Meta = {
+    val (startPage, endPage) = nextStartAndEndPage()
+
+    Document.Meta(
+      nextOption(nextBoolean()),
+      startPage,
+      endPage
+    )
+  }
+
+  def nextDocumentMetaJson(): TextJson[Document.Meta] = {
+    TextJson(nextDocumentMeta())
+  }
+
+  def nextDocument(): Document = {
+    val dates = nextDates()
+
+    Document(
+      id = nextLongId[Document],
+      status = nextDocumentStatus(),
+      previousStatus = None,
+      assignee = nextOption(nextStringId[User]),
+      previousAssignee = nextOption(nextStringId[User]),
+      lastActiveUserId = nextOption(nextStringId[User]),
+      recordId = nextLongId[MedicalRecord],
+      physician = nextOption(nextString()),
+      typeId = nextOption(nextLongId[DocumentType]),
+      providerName = nextOption(nextString()),
+      providerTypeId = nextOption(nextLongId[ProviderType]),
+      requiredType = nextOption(nextDocumentRequiredType()),
+      meta = nextOption(nextDocumentMetaJson()),
+      startDate = dates._1,
+      endDate = dates._2,
+      lastUpdate = nextLocalDateTime
+    )
+  }
+
+  def nextDocumentType(): DocumentType =
+    generators.oneOf(DocumentType.All: _*)
+
+  def nextDocumentIssue(documentId: LongId[Document] = nextLongId): DocumentIssue = {
+    val pages = nextStartAndEndPagesOption()
+
+    DocumentIssue(
+      id = nextLongId[DocumentIssue],
+      userId = nextStringId[User],
+      documentId = documentId,
+      startPage = pages._1,
+      endPage = pages._2,
+      lastUpdate = nextLocalDateTime,
+      isDraft = nextBoolean(),
+      text = nextString(),
+      archiveRequired = nextBoolean()
+    )
+  }
+
+  def nextDocumentHistory(documentId: LongId[Document] = nextLongId): DocumentHistory = {
+    DocumentHistory(
+      id = nextLongId[DocumentHistory],
+      executor = nextStringId[User],
+      documentId = documentId,
+      state = nextDocumentHistoryState(),
+      action = nextDocumentHistoryAction(),
+      created = nextLocalDateTime
+    )
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExportPatientGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExportPatientGen.scala
new file mode 100644
index 0000000..3fcc4cb
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExportPatientGen.scala
@@ -0,0 +1,54 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators._
+import xyz.driver.entities.labels.Label
+import xyz.driver.pdsuicommon.domain.{LongId, UuidId}
+import xyz.driver.pdsuidomain.fakes.entities.common._
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.entities.export.patient._
+import xyz.driver.pdsuidomain.fakes.entities.common.{nextLocalDate, nextLongId}
+import xyz.driver.pdsuidomain.fakes.entities.rep.DocumentGen._
+import xyz.driver.pdsuidomain.fakes.entities.rep.MedicalRecordGen._
+
+object ExportPatientGen {
+  private val maxItemsInCollectionNumber = 3
+
+  def nextExportPatientLabelEvidenceDocument(documentId: LongId[Document]): ExportPatientLabelEvidenceDocument = {
+    ExportPatientLabelEvidenceDocument(
+      documentId = documentId,
+      requestId = RecordRequestId(nextUuid()),
+      documentType = nextDocumentType(),
+      providerType = nextProviderType(),
+      date = nextLocalDate
+    )
+  }
+
+  def nextExportPatientLabelEvidence(documentId: LongId[Document]): ExportPatientLabelEvidence = {
+    ExportPatientLabelEvidence(
+      id = nextLongId[ExtractedData],
+      value = nextFuzzyValue(),
+      evidenceText = nextString(),
+      document = nextExportPatientLabelEvidenceDocument(documentId)
+    )
+  }
+
+  def nextExportPatientLabel(documentId: LongId[Document]): ExportPatientLabel = {
+    ExportPatientLabel(
+      id = nextLongId[Label],
+      evidences = List.fill(
+        nextInt(maxItemsInCollectionNumber, minValue = 0)
+      )(nextExportPatientLabelEvidence(documentId))
+    )
+  }
+
+  def nextExportPatientWithLabels(documentId: LongId[Document]): ExportPatientWithLabels = {
+    ExportPatientWithLabels(
+      patientId = UuidId[xyz.driver.pdsuidomain.entities.Patient](nextUuid()),
+      labelVersion = scala.util.Random.nextLong(),
+      labels = List.fill(
+        nextInt(maxItemsInCollectionNumber, minValue = 0)
+      )(nextExportPatientLabel(documentId))
+    )
+  }
+
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala
new file mode 100644
index 0000000..8e77445
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/ExtractedDataGen.scala
@@ -0,0 +1,100 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.core.generators._
+import xyz.driver.entities.labels.{Label, LabelCategory}
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson}
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.entities.ExtractedData.Meta
+import xyz.driver.pdsuidomain.fakes.entities.common._
+import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
+
+object ExtractedDataGen {
+  private val maxItemsInCollectionNumber = 50
+
+  private val maxPageNumber   = 100
+  private val maxIndexNumber  = 100
+  private val maxOffsetNumber = 10
+
+  implicit private class TextLayerPositionOrdering(textLayerPosition: ExtractedData.Meta.TextLayerPosition)
+      extends Ordered[ExtractedData.Meta.TextLayerPosition] {
+    override def compare(that: Meta.TextLayerPosition): Int = {
+      if (this.textLayerPosition.page < that.page) -1
+      else if (this.textLayerPosition.page > that.page) 1
+      else if (this.textLayerPosition.index < that.index) -1
+      else if (this.textLayerPosition.index > that.index) 1
+      else if (this.textLayerPosition.offset < that.offset) -1
+      else if (this.textLayerPosition.offset > that.offset) 1
+      else 0
+    }
+  }
+
+  def nextExtractedDataMetaKeyword(): Meta.Keyword = {
+    ExtractedData.Meta.Keyword(
+      page = nextInt(maxPageNumber, minValue = 0),
+      pageRatio = nextOption(nextDouble()),
+      index = nextInt(maxIndexNumber, minValue = 0),
+      sortIndex = nextString()
+    )
+  }
+
+  def nextExtractedDataMetaTextLayerPosition(): Meta.TextLayerPosition = {
+    ExtractedData.Meta.TextLayerPosition(
+      page = nextInt(maxPageNumber, minValue = 0),
+      index = nextInt(maxIndexNumber, minValue = 0),
+      offset = nextInt(maxOffsetNumber, minValue = 0)
+    )
+  }
+
+  def nextExtractedDataMetaEvidence(): Meta.Evidence = {
+    val layersPosition =
+      genBoundedRange[ExtractedData.Meta.TextLayerPosition](
+        nextExtractedDataMetaTextLayerPosition(),
+        nextExtractedDataMetaTextLayerPosition()
+      )
+
+    ExtractedData.Meta.Evidence(
+      pageRatio = nextDouble(),
+      start = layersPosition._1,
+      end = layersPosition._2
+    )
+  }
+
+  def nextExtractedDataMeta(): Meta = {
+    ExtractedData.Meta(
+      nextExtractedDataMetaKeyword(),
+      nextExtractedDataMetaEvidence()
+    )
+  }
+
+  def nextExtractedDataMetaJson(): TextJson[Meta] =
+    TextJson(ExtractedData.Meta(nextExtractedDataMetaKeyword(), nextExtractedDataMetaEvidence()))
+
+  def nextExtractedData(documentId: LongId[Document]): ExtractedData = {
+    ExtractedData(
+      id = nextLongId[ExtractedData],
+      documentId = documentId,
+      keywordId = nextOption(nextLongId[xyz.driver.pdsuidomain.entities.Keyword]),
+      evidenceText = nextOption(nextString()),
+      meta = nextOption(nextExtractedDataMetaJson())
+    )
+  }
+
+  def nextExtractedDataLabel(): ExtractedDataLabel = {
+    ExtractedDataLabel(
+      id = nextLongId[ExtractedDataLabel],
+      dataId = nextLongId[ExtractedData],
+      labelId = nextOption(nextLongId[Label]),
+      categoryId = nextOption(nextLongId[LabelCategory]),
+      value = nextOption(nextFuzzyValue())
+    )
+  }
+
+  def nextRichExtractedData(documentId: LongId[Document] = nextLongId): RichExtractedData = {
+    RichExtractedData(
+      extractedData = nextExtractedData(documentId),
+      labels = List.fill(
+        nextInt(maxItemsInCollectionNumber, minValue = 0)
+      )(nextExtractedDataLabel())
+    )
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala
new file mode 100644
index 0000000..2777116
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/rep/MedicalRecordGen.scala
@@ -0,0 +1,147 @@
+package xyz.driver.pdsuidomain.fakes.entities.rep
+
+import xyz.driver.pdsuidomain.entities._
+import xyz.driver.core.generators
+import xyz.driver.core.generators._
+import xyz.driver.pdsuicommon.domain.{LongId, TextJson, User}
+import xyz.driver.pdsuidomain.fakes.entities.common._
+
+object MedicalRecordGen {
+  private val maxItemsInCollectionNumber: Int = 50
+
+  private val pageMaxNumber: Int = 1000
+
+  private val medicalRecordMetas: Set[() => MedicalRecord.Meta] = {
+    Set(
+      () => nextMedicalRecordMetaReorder(),
+      () => nextMedicalRecordMetaDuplicate(),
+      () => nextMedicalRecordMetaRotation()
+    )
+  }
+
+  def nextMedicalRecordMetas(count: Int): List[MedicalRecord.Meta] =
+    List.fill(count)(nextMedicalRecordMeta())
+
+  def nextMedicalRecordMetasJson(): TextJson[List[MedicalRecord.Meta]] =
+    TextJson(nextMedicalRecordMetas(nextInt(maxItemsInCollectionNumber, minValue = 0)))
+
+  private def nextDocument(): Document =
+    DocumentGen.nextDocument()
+
+  private def nextDocuments(count: Int): List[Document] =
+    List.fill(count)(nextDocument())
+
+  def nextDocuments(recordId: LongId[MedicalRecord]): TextJson[List[Document]] = {
+    val documents = nextDocuments(
+      nextInt(maxItemsInCollectionNumber, minValue = 0)
+    )
+
+    TextJson(documents.map(_.copy(recordId = recordId)))
+  }
+
+  def nextMedicalRecordStatus(): MedicalRecord.Status =
+    MedicalRecord.Status.New
+
+  def nextMedicalRecordHistoryState(): MedicalRecordHistory.State =
+    generators.oneOf[MedicalRecordHistory.State](MedicalRecordHistory.State.All)
+
+  def nextMedicalRecordHistoryAction(): MedicalRecordHistory.Action =
+    generators.oneOf[MedicalRecordHistory.Action](MedicalRecordHistory.Action.All)
+
+  def nextMedicalRecordMetaReorder(): MedicalRecord.Meta.Reorder = {
+    val itemsNumber =
+      maxItemsInCollectionNumber
+    val items = scala.util.Random
+      .shuffle(Seq.tabulate(itemsNumber)(identity))
+
+    MedicalRecord.Meta.Reorder(
+      predicted = nextOption(nextBoolean),
+      items = items
+    )
+  }
+
+  def nextMedicalRecordMetaDuplicate(): MedicalRecord.Meta.Duplicate = {
+    val startPageGen =
+      nextInt(pageMaxNumber, minValue = 0)
+    val endPageGen =
+      nextInt(pageMaxNumber, startPageGen)
+
+    MedicalRecord.Meta.Duplicate(
+      predicted = nextOption(nextBoolean),
+      startPage = startPageGen.toDouble,
+      endPage = endPageGen.toDouble,
+      startOriginalPage = startPageGen.toDouble,
+      endOriginalPage = nextOption(endPageGen.toDouble)
+    )
+  }
+
+  def nextMedicalRecordMetaRotation(): MedicalRecord.Meta.Rotation = {
+    val items =
+      Array
+        .tabulate(maxItemsInCollectionNumber)(
+          index => nextString() -> index
+        )
+        .toMap
+
+    MedicalRecord.Meta.Rotation(
+      predicted = nextOption(nextBoolean()),
+      items = items
+    )
+  }
+
+  def nextMedicalRecordMeta(): MedicalRecord.Meta = {
+    generators.oneOf(medicalRecordMetas)()
+  }
+
+  def nextMedicalRecord(): MedicalRecord = {
+    val id = nextLongId[MedicalRecord]
+    MedicalRecord(
+      id = nextLongId[MedicalRecord],
+      status = nextMedicalRecordStatus(),
+      previousStatus = None,
+      assignee = nextOption(nextStringId),
+      previousAssignee = nextOption(nextStringId),
+      lastActiveUserId = nextOption(nextStringId),
+      patientId = nextUuidId,
+      requestId = RecordRequestId(generators.nextUuid()),
+      disease = generators.nextString(),
+      caseId = nextOption(CaseId(generators.nextString())),
+      physician = nextOption(generators.nextString()),
+      meta = nextOption(nextMedicalRecordMetasJson()),
+      predictedMeta = nextOption(nextMedicalRecordMetasJson()),
+      predictedDocuments = nextOption(nextDocuments(id)),
+      lastUpdate = nextLocalDateTime
+    )
+  }
+
+  def nextMedicalRecordHistory(): MedicalRecordHistory = {
+    MedicalRecordHistory(
+      id = nextLongId[MedicalRecordHistory],
+      executor = nextStringId[User],
+      recordId = nextLongId[MedicalRecord],
+      state = nextMedicalRecordHistoryState(),
+      action = nextMedicalRecordHistoryAction(),
+      created = nextLocalDateTime
+    )
+  }
+
+  def nextMedicalRecordIssue(): MedicalRecordIssue = {
+    val pages = nextStartAndEndPages
+
+    MedicalRecordIssue(
+      id = nextLongId[MedicalRecordIssue],
+      userId = nextStringId[User],
+      recordId = nextLongId[MedicalRecord],
+      startPage = pages._1,
+      endPage = pages._2,
+      lastUpdate = nextLocalDateTime,
+      isDraft = nextBoolean(),
+      text = nextString(),
+      archiveRequired = nextBoolean()
+    )
+  }
+
+  def nextProviderType(): ProviderType =
+    generators.oneOf(ProviderType.All: _*)
+
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala
index fe5bf09..9a5022c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/fakes/entities/trialcuration.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.fakes.entities
 
+import xyz.driver.entities.labels.{Label, LabelCategory}
 import xyz.driver.pdsuicommon.domain.{LongId, User}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.services.CriterionService.RichCriterion
@@ -44,14 +45,15 @@ object trialcuration {
     trialId = nextStringId[Trial],
     text = Option(generators.nextString()),
     isCompound = generators.nextBoolean(),
-    meta = generators.nextString()
+    meta = generators.nextString(),
+    inclusion = Option(generators.nextBoolean())
   )
 
   def nextCriterionLabel(criterionId: LongId[Criterion]): CriterionLabel = CriterionLabel(
     id = nextLongId[CriterionLabel],
     labelId = Option(nextLongId[Label]),
     criterionId = criterionId,
-    categoryId = Option(nextLongId[Category]),
+    categoryId = Option(nextLongId[LabelCategory]),
     value = Option(generators.nextBoolean()),
     isDefining = generators.nextBoolean()
   )
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala
deleted file mode 100644
index f1e15f3..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/category/ApiCategory.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.category
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuidomain.entities.CategoryWithLabels
-import xyz.driver.pdsuidomain.formats.json.label.ApiLabel
-
-final case class ApiCategory(id: Long, name: String, labels: List[ApiLabel])
-
-object ApiCategory {
-
-  implicit val format: Format[ApiCategory] = (
-    (JsPath \ "id").format[Long] and
-      (JsPath \ "name").format[String] and
-      (JsPath \ "labels").format[List[ApiLabel]]
-  )(ApiCategory.apply, unlift(ApiCategory.unapply))
-
-  def fromDomain(categoryWithLabels: CategoryWithLabels) = ApiCategory(
-    id = categoryWithLabels.category.id.id,
-    name = categoryWithLabels.category.name,
-    labels = categoryWithLabels.labels.map(x => ApiLabel(x.id.id, x.name, x.categoryId.id))
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala
index 4986b17..43b5494 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiCriterion.scala
@@ -14,7 +14,8 @@ final case class ApiCriterion(id: Long,
                               text: Option[String],
                               isCompound: Boolean,
                               labels: Seq[ApiCriterionLabel],
-                              trialId: String) {
+                              trialId: String,
+                              inclusion: Option[Boolean]) {
 
   def toDomain = RichCriterion(
     criterion = Criterion(
@@ -22,7 +23,8 @@ final case class ApiCriterion(id: Long,
       trialId = StringId[Trial](trialId),
       text,
       isCompound,
-      meta.getOrElse("")
+      meta.getOrElse(""),
+      inclusion
     ),
     armIds = arms.map(LongId[Arm]),
     labels = labels.map(_.toDomain(LongId[Criterion](id)))
@@ -40,7 +42,8 @@ object ApiCriterion {
       (JsPath \ "text").formatNullable[String] and
       (JsPath \ "isCompound").format[Boolean] and
       (JsPath \ "labels").format(seqJsonFormat[ApiCriterionLabel]) and
-      (JsPath \ "trialId").format[String]
+      (JsPath \ "trialId").format[String] and
+      (JsPath \ "inclusion").formatNullable[Boolean]
   )(ApiCriterion.apply, unlift(ApiCriterion.unapply))
 
   def fromDomain(richCriterion: RichCriterion) = ApiCriterion(
@@ -50,6 +53,7 @@ object ApiCriterion {
     text = richCriterion.criterion.text,
     isCompound = richCriterion.criterion.isCompound,
     labels = richCriterion.labels.map(ApiCriterionLabel.fromDomain),
-    trialId = richCriterion.criterion.trialId.id
+    trialId = richCriterion.criterion.trialId.id,
+    inclusion = richCriterion.criterion.inclusion
   )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
index ab7641f..d72a9b4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiNewCriterion.scala
@@ -13,7 +13,8 @@ final case class ApiNewCriterion(meta: Option[String],
                                  text: Option[String],
                                  isCompound: Option[Boolean],
                                  labels: Seq[ApiCriterionLabel],
-                                 trialId: String) {
+                                 trialId: String,
+                                 inclusion: Option[Boolean]) {
 
   def toDomain = RichCriterion(
     criterion = Criterion(
@@ -21,7 +22,8 @@ final case class ApiNewCriterion(meta: Option[String],
       meta = meta.getOrElse(""),
       trialId = StringId(trialId),
       isCompound = isCompound.getOrElse(false),
-      text = text
+      text = text,
+      inclusion = inclusion
     ),
     armIds = arms.getOrElse(Seq.empty).map(LongId[Arm]),
     labels = labels.map(_.toDomain(LongId(Long.MaxValue))) // A developer should specify right criterionId himself
@@ -38,6 +40,7 @@ object ApiNewCriterion {
       (JsPath \ "text").formatNullable[String] and
       (JsPath \ "isCompound").formatNullable[Boolean] and
       (JsPath \ "labels").format(seqJsonFormat[ApiCriterionLabel]) and
-      (JsPath \ "trialId").format[String]
+      (JsPath \ "trialId").format[String] and
+      (JsPath \ "inclusion").formatNullable[Boolean]
   )(ApiNewCriterion.apply, unlift(ApiNewCriterion.unapply))
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala
index 2bcda56..77989f0 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/criterion/ApiUpdateCriterion.scala
@@ -14,6 +14,7 @@ final case class ApiUpdateCriterion(meta: Tristate[String],
                                     arms: Tristate[Seq[Long]],
                                     text: Option[String],
                                     isCompound: Option[Boolean],
+                                    inclusion: Tristate[Boolean],
                                     labels: Tristate[Seq[ApiCriterionLabel]]) {
 
   def applyTo(orig: RichCriterion): RichCriterion = RichCriterion(
@@ -27,7 +28,8 @@ final case class ApiUpdateCriterion(meta: Tristate[String],
     meta = meta.cata(identity, "{}", orig.meta),
     text = text.orElse(orig.text),
     isCompound = isCompound.getOrElse(orig.isCompound),
-    trialId = orig.trialId
+    trialId = orig.trialId,
+    inclusion = inclusion.cata(x => Some(x), None, orig.inclusion)
   )
 }
 
@@ -45,6 +47,7 @@ object ApiUpdateCriterion {
       (JsPath \ "arms").readTristate(seqJsonFormat[Long]) and
       (JsPath \ "text").readNullable[String] and
       (JsPath \ "isCompound").readNullable[Boolean] and
+      (JsPath \ "inclusion").readTristate[Boolean] and
       (JsPath \ "labels").readTristate(seqJsonFormat[ApiCriterionLabel])
   )(ApiUpdateCriterion.apply _)
 
@@ -53,6 +56,7 @@ object ApiUpdateCriterion {
       (JsPath \ "arms").writeTristate(seqJsonFormat[Long]) and
       (JsPath \ "text").writeNullable[String] and
       (JsPath \ "isCompound").writeNullable[Boolean] and
+      (JsPath \ "inclusion").writeTristate[Boolean] and
       (JsPath \ "labels").writeTristate(seqJsonFormat[ApiCriterionLabel])
   )(unlift(ApiUpdateCriterion.unapply))
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala
index 8b4974f..22bea6b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiDocumentType.scala
@@ -2,15 +2,14 @@ package xyz.driver.pdsuidomain.formats.json.document
 
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.DocumentType
 
 final case class ApiDocumentType(id: Long, name: String) {
 
-  def toDomain = DocumentType(
-    id = LongId(this.id),
-    name = this.name
-  )
+  def toDomain: DocumentType =
+    DocumentType
+      .fromString(name)
+      .getOrElse(throw new IllegalArgumentException(s"Unknown document type name $name"))
 
 }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala
index c0eddad..9c0c216 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/document/ApiProviderType.scala
@@ -2,15 +2,14 @@ package xyz.driver.pdsuidomain.formats.json.document
 
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuicommon.domain.LongId
 import xyz.driver.pdsuidomain.entities.ProviderType
 
 final case class ApiProviderType(id: Long, name: String) {
 
-  def toDomain = ProviderType(
-    id = LongId(this.id),
-    name = this.name
-  )
+  def toDomain: ProviderType =
+    ProviderType
+      .fromString(name)
+      .getOrElse(throw new IllegalArgumentException(s"Unknown provider type name $name"))
 
 }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabel.scala
deleted file mode 100644
index 0ef1c68..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabel.scala
+++ /dev/null
@@ -1,28 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuicommon.domain.LongId
-import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientLabel
-
-final case class ApiExportPatientLabel(id: String, evidences: List[ApiExportPatientLabelEvidence]) {
-
-  def toDomain = ExportPatientLabel(
-    id = LongId(this.id.toLong),
-    evidences = this.evidences.map(_.toDomain)
-  )
-
-}
-
-object ApiExportPatientLabel {
-
-  implicit val format: Format[ApiExportPatientLabel] = (
-    (JsPath \ "labelId").format[String] and
-      (JsPath \ "evidence").format[List[ApiExportPatientLabelEvidence]]
-  )(ApiExportPatientLabel.apply, unlift(ApiExportPatientLabel.unapply))
-
-  def fromDomain(label: ExportPatientLabel) = ApiExportPatientLabel(
-    id = label.id.toString,
-    evidences = label.evidences.map(ApiExportPatientLabelEvidence.fromDomain)
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabelEvidence.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabelEvidence.scala
deleted file mode 100644
index d141762..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabelEvidence.scala
+++ /dev/null
@@ -1,38 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
-import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientLabelEvidence
-
-final case class ApiExportPatientLabelEvidence(evidenceId: String,
-                                               labelValue: String,
-                                               evidenceText: String,
-                                               document: ApiExportPatientLabelEvidenceDocument) {
-
-  def toDomain = ExportPatientLabelEvidence(
-    id = LongId(this.evidenceId.toLong),
-    value = FuzzyValue.fromString
-      .applyOrElse(this.labelValue, (s: String) => throw new NoSuchElementException(s"Unknown fuzzy value $s")),
-    evidenceText = this.evidenceText,
-    document = this.document.toDomain
-  )
-
-}
-
-object ApiExportPatientLabelEvidence {
-
-  implicit val format: Format[ApiExportPatientLabelEvidence] = (
-    (JsPath \ "evidenceId").format[String] and
-      (JsPath \ "labelValue").format[String](Writes[String](x => JsString(x.toUpperCase))) and
-      (JsPath \ "evidenceText").format[String] and
-      (JsPath \ "document").format[ApiExportPatientLabelEvidenceDocument]
-  )(ApiExportPatientLabelEvidence.apply, unlift(ApiExportPatientLabelEvidence.unapply))
-
-  def fromDomain(evidence: ExportPatientLabelEvidence) = ApiExportPatientLabelEvidence(
-    evidenceId = evidence.id.toString,
-    labelValue = FuzzyValue.valueToString(evidence.value),
-    evidenceText = evidence.evidenceText,
-    document = ApiExportPatientLabelEvidenceDocument.fromDomain(evidence.document)
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabelEvidenceDocument.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabelEvidenceDocument.scala
deleted file mode 100644
index 6999301..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientLabelEvidenceDocument.scala
+++ /dev/null
@@ -1,46 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import java.time.LocalDate
-import java.util.UUID
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuicommon.domain.LongId
-import xyz.driver.pdsuidomain.entities.RecordRequestId
-import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientLabelEvidenceDocument
-
-final case class ApiExportPatientLabelEvidenceDocument(documentId: String,
-                                                       requestId: String,
-                                                       documentType: String,
-                                                       providerType: String,
-                                                       date: LocalDate) {
-
-  def toDomain = ExportPatientLabelEvidenceDocument(
-    documentId = LongId(this.documentId.toLong),
-    requestId = RecordRequestId(UUID.fromString(this.requestId)),
-    documentType = this.documentType,
-    providerType = this.providerType,
-    date = this.date
-  )
-
-}
-
-object ApiExportPatientLabelEvidenceDocument {
-
-  implicit val format: Format[ApiExportPatientLabelEvidenceDocument] = (
-    (JsPath \ "documentId").format[String] and
-      (JsPath \ "requestId").format[String] and
-      (JsPath \ "documentType").format[String] and
-      (JsPath \ "providerType").format[String] and
-      (JsPath \ "date").format[LocalDate]
-  )(ApiExportPatientLabelEvidenceDocument.apply, unlift(ApiExportPatientLabelEvidenceDocument.unapply))
-
-  def fromDomain(document: ExportPatientLabelEvidenceDocument) =
-    ApiExportPatientLabelEvidenceDocument(
-      documentId = document.documentId.toString,
-      requestId = document.requestId.toString,
-      documentType = document.documentType,
-      providerType = document.providerType,
-      date = document.date
-    )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientWithLabels.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientWithLabels.scala
deleted file mode 100644
index fc9bab7..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportPatientWithLabels.scala
+++ /dev/null
@@ -1,31 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuicommon.domain.UuidId
-import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientWithLabels
-
-final case class ApiExportPatientWithLabels(patientId: String, labelVersion: Long, labels: List[ApiExportPatientLabel]) {
-
-  def toDomain = ExportPatientWithLabels(
-    patientId = UuidId(this.patientId),
-    labelVersion = this.labelVersion,
-    labels = this.labels.map(_.toDomain)
-  )
-
-}
-
-object ApiExportPatientWithLabels {
-
-  implicit val format: Format[ApiExportPatientWithLabels] = (
-    (JsPath \ "patientId").format[String] and
-      (JsPath \ "labelVersion").format[Long] and
-      (JsPath \ "labels").format[List[ApiExportPatientLabel]]
-  )(ApiExportPatientWithLabels.apply, unlift(ApiExportPatientWithLabels.unapply))
-
-  def fromDomain(patient: ExportPatientWithLabels) = ApiExportPatientWithLabels(
-    patientId = patient.patientId.toString,
-    labelVersion = patient.labelVersion,
-    labels = patient.labels.map(ApiExportPatientLabel.fromDomain)
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialArm.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialArm.scala
deleted file mode 100644
index ea96f58..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialArm.scala
+++ /dev/null
@@ -1,27 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.LongId
-import xyz.driver.pdsuidomain.entities.Arm
-import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialArm
-
-final case class ApiExportTrialArm(armId: String, armName: String) {
-
-  def toDomain: ExportTrialArm = {
-    ExportTrialArm(LongId[Arm](armId.toLong), armName)
-  }
-}
-
-object ApiExportTrialArm {
-
-  implicit val format: Format[ApiExportTrialArm] = (
-    (JsPath \ "armId").format[String] and
-      (JsPath \ "armName").format[String]
-  )(ApiExportTrialArm.apply, unlift(ApiExportTrialArm.unapply))
-
-  def fromDomain(arm: ExportTrialArm) = ApiExportTrialArm(
-    armId = arm.armId.toString,
-    armName = arm.armName
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialLabelCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialLabelCriterion.scala
deleted file mode 100644
index df1ebb4..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialLabelCriterion.scala
+++ /dev/null
@@ -1,55 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json._
-import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
-import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialLabelCriterion
-import xyz.driver.pdsuidomain.entities.{Arm, Criterion, Label}
-
-final case class ApiExportTrialLabelCriterion(value: String,
-                                              labelId: String,
-                                              criterionId: String,
-                                              criterionText: String,
-                                              armIds: List[String],
-                                              isCompound: Boolean,
-                                              isDefining: Boolean) {
-
-  def toDomain: ExportTrialLabelCriterion = {
-    ExportTrialLabelCriterion(
-      LongId[Criterion](criterionId.toLong),
-      FuzzyValue.fromString.lift(value).map(_ == FuzzyValue.Yes),
-      LongId[Label](labelId.toLong),
-      armIds.map(armId => LongId[Arm](armId.toLong)).toSet,
-      criterionText,
-      isCompound,
-      isDefining
-    )
-  }
-}
-
-object ApiExportTrialLabelCriterion {
-
-  implicit val format: Format[ApiExportTrialLabelCriterion] = (
-    (JsPath \ "value").format[String](Writes[String](x => JsString(x.toUpperCase))) and
-      (JsPath \ "labelId").format[String] and
-      (JsPath \ "criterionId").format[String] and
-      (JsPath \ "criterionText").format[String] and
-      (JsPath \ "armIds").format[List[String]] and
-      (JsPath \ "isCompound").format[Boolean] and
-      (JsPath \ "isDefining").format[Boolean]
-  )(ApiExportTrialLabelCriterion.apply, unlift(ApiExportTrialLabelCriterion.unapply))
-
-  def fromDomain(x: ExportTrialLabelCriterion) = ApiExportTrialLabelCriterion(
-    value = x.value
-      .map { x =>
-        FuzzyValue.valueToString(FuzzyValue.fromBoolean(x))
-      }
-      .getOrElse("Unknown"),
-    labelId = x.labelId.toString,
-    criterionId = x.criterionId.toString,
-    criterionText = x.criteria,
-    armIds = x.armIds.map(_.toString).toList,
-    isCompound = x.isCompound,
-    isDefining = x.isDefining
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialWithLabels.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialWithLabels.scala
deleted file mode 100644
index e383a1f..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/export/ApiExportTrialWithLabels.scala
+++ /dev/null
@@ -1,53 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.export
-
-import java.time.{Instant, ZoneId}
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuicommon.domain.{StringId, UuidId}
-import xyz.driver.pdsuidomain.entities.Trial
-import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialWithLabels
-
-final case class ApiExportTrialWithLabels(nctId: String,
-                                          trialId: String,
-                                          condition: String,
-                                          lastReviewed: Long,
-                                          labelVersion: Long,
-                                          arms: List[ApiExportTrialArm],
-                                          criteria: List[ApiExportTrialLabelCriterion]) {
-
-  def toDomain: ExportTrialWithLabels = {
-    ExportTrialWithLabels(
-      StringId[Trial](nctId),
-      UuidId[Trial](trialId),
-      condition,
-      lastReviewed = Instant.ofEpochMilli(lastReviewed).atZone(ZoneId.of("Z")).toLocalDateTime,
-      labelVersion,
-      arms.map(_.toDomain),
-      criteria.map(_.toDomain)
-    )
-  }
-}
-
-object ApiExportTrialWithLabels {
-
-  implicit val format: Format[ApiExportTrialWithLabels] = (
-    (JsPath \ "nctId").format[String] and
-      (JsPath \ "trialId").format[String] and
-      (JsPath \ "disease").format[String] and
-      (JsPath \ "lastReviewed").format[Long] and
-      (JsPath \ "labelVersion").format[Long] and
-      (JsPath \ "arms").format[List[ApiExportTrialArm]] and
-      (JsPath \ "criteria").format[List[ApiExportTrialLabelCriterion]]
-  )(ApiExportTrialWithLabels.apply, unlift(ApiExportTrialWithLabels.unapply))
-
-  def fromDomain(x: ExportTrialWithLabels) = ApiExportTrialWithLabels(
-    nctId = x.nctId.id,
-    trialId = x.trialId.toString,
-    condition = x.condition,
-    lastReviewed = x.lastReviewed.atZone(ZoneId.of("Z")).toEpochSecond,
-    labelVersion = x.labelVersion,
-    arms = x.arms.map(ApiExportTrialArm.fromDomain),
-    criteria = x.criteria.map(ApiExportTrialLabelCriterion.fromDomain)
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala
deleted file mode 100644
index a9d02fc..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/keyword/ApiKeyword.scala
+++ /dev/null
@@ -1,23 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.keyword
-
-import xyz.driver.pdsuidomain.entities.KeywordWithLabels
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuidomain.formats.json.label.ApiLabel
-
-final case class ApiKeyword(id: Long, keyword: String, labels: List[ApiLabel])
-
-object ApiKeyword {
-
-  implicit val format: Format[ApiKeyword] = (
-    (JsPath \ "id").format[Long] and
-      (JsPath \ "keyword").format[String] and
-      (JsPath \ "labels").format[List[ApiLabel]]
-  )(ApiKeyword.apply, unlift(ApiKeyword.unapply))
-
-  def fromDomain(keywordWithLabels: KeywordWithLabels) = ApiKeyword(
-    id = keywordWithLabels.keyword.id.id,
-    keyword = keywordWithLabels.keyword.keyword,
-    labels = keywordWithLabels.labels.map(x => ApiLabel(x.id.id, x.name, x.categoryId.id))
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala
index 7a65af8..d486749 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiCriterionLabel.scala
@@ -1,10 +1,11 @@
 package xyz.driver.pdsuidomain.formats.json.label
 
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
-import xyz.driver.pdsuidomain.entities.{Category, Criterion, CriterionLabel, Label}
+import xyz.driver.pdsuidomain.entities.{Criterion, CriterionLabel}
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
+import xyz.driver.entities.labels.{Label, LabelCategory}
 
 /**
   * @param value Yes|No
@@ -18,7 +19,7 @@ final case class ApiCriterionLabel(labelId: Option[Long],
     id = LongId(0L),
     labelId = labelId.map(LongId[Label]),
     criterionId = criterionId,
-    categoryId = categoryId.map(LongId[Category]),
+    categoryId = categoryId.map(LongId[LabelCategory]),
     value = value.map {
       case "Yes" => true
       case "No"  => false
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala
index cb45025..f8161af 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiExtractedDataLabel.scala
@@ -1,10 +1,11 @@
 package xyz.driver.pdsuidomain.formats.json.label
 
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
-import xyz.driver.pdsuidomain.entities.{Category, ExtractedData, ExtractedDataLabel, Label}
+import xyz.driver.pdsuidomain.entities.{ExtractedData, ExtractedDataLabel}
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
+import xyz.driver.entities.labels.{Label, LabelCategory}
 
 final case class ApiExtractedDataLabel(id: Option[Long], categoryId: Option[Long], value: Option[String]) {
 
@@ -12,7 +13,7 @@ final case class ApiExtractedDataLabel(id: Option[Long], categoryId: Option[Long
     id = LongId(0),
     dataId = dataId,
     labelId = id.map(LongId[Label]),
-    categoryId = categoryId.map(LongId[Category]),
+    categoryId = categoryId.map(LongId[LabelCategory]),
     value = value.map(FuzzyValue.fromString)
   )
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala
deleted file mode 100644
index 042b380..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/label/ApiLabel.scala
+++ /dev/null
@@ -1,22 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.label
-
-import play.api.libs.functional.syntax._
-import play.api.libs.json.{Format, JsPath}
-import xyz.driver.pdsuidomain.entities.Label
-
-final case class ApiLabel(id: Long, name: String, categoryId: Long)
-
-object ApiLabel {
-
-  implicit val format: Format[ApiLabel] = (
-    (JsPath \ "id").format[Long] and
-      (JsPath \ "name").format[String] and
-      (JsPath \ "categoryId").format[Long]
-  )(ApiLabel.apply, unlift(ApiLabel.unapply))
-
-  def fromDomain(x: Label) = ApiLabel(
-    id = x.id.id,
-    name = x.name,
-    categoryId = x.categoryId.id
-  )
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
index 75347f4..6eeb40b 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/patient/trial/ApiPatientCriterion.scala
@@ -3,10 +3,11 @@ package xyz.driver.pdsuidomain.formats.json.patient.trial
 import java.time.{ZoneId, ZonedDateTime}
 
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
-import xyz.driver.pdsuidomain.entities.{Label, PatientCriterion, PatientCriterionArm}
+import xyz.driver.pdsuidomain.entities.{PatientCriterion, PatientCriterionArm}
 import play.api.data.validation.ValidationError
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{Format, JsPath, Reads, Writes}
+import xyz.driver.entities.labels.Label
 
 final case class ApiPatientCriterion(id: Long,
                                      labelId: Long,
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala
index 732bcad..8da719c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/criterion.scala
@@ -1,6 +1,7 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
+import xyz.driver.entities.labels.{Label, LabelCategory}
 import xyz.driver.pdsuicommon.domain.{LongId, StringId}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.services.CriterionService.RichCriterion
@@ -29,7 +30,7 @@ object criterion {
 
       val categoryId = fields
         .get("categoryId")
-        .map(_.convertTo[LongId[Category]])
+        .map(_.convertTo[LongId[LabelCategory]])
 
       val value = fields
         .get("value")
@@ -72,6 +73,11 @@ object criterion {
         .map(_.convertTo[Option[String]].getOrElse("{}"))
         .getOrElse(orig.criterion.meta)
 
+      val inclusion = fields
+        .get("inclusion")
+        .map(_.convertTo[Option[Boolean]])
+        .getOrElse(orig.criterion.inclusion)
+
       val arms = fields
         .get("arms")
         .map(_.convertTo[Option[List[LongId[Arm]]]].getOrElse(List.empty[LongId[Arm]]))
@@ -87,7 +93,8 @@ object criterion {
         criterion = orig.criterion.copy(
           meta = meta,
           text = text,
-          isCompound = isCompound
+          isCompound = isCompound,
+          inclusion = inclusion
         ),
         armIds = arms,
         labels = labels
@@ -105,7 +112,8 @@ object criterion {
         "text"       -> obj.criterion.text.toJson,
         "isCompound" -> obj.criterion.isCompound.toJson,
         "labels"     -> obj.labels.map(_.toJson).toJson,
-        "trialId"    -> obj.criterion.trialId.toJson
+        "trialId"    -> obj.criterion.trialId.toJson,
+        "inclusion"  -> obj.criterion.inclusion.toJson
       )
 
     override def read(json: JsValue): RichCriterion = json match {
@@ -128,6 +136,11 @@ object criterion {
           .map(_.convertTo[String])
           .getOrElse("")
 
+        val inclusion = fields
+          .get("inclusion")
+          .map(_.convertTo[Option[Boolean]])
+          .getOrElse(None)
+
         val arms = fields
           .get("arms")
           .map(_.convertTo[List[LongId[Arm]]])
@@ -145,7 +158,8 @@ object criterion {
             trialId = trialId,
             text = text,
             isCompound = isCompound,
-            meta = meta
+            meta = meta,
+            inclusion = inclusion
           ),
           armIds = arms,
           labels = labels
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala
index baf1b4e..e3f6a9c 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/document.scala
@@ -28,6 +28,25 @@ object document {
 
   implicit val documentMetaFormat: RootJsonFormat[Meta] = jsonFormat3(Meta.apply)
 
+  implicit val documentTypeFormat: RootJsonFormat[DocumentType] = new RootJsonFormat[DocumentType] {
+    override def read(json: JsValue): DocumentType = json match {
+      case JsObject(fields) =>
+        val name = fields
+          .get("name")
+          .map(_.convertTo[String])
+          .getOrElse(deserializationError(s"Intervention type json object does not contain `name` field: $json"))
+
+        DocumentType
+          .fromString(name)
+          .getOrElse(deserializationError(s"Unknown document type: $name"))
+
+      case _ => deserializationError(s"Expected Json Object as Intervention type, but got $json")
+    }
+
+    override def write(obj: DocumentType) =
+      JsObject("id" -> obj.id.toJson, "name" -> obj.name.toJson)
+  }
+
   implicit val fullDocumentMetaFormat = new RootJsonFormat[TextJson[Meta]] {
     override def write(obj: TextJson[Meta]): JsValue = obj.content.toJson
     override def read(json: JsValue)                 = TextJson(documentMetaFormat.read(json))
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documenttype.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documenttype.scala
deleted file mode 100644
index 8119d35..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/documenttype.scala
+++ /dev/null
@@ -1,13 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.sprayformats
-
-import spray.json._
-import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.entities.DocumentType
-
-object documenttype {
-  import DefaultJsonProtocol._
-  import common._
-
-  implicit val format: RootJsonFormat[DocumentType] = jsonFormat2(DocumentType.apply)
-
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala
new file mode 100644
index 0000000..b836e1c
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/eligibility.scala
@@ -0,0 +1,101 @@
+package xyz.driver.pdsuidomain.formats.json.sprayformats
+
+import spray.json._
+import DefaultJsonProtocol._
+import xyz.driver.core.Id
+import xyz.driver.core.json._
+import xyz.driver.entities.labels.LabelValue
+import xyz.driver.pdsuidomain.entities.eligibility._
+
+object eligibility {
+  import xyz.driver.formats.json.assay._
+  import xyz.driver.formats.json.common._
+  import xyz.driver.formats.json.labels._
+  import xyz.driver.formats.json.process._
+  import xyz.driver.pdsuidomain.formats.json.sprayformats.document._
+  import xyz.driver.pdsuidomain.formats.json.sprayformats.record._
+  import xyz.driver.pdsuidomain.formats.json.sprayformats.export._
+
+  implicit val molecularDocumentFormat: RootJsonFormat[MolecularEvidenceDocument] = jsonFormat7(
+    MolecularEvidenceDocument)
+  implicit val clinicalDocumentFormat: RootJsonFormat[ClinicalEvidenceDocument] = jsonFormat7(ClinicalEvidenceDocument)
+
+  implicit val evidenceDocumentFormat: RootJsonFormat[EvidenceDocument] =
+    GadtJsonFormat.create[EvidenceDocument]("documentType") {
+      case _: MolecularEvidenceDocument => "Molecular"
+      case _: ClinicalEvidenceDocument  => "Clinical"
+    } {
+      case "Molecular" => molecularDocumentFormat
+      case "Clinical"  => clinicalDocumentFormat
+    }
+
+  implicit object evidenceFormat extends RootJsonFormat[Evidence] {
+
+    override def write(evidence: Evidence): JsValue = {
+      JsObject(
+        "evidenceId"     -> evidence.evidenceId.toJson,
+        "evidenceText"   -> evidence.evidenceText.toJson,
+        "labelValue"     -> evidence.labelValue.toJson,
+        "document"       -> evidence.document.toJson,
+        "isPrimaryValue" -> evidence.isPrimaryValue.toJson
+      )
+    }
+
+    override def read(json: JsValue): Evidence = {
+      json match {
+        case JsObject(fields) =>
+          val evidenceId = fields
+            .get("evidenceId")
+            .map(_.convertTo[Id[Evidence]])
+
+          val evidenceText = fields
+            .get("evidenceText")
+            .map(_.convertTo[String])
+            .getOrElse(deserializationError(s"Evidence json object do not contain 'evidenceText' field: $json"))
+
+          val labelValue = fields
+            .get("labelValue")
+            .map(_.convertTo[LabelValue])
+            .getOrElse(deserializationError(s"Evidence json object do not contain 'labelValue' field: $json"))
+
+          val isDriverDocument = fields
+            .get("document")
+            .flatMap {
+              case JsObject(fieldMap) =>
+                fieldMap
+                  .get("isDriverDocument")
+                  .map(_.convertTo[Boolean])
+              case _ => deserializationError(s"Expected Json Object as 'isDriverDocument', but got $json")
+            }
+            .getOrElse(deserializationError(s"Evidence json object do not contain 'document' field: $json"))
+
+          val document = customDocumentParser(isDriverDocument, fields, json)
+
+          val isPrimaryValue = fields
+            .get("isPrimaryValue")
+            .map(_.convertTo[Option[Boolean]])
+            .getOrElse(deserializationError(s"Evidence json object do not contain 'isPrimaryValue' field: $json"))
+
+          Evidence(evidenceId, evidenceText, labelValue, document, isPrimaryValue)
+        case _ => deserializationError(s"Expected Json Object as 'Evidence', but got $json")
+      }
+    }
+
+    def customDocumentParser(isDriverDocument: Boolean,
+                             fields: Map[String, JsValue],
+                             json: JsValue): EvidenceDocument = {
+      fields.get("document").fold { deserializationError(s"Expected Json Object as 'Document', but got $json") } {
+        document =>
+          if (isDriverDocument) document.convertTo[MolecularEvidenceDocument]
+          else document.convertTo[ClinicalEvidenceDocument]
+      }
+    }
+  }
+
+  implicit def labelWithEvidenceJsonFormat: RootJsonFormat[LabelEvidence] = jsonFormat2(LabelEvidence)
+
+  implicit def labelRankingFormat: RootJsonFormat[LabelMismatchRank]     = jsonFormat4(LabelMismatchRank)
+  implicit def labelRankingsFormat: RootJsonFormat[MismatchRankedLabels] = jsonFormat2(MismatchRankedLabels)
+
+  implicit def matchedPatientFormat: RootJsonFormat[MatchedPatient] = jsonFormat6(MatchedPatient)
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala
index 20b6ed0..39d5c59 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/export.scala
@@ -1,6 +1,8 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
+import xyz.driver.entities.labels.Label
+import xyz.driver.pdsuidomain.entities.{Arm, Criterion}
 import xyz.driver.pdsuidomain.entities.export.patient._
 import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrialArm, ExportTrialLabelCriterion, ExportTrialWithLabels}
 
@@ -8,42 +10,24 @@ object export {
   import DefaultJsonProtocol._
   import common._
   import record._
+  import document._
 
-  implicit val patientLabelEvidenceDocumentFormat: RootJsonFormat[ExportPatientLabelEvidenceDocument] = jsonFormat5(
-    ExportPatientLabelEvidenceDocument.apply)
+  implicit val patientLabelEvidenceDocumentFormat: RootJsonFormat[ExportPatientLabelEvidenceDocument] =
+    jsonFormat5(ExportPatientLabelEvidenceDocument.apply)
 
-  implicit val patientLabelEvidenceWriter: JsonWriter[ExportPatientLabelEvidence] =
-    new JsonWriter[ExportPatientLabelEvidence] {
-      override def write(obj: ExportPatientLabelEvidence): JsValue =
-        JsObject(
-          "evidenceId"   -> obj.id.toJson,
-          "labelValue"   -> obj.value.toJson,
-          "evidenceText" -> obj.evidenceText.toJson,
-          "document"     -> obj.document.toJson
-        )
-    }
+  implicit val patientLabelEvidenceFormat: RootJsonFormat[ExportPatientLabelEvidence] =
+    jsonFormat(ExportPatientLabelEvidence.apply, "evidenceId", "labelValue", "evidenceText", "document")
 
-  implicit val patientLabelWriter: JsonWriter[ExportPatientLabel] = new JsonWriter[ExportPatientLabel] {
-    override def write(obj: ExportPatientLabel): JsValue =
-      JsObject(
-        "labelId"  -> obj.id.toJson,
-        "evidence" -> obj.evidences.map(_.toJson).toJson
-      )
-  }
+  implicit val patientLabelFormat: RootJsonFormat[ExportPatientLabel] =
+    jsonFormat(ExportPatientLabel.apply, "labelId", "evidence")
 
-  implicit val patientWithLabelsWriter: JsonWriter[ExportPatientWithLabels] = new JsonWriter[ExportPatientWithLabels] {
-    override def write(obj: ExportPatientWithLabels): JsValue =
-      JsObject(
-        "patientId"    -> obj.patientId.toJson,
-        "labelVersion" -> obj.labelVersion.toJson,
-        "labels"       -> obj.labels.map(_.toJson).toJson
-      )
-  }
+  implicit val patientWithLabelsFormat: RootJsonFormat[ExportPatientWithLabels] =
+    jsonFormat(ExportPatientWithLabels.apply, "patientId", "labelVersion", "labels")
 
   implicit val trialArmFormat: RootJsonFormat[ExportTrialArm] = jsonFormat2(ExportTrialArm.apply)
 
-  implicit val trialLabelCriterionWriter: JsonWriter[ExportTrialLabelCriterion] =
-    new JsonWriter[ExportTrialLabelCriterion] {
+  implicit val trialLabelCriterionFormat: RootJsonFormat[ExportTrialLabelCriterion] =
+    new RootJsonFormat[ExportTrialLabelCriterion] {
       override def write(obj: ExportTrialLabelCriterion): JsValue =
         JsObject(
           "value" -> obj.value
@@ -60,19 +44,49 @@ object export {
           "isCompound"    -> obj.isCompound.toJson,
           "isDefining"    -> obj.isDefining.toJson
         )
-    }
 
-  implicit val trialWithLabelsWriter: JsonWriter[ExportTrialWithLabels] = new JsonWriter[ExportTrialWithLabels] {
-    override def write(obj: ExportTrialWithLabels) =
-      JsObject(
-        "nctId"        -> obj.nctId.toJson,
-        "trialId"      -> obj.trialId.toJson,
-        "disease"      -> obj.condition.toJson,
-        "lastReviewed" -> obj.lastReviewed.toJson,
-        "labelVersion" -> obj.labelVersion.toJson,
-        "arms"         -> obj.arms.toJson,
-        "criteria"     -> obj.criteria.map(_.toJson).toJson
-      )
-  }
+      override def read(json: JsValue): ExportTrialLabelCriterion = {
+
+        val fields = Seq("value", "labelId", "criterionId", "criterionText", "armIds", "isCompound", "isDefining")
+
+        json.asJsObject.getFields(fields: _*) match {
+          case Seq(JsString(valueString),
+                   labelId,
+                   criterionId,
+                   JsString(criterionText),
+                   JsArray(armIdsVector),
+                   JsBoolean(isCompound),
+                   JsBoolean(isDefining)) =>
+            val value = valueString match {
+              case "Yes"     => Option(true)
+              case "No"      => Option(false)
+              case "Unknown" => Option.empty[Boolean]
+            }
+
+            ExportTrialLabelCriterion(
+              longIdFormat[Criterion].read(criterionId),
+              value,
+              longIdFormat[Label].read(labelId),
+              armIdsVector.map(longIdFormat[Arm].read).toSet,
+              criterionText,
+              isCompound,
+              isDefining
+            )
+
+          case _ =>
+            deserializationError(
+              s"Cannot find required fields ${fields.mkString(", ")} in ExportTrialLabelCriterion object!")
+        }
+      }
+    }
 
+  implicit val trialWithLabelsFormat: RootJsonFormat[ExportTrialWithLabels] =
+    jsonFormat(ExportTrialWithLabels.apply,
+               "nctId",
+               "trialId",
+               "disease",
+               "lastReviewed",
+               "labelVersion",
+               "arms",
+               "criteria")
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala
index 42473bc..d6eadbd 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/extracteddata.scala
@@ -1,6 +1,7 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
+import xyz.driver.entities.labels.{Label, LabelCategory}
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, TextJson}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.services.ExtractedDataService.RichExtractedData
@@ -39,7 +40,7 @@ object extracteddata {
 
       val categoryId = fields
         .get("categoryId")
-        .map(_.convertTo[LongId[Category]])
+        .map(_.convertTo[LongId[LabelCategory]])
 
       val value = fields
         .get("value")
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala
index 53e927d..b091746 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/patientcriterion.scala
@@ -1,6 +1,7 @@
 package xyz.driver.pdsuidomain.formats.json.sprayformats
 
 import spray.json._
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId}
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.services.PatientCriterionService.DraftPatientCriterion
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/providerttype.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/providerttype.scala
deleted file mode 100644
index 385feb2..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/providerttype.scala
+++ /dev/null
@@ -1,12 +0,0 @@
-package xyz.driver.pdsuidomain.formats.json.sprayformats
-
-import spray.json._
-import xyz.driver.pdsuidomain.entities.ProviderType
-
-object providertype {
-  import DefaultJsonProtocol._
-  import common._
-
-  implicit val providerTypeFormat: RootJsonFormat[ProviderType] = jsonFormat2(ProviderType.apply)
-
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala
index e378dbd..8eef44a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/record.scala
@@ -36,6 +36,25 @@ object record {
     }
   }
 
+  implicit val providerTypeFormat: RootJsonFormat[ProviderType] = new RootJsonFormat[ProviderType] {
+    override def read(json: JsValue): ProviderType = json match {
+      case JsObject(fields) =>
+        val name = fields
+          .get("name")
+          .map(_.convertTo[String])
+          .getOrElse(deserializationError(s"Intervention type json object does not contain `name` field: $json"))
+
+        ProviderType
+          .fromString(name)
+          .getOrElse(deserializationError(s"Unknown provider type: $name"))
+
+      case _ => deserializationError(s"Expected Json Object as Intervention type, but got $json")
+    }
+
+    override def write(obj: ProviderType) =
+      JsObject("id" -> obj.id.toJson, "name" -> obj.name.toJson)
+  }
+
   implicit val caseIdFormat = new RootJsonFormat[CaseId] {
     override def write(caseId: CaseId): JsString = JsString(caseId.toString)
     override def read(json: JsValue): CaseId = json match {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala
new file mode 100644
index 0000000..d3e977e
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/EligibilityVerificationService.scala
@@ -0,0 +1,18 @@
+package xyz.driver.pdsuidomain.services
+
+import xyz.driver.core.Id
+import xyz.driver.core.rest.ServiceRequestContext
+import xyz.driver.entities.patient.CancerType
+import xyz.driver.pdsuidomain.entities.eligibility.{MatchedPatient, MismatchRankedLabels}
+import xyz.driver.pdsuidomain.entities.{Arm, Patient}
+
+import scala.concurrent.Future
+import scalaz.ListT
+
+trait EligibilityVerificationService {
+
+  def getMatchedPatients()(implicit ctx: ServiceRequestContext): ListT[Future, MatchedPatient]
+
+  def getMismatchRankedLabels(patientId: Id[Patient], cancerType: CancerType, excludedArms: Seq[Id[Arm]])(
+          implicit ctx: ServiceRequestContext): Future[MismatchRankedLabels]
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
index 9ff3879..6d85f85 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientCriterionService.scala
@@ -2,6 +2,7 @@ package xyz.driver.pdsuidomain.services
 
 import java.time.LocalDateTime
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala
index 2c17f74..abb3f8a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientEligibleTrialService.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.services
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
 import xyz.driver.pdsuicommon.domain.{LongId, UuidId}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelEvidenceService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelEvidenceService.scala
index 56e2e3d..6871f3e 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelEvidenceService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelEvidenceService.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.services
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain.{LongId, UuidId}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala
index 71b8bd4..2a4d7fc 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/PatientLabelService.scala
@@ -1,5 +1,6 @@
 package xyz.driver.pdsuidomain.services
 
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala
new file mode 100644
index 0000000..c5531f9
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeEligibilityVerificationService.scala
@@ -0,0 +1,28 @@
+package xyz.driver.pdsuidomain.services.fake
+
+import xyz.driver.core.rest.ServiceRequestContext
+import xyz.driver.core.{Id, generators}
+import xyz.driver.entities.patient
+import xyz.driver.pdsuidomain.entities.eligibility.MismatchRankedLabels
+import xyz.driver.pdsuidomain.entities.{Arm, Patient, eligibility}
+import xyz.driver.pdsuidomain.services.EligibilityVerificationService
+
+import scala.concurrent.Future
+import scalaz.ListT
+
+class FakeEligibilityVerificationService extends EligibilityVerificationService {
+
+  override def getMatchedPatients()(implicit ctx: ServiceRequestContext): ListT[Future, eligibility.MatchedPatient] =
+    ListT.listT[Future](
+      Future.successful(List(xyz.driver.pdsuidomain.fakes.entities.eligibility.nextMatchedPatient())))
+
+  override def getMismatchRankedLabels(
+          patientId: Id[Patient],
+          cancerType: patient.CancerType,
+          excludedArms: Seq[Id[Arm]])(implicit ctx: ServiceRequestContext): Future[eligibility.MismatchRankedLabels] =
+    Future.successful(
+      MismatchRankedLabels(
+        generators.seqOf(xyz.driver.pdsuidomain.fakes.entities.eligibility.nextLabelMismatchRank()),
+        labelVersion = generators.nextInt(10)
+      ))
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
index 3793c1f..9aeb820 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/fake/FakeTrialService.scala
@@ -6,10 +6,11 @@ import akka.NotUsed
 import akka.stream.scaladsl.Source
 import akka.util.ByteString
 import xyz.driver.core.generators
+import xyz.driver.entities.labels.Label
 import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain.{LongId, StringId, UuidId}
-import xyz.driver.pdsuidomain.entities.{Arm, Criterion, Label, Trial}
+import xyz.driver.pdsuidomain.entities.{Arm, Criterion, Trial}
 import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrialArm, ExportTrialLabelCriterion, ExportTrialWithLabels}
 import xyz.driver.pdsuidomain.services.TrialService
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
new file mode 100644
index 0000000..07757e3
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
@@ -0,0 +1,43 @@
+package xyz.driver.pdsuidomain.services.rest
+
+import akka.http.scaladsl.model.Uri
+import akka.stream.Materializer
+import spray.json.DefaultJsonProtocol
+import xyz.driver.core.Id
+import xyz.driver.core.rest.{RestService, ServiceRequestContext, ServiceTransport}
+import xyz.driver.entities.patient
+import xyz.driver.pdsuidomain.entities.eligibility.{MatchedPatient, MismatchRankedLabels}
+import xyz.driver.pdsuidomain.entities.{Arm, Patient, eligibility}
+import xyz.driver.pdsuidomain.services.EligibilityVerificationService
+
+import scala.concurrent.{ExecutionContext, Future}
+import scalaz.ListT
+import scalaz.Scalaz.futureInstance
+
+class RestEligibilityVerificationService(transport: ServiceTransport, baseUri: Uri)(
+        implicit protected val materializer: Materializer,
+        protected val exec: ExecutionContext
+) extends EligibilityVerificationService with RestService {
+
+  import DefaultJsonProtocol._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.sprayformats.eligibility._
+
+  override def getMatchedPatients()(implicit ctx: ServiceRequestContext): ListT[Future, eligibility.MatchedPatient] = {
+    val request = get(baseUri, s"/v1/patients")
+    listResponse[MatchedPatient](transport.sendRequest(ctx)(request))
+  }
+
+  override def getMismatchRankedLabels(patientId: Id[Patient],
+                                       cancerType: patient.CancerType,
+                                       excludedArms: Seq[Id[Arm]])(
+          implicit ctx: ServiceRequestContext): Future[eligibility.MismatchRankedLabels] = {
+
+    val query =
+      Seq("disease" -> cancerType.toString.toUpperCase, "ineligible_arms" -> excludedArms.map(_.value).mkString(","))
+
+    val request = get(baseUri, s"/v1/patients/$patientId/labels", query)
+    optionalResponse[MismatchRankedLabels](transport.sendRequest(ctx)(request))
+      .getOrElse(throw new Exception(s"The data of patient $patientId is not ready yet"))
+  }
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala
index 53b9f38..a65e1f4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala
@@ -1,7 +1,6 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
@@ -10,10 +9,12 @@ import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientWithLabels
 import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.export.ApiExportPatientWithLabels
 import xyz.driver.pdsuidomain.formats.json.extracteddata.ApiExtractedData
 import xyz.driver.pdsuidomain.services.ExtractedDataService
+import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+import xyz.driver.pdsuidomain.formats.json.sprayformats.export._
 
 class RestExtractedDataService(transport: ServiceTransport, baseUri: Uri)(
         implicit protected val materializer: Materializer,
@@ -88,9 +89,9 @@ class RestExtractedDataService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/export/patient/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiExportPatientWithLabels](response)
+      reply    <- apiResponse[ExportPatientWithLabels](response)
     } yield {
-      GetPatientLabelsReply.Entity(reply.toDomain)
+      GetPatientLabelsReply.Entity(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
index b77e6df..7e33919 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
@@ -12,10 +12,12 @@ import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuidomain.entities._
+import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialWithLabels
 import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.export.ApiExportTrialWithLabels
 import xyz.driver.pdsuidomain.formats.json.trial.ApiTrial
 import xyz.driver.pdsuidomain.services.TrialService
+import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+import xyz.driver.pdsuidomain.formats.json.sprayformats.export._
 
 class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
                                                                   protected val exec: ExecutionContext)
@@ -39,9 +41,9 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/export/trial/$disease/$trialId"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiExportTrialWithLabels](response)
+      reply    <- apiResponse[ExportTrialWithLabels](response)
     } yield {
-      GetTrialWithLabelsReply.Entity(reply.toDomain)
+      GetTrialWithLabelsReply.Entity(reply)
     }
   }
 
diff --git a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
index ba67d13..5deaecb 100644
--- a/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuicommon/parsers/SearchFilterParserSuite.scala
@@ -14,7 +14,7 @@ import xyz.driver.pdsuicommon.db.SearchFilterNAryOperation.In
 import xyz.driver.pdsuicommon.utils.Utils
 import xyz.driver.pdsuicommon.utils.Utils._
 
-import scala.util.Success
+import scala.util._
 
 object SearchFilterParserSuite {
 
@@ -133,6 +133,17 @@ class SearchFilterParserSuite extends FreeSpecLike with Checkers {
       }
 
       "n-ary" - {
+        "actual record Ids" - {
+          "should not be parsed with text values" in {
+            val filter = SearchFilterParser.parse(Seq("filters" -> "id IN 1,5"))
+            filter match {
+              case Success(_) => ()
+              case Failure(t) => t.printStackTrace()
+            }
+            assert(filter === Success(SearchFilterExpr.Atom.NAry(Dimension(None, "id"), In, Seq(Long.box(1), Long.box(5)))))
+          }
+        }
+
         "in" in check {
           val testQueryGen = queryGen(
             dimensionGen = Gen.identifier,
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala
index d24c4c1..708aed9 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/CriterionFormatSuite.scala
@@ -15,7 +15,8 @@ class CriterionFormatSuite extends FlatSpec with Matchers {
       trialId = StringId("NCT000001"),
       text = Some("text"),
       isCompound = false,
-      meta = "{}"
+      meta = "{}",
+      inclusion = None
     )
     val labels = List(
       CriterionLabel(
@@ -44,12 +45,12 @@ class CriterionFormatSuite extends FlatSpec with Matchers {
     val writtenJson = richCriterionFormat.write(richCriterion)
 
     writtenJson should be(
-      """{"text":"text","isCompound":false,"trialId":"NCT000001","arms":[20,21,21],"id":10,"meta":"{}",
+      """{"text":"text","isCompound":false,"trialId":"NCT000001","inclusion":null,"arms":[20,21,21],"id":10,"meta":"{}",
         "labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true},
         {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson)
 
     val createCriterionJson =
-      """{"text":"text","isCompound":false,"trialId":"NCT000001",
+      """{"text":"text","isCompound":false,"trialId":"NCT000001","inclusion":null,
         "arms":[20,21,21],"meta":"{}","labels":[{"labelId":101,"categoryId":3,"value":"Yes","isDefining":true},
         {"labelId":102,"categoryId":3,"value":"No","isDefining":true}]}""".parseJson
     val parsedRichCriterion = richCriterionFormat.read(createCriterionJson)
@@ -59,8 +60,14 @@ class CriterionFormatSuite extends FlatSpec with Matchers {
     )
     parsedRichCriterion should be(expectedRichCriterion)
 
-    val updateCriterionJson = """{"meta":null,"text":"new text","isCompound":true}""".parseJson
-    val expectedUpdatedCriterion = richCriterion.copy(criterion = criterion.copy(text = Some("new text"), isCompound = true, meta = "{}"))
+    val updateCriterionJson = """{"meta":null,"text":"new text","isCompound":true,"inclusion":true}""".parseJson
+    val expectedUpdatedCriterion = richCriterion.copy(
+      criterion = criterion.copy(
+        text = Some("new text"),
+        isCompound = true,
+        meta = "{}",
+        inclusion = Some(true)
+      ))
     val parsedUpdateCriterion = applyUpdateToCriterion(updateCriterionJson, richCriterion)
     parsedUpdateCriterion should be(expectedUpdatedCriterion)
   }
diff --git a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala
index d0d4d1a..a451905 100644
--- a/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala
+++ b/src/test/scala/xyz/driver/pdsuidomain/formats/json/sprayformats/ExportFormatSuite.scala
@@ -6,7 +6,7 @@ import java.util.UUID
 import spray.json._
 import org.scalatest.{FlatSpec, Matchers}
 import xyz.driver.pdsuicommon.domain.{FuzzyValue, LongId, StringId, UuidId}
-import xyz.driver.pdsuidomain.entities.RecordRequestId
+import xyz.driver.pdsuidomain.entities.{DocumentType, ProviderType, RecordRequestId}
 
 class ExportFormatSuite extends FlatSpec with Matchers {
   import export._
@@ -16,10 +16,11 @@ class ExportFormatSuite extends FlatSpec with Matchers {
     val document = ExportPatientLabelEvidenceDocument(
       documentId = LongId(101),
       requestId = RecordRequestId(UUID.fromString("7b54a75d-4197-4b27-9045-b9b6cb131be9")),
-      documentType = "document type",
-      providerType = "provider type",
+      documentType = DocumentType.OutpatientPhysicianNote,
+      providerType = ProviderType.Surgery,
       date = LocalDate.parse("2017-08-10")
     )
+
     val labels = List(
       ExportPatientLabel(
         id = LongId(1),
@@ -62,18 +63,18 @@ class ExportFormatSuite extends FlatSpec with Matchers {
       labels = labels
     )
 
-    val writtenJson = patientWithLabelsWriter.write(patientWithLabels)
+    val writtenJson = patientWithLabelsFormat.write(patientWithLabels)
     writtenJson should be(
       """{"patientId":"748b5884-3528-4cb9-904b-7a8151d6e343","labelVersion":1,"labels":[{"labelId":1,"evidence":[{"evidenceId":11,
          "labelValue":"Yes","evidenceText":"evidence text 11","document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9",
-         "documentType":"document type","providerType":"provider type","date":"2017-08-10"}},{"evidenceId":12,"labelValue":"No",
-         "evidenceText":"evidence text 12","document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9",
-         "documentType":"document type","providerType":"provider type","date":"2017-08-10"}}]},
+         "documentType":{"id":1,"name":"Outpatient Physician Note"},"providerType":{"id":2,"name":"Surgery"},"date":"2017-08-10"}},
+        {"evidenceId":12,"labelValue":"No","evidenceText":"evidence text 12","document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9",
+         "documentType":{"id":1,"name":"Outpatient Physician Note"},"providerType":{"id":2,"name":"Surgery"},"date":"2017-08-10"}}]},
         {"labelId":2,"evidence":[{"evidenceId":12,"labelValue":"Yes","evidenceText":"evidence text 12","document":
-        {"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","documentType":"document type",
-        "providerType":"provider type","date":"2017-08-10"}},{"evidenceId":13,"labelValue":"Yes","evidenceText":"evidence text 13",
-        "document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","documentType":"document type",
-        "providerType":"provider type","date":"2017-08-10"}}]}]}""".parseJson)
+        {"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","documentType":{"id":1,"name":"Outpatient Physician Note"},
+        "providerType":{"id":2,"name":"Surgery"},"date":"2017-08-10"}},{"evidenceId":13,"labelValue":"Yes","evidenceText":"evidence text 13",
+        "document":{"documentId":101,"requestId":"7b54a75d-4197-4b27-9045-b9b6cb131be9","documentType":{"id":1,"name":"Outpatient Physician Note"},
+        "providerType":{"id":2,"name":"Surgery"},"date":"2017-08-10"}}]}]}""".parseJson)
   }
 
   "Json format for ApiExportTrialWithLabels" should "read and write correct JSON" in {
@@ -112,7 +113,7 @@ class ExportFormatSuite extends FlatSpec with Matchers {
       criteria = criteriaList
     )
 
-    val writtenJson = trialWithLabelsWriter.write(trialWithLabels)
+    val writtenJson = trialWithLabelsFormat.write(trialWithLabels)
     writtenJson should be(
       """{"nctId":"NCT000001","trialId":"40892a07-c638-49d2-9795-1edfefbbcc7c","disease":"Breast","lastReviewed":"2017-08-10T18:00Z",
         "labelVersion":1,"arms":[{"armId":1,"armName":"arm 1"},{"armId":2,"armName":"arm 2"}],"criteria":[
@@ -120,5 +121,4 @@ class ExportFormatSuite extends FlatSpec with Matchers {
         {"value":"Unknown","labelId":21,"criterionId":11,"criterionText":"criteria 11 text","armIds":[2],"isCompound":true,"isDefining":false}]}""".parseJson)
   }
 
-
 }