/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.8.18
 * User agent: apibuilder app.apibuilder.io/flow/dependency/0.8.18/http4s_0_23
 */
package io.flow.dependency.v0.models {

  package object json {
    import io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import io.flow.common.v0.models.json._
    import io.flow.dependency.v0.models.json._
    import io.flow.error.v0.models.json._
    import io.flow.github.v0.models.json._
    import io.flow.healthcheck.v0.models.json._

    // Make Scala 2.11 Either monadic
    private[v0] implicit def eitherOps[A,B](e: Either[A,B]) = cats.implicits.catsSyntaxEither(e)

    private[v0] implicit val decodeUUID: Decoder[_root_.java.util.UUID] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.util.UUID.fromString(str)))

    private[v0] implicit val encodeUUID: Encoder[_root_.java.util.UUID] =
      Encoder.encodeString.contramap[_root_.java.util.UUID](uuid => uuid.toString)

    private[v0] implicit val decodeInstant: Decoder[_root_.java.time.Instant] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.OffsetDateTime.parse(str).toInstant))

    private[v0] implicit val encodeInstant: Encoder[_root_.java.time.Instant] =
      Encoder.encodeString.contramap[_root_.java.time.Instant](_.toString)

    private[v0] implicit val decodeLocalDate: Decoder[_root_.java.time.LocalDate] =
      Decoder.decodeString.emapTry(str => Try(_root_.java.time.LocalDate.parse(str)))

    private[v0] implicit val encodeLocalDate: Encoder[_root_.java.time.LocalDate] =
      Encoder.encodeString.contramap[_root_.java.time.LocalDate](_.toString)

    implicit val jsonDecoderDependencyBinaryType: Decoder[io.flow.dependency.v0.models.BinaryType] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.BinaryType(_))

    implicit val jsonEncoderDependencyBinaryType: Encoder[io.flow.dependency.v0.models.BinaryType] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.BinaryType](_.toString)

    implicit val jsonDecoderDependencyPublication: Decoder[io.flow.dependency.v0.models.Publication] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.Publication(_))

    implicit val jsonEncoderDependencyPublication: Encoder[io.flow.dependency.v0.models.Publication] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.Publication](_.toString)

    implicit val jsonDecoderDependencyRecommendationType: Decoder[io.flow.dependency.v0.models.RecommendationType] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.RecommendationType(_))

    implicit val jsonEncoderDependencyRecommendationType: Encoder[io.flow.dependency.v0.models.RecommendationType] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.RecommendationType](_.toString)

    implicit val jsonDecoderDependencyRole: Decoder[io.flow.dependency.v0.models.Role] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.Role(_))

    implicit val jsonEncoderDependencyRole: Encoder[io.flow.dependency.v0.models.Role] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.Role](_.toString)

    implicit val jsonDecoderDependencyScms: Decoder[io.flow.dependency.v0.models.Scms] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.Scms(_))

    implicit val jsonEncoderDependencyScms: Encoder[io.flow.dependency.v0.models.Scms] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.Scms](_.toString)

    implicit val jsonDecoderDependencySyncEvent: Decoder[io.flow.dependency.v0.models.SyncEvent] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.SyncEvent(_))

    implicit val jsonEncoderDependencySyncEvent: Encoder[io.flow.dependency.v0.models.SyncEvent] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.SyncEvent](_.toString)

    implicit val jsonDecoderDependencySyncType: Decoder[io.flow.dependency.v0.models.SyncType] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.SyncType(_))

    implicit val jsonEncoderDependencySyncType: Encoder[io.flow.dependency.v0.models.SyncType] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.SyncType](_.toString)

    implicit val jsonDecoderDependencyVisibility: Decoder[io.flow.dependency.v0.models.Visibility] =
      Decoder.decodeString.map(io.flow.dependency.v0.models.Visibility(_))

    implicit val jsonEncoderDependencyVisibility: Encoder[io.flow.dependency.v0.models.Visibility] =
      Encoder.encodeString.contramap[io.flow.dependency.v0.models.Visibility](_.toString)

    implicit def decodeDependencyBinary: Decoder[Binary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        name <- c.downField("name").as[io.flow.dependency.v0.models.BinaryType]
      } yield {
        Binary(
          id = id,
          organization = organization,
          name = name
        )
      }
    }

    implicit def encodeDependencyBinary: Encoder[Binary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeDependencyBinaryForm: Decoder[BinaryForm] = Decoder.instance { c =>
     for {
        organizationId <- c.downField("organization_id").as[String]
        name <- c.downField("name").as[io.flow.dependency.v0.models.BinaryType]
      } yield {
        BinaryForm(
          organizationId = organizationId,
          name = name
        )
      }
    }

    implicit def encodeDependencyBinaryForm: Encoder[BinaryForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("organization_id" -> t.organizationId.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeDependencyBinarySummary: Decoder[BinarySummary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        name <- c.downField("name").as[io.flow.dependency.v0.models.BinaryType]
      } yield {
        BinarySummary(
          id = id,
          organization = organization,
          name = name
        )
      }
    }

    implicit def encodeDependencyBinarySummary: Encoder[BinarySummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeDependencyBinaryVersion: Decoder[BinaryVersion] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        binary <- c.downField("binary").as[io.flow.dependency.v0.models.Binary]
        version <- c.downField("version").as[String]
      } yield {
        BinaryVersion(
          id = id,
          binary = binary,
          version = version
        )
      }
    }

    implicit def encodeDependencyBinaryVersion: Encoder[BinaryVersion] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("binary" -> t.binary.asJson),
        Some("version" -> t.version.asJson)
      ).flatten)
    }

    implicit def decodeDependencyGithubAuthenticationForm: Decoder[GithubAuthenticationForm] = Decoder.instance { c =>
     for {
        code <- c.downField("code").as[String]
      } yield {
        GithubAuthenticationForm(
          code = code
        )
      }
    }

    implicit def encodeDependencyGithubAuthenticationForm: Encoder[GithubAuthenticationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("code" -> t.code.asJson)
      ).flatten)
    }

    implicit def decodeDependencyGithubUser: Decoder[GithubUser] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        user <- c.downField("user").as[io.flow.common.v0.models.UserReference]
        githubUserId <- c.downField("github_user_id").as[Long]
        login <- c.downField("login").as[String]
      } yield {
        GithubUser(
          id = id,
          user = user,
          githubUserId = githubUserId,
          login = login
        )
      }
    }

    implicit def encodeDependencyGithubUser: Encoder[GithubUser] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("user" -> t.user.asJson),
        Some("github_user_id" -> t.githubUserId.asJson),
        Some("login" -> t.login.asJson)
      ).flatten)
    }

    implicit def decodeDependencyGithubUserForm: Decoder[GithubUserForm] = Decoder.instance { c =>
     for {
        userId <- c.downField("user_id").as[String]
        githubUserId <- c.downField("github_user_id").as[Long]
        login <- c.downField("login").as[String]
      } yield {
        GithubUserForm(
          userId = userId,
          githubUserId = githubUserId,
          login = login
        )
      }
    }

    implicit def encodeDependencyGithubUserForm: Encoder[GithubUserForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_id" -> t.userId.asJson),
        Some("github_user_id" -> t.githubUserId.asJson),
        Some("login" -> t.login.asJson)
      ).flatten)
    }

    implicit def decodeDependencyGithubWebhook: Decoder[GithubWebhook] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[Long]
      } yield {
        GithubWebhook(
          id = id
        )
      }
    }

    implicit def encodeDependencyGithubWebhook: Encoder[GithubWebhook] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson)
      ).flatten)
    }

    implicit def decodeDependencyItem: Decoder[Item] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        summary <- c.downField("summary").as[io.flow.dependency.v0.models.ItemSummary]
        label <- c.downField("label").as[String]
        description <- c.downField("description").as[Option[String]]
      } yield {
        Item(
          id = id,
          organization = organization,
          visibility = visibility,
          summary = summary,
          label = label,
          description = description
        )
      }
    }

    implicit def encodeDependencyItem: Encoder[Item] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("summary" -> t.summary.asJson),
        Some("label" -> t.label.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyLibrary: Decoder[Library] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        groupId <- c.downField("group_id").as[String]
        artifactId <- c.downField("artifact_id").as[String]
        resolver <- c.downField("resolver").as[io.flow.dependency.v0.models.ResolverSummary]
      } yield {
        Library(
          id = id,
          organization = organization,
          groupId = groupId,
          artifactId = artifactId,
          resolver = resolver
        )
      }
    }

    implicit def encodeDependencyLibrary: Encoder[Library] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("group_id" -> t.groupId.asJson),
        Some("artifact_id" -> t.artifactId.asJson),
        Some("resolver" -> t.resolver.asJson)
      ).flatten)
    }

    implicit def decodeDependencyLibraryForm: Decoder[LibraryForm] = Decoder.instance { c =>
     for {
        organizationId <- c.downField("organization_id").as[String]
        groupId <- c.downField("group_id").as[String]
        artifactId <- c.downField("artifact_id").as[String]
        resolverId <- c.downField("resolver_id").as[String]
        version <- c.downField("version").as[Option[io.flow.dependency.v0.models.VersionForm]]
      } yield {
        LibraryForm(
          organizationId = organizationId,
          groupId = groupId,
          artifactId = artifactId,
          resolverId = resolverId,
          version = version
        )
      }
    }

    implicit def encodeDependencyLibraryForm: Encoder[LibraryForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("organization_id" -> t.organizationId.asJson),
        Some("group_id" -> t.groupId.asJson),
        Some("artifact_id" -> t.artifactId.asJson),
        Some("resolver_id" -> t.resolverId.asJson),
        t.version.map(t => "version" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyLibrarySummary: Decoder[LibrarySummary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        groupId <- c.downField("group_id").as[String]
        artifactId <- c.downField("artifact_id").as[String]
      } yield {
        LibrarySummary(
          id = id,
          organization = organization,
          groupId = groupId,
          artifactId = artifactId
        )
      }
    }

    implicit def encodeDependencyLibrarySummary: Encoder[LibrarySummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("group_id" -> t.groupId.asJson),
        Some("artifact_id" -> t.artifactId.asJson)
      ).flatten)
    }

    implicit def decodeDependencyLibraryVersion: Decoder[LibraryVersion] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        library <- c.downField("library").as[io.flow.dependency.v0.models.Library]
        version <- c.downField("version").as[String]
        crossBuildVersion <- c.downField("cross_build_version").as[Option[String]]
      } yield {
        LibraryVersion(
          id = id,
          library = library,
          version = version,
          crossBuildVersion = crossBuildVersion
        )
      }
    }

    implicit def encodeDependencyLibraryVersion: Encoder[LibraryVersion] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("library" -> t.library.asJson),
        Some("version" -> t.version.asJson),
        t.crossBuildVersion.map(t => "cross_build_version" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyMembership: Decoder[Membership] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        user <- c.downField("user").as[io.flow.dependency.v0.models.UserSummary]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        role <- c.downField("role").as[io.flow.dependency.v0.models.Role]
      } yield {
        Membership(
          id = id,
          user = user,
          organization = organization,
          role = role
        )
      }
    }

    implicit def encodeDependencyMembership: Encoder[Membership] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("user" -> t.user.asJson),
        Some("organization" -> t.organization.asJson),
        Some("role" -> t.role.asJson)
      ).flatten)
    }

    implicit def decodeDependencyMembershipForm: Decoder[MembershipForm] = Decoder.instance { c =>
     for {
        userId <- c.downField("user_id").as[String]
        organization <- c.downField("organization").as[String]
        role <- c.downField("role").as[io.flow.dependency.v0.models.Role]
      } yield {
        MembershipForm(
          userId = userId,
          organization = organization,
          role = role
        )
      }
    }

    implicit def encodeDependencyMembershipForm: Encoder[MembershipForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_id" -> t.userId.asJson),
        Some("organization" -> t.organization.asJson),
        Some("role" -> t.role.asJson)
      ).flatten)
    }

    implicit def decodeDependencyOrganization: Decoder[Organization] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        user <- c.downField("user").as[io.flow.common.v0.models.UserReference]
        key <- c.downField("key").as[String]
      } yield {
        Organization(
          id = id,
          user = user,
          key = key
        )
      }
    }

    implicit def encodeDependencyOrganization: Encoder[Organization] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("user" -> t.user.asJson),
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeDependencyOrganizationForm: Decoder[OrganizationForm] = Decoder.instance { c =>
     for {
        key <- c.downField("key").as[String]
      } yield {
        OrganizationForm(
          key = key
        )
      }
    }

    implicit def encodeDependencyOrganizationForm: Encoder[OrganizationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeDependencyOrganizationSummary: Decoder[OrganizationSummary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        key <- c.downField("key").as[String]
      } yield {
        OrganizationSummary(
          id = id,
          key = key
        )
      }
    }

    implicit def encodeDependencyOrganizationSummary: Encoder[OrganizationSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProject: Decoder[Project] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        user <- c.downField("user").as[io.flow.common.v0.models.UserReference]
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        scms <- c.downField("scms").as[io.flow.dependency.v0.models.Scms]
        name <- c.downField("name").as[String]
        uri <- c.downField("uri").as[String]
        branch <- c.downField("branch").as[String]
      } yield {
        Project(
          id = id,
          organization = organization,
          user = user,
          visibility = visibility,
          scms = scms,
          name = name,
          uri = uri,
          branch = branch
        )
      }
    }

    implicit def encodeDependencyProject: Encoder[Project] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("user" -> t.user.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("scms" -> t.scms.asJson),
        Some("name" -> t.name.asJson),
        Some("uri" -> t.uri.asJson),
        Some("branch" -> t.branch.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectBinary: Decoder[ProjectBinary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        project <- c.downField("project").as[io.flow.dependency.v0.models.ProjectDetail]
        name <- c.downField("name").as[String]
        version <- c.downField("version").as[String]
        path <- c.downField("path").as[String]
        binary <- c.downField("binary").as[Option[io.flow.dependency.v0.models.Reference]]
      } yield {
        ProjectBinary(
          id = id,
          project = project,
          name = name,
          version = version,
          path = path,
          binary = binary
        )
      }
    }

    implicit def encodeDependencyProjectBinary: Encoder[ProjectBinary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("project" -> t.project.asJson),
        Some("name" -> t.name.asJson),
        Some("version" -> t.version.asJson),
        Some("path" -> t.path.asJson),
        t.binary.map(t => "binary" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectDependencyResolution: Decoder[ProjectDependencyResolution] = Decoder.instance { c =>
     for {
        resolved <- c.downField("resolved").as[Seq[io.flow.dependency.v0.models.ProjectDependencyResolutionResolved]]
        unresolved <- c.downField("unresolved").as[Seq[io.flow.dependency.v0.models.ProjectUnresolvedSummary]]
        steps <- c.downField("steps").as[Map[String, String]]
      } yield {
        ProjectDependencyResolution(
          resolved = resolved,
          unresolved = unresolved,
          steps = steps
        )
      }
    }

    implicit def encodeDependencyProjectDependencyResolution: Encoder[ProjectDependencyResolution] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("resolved" -> t.resolved.asJson),
        Some("unresolved" -> t.unresolved.asJson),
        Some("steps" -> t.steps.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectDependencyResolutionResolved: Decoder[ProjectDependencyResolutionResolved] = Decoder.instance { c =>
     for {
        projects <- c.downField("projects").as[Seq[io.flow.dependency.v0.models.ProjectSummary]]
      } yield {
        ProjectDependencyResolutionResolved(
          projects = projects
        )
      }
    }

    implicit def encodeDependencyProjectDependencyResolutionResolved: Encoder[ProjectDependencyResolutionResolved] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("projects" -> t.projects.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectDetail: Decoder[ProjectDetail] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        name <- c.downField("name").as[String]
      } yield {
        ProjectDetail(
          id = id,
          organization = organization,
          name = name
        )
      }
    }

    implicit def encodeDependencyProjectDetail: Encoder[ProjectDetail] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectForm: Decoder[ProjectForm] = Decoder.instance { c =>
     for {
        organization <- c.downField("organization").as[String]
        name <- c.downField("name").as[String]
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        scms <- c.downField("scms").as[io.flow.dependency.v0.models.Scms]
        uri <- c.downField("uri").as[String]
        branch <- c.downField("branch").as[String]
      } yield {
        ProjectForm(
          organization = organization,
          name = name,
          visibility = visibility,
          scms = scms,
          uri = uri,
          branch = branch
        )
      }
    }

    implicit def encodeDependencyProjectForm: Encoder[ProjectForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("scms" -> t.scms.asJson),
        Some("uri" -> t.uri.asJson),
        Some("branch" -> t.branch.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectLibrary: Decoder[ProjectLibrary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        project <- c.downField("project").as[io.flow.dependency.v0.models.ProjectDetail]
        groupId <- c.downField("group_id").as[String]
        artifactId <- c.downField("artifact_id").as[String]
        version <- c.downField("version").as[String]
        crossBuildVersion <- c.downField("cross_build_version").as[Option[String]]
        path <- c.downField("path").as[String]
        library <- c.downField("library").as[Option[io.flow.dependency.v0.models.Reference]]
      } yield {
        ProjectLibrary(
          id = id,
          project = project,
          groupId = groupId,
          artifactId = artifactId,
          version = version,
          crossBuildVersion = crossBuildVersion,
          path = path,
          library = library
        )
      }
    }

    implicit def encodeDependencyProjectLibrary: Encoder[ProjectLibrary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("project" -> t.project.asJson),
        Some("group_id" -> t.groupId.asJson),
        Some("artifact_id" -> t.artifactId.asJson),
        Some("version" -> t.version.asJson),
        t.crossBuildVersion.map(t => "cross_build_version" -> t.asJson),
        Some("path" -> t.path.asJson),
        t.library.map(t => "library" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectPatchForm: Decoder[ProjectPatchForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[Option[String]]
        visibility <- c.downField("visibility").as[Option[io.flow.dependency.v0.models.Visibility]]
        scms <- c.downField("scms").as[Option[io.flow.dependency.v0.models.Scms]]
        uri <- c.downField("uri").as[Option[String]]
        branch <- c.downField("branch").as[Option[String]]
      } yield {
        ProjectPatchForm(
          name = name,
          visibility = visibility,
          scms = scms,
          uri = uri,
          branch = branch
        )
      }
    }

    implicit def encodeDependencyProjectPatchForm: Encoder[ProjectPatchForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.name.map(t => "name" -> t.asJson),
        t.visibility.map(t => "visibility" -> t.asJson),
        t.scms.map(t => "scms" -> t.asJson),
        t.uri.map(t => "uri" -> t.asJson),
        t.branch.map(t => "branch" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectSummary: Decoder[ProjectSummary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[io.flow.dependency.v0.models.OrganizationSummary]
        name <- c.downField("name").as[String]
      } yield {
        ProjectSummary(
          id = id,
          organization = organization,
          name = name
        )
      }
    }

    implicit def encodeDependencyProjectSummary: Encoder[ProjectSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeDependencyProjectUnresolvedSummary: Decoder[ProjectUnresolvedSummary] = Decoder.instance { c =>
     for {
        project <- c.downField("project").as[io.flow.dependency.v0.models.ProjectSummary]
        resolvedLibraries <- c.downField("resolved_libraries").as[Seq[String]]
        unresolvedLibraries <- c.downField("unresolved_libraries").as[Seq[String]]
      } yield {
        ProjectUnresolvedSummary(
          project = project,
          resolvedLibraries = resolvedLibraries,
          unresolvedLibraries = unresolvedLibraries
        )
      }
    }

    implicit def encodeDependencyProjectUnresolvedSummary: Encoder[ProjectUnresolvedSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("project" -> t.project.asJson),
        Some("resolved_libraries" -> t.resolvedLibraries.asJson),
        Some("unresolved_libraries" -> t.unresolvedLibraries.asJson)
      ).flatten)
    }

    implicit def decodeDependencyRecommendation: Decoder[Recommendation] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        project <- c.downField("project").as[io.flow.dependency.v0.models.ProjectDetail]
        __type__ <- c.downField("type").as[io.flow.dependency.v0.models.RecommendationType]
        __object__ <- c.downField("object").as[io.flow.dependency.v0.models.Reference]
        name <- c.downField("name").as[String]
        from <- c.downField("from").as[String]
        to <- c.downField("to").as[String]
        createdAt <- c.downField("created_at").as[_root_.java.time.Instant]
      } yield {
        Recommendation(
          id = id,
          project = project,
          `type` = __type__,
          `object` = __object__,
          name = name,
          from = from,
          to = to,
          createdAt = createdAt
        )
      }
    }

    implicit def encodeDependencyRecommendation: Encoder[Recommendation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("project" -> t.project.asJson),
        Some("type" -> t.`type`.asJson),
        Some("object" -> t.`object`.asJson),
        Some("name" -> t.name.asJson),
        Some("from" -> t.from.asJson),
        Some("to" -> t.to.asJson),
        Some("created_at" -> t.createdAt.asJson)
      ).flatten)
    }

    implicit def decodeDependencyReference: Decoder[Reference] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
      } yield {
        Reference(
          id = id
        )
      }
    }

    implicit def encodeDependencyReference: Encoder[Reference] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson)
      ).flatten)
    }

    implicit def decodeDependencyRepository: Decoder[Repository] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        uri <- c.downField("uri").as[String]
      } yield {
        Repository(
          name = name,
          visibility = visibility,
          uri = uri
        )
      }
    }

    implicit def encodeDependencyRepository: Encoder[Repository] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("uri" -> t.uri.asJson)
      ).flatten)
    }

    implicit def decodeDependencyResolver: Decoder[Resolver] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        organization <- c.downField("organization").as[Option[io.flow.dependency.v0.models.OrganizationSummary]]
        uri <- c.downField("uri").as[String]
        credentials <- c.downField("credentials").as[Option[io.flow.dependency.v0.models.Credentials]]
      } yield {
        Resolver(
          id = id,
          visibility = visibility,
          organization = organization,
          uri = uri,
          credentials = credentials
        )
      }
    }

    implicit def encodeDependencyResolver: Encoder[Resolver] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("visibility" -> t.visibility.asJson),
        t.organization.map(t => "organization" -> t.asJson),
        Some("uri" -> t.uri.asJson),
        t.credentials.map(t => "credentials" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyResolverForm: Decoder[ResolverForm] = Decoder.instance { c =>
     for {
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        organization <- c.downField("organization").as[String]
        uri <- c.downField("uri").as[String]
        credentials <- c.downField("credentials").as[Option[io.flow.dependency.v0.models.Credentials]]
      } yield {
        ResolverForm(
          visibility = visibility,
          organization = organization,
          uri = uri,
          credentials = credentials
        )
      }
    }

    implicit def encodeDependencyResolverForm: Encoder[ResolverForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("visibility" -> t.visibility.asJson),
        Some("organization" -> t.organization.asJson),
        Some("uri" -> t.uri.asJson),
        t.credentials.map(t => "credentials" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyResolverSummary: Decoder[ResolverSummary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        organization <- c.downField("organization").as[Option[io.flow.dependency.v0.models.OrganizationSummary]]
        visibility <- c.downField("visibility").as[io.flow.dependency.v0.models.Visibility]
        uri <- c.downField("uri").as[String]
      } yield {
        ResolverSummary(
          id = id,
          organization = organization,
          visibility = visibility,
          uri = uri
        )
      }
    }

    implicit def encodeDependencyResolverSummary: Encoder[ResolverSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        t.organization.map(t => "organization" -> t.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("uri" -> t.uri.asJson)
      ).flatten)
    }

    implicit def decodeDependencySubscription: Decoder[Subscription] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        user <- c.downField("user").as[io.flow.common.v0.models.UserReference]
        publication <- c.downField("publication").as[io.flow.dependency.v0.models.Publication]
      } yield {
        Subscription(
          id = id,
          user = user,
          publication = publication
        )
      }
    }

    implicit def encodeDependencySubscription: Encoder[Subscription] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("user" -> t.user.asJson),
        Some("publication" -> t.publication.asJson)
      ).flatten)
    }

    implicit def decodeDependencySubscriptionForm: Decoder[SubscriptionForm] = Decoder.instance { c =>
     for {
        userId <- c.downField("user_id").as[String]
        publication <- c.downField("publication").as[io.flow.dependency.v0.models.Publication]
      } yield {
        SubscriptionForm(
          userId = userId,
          publication = publication
        )
      }
    }

    implicit def encodeDependencySubscriptionForm: Encoder[SubscriptionForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_id" -> t.userId.asJson),
        Some("publication" -> t.publication.asJson)
      ).flatten)
    }

    implicit def decodeDependencySync: Decoder[Sync] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        objectId <- c.downField("object_id").as[String]
        event <- c.downField("event").as[io.flow.dependency.v0.models.SyncEvent]
        createdAt <- c.downField("created_at").as[_root_.java.time.Instant]
      } yield {
        Sync(
          id = id,
          objectId = objectId,
          event = event,
          createdAt = createdAt
        )
      }
    }

    implicit def encodeDependencySync: Encoder[Sync] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("object_id" -> t.objectId.asJson),
        Some("event" -> t.event.asJson),
        Some("created_at" -> t.createdAt.asJson)
      ).flatten)
    }

    implicit def decodeDependencyTaskDataSync: Decoder[TaskDataSync] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[Option[io.flow.dependency.v0.models.SyncType]]
      } yield {
        TaskDataSync(
          `type` = __type__
        )
      }
    }

    implicit def encodeDependencyTaskDataSync: Encoder[TaskDataSync] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.`type`.map(t => "type" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyTaskDataSyncLibrariesByPrefix: Decoder[TaskDataSyncLibrariesByPrefix] = Decoder.instance { c =>
     for {
        userId <- c.downField("user_id").as[String]
        prefix <- c.downField("prefix").as[String]
      } yield {
        TaskDataSyncLibrariesByPrefix(
          userId = userId,
          prefix = prefix
        )
      }
    }

    implicit def encodeDependencyTaskDataSyncLibrariesByPrefix: Encoder[TaskDataSyncLibrariesByPrefix] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_id" -> t.userId.asJson),
        Some("prefix" -> t.prefix.asJson)
      ).flatten)
    }

    implicit def decodeDependencyTaskDataSyncOne: Decoder[TaskDataSyncOne] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        __type__ <- c.downField("type").as[io.flow.dependency.v0.models.SyncType]
      } yield {
        TaskDataSyncOne(
          id = id,
          `type` = __type__
        )
      }
    }

    implicit def encodeDependencyTaskDataSyncOne: Encoder[TaskDataSyncOne] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeDependencyTaskDataSyncOrganizationLibraries: Decoder[TaskDataSyncOrganizationLibraries] = Decoder.instance { c =>
     for {
        organizationId <- c.downField("organization_id").as[String]
      } yield {
        TaskDataSyncOrganizationLibraries(
          organizationId = organizationId
        )
      }
    }

    implicit def encodeDependencyTaskDataSyncOrganizationLibraries: Encoder[TaskDataSyncOrganizationLibraries] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("organization_id" -> t.organizationId.asJson)
      ).flatten)
    }

    implicit def decodeDependencyTaskDataUpserted: Decoder[TaskDataUpserted] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        __type__ <- c.downField("type").as[io.flow.dependency.v0.models.SyncType]
      } yield {
        TaskDataUpserted(
          id = id,
          `type` = __type__
        )
      }
    }

    implicit def encodeDependencyTaskDataUpserted: Encoder[TaskDataUpserted] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("type" -> t.`type`.asJson)
      ).flatten)
    }

    implicit def decodeDependencyToken: Decoder[Token] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        user <- c.downField("user").as[io.flow.common.v0.models.UserReference]
        masked <- c.downField("masked").as[String]
        cleartext <- c.downField("cleartext").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
      } yield {
        Token(
          id = id,
          user = user,
          masked = masked,
          cleartext = cleartext,
          description = description
        )
      }
    }

    implicit def encodeDependencyToken: Encoder[Token] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("user" -> t.user.asJson),
        Some("masked" -> t.masked.asJson),
        t.cleartext.map(t => "cleartext" -> t.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyTokenForm: Decoder[TokenForm] = Decoder.instance { c =>
     for {
        userId <- c.downField("user_id").as[String]
        description <- c.downField("description").as[Option[String]]
      } yield {
        TokenForm(
          userId = userId,
          description = description
        )
      }
    }

    implicit def encodeDependencyTokenForm: Encoder[TokenForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_id" -> t.userId.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyUserForm: Decoder[UserForm] = Decoder.instance { c =>
     for {
        email <- c.downField("email").as[Option[String]]
        name <- c.downField("name").as[Option[io.flow.common.v0.models.Name]]
      } yield {
        UserForm(
          email = email,
          name = name
        )
      }
    }

    implicit def encodeDependencyUserForm: Encoder[UserForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.email.map(t => "email" -> t.asJson),
        t.name.map(t => "name" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyUserIdentifier: Decoder[UserIdentifier] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        user <- c.downField("user").as[io.flow.common.v0.models.UserReference]
        value <- c.downField("value").as[String]
      } yield {
        UserIdentifier(
          id = id,
          user = user,
          value = value
        )
      }
    }

    implicit def encodeDependencyUserIdentifier: Encoder[UserIdentifier] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("user" -> t.user.asJson),
        Some("value" -> t.value.asJson)
      ).flatten)
    }

    implicit def decodeDependencyUserSummary: Decoder[UserSummary] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        email <- c.downField("email").as[Option[String]]
        name <- c.downField("name").as[io.flow.common.v0.models.Name]
      } yield {
        UserSummary(
          id = id,
          email = email,
          name = name
        )
      }
    }

    implicit def encodeDependencyUserSummary: Encoder[UserSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        t.email.map(t => "email" -> t.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeDependencyUsernamePassword: Decoder[UsernamePassword] = Decoder.instance { c =>
     for {
        username <- c.downField("username").as[String]
        password <- c.downField("password").as[Option[String]]
      } yield {
        UsernamePassword(
          username = username,
          password = password
        )
      }
    }

    implicit def encodeDependencyUsernamePassword: Encoder[UsernamePassword] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("username" -> t.username.asJson),
        t.password.map(t => "password" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyVersionForm: Decoder[VersionForm] = Decoder.instance { c =>
     for {
        version <- c.downField("version").as[String]
        crossBuildVersion <- c.downField("cross_build_version").as[Option[String]]
      } yield {
        VersionForm(
          version = version,
          crossBuildVersion = crossBuildVersion
        )
      }
    }

    implicit def encodeDependencyVersionForm: Encoder[VersionForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("version" -> t.version.asJson),
        t.crossBuildVersion.map(t => "cross_build_version" -> t.asJson)
      ).flatten)
    }

    implicit def decodeDependencyCredentials: Decoder[Credentials] = Decoder.instance { c =>
      c.get[Option[String]]("discriminator") match {
        case Right(Some(s)) if s == "username_password" => c.as[io.flow.dependency.v0.models.UsernamePassword]
        case Right(Some(s)) => Right(io.flow.dependency.v0.models.CredentialsUndefinedType(s))
        case _ => Left(DecodingFailure("Union[Credentials] requires a discriminator named 'discriminator' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeDependencyCredentials: Encoder[Credentials] = Encoder.instance {
      case t: io.flow.dependency.v0.models.UsernamePassword => t.asJson.mapObject(obj => ("discriminator", Json.fromString("username_password")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }

    implicit def decodeDependencyItemSummary: Decoder[ItemSummary] = Decoder.instance { c =>
      c.get[Option[String]]("discriminator") match {
        case Right(Some(s)) if s == "binary_summary" => c.as[io.flow.dependency.v0.models.BinarySummary]
        case Right(Some(s)) if s == "library_summary" => c.as[io.flow.dependency.v0.models.LibrarySummary]
        case Right(Some(s)) if s == "project_summary" => c.as[io.flow.dependency.v0.models.ProjectSummary]
        case Right(Some(s)) => Right(io.flow.dependency.v0.models.ItemSummaryUndefinedType(s))
        case _ => Left(DecodingFailure("Union[ItemSummary] requires a discriminator named 'discriminator' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeDependencyItemSummary: Encoder[ItemSummary] = Encoder.instance {
      case t: io.flow.dependency.v0.models.BinarySummary => t.asJson.mapObject(obj => ("discriminator", Json.fromString("binary_summary")) +: obj)
      case t: io.flow.dependency.v0.models.LibrarySummary => t.asJson.mapObject(obj => ("discriminator", Json.fromString("library_summary")) +: obj)
      case t: io.flow.dependency.v0.models.ProjectSummary => t.asJson.mapObject(obj => ("discriminator", Json.fromString("project_summary")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }

    implicit def decodeDependencyTaskData: Decoder[TaskData] = Decoder.instance { c =>
      c.get[Option[String]]("discriminator") match {
        case Right(Some(s)) if s == "task_data_upserted" => c.as[io.flow.dependency.v0.models.TaskDataUpserted]
        case Right(Some(s)) if s == "task_data_sync" => c.as[io.flow.dependency.v0.models.TaskDataSync]
        case Right(Some(s)) if s == "task_data_sync_one" => c.as[io.flow.dependency.v0.models.TaskDataSyncOne]
        case Right(Some(s)) if s == "task_data_sync_libraries_by_prefix" => c.as[io.flow.dependency.v0.models.TaskDataSyncLibrariesByPrefix]
        case Right(Some(s)) if s == "task_data_sync_organization_libraries" => c.as[io.flow.dependency.v0.models.TaskDataSyncOrganizationLibraries]
        case Right(Some(s)) => Right(io.flow.dependency.v0.models.TaskDataUndefinedType(s))
        case _ => Left(DecodingFailure("Union[TaskData] requires a discriminator named 'discriminator' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeDependencyTaskData: Encoder[TaskData] = Encoder.instance {
      case t: io.flow.dependency.v0.models.TaskDataUpserted => t.asJson.mapObject(obj => ("discriminator", Json.fromString("task_data_upserted")) +: obj)
      case t: io.flow.dependency.v0.models.TaskDataSync => t.asJson.mapObject(obj => ("discriminator", Json.fromString("task_data_sync")) +: obj)
      case t: io.flow.dependency.v0.models.TaskDataSyncOne => t.asJson.mapObject(obj => ("discriminator", Json.fromString("task_data_sync_one")) +: obj)
      case t: io.flow.dependency.v0.models.TaskDataSyncLibrariesByPrefix => t.asJson.mapObject(obj => ("discriminator", Json.fromString("task_data_sync_libraries_by_prefix")) +: obj)
      case t: io.flow.dependency.v0.models.TaskDataSyncOrganizationLibraries => t.asJson.mapObject(obj => ("discriminator", Json.fromString("task_data_sync_organization_libraries")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}