/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.2.7
 * User agent: apibuilder app.apibuilder.io/gilt/svc-sundial/0.2.7/http4s_0_17
 */
package com.gilt.svc.sundial.v0.server

import org.http4s.dsl._

import com.gilt.svc.sundial.v0.models.json._

private[server] object Matchers {

  implicit lazy val queryParamDecodeBigDecimal: org.http4s.QueryParamDecoder[BigDecimal] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[BigDecimal](p => BigDecimal(p.value))("BigDecimal")

  implicit lazy val queryParamDecodeInstant: org.http4s.QueryParamDecoder[_root_.java.time.Instant] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.time.Instant](p => _root_.java.time.OffsetDateTime.parse(p.value).toInstant)("_root_.java.time.Instant")

  implicit lazy val queryParamDecodeLocalDate: org.http4s.QueryParamDecoder[_root_.java.time.LocalDate] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.time.LocalDate](p => _root_.java.time.LocalDate.parse(p.value))("_root_.java.time.LocalDate")

  implicit lazy val queryParamDecodeUUID: org.http4s.QueryParamDecoder[_root_.java.util.UUID] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[_root_.java.util.UUID](p => _root_.java.util.UUID.fromString(p.value))("_root_.java.util.UUID")

  implicit lazy val processStatusQueryParamDecoder: org.http4s.QueryParamDecoder[com.gilt.svc.sundial.v0.models.ProcessStatus] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[com.gilt.svc.sundial.v0.models.ProcessStatus](p => com.gilt.svc.sundial.v0.models.ProcessStatus.fromString(p.value).get)("com.gilt.svc.sundial.v0.models.ProcessStatus")

  implicit lazy val taskStatusQueryParamDecoder: org.http4s.QueryParamDecoder[com.gilt.svc.sundial.v0.models.TaskStatus] =
    org.http4s.QueryParamDecoder.fromUnsafeCast[com.gilt.svc.sundial.v0.models.TaskStatus](p => com.gilt.svc.sundial.v0.models.TaskStatus.fromString(p.value).get)("com.gilt.svc.sundial.v0.models.TaskStatus")

  object ApiVersion {
    val ApiVersionMajor = {
      "X-Apidoc-Version-Major".ci
    }

    def apply(req: org.http4s.Message): Boolean = req.headers.get(ApiVersionMajor) match {
      case Some(v) if v.value == "0" => true
      case _ => false
    }
  }

  object UUIDVal {
    def unapply(s: String): Option[_root_.java.util.UUID] = scala.util.Try(_root_.java.util.UUID.fromString(s)).toOption
  }

  object AllowedStatusesListProcessStatusMatcher extends OptionalMultiQueryParamDecoderMatcher[com.gilt.svc.sundial.v0.models.ProcessStatus]("allowed_statuses")

  object AllowedStatusesListTaskStatusMatcher extends OptionalMultiQueryParamDecoderMatcher[com.gilt.svc.sundial.v0.models.TaskStatus]("allowed_statuses")

  object EndTimeOptInstantMatcher extends OptionalQueryParamDecoderMatcher[_root_.java.time.Instant]("end_time")

  object LimitOptIntMatcher extends OptionalQueryParamDecoderMatcher[Int]("limit")

  object MaxRecordsOptIntMatcher extends OptionalQueryParamDecoderMatcher[Int]("max_records")

  object ProcessDefinitionNameOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("process_definition_name")

  object ProcessDefinitionNameStringMatcher extends QueryParamDecoderMatcher[String]("process_definition_name")

  object StartTimeOptInstantMatcher extends OptionalQueryParamDecoderMatcher[_root_.java.time.Instant]("start_time")

  object TaskDefinitionNameOptStringMatcher extends OptionalQueryParamDecoderMatcher[String]("task_definition_name")

  object TaskDefinitionNameStringMatcher extends QueryParamDecoderMatcher[String]("task_definition_name")
}

