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

  sealed trait Credentials extends _root_.scala.Product with _root_.scala.Serializable {
    def credentialsDiscriminator: CredentialsDiscriminator

  }

  /**
   * Defines the valid discriminator values for the type Credentials
   */
  sealed trait CredentialsDiscriminator extends _root_.scala.Product with _root_.scala.Serializable

  object CredentialsDiscriminator {

    case object UsernamePassword extends CredentialsDiscriminator { override def toString = "username_password" }

    final case class UNDEFINED(override val toString: String) extends CredentialsDiscriminator

    val all: scala.List[CredentialsDiscriminator] = scala.List(UsernamePassword)

    private val byName: Map[String, CredentialsDiscriminator] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): CredentialsDiscriminator = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[CredentialsDiscriminator] = byName.get(value.toLowerCase)

  }

  sealed trait ItemSummary extends _root_.scala.Product with _root_.scala.Serializable {
    def itemSummaryDiscriminator: ItemSummaryDiscriminator

  }

  /**
   * Defines the valid discriminator values for the type ItemSummary
   */
  sealed trait ItemSummaryDiscriminator extends _root_.scala.Product with _root_.scala.Serializable

  object ItemSummaryDiscriminator {

    case object BinarySummary extends ItemSummaryDiscriminator { override def toString = "binary_summary" }
    case object LibrarySummary extends ItemSummaryDiscriminator { override def toString = "library_summary" }
    case object ProjectSummary extends ItemSummaryDiscriminator { override def toString = "project_summary" }

    final case class UNDEFINED(override val toString: String) extends ItemSummaryDiscriminator

    val all: scala.List[ItemSummaryDiscriminator] = scala.List(BinarySummary, LibrarySummary, ProjectSummary)

    private val byName: Map[String, ItemSummaryDiscriminator] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): ItemSummaryDiscriminator = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[ItemSummaryDiscriminator] = byName.get(value.toLowerCase)

  }

  sealed trait TaskData extends _root_.scala.Product with _root_.scala.Serializable {
    def taskDataDiscriminator: TaskDataDiscriminator

  }

  /**
   * Defines the valid discriminator values for the type TaskData
   */
  sealed trait TaskDataDiscriminator extends _root_.scala.Product with _root_.scala.Serializable

  object TaskDataDiscriminator {

    case object TaskDataUpserted extends TaskDataDiscriminator { override def toString = "task_data_upserted" }
    case object TaskDataSync extends TaskDataDiscriminator { override def toString = "task_data_sync" }
    case object TaskDataSyncOne extends TaskDataDiscriminator { override def toString = "task_data_sync_one" }
    case object TaskDataSyncLibrariesByPrefix extends TaskDataDiscriminator { override def toString = "task_data_sync_libraries_by_prefix" }
    case object TaskDataSyncOrganizationLibraries extends TaskDataDiscriminator { override def toString = "task_data_sync_organization_libraries" }

    final case class UNDEFINED(override val toString: String) extends TaskDataDiscriminator

    val all: scala.List[TaskDataDiscriminator] = scala.List(TaskDataUpserted, TaskDataSync, TaskDataSyncOne, TaskDataSyncLibrariesByPrefix, TaskDataSyncOrganizationLibraries)

    private val byName: Map[String, TaskDataDiscriminator] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): TaskDataDiscriminator = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[TaskDataDiscriminator] = byName.get(value.toLowerCase)

  }
  final case class Binary(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    name: io.flow.dependency.v0.models.BinaryType
  )

  final case class BinaryForm(
    organizationId: String,
    name: io.flow.dependency.v0.models.BinaryType
  )

  final case class BinarySummary(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    name: io.flow.dependency.v0.models.BinaryType
  ) extends ItemSummary {
    override val itemSummaryDiscriminator: ItemSummaryDiscriminator = ItemSummaryDiscriminator.BinarySummary
  }

  final case class BinaryVersion(
    id: String,
    binary: io.flow.dependency.v0.models.Binary,
    version: String
  )

  /**
   * Used to authenticate user based on the oauth code we receive from github
   */

  final case class GithubAuthenticationForm(
    code: String
  )

  final case class GithubUser(
    id: String,
    user: io.flow.common.v0.models.UserReference,
    githubUserId: Long,
    login: String
  )

  final case class GithubUserForm(
    userId: String,
    githubUserId: Long,
    login: String
  )

  /**
   * Defines a github hook
   */

  final case class GithubWebhook(
    id: Long
  )

  /**
   * A denormalization of item content for search
   *
   * @param id Unique identifier for this item.
   */

  final case class Item(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    visibility: io.flow.dependency.v0.models.Visibility,
    summary: io.flow.dependency.v0.models.ItemSummary,
    label: String,
    description: _root_.scala.Option[String] = None
  )

  /**
   * @param resolver The resolver where we found this library
   */

  final case class Library(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    groupId: String,
    artifactId: String,
    resolver: io.flow.dependency.v0.models.ResolverSummary
  )

  /**
   * @param version If provided, we automatically record this version of this library.
   */

  final case class LibraryForm(
    organizationId: String,
    groupId: String,
    artifactId: String,
    resolverId: String,
    version: _root_.scala.Option[io.flow.dependency.v0.models.VersionForm] = None
  )

  final case class LibrarySummary(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    groupId: String,
    artifactId: String
  ) extends ItemSummary {
    override val itemSummaryDiscriminator: ItemSummaryDiscriminator = ItemSummaryDiscriminator.LibrarySummary
  }

  final case class LibraryVersion(
    id: String,
    library: io.flow.dependency.v0.models.Library,
    version: String,
    crossBuildVersion: _root_.scala.Option[String] = None
  )

  /**
   * A user can belong to one or more organizations via memberships.
   *
   * @param id Unique identifier for this membership
   */

  final case class Membership(
    id: String,
    user: io.flow.dependency.v0.models.UserSummary,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    role: io.flow.dependency.v0.models.Role
  )

  final case class MembershipForm(
    userId: String,
    organization: String,
    role: io.flow.dependency.v0.models.Role = io.flow.dependency.v0.models.Role.Member
  )

  /**
   * @param user The user that created this organization
   */

  final case class Organization(
    id: String,
    user: io.flow.common.v0.models.UserReference,
    key: String
  )

  final case class OrganizationForm(
    key: String
  )

  final case class OrganizationSummary(
    id: String,
    key: String
  )

  /**
   * @param user The user that created this project
   */

  final case class Project(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    user: io.flow.common.v0.models.UserReference,
    visibility: io.flow.dependency.v0.models.Visibility,
    scms: io.flow.dependency.v0.models.Scms,
    name: String,
    uri: String,
    branch: String
  )

  final case class ProjectBinary(
    id: String,
    project: io.flow.dependency.v0.models.ProjectDetail,
    name: String,
    version: String,
    path: String,
    binary: _root_.scala.Option[io.flow.dependency.v0.models.Reference] = None
  )

  /**
   * Provides an ordered set of projects such that each set of projects is sure to
   * have its dependencies resolved. ie. when upgrading projects, you can efficiently
   * upgrade each set of projects in resolved togther.
   *
   * @param unresolved A list of projects that could not be resolved due to circular dependencies
   */

  final case class ProjectDependencyResolution(
    resolved: Seq[io.flow.dependency.v0.models.ProjectDependencyResolutionResolved],
    unresolved: Seq[io.flow.dependency.v0.models.ProjectUnresolvedSummary],
    steps: Map[String, String]
  )

  final case class ProjectDependencyResolutionResolved(
    projects: Seq[io.flow.dependency.v0.models.ProjectSummary]
  )

  final case class ProjectDetail(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    name: String
  )

  final case class ProjectForm(
    organization: String,
    name: String,
    visibility: io.flow.dependency.v0.models.Visibility,
    scms: io.flow.dependency.v0.models.Scms,
    uri: String,
    branch: String
  )

  final case class ProjectLibrary(
    id: String,
    project: io.flow.dependency.v0.models.ProjectDetail,
    groupId: String,
    artifactId: String,
    version: String,
    crossBuildVersion: _root_.scala.Option[String] = None,
    path: String,
    library: _root_.scala.Option[io.flow.dependency.v0.models.Reference] = None
  )

  final case class ProjectPatchForm(
    name: _root_.scala.Option[String] = None,
    visibility: _root_.scala.Option[io.flow.dependency.v0.models.Visibility] = None,
    scms: _root_.scala.Option[io.flow.dependency.v0.models.Scms] = None,
    uri: _root_.scala.Option[String] = None,
    branch: _root_.scala.Option[String] = None
  )

  final case class ProjectSummary(
    id: String,
    organization: io.flow.dependency.v0.models.OrganizationSummary,
    name: String
  ) extends ItemSummary {
    override val itemSummaryDiscriminator: ItemSummaryDiscriminator = ItemSummaryDiscriminator.ProjectSummary
  }

  final case class ProjectUnresolvedSummary(
    project: io.flow.dependency.v0.models.ProjectSummary,
    resolvedLibraries: Seq[String],
    unresolvedLibraries: Seq[String]
  )

  /**
   * Summary of a specific recommendations for a project. Designed for display in the
   * project dashboard
   *
   * @param name The name of the library or binary to upgrade
   * @param from The current version
   * @param to The version to which we recommend upgrading
   */

  final case class Recommendation(
    id: String,
    project: io.flow.dependency.v0.models.ProjectDetail,
    `type`: io.flow.dependency.v0.models.RecommendationType,
    `object`: io.flow.dependency.v0.models.Reference,
    name: String,
    from: String,
    to: String,
    createdAt: _root_.org.joda.time.DateTime
  )

  final case class Reference(
    id: String
  )

  final case class Repository(
    name: String,
    visibility: io.flow.dependency.v0.models.Visibility,
    uri: String
  )

  /**
   * @param organization The organization that created the resolver. If empty, indicates a globally
   *        public resolver
   */

  final case class Resolver(
    id: String,
    visibility: io.flow.dependency.v0.models.Visibility,
    organization: _root_.scala.Option[io.flow.dependency.v0.models.OrganizationSummary] = None,
    uri: String,
    credentials: _root_.scala.Option[io.flow.dependency.v0.models.Credentials] = None
  )

  final case class ResolverForm(
    visibility: io.flow.dependency.v0.models.Visibility,
    organization: String,
    uri: String,
    credentials: _root_.scala.Option[io.flow.dependency.v0.models.Credentials] = None
  )

  final case class ResolverSummary(
    id: String,
    organization: _root_.scala.Option[io.flow.dependency.v0.models.OrganizationSummary] = None,
    visibility: io.flow.dependency.v0.models.Visibility,
    uri: String
  )

  /**
   * Represents a user that is currently subscribed to a publication
   *
   * @param id Internal unique identifier for this subscription record
   */

  final case class Subscription(
    id: String,
    user: io.flow.common.v0.models.UserReference,
    publication: io.flow.dependency.v0.models.Publication
  )

  final case class SubscriptionForm(
    userId: String,
    publication: io.flow.dependency.v0.models.Publication
  )

  /**
   * Records when we start and complete each sync of a module (e.g. project)
   *
   * @param id Unique identifier for this item.
   */

  final case class Sync(
    id: String,
    objectId: String,
    event: io.flow.dependency.v0.models.SyncEvent,
    createdAt: _root_.org.joda.time.DateTime
  )

  /**
   * @param `type` If not specified, we sync all types
   */

  final case class TaskDataSync(
    `type`: _root_.scala.Option[io.flow.dependency.v0.models.SyncType] = None
  ) extends TaskData {
    override val taskDataDiscriminator: TaskDataDiscriminator = TaskDataDiscriminator.TaskDataSync
  }

  final case class TaskDataSyncLibrariesByPrefix(
    userId: String,
    prefix: String
  ) extends TaskData {
    override val taskDataDiscriminator: TaskDataDiscriminator = TaskDataDiscriminator.TaskDataSyncLibrariesByPrefix
  }

  final case class TaskDataSyncOne(
    id: String,
    `type`: io.flow.dependency.v0.models.SyncType
  ) extends TaskData {
    override val taskDataDiscriminator: TaskDataDiscriminator = TaskDataDiscriminator.TaskDataSyncOne
  }

  final case class TaskDataSyncOrganizationLibraries(
    organizationId: String
  ) extends TaskData {
    override val taskDataDiscriminator: TaskDataDiscriminator = TaskDataDiscriminator.TaskDataSyncOrganizationLibraries
  }

  /**
   * Represents that a new, for example, project was created or updated
   */

  final case class TaskDataUpserted(
    id: String,
    `type`: io.flow.dependency.v0.models.SyncType
  ) extends TaskData {
    override val taskDataDiscriminator: TaskDataDiscriminator = TaskDataDiscriminator.TaskDataUpserted
  }

  /**
   * @param cleartext The cleartext token. Only available when the token is initially created
   */

  final case class Token(
    id: String,
    user: io.flow.common.v0.models.UserReference,
    masked: String,
    cleartext: _root_.scala.Option[String] = None,
    description: _root_.scala.Option[String] = None
  )

  final case class TokenForm(
    userId: String,
    description: _root_.scala.Option[String] = None
  )

  final case class UserForm(
    email: _root_.scala.Option[String] = None,
    name: _root_.scala.Option[io.flow.common.v0.models.Name] = None
  )

  final case class UserIdentifier(
    id: String,
    user: io.flow.common.v0.models.UserReference,
    value: String
  )

  final case class UserSummary(
    id: String,
    email: _root_.scala.Option[String] = None,
    name: io.flow.common.v0.models.Name
  )

  final case class UsernamePassword(
    username: String,
    password: _root_.scala.Option[String] = None
  ) extends Credentials {
    override val credentialsDiscriminator: CredentialsDiscriminator = CredentialsDiscriminator.UsernamePassword
  }

  final case class VersionForm(
    version: String,
    crossBuildVersion: _root_.scala.Option[String] = None
  )

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union Credentials, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class CredentialsUndefinedType(
    description: String
  ) extends Credentials {
    override val credentialsDiscriminator: CredentialsDiscriminator = CredentialsDiscriminator.UNDEFINED(description)
  }

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union ItemSummary, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class ItemSummaryUndefinedType(
    description: String
  ) extends ItemSummary {
    override val itemSummaryDiscriminator: ItemSummaryDiscriminator = ItemSummaryDiscriminator.UNDEFINED(description)
  }

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union TaskData, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class TaskDataUndefinedType(
    description: String
  ) extends TaskData {
    override val taskDataDiscriminator: TaskDataDiscriminator = TaskDataDiscriminator.UNDEFINED(description)
  }
  sealed trait BinaryType extends _root_.scala.Product with _root_.scala.Serializable

  object BinaryType {

    /**
     * See http://www.scala-lang.org/
     */
    case object Scala extends BinaryType { override def toString = "scala" }
    /**
     * See http://www.scala-sbt.org/
     */
    case object Sbt extends BinaryType { override def toString = "sbt" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends BinaryType

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[BinaryType] = scala.List(Scala, Sbt)

    private
    val byName: Map[String, BinaryType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): BinaryType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[BinaryType] = byName.get(value.toLowerCase)

  }

  /**
   * A publication represents something that a user can subscribe to.
   */
  sealed trait Publication extends _root_.scala.Product with _root_.scala.Serializable

  object Publication {

    /**
     * A daily summary of dependencies that can be upgraded
     */
    case object DailySummary extends Publication {
      override def toString = "daily_summary"
    }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Publication

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Publication] = scala.List(DailySummary)

    private
    val byName: Map[String, Publication] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Publication = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Publication] = byName.get(value.toLowerCase)

  }

  sealed trait RecommendationType extends _root_.scala.Product with _root_.scala.Serializable

  object RecommendationType {

    case object Library extends RecommendationType { override def toString = "library" }
    case object Binary extends RecommendationType { override def toString = "binary" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends RecommendationType

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[RecommendationType] = scala.List(Library, Binary)

    private
    val byName: Map[String, RecommendationType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): RecommendationType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[RecommendationType] = byName.get(value.toLowerCase)

  }

  sealed trait Role extends _root_.scala.Product with _root_.scala.Serializable

  object Role {

    case object Member extends Role { override def toString = "member" }
    case object Admin extends Role { override def toString = "admin" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Role

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Role] = scala.List(Member, Admin)

    private
    val byName: Map[String, Role] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Role = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Role] = byName.get(value.toLowerCase)

  }

  sealed trait Scms extends _root_.scala.Product with _root_.scala.Serializable

  object Scms {

    case object Github extends Scms { override def toString = "github" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Scms

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Scms] = scala.List(Github)

    private
    val byName: Map[String, Scms] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Scms = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Scms] = byName.get(value.toLowerCase)

  }

  sealed trait SyncEvent extends _root_.scala.Product with _root_.scala.Serializable

  object SyncEvent {

    case object Started extends SyncEvent { override def toString = "started" }
    case object Completed extends SyncEvent { override def toString = "completed" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends SyncEvent

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[SyncEvent] = scala.List(Started, Completed)

    private
    val byName: Map[String, SyncEvent] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): SyncEvent = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[SyncEvent] = byName.get(value.toLowerCase)

  }

  sealed trait SyncType extends _root_.scala.Product with _root_.scala.Serializable

  object SyncType {

    case object Project extends SyncType { override def toString = "project" }
    case object Library extends SyncType { override def toString = "library" }
    case object Binary extends SyncType { override def toString = "binary" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends SyncType

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[SyncType] = scala.List(Project, Library, Binary)

    private
    val byName: Map[String, SyncType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): SyncType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[SyncType] = byName.get(value.toLowerCase)

  }

  sealed trait Visibility extends _root_.scala.Product with _root_.scala.Serializable

  object Visibility {

    case object Public extends Visibility { override def toString = "public" }
    case object Private extends Visibility { override def toString = "private" }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious for users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Visibility

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Visibility] = scala.List(Public, Private)

    private
    val byName: Map[String, Visibility] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Visibility = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Visibility] = byName.get(value.toLowerCase)

  }

}