trait HealthcheckRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetMetricsResponse

  object GetMetricsResponse {
    case class HTTP200(value: String, headers: Seq[org.http4s.Header] = Nil) extends GetMetricsResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends GetMetricsResponse
  }

  def getMetrics(
    _req: org.http4s.Request
  ): fs2.Task[GetMetricsResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "_internal_" / "metrics" if apiVersionMatch(_req) =>
      getMetrics(_req).flatMap {
        case GetMetricsResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetMetricsResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "_internal_" / "metrics" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ProcessDefinitionRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[com.gilt.svc.sundial.v0.models.ProcessDefinition], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request
  ): fs2.Task[GetResponse]

  sealed trait GetByProcessDefinitionNameResponse

  object GetByProcessDefinitionNameResponse {
    case class HTTP200(value: com.gilt.svc.sundial.v0.models.ProcessDefinition, headers: Seq[org.http4s.Header] = Nil) extends GetByProcessDefinitionNameResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends GetByProcessDefinitionNameResponse
  }

  def getByProcessDefinitionName(
    _req: org.http4s.Request,
    processDefinitionName: String
  ): fs2.Task[GetByProcessDefinitionNameResponse]

  sealed trait PutByProcessDefinitionNameResponse

  object PutByProcessDefinitionNameResponse {
    case class HTTP200(value: com.gilt.svc.sundial.v0.models.ProcessDefinition, headers: Seq[org.http4s.Header] = Nil) extends PutByProcessDefinitionNameResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PutByProcessDefinitionNameResponse
  }

  def putByProcessDefinitionName(
    _req: org.http4s.Request,
    processDefinitionName: String,
    body: => org.http4s.DecodeResult[com.gilt.svc.sundial.v0.models.ProcessDefinition]
  ): fs2.Task[PutByProcessDefinitionNameResponse]

  sealed trait DeleteByProcessDefinitionNameResponse

  object DeleteByProcessDefinitionNameResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends DeleteByProcessDefinitionNameResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends DeleteByProcessDefinitionNameResponse
  }

  def deleteByProcessDefinitionName(
    _req: org.http4s.Request,
    processDefinitionName: String
  ): fs2.Task[DeleteByProcessDefinitionNameResponse]

  sealed trait PostTriggerByProcessDefinitionNameResponse

  object PostTriggerByProcessDefinitionNameResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostTriggerByProcessDefinitionNameResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostTriggerByProcessDefinitionNameResponse
  }

  def postTriggerByProcessDefinitionName(
    _req: org.http4s.Request,
    processDefinitionName: String,
    taskDefinitionName: _root_.scala.Option[String]
  ): fs2.Task[PostTriggerByProcessDefinitionNameResponse]

  sealed trait PostPauseByProcessDefinitionNameResponse

  object PostPauseByProcessDefinitionNameResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostPauseByProcessDefinitionNameResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostPauseByProcessDefinitionNameResponse
  }

  def postPauseByProcessDefinitionName(
    _req: org.http4s.Request,
    processDefinitionName: String
  ): fs2.Task[PostPauseByProcessDefinitionNameResponse]

  sealed trait PostResumeByProcessDefinitionNameResponse

  object PostResumeByProcessDefinitionNameResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostResumeByProcessDefinitionNameResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostResumeByProcessDefinitionNameResponse
  }

  def postResumeByProcessDefinitionName(
    _req: org.http4s.Request,
    processDefinitionName: String
  ): fs2.Task[PostResumeByProcessDefinitionNameResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "api" / "process_definitions" if apiVersionMatch(_req) =>
      get(_req).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "api" / "process_definitions" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "api" / "process_definitions" / processDefinitionName if apiVersionMatch(_req) =>
      getByProcessDefinitionName(_req, processDefinitionName).flatMap {
        case GetByProcessDefinitionNameResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetByProcessDefinitionNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "api" / "process_definitions" / processDefinitionName if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ PUT -> Root / "api" / "process_definitions" / processDefinitionName if apiVersionMatch(_req) =>
      putByProcessDefinitionName(_req, processDefinitionName, _req.attemptAs[com.gilt.svc.sundial.v0.models.ProcessDefinition]).flatMap {
        case PutByProcessDefinitionNameResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case PutByProcessDefinitionNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ PUT -> Root / "api" / "process_definitions" / processDefinitionName if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ DELETE -> Root / "api" / "process_definitions" / processDefinitionName if apiVersionMatch(_req) =>
      deleteByProcessDefinitionName(_req, processDefinitionName).flatMap {
        case DeleteByProcessDefinitionNameResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case DeleteByProcessDefinitionNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ DELETE -> Root / "api" / "process_definitions" / processDefinitionName if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "process_definitions" / processDefinitionName / "trigger" :? TaskDefinitionNameOptStringMatcher(taskDefinitionName) if apiVersionMatch(_req) =>
      postTriggerByProcessDefinitionName(_req, processDefinitionName, taskDefinitionName).flatMap {
        case PostTriggerByProcessDefinitionNameResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostTriggerByProcessDefinitionNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "process_definitions" / processDefinitionName / "trigger" :? TaskDefinitionNameOptStringMatcher(taskDefinitionName) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "process_definitions" / processDefinitionName / "pause" if apiVersionMatch(_req) =>
      postPauseByProcessDefinitionName(_req, processDefinitionName).flatMap {
        case PostPauseByProcessDefinitionNameResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostPauseByProcessDefinitionNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "process_definitions" / processDefinitionName / "pause" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "process_definitions" / processDefinitionName / "resume" if apiVersionMatch(_req) =>
      postResumeByProcessDefinitionName(_req, processDefinitionName).flatMap {
        case PostResumeByProcessDefinitionNameResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostResumeByProcessDefinitionNameResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "process_definitions" / processDefinitionName / "resume" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait ProcessRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[com.gilt.svc.sundial.v0.models.Process], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request,
    processDefinitionName: _root_.scala.Option[String],
    startTime: _root_.scala.Option[_root_.java.time.Instant],
    endTime: _root_.scala.Option[_root_.java.time.Instant],
    maxRecords: _root_.scala.Option[Int],
    allowedStatuses: Seq[com.gilt.svc.sundial.v0.models.ProcessStatus]
  ): fs2.Task[GetResponse]

  sealed trait GetByProcessIdResponse

  object GetByProcessIdResponse {
    case class HTTP200(value: com.gilt.svc.sundial.v0.models.Process, headers: Seq[org.http4s.Header] = Nil) extends GetByProcessIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends GetByProcessIdResponse
  }

  def getByProcessId(
    _req: org.http4s.Request,
    processId: _root_.java.util.UUID
  ): fs2.Task[GetByProcessIdResponse]

  sealed trait PostRetryByProcessIdResponse

  object PostRetryByProcessIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostRetryByProcessIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostRetryByProcessIdResponse
  }

  def postRetryByProcessId(
    _req: org.http4s.Request,
    processId: _root_.java.util.UUID
  ): fs2.Task[PostRetryByProcessIdResponse]

  sealed trait PostKillByProcessIdResponse

  object PostKillByProcessIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostKillByProcessIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostKillByProcessIdResponse
  }

  def postKillByProcessId(
    _req: org.http4s.Request,
    processId: _root_.java.util.UUID
  ): fs2.Task[PostKillByProcessIdResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "api" / "processes" :? ProcessDefinitionNameOptStringMatcher(processDefinitionName) +& StartTimeOptInstantMatcher(startTime) +& EndTimeOptInstantMatcher(endTime) +& MaxRecordsOptIntMatcher(maxRecords) +& AllowedStatusesListProcessStatusMatcher(cats.data.Validated.Valid(allowedStatuses)) if apiVersionMatch(_req) =>
      get(_req, processDefinitionName, startTime, endTime, maxRecords, allowedStatuses).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "api" / "processes" :? ProcessDefinitionNameOptStringMatcher(processDefinitionName) +& StartTimeOptInstantMatcher(startTime) +& EndTimeOptInstantMatcher(endTime) +& MaxRecordsOptIntMatcher(maxRecords) +& AllowedStatusesListProcessStatusMatcher(cats.data.Validated.Valid(allowedStatuses)) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ GET -> Root / "api" / "processes" / UUIDVal(processId) if apiVersionMatch(_req) =>
      getByProcessId(_req, processId).flatMap {
        case GetByProcessIdResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetByProcessIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "api" / "processes" / UUIDVal(processId) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "processes" / UUIDVal(processId) / "retry" if apiVersionMatch(_req) =>
      postRetryByProcessId(_req, processId).flatMap {
        case PostRetryByProcessIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostRetryByProcessIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "processes" / UUIDVal(processId) / "retry" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "processes" / UUIDVal(processId) / "kill" if apiVersionMatch(_req) =>
      postKillByProcessId(_req, processId).flatMap {
        case PostKillByProcessIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostKillByProcessIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "processes" / UUIDVal(processId) / "kill" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}

trait TaskRoutes {

  import Matchers._

  implicit def circeJsonDecoder[A](implicit decoder: _root_.io.circe.Decoder[A]) = org.http4s.circe.jsonOf[A]
  implicit def circeJsonEncoder[A](implicit encoder: _root_.io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[A]

  sealed trait GetResponse

  object GetResponse {
    case class HTTP200(value: Seq[com.gilt.svc.sundial.v0.models.Task], headers: Seq[org.http4s.Header] = Nil) extends GetResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends GetResponse
  }

  def get(
    _req: org.http4s.Request,
    processDefinitionName: String,
    taskDefinitionName: String,
    allowedStatuses: Seq[com.gilt.svc.sundial.v0.models.TaskStatus],
    startTime: _root_.scala.Option[_root_.java.time.Instant],
    endTime: _root_.scala.Option[_root_.java.time.Instant],
    limit: _root_.scala.Option[Int]
  ): fs2.Task[GetResponse]

  sealed trait PostLogEntriesByTaskIdResponse

  object PostLogEntriesByTaskIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostLogEntriesByTaskIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostLogEntriesByTaskIdResponse
  }

  def postLogEntriesByTaskId(
    _req: org.http4s.Request,
    taskId: _root_.java.util.UUID,
    body: => org.http4s.DecodeResult[Seq[com.gilt.svc.sundial.v0.models.LogEntry]]
  ): fs2.Task[PostLogEntriesByTaskIdResponse]

  sealed trait PostMetadataByTaskIdResponse

  object PostMetadataByTaskIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostMetadataByTaskIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostMetadataByTaskIdResponse
  }

  def postMetadataByTaskId(
    _req: org.http4s.Request,
    taskId: _root_.java.util.UUID,
    body: => org.http4s.DecodeResult[Seq[com.gilt.svc.sundial.v0.models.MetadataEntry]]
  ): fs2.Task[PostMetadataByTaskIdResponse]

  sealed trait PostSucceedByTaskIdResponse

  object PostSucceedByTaskIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostSucceedByTaskIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostSucceedByTaskIdResponse
  }

  def postSucceedByTaskId(
    _req: org.http4s.Request,
    taskId: _root_.java.util.UUID
  ): fs2.Task[PostSucceedByTaskIdResponse]

  sealed trait PostFailByTaskIdResponse

  object PostFailByTaskIdResponse {
    case class HTTP204(headers: Seq[org.http4s.Header] = Nil) extends PostFailByTaskIdResponse
    case class UndocumentedResponse(response: fs2.Task[org.http4s.Response]) extends PostFailByTaskIdResponse
  }

  def postFailByTaskId(
    _req: org.http4s.Request,
    taskId: _root_.java.util.UUID
  ): fs2.Task[PostFailByTaskIdResponse]

  def apiVersionMatch(req: org.http4s.Message): Boolean = ApiVersion(req)

  def service() = org.http4s.HttpService {
    case _req @ GET -> Root / "api" / "tasks" :? ProcessDefinitionNameStringMatcher(processDefinitionName) +& TaskDefinitionNameStringMatcher(taskDefinitionName) +& AllowedStatusesListTaskStatusMatcher(cats.data.Validated.Valid(allowedStatuses)) +& StartTimeOptInstantMatcher(startTime) +& EndTimeOptInstantMatcher(endTime) +& LimitOptIntMatcher(limit) if apiVersionMatch(_req) =>
      get(_req, processDefinitionName, taskDefinitionName, allowedStatuses, startTime, endTime, limit).flatMap {
        case GetResponse.HTTP200(value, headers) => Ok(value).putHeaders(headers: _*)
        case GetResponse.UndocumentedResponse(response) => response
      }
    case _req @ GET -> Root / "api" / "tasks" :? ProcessDefinitionNameStringMatcher(processDefinitionName) +& TaskDefinitionNameStringMatcher(taskDefinitionName) +& AllowedStatusesListTaskStatusMatcher(cats.data.Validated.Valid(allowedStatuses)) +& StartTimeOptInstantMatcher(startTime) +& EndTimeOptInstantMatcher(endTime) +& LimitOptIntMatcher(limit) if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "log_entries" if apiVersionMatch(_req) =>
      postLogEntriesByTaskId(_req, taskId, _req.attemptAs[Seq[com.gilt.svc.sundial.v0.models.LogEntry]]).flatMap {
        case PostLogEntriesByTaskIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostLogEntriesByTaskIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "log_entries" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "metadata" if apiVersionMatch(_req) =>
      postMetadataByTaskId(_req, taskId, _req.attemptAs[Seq[com.gilt.svc.sundial.v0.models.MetadataEntry]]).flatMap {
        case PostMetadataByTaskIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostMetadataByTaskIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "metadata" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "succeed" if apiVersionMatch(_req) =>
      postSucceedByTaskId(_req, taskId).flatMap {
        case PostSucceedByTaskIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostSucceedByTaskIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "succeed" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")

    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "fail" if apiVersionMatch(_req) =>
      postFailByTaskId(_req, taskId).flatMap {
        case PostFailByTaskIdResponse.HTTP204(headers) => NoContent().putHeaders(headers: _*)
        case PostFailByTaskIdResponse.UndocumentedResponse(response) => response
      }
    case _req @ POST -> Root / "api" / "tasks" / UUIDVal(taskId) / "fail" if !_req.headers.get(ApiVersion.ApiVersionMajor).isDefined =>
      BadRequest(s"Missing required request header: ${ApiVersion.ApiVersionMajor}.")
  }
}