package io.flow.dependency.v0.models {

  package object json {
    import play.api.libs.json.__
    import play.api.libs.json.JsString
    import play.api.libs.json.Writes
    import play.api.libs.functional.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._

    private[v0] implicit val jsonReadsUUID: play.api.libs.json.Reads[_root_.java.util.UUID] = __.read[String].map { str =>
      _root_.java.util.UUID.fromString(str)
    }

    private[v0] implicit val jsonWritesUUID: play.api.libs.json.Writes[_root_.java.util.UUID] = (x: _root_.java.util.UUID) => play.api.libs.json.JsString(x.toString)

    private[v0] implicit val jsonReadsJodaDateTime: play.api.libs.json.Reads[_root_.org.joda.time.DateTime] = __.read[String].map { str =>
      _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseDateTime(str)
    }

    private[v0] implicit val jsonWritesJodaDateTime: play.api.libs.json.Writes[_root_.org.joda.time.DateTime] = (x: _root_.org.joda.time.DateTime) => {
      play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(x))
    }

    private[v0] implicit val jsonReadsJodaLocalDate: play.api.libs.json.Reads[_root_.org.joda.time.LocalDate] = __.read[String].map { str =>
      _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseLocalDate(str)
    }

    private[v0] implicit val jsonWritesJodaLocalDate: play.api.libs.json.Writes[_root_.org.joda.time.LocalDate] = (x: _root_.org.joda.time.LocalDate) => {
      play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.date.print(x))
    }

    implicit val jsonReadsDependencyBinaryType: play.api.libs.json.Reads[io.flow.dependency.v0.models.BinaryType] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.BinaryType] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.BinaryType] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.BinaryType(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.BinaryType(v))
              case err: play.api.libs.json.JsError =>
                (js \ "binary_type").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.BinaryType(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencyBinaryType(obj: io.flow.dependency.v0.models.BinaryType) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectBinaryType(obj: io.flow.dependency.v0.models.BinaryType) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencyBinaryType: play.api.libs.json.Writes[BinaryType] = {
      (obj: io.flow.dependency.v0.models.BinaryType) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencyBinaryType(obj)
      }
    }

    implicit val jsonReadsDependencyPublication: play.api.libs.json.Reads[io.flow.dependency.v0.models.Publication] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.Publication] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.Publication] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Publication(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Publication(v))
              case err: play.api.libs.json.JsError =>
                (js \ "publication").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Publication(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencyPublication(obj: io.flow.dependency.v0.models.Publication) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectPublication(obj: io.flow.dependency.v0.models.Publication) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencyPublication: play.api.libs.json.Writes[Publication] = {
      (obj: io.flow.dependency.v0.models.Publication) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencyPublication(obj)
      }
    }

    implicit val jsonReadsDependencyRecommendationType: play.api.libs.json.Reads[io.flow.dependency.v0.models.RecommendationType] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.RecommendationType] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.RecommendationType] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.RecommendationType(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.RecommendationType(v))
              case err: play.api.libs.json.JsError =>
                (js \ "recommendation_type").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.RecommendationType(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencyRecommendationType(obj: io.flow.dependency.v0.models.RecommendationType) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectRecommendationType(obj: io.flow.dependency.v0.models.RecommendationType) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencyRecommendationType: play.api.libs.json.Writes[RecommendationType] = {
      (obj: io.flow.dependency.v0.models.RecommendationType) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencyRecommendationType(obj)
      }
    }

    implicit val jsonReadsDependencyRole: play.api.libs.json.Reads[io.flow.dependency.v0.models.Role] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.Role] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.Role] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Role(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Role(v))
              case err: play.api.libs.json.JsError =>
                (js \ "role").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Role(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencyRole(obj: io.flow.dependency.v0.models.Role) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectRole(obj: io.flow.dependency.v0.models.Role) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencyRole: play.api.libs.json.Writes[Role] = {
      (obj: io.flow.dependency.v0.models.Role) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencyRole(obj)
      }
    }

    implicit val jsonReadsDependencyScms: play.api.libs.json.Reads[io.flow.dependency.v0.models.Scms] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.Scms] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.Scms] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Scms(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Scms(v))
              case err: play.api.libs.json.JsError =>
                (js \ "scms").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Scms(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencyScms(obj: io.flow.dependency.v0.models.Scms) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectScms(obj: io.flow.dependency.v0.models.Scms) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencyScms: play.api.libs.json.Writes[Scms] = {
      (obj: io.flow.dependency.v0.models.Scms) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencyScms(obj)
      }
    }

    implicit val jsonReadsDependencySyncEvent: play.api.libs.json.Reads[io.flow.dependency.v0.models.SyncEvent] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.SyncEvent] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.SyncEvent] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.SyncEvent(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.SyncEvent(v))
              case err: play.api.libs.json.JsError =>
                (js \ "sync_event").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.SyncEvent(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencySyncEvent(obj: io.flow.dependency.v0.models.SyncEvent) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectSyncEvent(obj: io.flow.dependency.v0.models.SyncEvent) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencySyncEvent: play.api.libs.json.Writes[SyncEvent] = {
      (obj: io.flow.dependency.v0.models.SyncEvent) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencySyncEvent(obj)
      }
    }

    implicit val jsonReadsDependencySyncType: play.api.libs.json.Reads[io.flow.dependency.v0.models.SyncType] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.SyncType] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.SyncType] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.SyncType(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.SyncType(v))
              case err: play.api.libs.json.JsError =>
                (js \ "sync_type").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.SyncType(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencySyncType(obj: io.flow.dependency.v0.models.SyncType) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectSyncType(obj: io.flow.dependency.v0.models.SyncType) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencySyncType: play.api.libs.json.Writes[SyncType] = {
      (obj: io.flow.dependency.v0.models.SyncType) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencySyncType(obj)
      }
    }

    implicit val jsonReadsDependencyVisibility: play.api.libs.json.Reads[io.flow.dependency.v0.models.Visibility] = new play.api.libs.json.Reads[io.flow.dependency.v0.models.Visibility] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.flow.dependency.v0.models.Visibility] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Visibility(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Visibility(v))
              case err: play.api.libs.json.JsError =>
                (js \ "visibility").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.Visibility(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesDependencyVisibility(obj: io.flow.dependency.v0.models.Visibility) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectVisibility(obj: io.flow.dependency.v0.models.Visibility) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesDependencyVisibility: play.api.libs.json.Writes[Visibility] = {
      (obj: io.flow.dependency.v0.models.Visibility) => {
        io.flow.dependency.v0.models.json.jsonWritesDependencyVisibility(obj)
      }
    }

    implicit def jsonReadsDependencyBinary: play.api.libs.json.Reads[io.flow.dependency.v0.models.Binary] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        name <- (__ \ "name").read[io.flow.dependency.v0.models.BinaryType]
      } yield Binary(id, organization, name)
    }

    def jsObjectBinary(obj: io.flow.dependency.v0.models.Binary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "name" -> play.api.libs.json.JsString(obj.name.toString)
      )
    }

    implicit def jsonWritesDependencyBinary: play.api.libs.json.Writes[Binary] = {
      (obj: io.flow.dependency.v0.models.Binary) => {
        io.flow.dependency.v0.models.json.jsObjectBinary(obj)
      }
    }

    implicit def jsonReadsDependencyBinaryForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.BinaryForm] = {
      for {
        organizationId <- (__ \ "organization_id").read[String]
        name <- (__ \ "name").read[io.flow.dependency.v0.models.BinaryType]
      } yield BinaryForm(organizationId, name)
    }

    def jsObjectBinaryForm(obj: io.flow.dependency.v0.models.BinaryForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "organization_id" -> play.api.libs.json.JsString(obj.organizationId),
        "name" -> play.api.libs.json.JsString(obj.name.toString)
      )
    }

    implicit def jsonWritesDependencyBinaryForm: play.api.libs.json.Writes[BinaryForm] = {
      (obj: io.flow.dependency.v0.models.BinaryForm) => {
        io.flow.dependency.v0.models.json.jsObjectBinaryForm(obj)
      }
    }

    implicit def jsonReadsDependencyBinarySummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.BinarySummary] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        name <- (__ \ "name").read[io.flow.dependency.v0.models.BinaryType]
      } yield BinarySummary(id, organization, name)
    }

    def jsObjectBinarySummary(obj: io.flow.dependency.v0.models.BinarySummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "name" -> play.api.libs.json.JsString(obj.name.toString)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "binary_summary")
    }

    implicit def jsonWritesDependencyBinarySummary: play.api.libs.json.Writes[BinarySummary] = {
      (obj: io.flow.dependency.v0.models.BinarySummary) => {
        io.flow.dependency.v0.models.json.jsObjectBinarySummary(obj)
      }
    }

    implicit def jsonReadsDependencyBinaryVersion: play.api.libs.json.Reads[io.flow.dependency.v0.models.BinaryVersion] = {
      for {
        id <- (__ \ "id").read[String]
        binary <- (__ \ "binary").read[io.flow.dependency.v0.models.Binary]
        version <- (__ \ "version").read[String]
      } yield BinaryVersion(id, binary, version)
    }

    def jsObjectBinaryVersion(obj: io.flow.dependency.v0.models.BinaryVersion): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "binary" -> io.flow.dependency.v0.models.json.jsObjectBinary(obj.binary),
        "version" -> play.api.libs.json.JsString(obj.version)
      )
    }

    implicit def jsonWritesDependencyBinaryVersion: play.api.libs.json.Writes[BinaryVersion] = {
      (obj: io.flow.dependency.v0.models.BinaryVersion) => {
        io.flow.dependency.v0.models.json.jsObjectBinaryVersion(obj)
      }
    }

    implicit def jsonReadsDependencyGithubAuthenticationForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.GithubAuthenticationForm] = {
      (__ \ "code").read[String].map { x => GithubAuthenticationForm(code = x) }
    }

    def jsObjectGithubAuthenticationForm(obj: io.flow.dependency.v0.models.GithubAuthenticationForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "code" -> play.api.libs.json.JsString(obj.code)
      )
    }

    implicit def jsonWritesDependencyGithubAuthenticationForm: play.api.libs.json.Writes[GithubAuthenticationForm] = {
      (obj: io.flow.dependency.v0.models.GithubAuthenticationForm) => {
        io.flow.dependency.v0.models.json.jsObjectGithubAuthenticationForm(obj)
      }
    }

    implicit def jsonReadsDependencyGithubUser: play.api.libs.json.Reads[io.flow.dependency.v0.models.GithubUser] = {
      for {
        id <- (__ \ "id").read[String]
        user <- (__ \ "user").read[io.flow.common.v0.models.UserReference]
        githubUserId <- (__ \ "github_user_id").read[Long]
        login <- (__ \ "login").read[String]
      } yield GithubUser(id, user, githubUserId, login)
    }

    def jsObjectGithubUser(obj: io.flow.dependency.v0.models.GithubUser): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "user" -> io.flow.common.v0.models.json.jsObjectUserReference(obj.user),
        "github_user_id" -> play.api.libs.json.JsNumber(obj.githubUserId),
        "login" -> play.api.libs.json.JsString(obj.login)
      )
    }

    implicit def jsonWritesDependencyGithubUser: play.api.libs.json.Writes[GithubUser] = {
      (obj: io.flow.dependency.v0.models.GithubUser) => {
        io.flow.dependency.v0.models.json.jsObjectGithubUser(obj)
      }
    }

    implicit def jsonReadsDependencyGithubUserForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.GithubUserForm] = {
      for {
        userId <- (__ \ "user_id").read[String]
        githubUserId <- (__ \ "github_user_id").read[Long]
        login <- (__ \ "login").read[String]
      } yield GithubUserForm(userId, githubUserId, login)
    }

    def jsObjectGithubUserForm(obj: io.flow.dependency.v0.models.GithubUserForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_id" -> play.api.libs.json.JsString(obj.userId),
        "github_user_id" -> play.api.libs.json.JsNumber(obj.githubUserId),
        "login" -> play.api.libs.json.JsString(obj.login)
      )
    }

    implicit def jsonWritesDependencyGithubUserForm: play.api.libs.json.Writes[GithubUserForm] = {
      (obj: io.flow.dependency.v0.models.GithubUserForm) => {
        io.flow.dependency.v0.models.json.jsObjectGithubUserForm(obj)
      }
    }

    implicit def jsonReadsDependencyGithubWebhook: play.api.libs.json.Reads[io.flow.dependency.v0.models.GithubWebhook] = {
      (__ \ "id").read[Long].map { x => GithubWebhook(id = x) }
    }

    def jsObjectGithubWebhook(obj: io.flow.dependency.v0.models.GithubWebhook): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsNumber(obj.id)
      )
    }

    implicit def jsonWritesDependencyGithubWebhook: play.api.libs.json.Writes[GithubWebhook] = {
      (obj: io.flow.dependency.v0.models.GithubWebhook) => {
        io.flow.dependency.v0.models.json.jsObjectGithubWebhook(obj)
      }
    }

    implicit def jsonReadsDependencyItem: play.api.libs.json.Reads[io.flow.dependency.v0.models.Item] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        summary <- (__ \ "summary").read[io.flow.dependency.v0.models.ItemSummary]
        label <- (__ \ "label").read[String]
        description <- (__ \ "description").readNullable[String]
      } yield Item(id, organization, visibility, summary, label, description)
    }

    def jsObjectItem(obj: io.flow.dependency.v0.models.Item): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "summary" -> io.flow.dependency.v0.models.json.jsObjectItemSummary(obj.summary),
        "label" -> play.api.libs.json.JsString(obj.label)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyItem: play.api.libs.json.Writes[Item] = {
      (obj: io.flow.dependency.v0.models.Item) => {
        io.flow.dependency.v0.models.json.jsObjectItem(obj)
      }
    }

    implicit def jsonReadsDependencyLibrary: play.api.libs.json.Reads[io.flow.dependency.v0.models.Library] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        groupId <- (__ \ "group_id").read[String]
        artifactId <- (__ \ "artifact_id").read[String]
        resolver <- (__ \ "resolver").read[io.flow.dependency.v0.models.ResolverSummary]
      } yield Library(id, organization, groupId, artifactId, resolver)
    }

    def jsObjectLibrary(obj: io.flow.dependency.v0.models.Library): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "group_id" -> play.api.libs.json.JsString(obj.groupId),
        "artifact_id" -> play.api.libs.json.JsString(obj.artifactId),
        "resolver" -> io.flow.dependency.v0.models.json.jsObjectResolverSummary(obj.resolver)
      )
    }

    implicit def jsonWritesDependencyLibrary: play.api.libs.json.Writes[Library] = {
      (obj: io.flow.dependency.v0.models.Library) => {
        io.flow.dependency.v0.models.json.jsObjectLibrary(obj)
      }
    }

    implicit def jsonReadsDependencyLibraryForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.LibraryForm] = {
      for {
        organizationId <- (__ \ "organization_id").read[String]
        groupId <- (__ \ "group_id").read[String]
        artifactId <- (__ \ "artifact_id").read[String]
        resolverId <- (__ \ "resolver_id").read[String]
        version <- (__ \ "version").readNullable[io.flow.dependency.v0.models.VersionForm]
      } yield LibraryForm(organizationId, groupId, artifactId, resolverId, version)
    }

    def jsObjectLibraryForm(obj: io.flow.dependency.v0.models.LibraryForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "organization_id" -> play.api.libs.json.JsString(obj.organizationId),
        "group_id" -> play.api.libs.json.JsString(obj.groupId),
        "artifact_id" -> play.api.libs.json.JsString(obj.artifactId),
        "resolver_id" -> play.api.libs.json.JsString(obj.resolverId)
      ) ++ (obj.version match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("version" -> io.flow.dependency.v0.models.json.jsObjectVersionForm(x))
      })
    }

    implicit def jsonWritesDependencyLibraryForm: play.api.libs.json.Writes[LibraryForm] = {
      (obj: io.flow.dependency.v0.models.LibraryForm) => {
        io.flow.dependency.v0.models.json.jsObjectLibraryForm(obj)
      }
    }

    implicit def jsonReadsDependencyLibrarySummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.LibrarySummary] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        groupId <- (__ \ "group_id").read[String]
        artifactId <- (__ \ "artifact_id").read[String]
      } yield LibrarySummary(id, organization, groupId, artifactId)
    }

    def jsObjectLibrarySummary(obj: io.flow.dependency.v0.models.LibrarySummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "group_id" -> play.api.libs.json.JsString(obj.groupId),
        "artifact_id" -> play.api.libs.json.JsString(obj.artifactId)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "library_summary")
    }

    implicit def jsonWritesDependencyLibrarySummary: play.api.libs.json.Writes[LibrarySummary] = {
      (obj: io.flow.dependency.v0.models.LibrarySummary) => {
        io.flow.dependency.v0.models.json.jsObjectLibrarySummary(obj)
      }
    }

    implicit def jsonReadsDependencyLibraryVersion: play.api.libs.json.Reads[io.flow.dependency.v0.models.LibraryVersion] = {
      for {
        id <- (__ \ "id").read[String]
        library <- (__ \ "library").read[io.flow.dependency.v0.models.Library]
        version <- (__ \ "version").read[String]
        crossBuildVersion <- (__ \ "cross_build_version").readNullable[String]
      } yield LibraryVersion(id, library, version, crossBuildVersion)
    }

    def jsObjectLibraryVersion(obj: io.flow.dependency.v0.models.LibraryVersion): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "library" -> io.flow.dependency.v0.models.json.jsObjectLibrary(obj.library),
        "version" -> play.api.libs.json.JsString(obj.version)
      ) ++ (obj.crossBuildVersion match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("cross_build_version" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyLibraryVersion: play.api.libs.json.Writes[LibraryVersion] = {
      (obj: io.flow.dependency.v0.models.LibraryVersion) => {
        io.flow.dependency.v0.models.json.jsObjectLibraryVersion(obj)
      }
    }

    implicit def jsonReadsDependencyMembership: play.api.libs.json.Reads[io.flow.dependency.v0.models.Membership] = {
      for {
        id <- (__ \ "id").read[String]
        user <- (__ \ "user").read[io.flow.dependency.v0.models.UserSummary]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        role <- (__ \ "role").read[io.flow.dependency.v0.models.Role]
      } yield Membership(id, user, organization, role)
    }

    def jsObjectMembership(obj: io.flow.dependency.v0.models.Membership): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "user" -> io.flow.dependency.v0.models.json.jsObjectUserSummary(obj.user),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "role" -> play.api.libs.json.JsString(obj.role.toString)
      )
    }

    implicit def jsonWritesDependencyMembership: play.api.libs.json.Writes[Membership] = {
      (obj: io.flow.dependency.v0.models.Membership) => {
        io.flow.dependency.v0.models.json.jsObjectMembership(obj)
      }
    }

    implicit def jsonReadsDependencyMembershipForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.MembershipForm] = {
      for {
        userId <- (__ \ "user_id").read[String]
        organization <- (__ \ "organization").read[String]
        role <- (__ \ "role").read[io.flow.dependency.v0.models.Role]
      } yield MembershipForm(userId, organization, role)
    }

    def jsObjectMembershipForm(obj: io.flow.dependency.v0.models.MembershipForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_id" -> play.api.libs.json.JsString(obj.userId),
        "organization" -> play.api.libs.json.JsString(obj.organization),
        "role" -> play.api.libs.json.JsString(obj.role.toString)
      )
    }

    implicit def jsonWritesDependencyMembershipForm: play.api.libs.json.Writes[MembershipForm] = {
      (obj: io.flow.dependency.v0.models.MembershipForm) => {
        io.flow.dependency.v0.models.json.jsObjectMembershipForm(obj)
      }
    }

    implicit def jsonReadsDependencyOrganization: play.api.libs.json.Reads[io.flow.dependency.v0.models.Organization] = {
      for {
        id <- (__ \ "id").read[String]
        user <- (__ \ "user").read[io.flow.common.v0.models.UserReference]
        key <- (__ \ "key").read[String]
      } yield Organization(id, user, key)
    }

    def jsObjectOrganization(obj: io.flow.dependency.v0.models.Organization): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "user" -> io.flow.common.v0.models.json.jsObjectUserReference(obj.user),
        "key" -> play.api.libs.json.JsString(obj.key)
      )
    }

    implicit def jsonWritesDependencyOrganization: play.api.libs.json.Writes[Organization] = {
      (obj: io.flow.dependency.v0.models.Organization) => {
        io.flow.dependency.v0.models.json.jsObjectOrganization(obj)
      }
    }

    implicit def jsonReadsDependencyOrganizationForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.OrganizationForm] = {
      (__ \ "key").read[String].map { x => OrganizationForm(key = x) }
    }

    def jsObjectOrganizationForm(obj: io.flow.dependency.v0.models.OrganizationForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "key" -> play.api.libs.json.JsString(obj.key)
      )
    }

    implicit def jsonWritesDependencyOrganizationForm: play.api.libs.json.Writes[OrganizationForm] = {
      (obj: io.flow.dependency.v0.models.OrganizationForm) => {
        io.flow.dependency.v0.models.json.jsObjectOrganizationForm(obj)
      }
    }

    implicit def jsonReadsDependencyOrganizationSummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.OrganizationSummary] = {
      for {
        id <- (__ \ "id").read[String]
        key <- (__ \ "key").read[String]
      } yield OrganizationSummary(id, key)
    }

    def jsObjectOrganizationSummary(obj: io.flow.dependency.v0.models.OrganizationSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "key" -> play.api.libs.json.JsString(obj.key)
      )
    }

    implicit def jsonWritesDependencyOrganizationSummary: play.api.libs.json.Writes[OrganizationSummary] = {
      (obj: io.flow.dependency.v0.models.OrganizationSummary) => {
        io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj)
      }
    }

    implicit def jsonReadsDependencyProject: play.api.libs.json.Reads[io.flow.dependency.v0.models.Project] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        user <- (__ \ "user").read[io.flow.common.v0.models.UserReference]
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        scms <- (__ \ "scms").read[io.flow.dependency.v0.models.Scms]
        name <- (__ \ "name").read[String]
        uri <- (__ \ "uri").read[String]
        branch <- (__ \ "branch").read[String]
      } yield Project(id, organization, user, visibility, scms, name, uri, branch)
    }

    def jsObjectProject(obj: io.flow.dependency.v0.models.Project): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "user" -> io.flow.common.v0.models.json.jsObjectUserReference(obj.user),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "scms" -> play.api.libs.json.JsString(obj.scms.toString),
        "name" -> play.api.libs.json.JsString(obj.name),
        "uri" -> play.api.libs.json.JsString(obj.uri),
        "branch" -> play.api.libs.json.JsString(obj.branch)
      )
    }

    implicit def jsonWritesDependencyProject: play.api.libs.json.Writes[Project] = {
      (obj: io.flow.dependency.v0.models.Project) => {
        io.flow.dependency.v0.models.json.jsObjectProject(obj)
      }
    }

    implicit def jsonReadsDependencyProjectBinary: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectBinary] = {
      for {
        id <- (__ \ "id").read[String]
        project <- (__ \ "project").read[io.flow.dependency.v0.models.ProjectDetail]
        name <- (__ \ "name").read[String]
        version <- (__ \ "version").read[String]
        path <- (__ \ "path").read[String]
        binary <- (__ \ "binary").readNullable[io.flow.dependency.v0.models.Reference]
      } yield ProjectBinary(id, project, name, version, path, binary)
    }

    def jsObjectProjectBinary(obj: io.flow.dependency.v0.models.ProjectBinary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "project" -> io.flow.dependency.v0.models.json.jsObjectProjectDetail(obj.project),
        "name" -> play.api.libs.json.JsString(obj.name),
        "version" -> play.api.libs.json.JsString(obj.version),
        "path" -> play.api.libs.json.JsString(obj.path)
      ) ++ (obj.binary match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("binary" -> io.flow.dependency.v0.models.json.jsObjectReference(x))
      })
    }

    implicit def jsonWritesDependencyProjectBinary: play.api.libs.json.Writes[ProjectBinary] = {
      (obj: io.flow.dependency.v0.models.ProjectBinary) => {
        io.flow.dependency.v0.models.json.jsObjectProjectBinary(obj)
      }
    }

    implicit def jsonReadsDependencyProjectDependencyResolution: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectDependencyResolution] = {
      for {
        resolved <- (__ \ "resolved").read[Seq[io.flow.dependency.v0.models.ProjectDependencyResolutionResolved]]
        unresolved <- (__ \ "unresolved").read[Seq[io.flow.dependency.v0.models.ProjectUnresolvedSummary]]
        steps <- (__ \ "steps").read[Map[String, String]]
      } yield ProjectDependencyResolution(resolved, unresolved, steps)
    }

    def jsObjectProjectDependencyResolution(obj: io.flow.dependency.v0.models.ProjectDependencyResolution): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "resolved" -> play.api.libs.json.Json.toJson(obj.resolved),
        "unresolved" -> play.api.libs.json.Json.toJson(obj.unresolved),
        "steps" -> play.api.libs.json.Json.toJson(obj.steps)
      )
    }

    implicit def jsonWritesDependencyProjectDependencyResolution: play.api.libs.json.Writes[ProjectDependencyResolution] = {
      (obj: io.flow.dependency.v0.models.ProjectDependencyResolution) => {
        io.flow.dependency.v0.models.json.jsObjectProjectDependencyResolution(obj)
      }
    }

    implicit def jsonReadsDependencyProjectDependencyResolutionResolved: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectDependencyResolutionResolved] = {
      (__ \ "projects").read[Seq[io.flow.dependency.v0.models.ProjectSummary]].map { x => ProjectDependencyResolutionResolved(projects = x) }
    }

    def jsObjectProjectDependencyResolutionResolved(obj: io.flow.dependency.v0.models.ProjectDependencyResolutionResolved): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "projects" -> play.api.libs.json.Json.toJson(obj.projects)
      )
    }

    implicit def jsonWritesDependencyProjectDependencyResolutionResolved: play.api.libs.json.Writes[ProjectDependencyResolutionResolved] = {
      (obj: io.flow.dependency.v0.models.ProjectDependencyResolutionResolved) => {
        io.flow.dependency.v0.models.json.jsObjectProjectDependencyResolutionResolved(obj)
      }
    }

    implicit def jsonReadsDependencyProjectDetail: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectDetail] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        name <- (__ \ "name").read[String]
      } yield ProjectDetail(id, organization, name)
    }

    def jsObjectProjectDetail(obj: io.flow.dependency.v0.models.ProjectDetail): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "name" -> play.api.libs.json.JsString(obj.name)
      )
    }

    implicit def jsonWritesDependencyProjectDetail: play.api.libs.json.Writes[ProjectDetail] = {
      (obj: io.flow.dependency.v0.models.ProjectDetail) => {
        io.flow.dependency.v0.models.json.jsObjectProjectDetail(obj)
      }
    }

    implicit def jsonReadsDependencyProjectForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectForm] = {
      for {
        organization <- (__ \ "organization").read[String]
        name <- (__ \ "name").read[String]
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        scms <- (__ \ "scms").read[io.flow.dependency.v0.models.Scms]
        uri <- (__ \ "uri").read[String]
        branch <- (__ \ "branch").read[String]
      } yield ProjectForm(organization, name, visibility, scms, uri, branch)
    }

    def jsObjectProjectForm(obj: io.flow.dependency.v0.models.ProjectForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "organization" -> play.api.libs.json.JsString(obj.organization),
        "name" -> play.api.libs.json.JsString(obj.name),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "scms" -> play.api.libs.json.JsString(obj.scms.toString),
        "uri" -> play.api.libs.json.JsString(obj.uri),
        "branch" -> play.api.libs.json.JsString(obj.branch)
      )
    }

    implicit def jsonWritesDependencyProjectForm: play.api.libs.json.Writes[ProjectForm] = {
      (obj: io.flow.dependency.v0.models.ProjectForm) => {
        io.flow.dependency.v0.models.json.jsObjectProjectForm(obj)
      }
    }

    implicit def jsonReadsDependencyProjectLibrary: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectLibrary] = {
      for {
        id <- (__ \ "id").read[String]
        project <- (__ \ "project").read[io.flow.dependency.v0.models.ProjectDetail]
        groupId <- (__ \ "group_id").read[String]
        artifactId <- (__ \ "artifact_id").read[String]
        version <- (__ \ "version").read[String]
        crossBuildVersion <- (__ \ "cross_build_version").readNullable[String]
        path <- (__ \ "path").read[String]
        library <- (__ \ "library").readNullable[io.flow.dependency.v0.models.Reference]
      } yield ProjectLibrary(id, project, groupId, artifactId, version, crossBuildVersion, path, library)
    }

    def jsObjectProjectLibrary(obj: io.flow.dependency.v0.models.ProjectLibrary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "project" -> io.flow.dependency.v0.models.json.jsObjectProjectDetail(obj.project),
        "group_id" -> play.api.libs.json.JsString(obj.groupId),
        "artifact_id" -> play.api.libs.json.JsString(obj.artifactId),
        "version" -> play.api.libs.json.JsString(obj.version),
        "path" -> play.api.libs.json.JsString(obj.path)
      ) ++ (obj.crossBuildVersion match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("cross_build_version" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.library match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("library" -> io.flow.dependency.v0.models.json.jsObjectReference(x))
      })
    }

    implicit def jsonWritesDependencyProjectLibrary: play.api.libs.json.Writes[ProjectLibrary] = {
      (obj: io.flow.dependency.v0.models.ProjectLibrary) => {
        io.flow.dependency.v0.models.json.jsObjectProjectLibrary(obj)
      }
    }

    implicit def jsonReadsDependencyProjectPatchForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectPatchForm] = {
      for {
        name <- (__ \ "name").readNullable[String]
        visibility <- (__ \ "visibility").readNullable[io.flow.dependency.v0.models.Visibility]
        scms <- (__ \ "scms").readNullable[io.flow.dependency.v0.models.Scms]
        uri <- (__ \ "uri").readNullable[String]
        branch <- (__ \ "branch").readNullable[String]
      } yield ProjectPatchForm(name, visibility, scms, uri, branch)
    }

    def jsObjectProjectPatchForm(obj: io.flow.dependency.v0.models.ProjectPatchForm): play.api.libs.json.JsObject = {
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.visibility match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("visibility" -> play.api.libs.json.JsString(x.toString))
      }) ++
      (obj.scms match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("scms" -> play.api.libs.json.JsString(x.toString))
      }) ++
      (obj.uri match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("uri" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.branch match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("branch" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyProjectPatchForm: play.api.libs.json.Writes[ProjectPatchForm] = {
      (obj: io.flow.dependency.v0.models.ProjectPatchForm) => {
        io.flow.dependency.v0.models.json.jsObjectProjectPatchForm(obj)
      }
    }

    implicit def jsonReadsDependencyProjectSummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectSummary] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").read[io.flow.dependency.v0.models.OrganizationSummary]
        name <- (__ \ "name").read[String]
      } yield ProjectSummary(id, organization, name)
    }

    def jsObjectProjectSummary(obj: io.flow.dependency.v0.models.ProjectSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(obj.organization),
        "name" -> play.api.libs.json.JsString(obj.name)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "project_summary")
    }

    implicit def jsonWritesDependencyProjectSummary: play.api.libs.json.Writes[ProjectSummary] = {
      (obj: io.flow.dependency.v0.models.ProjectSummary) => {
        io.flow.dependency.v0.models.json.jsObjectProjectSummary(obj)
      }
    }

    implicit def jsonReadsDependencyProjectUnresolvedSummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.ProjectUnresolvedSummary] = {
      for {
        project <- (__ \ "project").read[io.flow.dependency.v0.models.ProjectSummary]
        resolvedLibraries <- (__ \ "resolved_libraries").read[Seq[String]]
        unresolvedLibraries <- (__ \ "unresolved_libraries").read[Seq[String]]
      } yield ProjectUnresolvedSummary(project, resolvedLibraries, unresolvedLibraries)
    }

    def jsObjectProjectUnresolvedSummary(obj: io.flow.dependency.v0.models.ProjectUnresolvedSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "project" -> io.flow.dependency.v0.models.json.jsObjectProjectSummary(obj.project),
        "resolved_libraries" -> play.api.libs.json.Json.toJson(obj.resolvedLibraries),
        "unresolved_libraries" -> play.api.libs.json.Json.toJson(obj.unresolvedLibraries)
      )
    }

    implicit def jsonWritesDependencyProjectUnresolvedSummary: play.api.libs.json.Writes[ProjectUnresolvedSummary] = {
      (obj: io.flow.dependency.v0.models.ProjectUnresolvedSummary) => {
        io.flow.dependency.v0.models.json.jsObjectProjectUnresolvedSummary(obj)
      }
    }

    implicit def jsonReadsDependencyRecommendation: play.api.libs.json.Reads[io.flow.dependency.v0.models.Recommendation] = {
      for {
        id <- (__ \ "id").read[String]
        project <- (__ \ "project").read[io.flow.dependency.v0.models.ProjectDetail]
        `type` <- (__ \ "type").read[io.flow.dependency.v0.models.RecommendationType]
        `object` <- (__ \ "object").read[io.flow.dependency.v0.models.Reference]
        name <- (__ \ "name").read[String]
        from <- (__ \ "from").read[String]
        to <- (__ \ "to").read[String]
        createdAt <- (__ \ "created_at").read[_root_.org.joda.time.DateTime]
      } yield Recommendation(id, project, `type`, `object`, name, from, to, createdAt)
    }

    def jsObjectRecommendation(obj: io.flow.dependency.v0.models.Recommendation): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "project" -> io.flow.dependency.v0.models.json.jsObjectProjectDetail(obj.project),
        "type" -> play.api.libs.json.JsString(obj.`type`.toString),
        "object" -> io.flow.dependency.v0.models.json.jsObjectReference(obj.`object`),
        "name" -> play.api.libs.json.JsString(obj.name),
        "from" -> play.api.libs.json.JsString(obj.from),
        "to" -> play.api.libs.json.JsString(obj.to),
        "created_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.createdAt))
      )
    }

    implicit def jsonWritesDependencyRecommendation: play.api.libs.json.Writes[Recommendation] = {
      (obj: io.flow.dependency.v0.models.Recommendation) => {
        io.flow.dependency.v0.models.json.jsObjectRecommendation(obj)
      }
    }

    implicit def jsonReadsDependencyReference: play.api.libs.json.Reads[io.flow.dependency.v0.models.Reference] = {
      (__ \ "id").read[String].map { x => Reference(id = x) }
    }

    def jsObjectReference(obj: io.flow.dependency.v0.models.Reference): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id)
      )
    }

    implicit def jsonWritesDependencyReference: play.api.libs.json.Writes[Reference] = {
      (obj: io.flow.dependency.v0.models.Reference) => {
        io.flow.dependency.v0.models.json.jsObjectReference(obj)
      }
    }

    implicit def jsonReadsDependencyRepository: play.api.libs.json.Reads[io.flow.dependency.v0.models.Repository] = {
      for {
        name <- (__ \ "name").read[String]
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        uri <- (__ \ "uri").read[String]
      } yield Repository(name, visibility, uri)
    }

    def jsObjectRepository(obj: io.flow.dependency.v0.models.Repository): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "name" -> play.api.libs.json.JsString(obj.name),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "uri" -> play.api.libs.json.JsString(obj.uri)
      )
    }

    implicit def jsonWritesDependencyRepository: play.api.libs.json.Writes[Repository] = {
      (obj: io.flow.dependency.v0.models.Repository) => {
        io.flow.dependency.v0.models.json.jsObjectRepository(obj)
      }
    }

    implicit def jsonReadsDependencyResolver: play.api.libs.json.Reads[io.flow.dependency.v0.models.Resolver] = {
      for {
        id <- (__ \ "id").read[String]
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        organization <- (__ \ "organization").readNullable[io.flow.dependency.v0.models.OrganizationSummary]
        uri <- (__ \ "uri").read[String]
        credentials <- (__ \ "credentials").readNullable[io.flow.dependency.v0.models.Credentials]
      } yield Resolver(id, visibility, organization, uri, credentials)
    }

    def jsObjectResolver(obj: io.flow.dependency.v0.models.Resolver): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "uri" -> play.api.libs.json.JsString(obj.uri)
      ) ++ (obj.organization match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(x))
      }) ++
      (obj.credentials match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("credentials" -> io.flow.dependency.v0.models.json.jsObjectCredentials(x))
      })
    }

    implicit def jsonWritesDependencyResolver: play.api.libs.json.Writes[Resolver] = {
      (obj: io.flow.dependency.v0.models.Resolver) => {
        io.flow.dependency.v0.models.json.jsObjectResolver(obj)
      }
    }

    implicit def jsonReadsDependencyResolverForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.ResolverForm] = {
      for {
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        organization <- (__ \ "organization").read[String]
        uri <- (__ \ "uri").read[String]
        credentials <- (__ \ "credentials").readNullable[io.flow.dependency.v0.models.Credentials]
      } yield ResolverForm(visibility, organization, uri, credentials)
    }

    def jsObjectResolverForm(obj: io.flow.dependency.v0.models.ResolverForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "organization" -> play.api.libs.json.JsString(obj.organization),
        "uri" -> play.api.libs.json.JsString(obj.uri)
      ) ++ (obj.credentials match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("credentials" -> io.flow.dependency.v0.models.json.jsObjectCredentials(x))
      })
    }

    implicit def jsonWritesDependencyResolverForm: play.api.libs.json.Writes[ResolverForm] = {
      (obj: io.flow.dependency.v0.models.ResolverForm) => {
        io.flow.dependency.v0.models.json.jsObjectResolverForm(obj)
      }
    }

    implicit def jsonReadsDependencyResolverSummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.ResolverSummary] = {
      for {
        id <- (__ \ "id").read[String]
        organization <- (__ \ "organization").readNullable[io.flow.dependency.v0.models.OrganizationSummary]
        visibility <- (__ \ "visibility").read[io.flow.dependency.v0.models.Visibility]
        uri <- (__ \ "uri").read[String]
      } yield ResolverSummary(id, organization, visibility, uri)
    }

    def jsObjectResolverSummary(obj: io.flow.dependency.v0.models.ResolverSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "uri" -> play.api.libs.json.JsString(obj.uri)
      ) ++ (obj.organization match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("organization" -> io.flow.dependency.v0.models.json.jsObjectOrganizationSummary(x))
      })
    }

    implicit def jsonWritesDependencyResolverSummary: play.api.libs.json.Writes[ResolverSummary] = {
      (obj: io.flow.dependency.v0.models.ResolverSummary) => {
        io.flow.dependency.v0.models.json.jsObjectResolverSummary(obj)
      }
    }

    implicit def jsonReadsDependencySubscription: play.api.libs.json.Reads[io.flow.dependency.v0.models.Subscription] = {
      for {
        id <- (__ \ "id").read[String]
        user <- (__ \ "user").read[io.flow.common.v0.models.UserReference]
        publication <- (__ \ "publication").read[io.flow.dependency.v0.models.Publication]
      } yield Subscription(id, user, publication)
    }

    def jsObjectSubscription(obj: io.flow.dependency.v0.models.Subscription): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "user" -> io.flow.common.v0.models.json.jsObjectUserReference(obj.user),
        "publication" -> play.api.libs.json.JsString(obj.publication.toString)
      )
    }

    implicit def jsonWritesDependencySubscription: play.api.libs.json.Writes[Subscription] = {
      (obj: io.flow.dependency.v0.models.Subscription) => {
        io.flow.dependency.v0.models.json.jsObjectSubscription(obj)
      }
    }

    implicit def jsonReadsDependencySubscriptionForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.SubscriptionForm] = {
      for {
        userId <- (__ \ "user_id").read[String]
        publication <- (__ \ "publication").read[io.flow.dependency.v0.models.Publication]
      } yield SubscriptionForm(userId, publication)
    }

    def jsObjectSubscriptionForm(obj: io.flow.dependency.v0.models.SubscriptionForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_id" -> play.api.libs.json.JsString(obj.userId),
        "publication" -> play.api.libs.json.JsString(obj.publication.toString)
      )
    }

    implicit def jsonWritesDependencySubscriptionForm: play.api.libs.json.Writes[SubscriptionForm] = {
      (obj: io.flow.dependency.v0.models.SubscriptionForm) => {
        io.flow.dependency.v0.models.json.jsObjectSubscriptionForm(obj)
      }
    }

    implicit def jsonReadsDependencySync: play.api.libs.json.Reads[io.flow.dependency.v0.models.Sync] = {
      for {
        id <- (__ \ "id").read[String]
        objectId <- (__ \ "object_id").read[String]
        event <- (__ \ "event").read[io.flow.dependency.v0.models.SyncEvent]
        createdAt <- (__ \ "created_at").read[_root_.org.joda.time.DateTime]
      } yield Sync(id, objectId, event, createdAt)
    }

    def jsObjectSync(obj: io.flow.dependency.v0.models.Sync): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "object_id" -> play.api.libs.json.JsString(obj.objectId),
        "event" -> play.api.libs.json.JsString(obj.event.toString),
        "created_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.createdAt))
      )
    }

    implicit def jsonWritesDependencySync: play.api.libs.json.Writes[Sync] = {
      (obj: io.flow.dependency.v0.models.Sync) => {
        io.flow.dependency.v0.models.json.jsObjectSync(obj)
      }
    }

    implicit def jsonReadsDependencyTaskDataSync: play.api.libs.json.Reads[io.flow.dependency.v0.models.TaskDataSync] = {
      (__ \ "type").readNullable[io.flow.dependency.v0.models.SyncType].map { x => TaskDataSync(`type` = x) }
    }

    def jsObjectTaskDataSync(obj: io.flow.dependency.v0.models.TaskDataSync): play.api.libs.json.JsObject = {
      (obj.`type` match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("type" -> play.api.libs.json.JsString(x.toString))
      }) ++ play.api.libs.json.Json.obj("discriminator" -> "task_data_sync")
    }

    implicit def jsonWritesDependencyTaskDataSync: play.api.libs.json.Writes[TaskDataSync] = {
      (obj: io.flow.dependency.v0.models.TaskDataSync) => {
        io.flow.dependency.v0.models.json.jsObjectTaskDataSync(obj)
      }
    }

    implicit def jsonReadsDependencyTaskDataSyncLibrariesByPrefix: play.api.libs.json.Reads[io.flow.dependency.v0.models.TaskDataSyncLibrariesByPrefix] = {
      for {
        userId <- (__ \ "user_id").read[String]
        prefix <- (__ \ "prefix").read[String]
      } yield TaskDataSyncLibrariesByPrefix(userId, prefix)
    }

    def jsObjectTaskDataSyncLibrariesByPrefix(obj: io.flow.dependency.v0.models.TaskDataSyncLibrariesByPrefix): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_id" -> play.api.libs.json.JsString(obj.userId),
        "prefix" -> play.api.libs.json.JsString(obj.prefix)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "task_data_sync_libraries_by_prefix")
    }

    implicit def jsonWritesDependencyTaskDataSyncLibrariesByPrefix: play.api.libs.json.Writes[TaskDataSyncLibrariesByPrefix] = {
      (obj: io.flow.dependency.v0.models.TaskDataSyncLibrariesByPrefix) => {
        io.flow.dependency.v0.models.json.jsObjectTaskDataSyncLibrariesByPrefix(obj)
      }
    }

    implicit def jsonReadsDependencyTaskDataSyncOne: play.api.libs.json.Reads[io.flow.dependency.v0.models.TaskDataSyncOne] = {
      for {
        id <- (__ \ "id").read[String]
        `type` <- (__ \ "type").read[io.flow.dependency.v0.models.SyncType]
      } yield TaskDataSyncOne(id, `type`)
    }

    def jsObjectTaskDataSyncOne(obj: io.flow.dependency.v0.models.TaskDataSyncOne): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "type" -> play.api.libs.json.JsString(obj.`type`.toString)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "task_data_sync_one")
    }

    implicit def jsonWritesDependencyTaskDataSyncOne: play.api.libs.json.Writes[TaskDataSyncOne] = {
      (obj: io.flow.dependency.v0.models.TaskDataSyncOne) => {
        io.flow.dependency.v0.models.json.jsObjectTaskDataSyncOne(obj)
      }
    }

    implicit def jsonReadsDependencyTaskDataSyncOrganizationLibraries: play.api.libs.json.Reads[io.flow.dependency.v0.models.TaskDataSyncOrganizationLibraries] = {
      (__ \ "organization_id").read[String].map { x => TaskDataSyncOrganizationLibraries(organizationId = x) }
    }

    def jsObjectTaskDataSyncOrganizationLibraries(obj: io.flow.dependency.v0.models.TaskDataSyncOrganizationLibraries): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "organization_id" -> play.api.libs.json.JsString(obj.organizationId)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "task_data_sync_organization_libraries")
    }

    implicit def jsonWritesDependencyTaskDataSyncOrganizationLibraries: play.api.libs.json.Writes[TaskDataSyncOrganizationLibraries] = {
      (obj: io.flow.dependency.v0.models.TaskDataSyncOrganizationLibraries) => {
        io.flow.dependency.v0.models.json.jsObjectTaskDataSyncOrganizationLibraries(obj)
      }
    }

    implicit def jsonReadsDependencyTaskDataUpserted: play.api.libs.json.Reads[io.flow.dependency.v0.models.TaskDataUpserted] = {
      for {
        id <- (__ \ "id").read[String]
        `type` <- (__ \ "type").read[io.flow.dependency.v0.models.SyncType]
      } yield TaskDataUpserted(id, `type`)
    }

    def jsObjectTaskDataUpserted(obj: io.flow.dependency.v0.models.TaskDataUpserted): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "type" -> play.api.libs.json.JsString(obj.`type`.toString)
      ) ++ play.api.libs.json.Json.obj("discriminator" -> "task_data_upserted")
    }

    implicit def jsonWritesDependencyTaskDataUpserted: play.api.libs.json.Writes[TaskDataUpserted] = {
      (obj: io.flow.dependency.v0.models.TaskDataUpserted) => {
        io.flow.dependency.v0.models.json.jsObjectTaskDataUpserted(obj)
      }
    }

    implicit def jsonReadsDependencyToken: play.api.libs.json.Reads[io.flow.dependency.v0.models.Token] = {
      for {
        id <- (__ \ "id").read[String]
        user <- (__ \ "user").read[io.flow.common.v0.models.UserReference]
        masked <- (__ \ "masked").read[String]
        cleartext <- (__ \ "cleartext").readNullable[String]
        description <- (__ \ "description").readNullable[String]
      } yield Token(id, user, masked, cleartext, description)
    }

    def jsObjectToken(obj: io.flow.dependency.v0.models.Token): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "user" -> io.flow.common.v0.models.json.jsObjectUserReference(obj.user),
        "masked" -> play.api.libs.json.JsString(obj.masked)
      ) ++ (obj.cleartext match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("cleartext" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyToken: play.api.libs.json.Writes[Token] = {
      (obj: io.flow.dependency.v0.models.Token) => {
        io.flow.dependency.v0.models.json.jsObjectToken(obj)
      }
    }

    implicit def jsonReadsDependencyTokenForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.TokenForm] = {
      for {
        userId <- (__ \ "user_id").read[String]
        description <- (__ \ "description").readNullable[String]
      } yield TokenForm(userId, description)
    }

    def jsObjectTokenForm(obj: io.flow.dependency.v0.models.TokenForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_id" -> play.api.libs.json.JsString(obj.userId)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyTokenForm: play.api.libs.json.Writes[TokenForm] = {
      (obj: io.flow.dependency.v0.models.TokenForm) => {
        io.flow.dependency.v0.models.json.jsObjectTokenForm(obj)
      }
    }

    implicit def jsonReadsDependencyUserForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.UserForm] = {
      for {
        email <- (__ \ "email").readNullable[String]
        name <- (__ \ "name").readNullable[io.flow.common.v0.models.Name]
      } yield UserForm(email, name)
    }

    def jsObjectUserForm(obj: io.flow.dependency.v0.models.UserForm): play.api.libs.json.JsObject = {
      (obj.email match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("email" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> io.flow.common.v0.models.json.jsObjectName(x))
      })
    }

    implicit def jsonWritesDependencyUserForm: play.api.libs.json.Writes[UserForm] = {
      (obj: io.flow.dependency.v0.models.UserForm) => {
        io.flow.dependency.v0.models.json.jsObjectUserForm(obj)
      }
    }

    implicit def jsonReadsDependencyUserIdentifier: play.api.libs.json.Reads[io.flow.dependency.v0.models.UserIdentifier] = {
      for {
        id <- (__ \ "id").read[String]
        user <- (__ \ "user").read[io.flow.common.v0.models.UserReference]
        value <- (__ \ "value").read[String]
      } yield UserIdentifier(id, user, value)
    }

    def jsObjectUserIdentifier(obj: io.flow.dependency.v0.models.UserIdentifier): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "user" -> io.flow.common.v0.models.json.jsObjectUserReference(obj.user),
        "value" -> play.api.libs.json.JsString(obj.value)
      )
    }

    implicit def jsonWritesDependencyUserIdentifier: play.api.libs.json.Writes[UserIdentifier] = {
      (obj: io.flow.dependency.v0.models.UserIdentifier) => {
        io.flow.dependency.v0.models.json.jsObjectUserIdentifier(obj)
      }
    }

    implicit def jsonReadsDependencyUserSummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.UserSummary] = {
      for {
        id <- (__ \ "id").read[String]
        email <- (__ \ "email").readNullable[String]
        name <- (__ \ "name").read[io.flow.common.v0.models.Name]
      } yield UserSummary(id, email, name)
    }

    def jsObjectUserSummary(obj: io.flow.dependency.v0.models.UserSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "name" -> io.flow.common.v0.models.json.jsObjectName(obj.name)
      ) ++ (obj.email match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("email" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyUserSummary: play.api.libs.json.Writes[UserSummary] = {
      (obj: io.flow.dependency.v0.models.UserSummary) => {
        io.flow.dependency.v0.models.json.jsObjectUserSummary(obj)
      }
    }

    implicit def jsonReadsDependencyUsernamePassword: play.api.libs.json.Reads[io.flow.dependency.v0.models.UsernamePassword] = {
      for {
        username <- (__ \ "username").read[String]
        password <- (__ \ "password").readNullable[String]
      } yield UsernamePassword(username, password)
    }

    def jsObjectUsernamePassword(obj: io.flow.dependency.v0.models.UsernamePassword): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "username" -> play.api.libs.json.JsString(obj.username)
      ) ++ (obj.password match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("password" -> play.api.libs.json.JsString(x))
      }) ++ play.api.libs.json.Json.obj("discriminator" -> "username_password")
    }

    implicit def jsonWritesDependencyUsernamePassword: play.api.libs.json.Writes[UsernamePassword] = {
      (obj: io.flow.dependency.v0.models.UsernamePassword) => {
        io.flow.dependency.v0.models.json.jsObjectUsernamePassword(obj)
      }
    }

    implicit def jsonReadsDependencyVersionForm: play.api.libs.json.Reads[io.flow.dependency.v0.models.VersionForm] = {
      for {
        version <- (__ \ "version").read[String]
        crossBuildVersion <- (__ \ "cross_build_version").readNullable[String]
      } yield VersionForm(version, crossBuildVersion)
    }

    def jsObjectVersionForm(obj: io.flow.dependency.v0.models.VersionForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "version" -> play.api.libs.json.JsString(obj.version)
      ) ++ (obj.crossBuildVersion match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("cross_build_version" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesDependencyVersionForm: play.api.libs.json.Writes[VersionForm] = {
      (obj: io.flow.dependency.v0.models.VersionForm) => {
        io.flow.dependency.v0.models.json.jsObjectVersionForm(obj)
      }
    }

    implicit def jsonReadsDependencyCredentials: play.api.libs.json.Reads[io.flow.dependency.v0.models.Credentials] = (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "username_password" => io.flow.dependency.v0.models.json.jsonReadsDependencyUsernamePassword.reads(js)
          case other => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.CredentialsUndefinedType(other))
        }
      }
      (js \ "discriminator").validate[String] match {
        case e: play.api.libs.json.JsError => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value)
      }
    }

    def jsObjectCredentials(obj: io.flow.dependency.v0.models.Credentials): play.api.libs.json.JsObject = {
      obj match {
        case x: io.flow.dependency.v0.models.UsernamePassword => io.flow.dependency.v0.models.json.jsObjectUsernamePassword(x)
        case other => {
          sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
        }
      }
    }
    implicit def jsonWritesDependencyCredentials: play.api.libs.json.Writes[Credentials] = {
      (obj: io.flow.dependency.v0.models.Credentials) => {
        io.flow.dependency.v0.models.json.jsObjectCredentials(obj)
      }
    }

    implicit def jsonReadsDependencyItemSummary: play.api.libs.json.Reads[io.flow.dependency.v0.models.ItemSummary] = (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "binary_summary" => io.flow.dependency.v0.models.json.jsonReadsDependencyBinarySummary.reads(js)
          case "library_summary" => io.flow.dependency.v0.models.json.jsonReadsDependencyLibrarySummary.reads(js)
          case "project_summary" => io.flow.dependency.v0.models.json.jsonReadsDependencyProjectSummary.reads(js)
          case other => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.ItemSummaryUndefinedType(other))
        }
      }
      (js \ "discriminator").validate[String] match {
        case e: play.api.libs.json.JsError => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value)
      }
    }

    def jsObjectItemSummary(obj: io.flow.dependency.v0.models.ItemSummary): play.api.libs.json.JsObject = {
      obj match {
        case x: io.flow.dependency.v0.models.BinarySummary => io.flow.dependency.v0.models.json.jsObjectBinarySummary(x)
        case x: io.flow.dependency.v0.models.LibrarySummary => io.flow.dependency.v0.models.json.jsObjectLibrarySummary(x)
        case x: io.flow.dependency.v0.models.ProjectSummary => io.flow.dependency.v0.models.json.jsObjectProjectSummary(x)
        case other => {
          sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
        }
      }
    }
    implicit def jsonWritesDependencyItemSummary: play.api.libs.json.Writes[ItemSummary] = {
      (obj: io.flow.dependency.v0.models.ItemSummary) => {
        io.flow.dependency.v0.models.json.jsObjectItemSummary(obj)
      }
    }

    implicit def jsonReadsDependencyTaskData: play.api.libs.json.Reads[io.flow.dependency.v0.models.TaskData] = (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "task_data_upserted" => io.flow.dependency.v0.models.json.jsonReadsDependencyTaskDataUpserted.reads(js)
          case "task_data_sync" => io.flow.dependency.v0.models.json.jsonReadsDependencyTaskDataSync.reads(js)
          case "task_data_sync_one" => io.flow.dependency.v0.models.json.jsonReadsDependencyTaskDataSyncOne.reads(js)
          case "task_data_sync_libraries_by_prefix" => io.flow.dependency.v0.models.json.jsonReadsDependencyTaskDataSyncLibrariesByPrefix.reads(js)
          case "task_data_sync_organization_libraries" => io.flow.dependency.v0.models.json.jsonReadsDependencyTaskDataSyncOrganizationLibraries.reads(js)
          case other => play.api.libs.json.JsSuccess(io.flow.dependency.v0.models.TaskDataUndefinedType(other))
        }
      }
      (js \ "discriminator").validate[String] match {
        case e: play.api.libs.json.JsError => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value)
      }
    }

    def jsObjectTaskData(obj: io.flow.dependency.v0.models.TaskData): play.api.libs.json.JsObject = {
      obj match {
        case x: io.flow.dependency.v0.models.TaskDataUpserted => io.flow.dependency.v0.models.json.jsObjectTaskDataUpserted(x)
        case x: io.flow.dependency.v0.models.TaskDataSync => io.flow.dependency.v0.models.json.jsObjectTaskDataSync(x)
        case x: io.flow.dependency.v0.models.TaskDataSyncOne => io.flow.dependency.v0.models.json.jsObjectTaskDataSyncOne(x)
        case x: io.flow.dependency.v0.models.TaskDataSyncLibrariesByPrefix => io.flow.dependency.v0.models.json.jsObjectTaskDataSyncLibrariesByPrefix(x)
        case x: io.flow.dependency.v0.models.TaskDataSyncOrganizationLibraries => io.flow.dependency.v0.models.json.jsObjectTaskDataSyncOrganizationLibraries(x)
        case other => {
          sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
        }
      }
    }
    implicit def jsonWritesDependencyTaskData: play.api.libs.json.Writes[TaskData] = {
      (obj: io.flow.dependency.v0.models.TaskData) => {
        io.flow.dependency.v0.models.json.jsObjectTaskData(obj)
      }
    }
  }
}