/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.8.18
 * User agent: apibuilder app.apibuilder.io/flow/dependency/0.8.18/async_http_2_5_client
 */
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)
      }
    }
  }
}



package io.flow.dependency.v0 {
  import org.asynchttpclient.{AsyncCompletionHandler, AsyncHttpClient, Realm, Request, RequestBuilder, Response, DefaultAsyncHttpClient, DefaultAsyncHttpClientConfig}

  object Constants {

    val Namespace = "io.flow.dependency.v0"
    val UserAgent = "apibuilder app.apibuilder.io/flow/dependency/0.8.18/async_http_2_5_client"
    val Version = "0.8.18"
    val VersionMajor = 0

  }

  class Client(
    val baseUrl: String,
    auth: scala.Option[io.flow.dependency.v0.Authorization] = None,
    defaultHeaders: Seq[(String, String)] = Nil,
    asyncHttpClient: AsyncHttpClient = Client.defaultAsyncHttpClient
  ) extends interfaces.Client {
    import org.slf4j.{Logger, LoggerFactory}
    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._

    def closeAsyncHttpClient(): Unit = {
      asyncHttpClient.close()
    }

    val logger = LoggerFactory.getLogger(getClass)

    def binaries: Binaries = Binaries

    def binaryVersions: BinaryVersions = BinaryVersions

    def githubUsers: GithubUsers = GithubUsers

    def githubWebhooks: GithubWebhooks = GithubWebhooks

    def healthchecks: Healthchecks = Healthchecks

    def items: Items = Items

    def libraries: Libraries = Libraries

    def libraryVersions: LibraryVersions = LibraryVersions

    def memberships: Memberships = Memberships

    def organizations: Organizations = Organizations

    def projectBinaries: ProjectBinaries = ProjectBinaries

    def projectDependencyResolutions: ProjectDependencyResolutions = ProjectDependencyResolutions

    def projectLibraries: ProjectLibraries = ProjectLibraries

    def projects: Projects = Projects

    def recommendations: Recommendations = Recommendations

    def repositories: Repositories = Repositories

    def resolvers: Resolvers = Resolvers

    def subscriptions: Subscriptions = Subscriptions

    def syncs: Syncs = Syncs

    def tokens: Tokens = Tokens

    def users: Users = Users

    object Binaries extends Binaries {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        projectId: _root_.scala.Option[String] = None,
        name: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Binary]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          projectId.map("project_id" -> _),
          name.map("name" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/binaries", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Binary]", r, _.validate[Seq[io.flow.dependency.v0.models.Binary]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Binary] = {
        _executeRequest("GET", s"/binaries/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Binary", r, _.validate[io.flow.dependency.v0.models.Binary])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        binaryForm: io.flow.dependency.v0.models.BinaryForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Binary] = {
        val payload = play.api.libs.json.Json.toJson(binaryForm)

        _executeRequest("POST", s"/binaries", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Binary", r, _.validate[io.flow.dependency.v0.models.Binary])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/binaries/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object BinaryVersions extends BinaryVersions {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        binaryId: _root_.scala.Option[String] = None,
        projectId: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.BinaryVersion]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          binaryId.map("binary_id" -> _),
          projectId.map("project_id" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/binary_versions", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.BinaryVersion]", r, _.validate[Seq[io.flow.dependency.v0.models.BinaryVersion]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.BinaryVersion] = {
        _executeRequest("GET", s"/binary_versions/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.BinaryVersion", r, _.validate[io.flow.dependency.v0.models.BinaryVersion])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object GithubUsers extends GithubUsers {
      override def postGithub(
        githubAuthenticationForm: io.flow.dependency.v0.models.GithubAuthenticationForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.common.v0.models.User] = {
        val payload = play.api.libs.json.Json.toJson(githubAuthenticationForm)

        _executeRequest("POST", s"/authentications/github", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.common.v0.models.User", r, _.validate[io.flow.common.v0.models.User])
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object GithubWebhooks extends GithubWebhooks {
      override def postByProjectId(
        projectId: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/webhooks/github/${_root_.io.flow.dependency.v0.PathSegment.encode(projectId, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Healthchecks extends Healthchecks {
      override def getHealthcheck(
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.healthcheck.v0.models.Healthcheck] = {
        _executeRequest("GET", s"/_internal_/healthcheck", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.healthcheck.v0.models.Healthcheck", r, _.validate[io.flow.healthcheck.v0.models.Healthcheck])
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Items extends Items {
      override def get(
        q: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Item]] = {
        val queryParameters = Seq(
          q.map("q" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/items", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Item]", r, _.validate[Seq[io.flow.dependency.v0.models.Item]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Libraries extends Libraries {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        projectId: _root_.scala.Option[String] = None,
        groupId: _root_.scala.Option[String] = None,
        artifactId: _root_.scala.Option[String] = None,
        resolverId: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Library]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          projectId.map("project_id" -> _),
          groupId.map("group_id" -> _),
          artifactId.map("artifact_id" -> _),
          resolverId.map("resolver_id" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/libraries", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Library]", r, _.validate[Seq[io.flow.dependency.v0.models.Library]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Library] = {
        _executeRequest("GET", s"/libraries/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Library", r, _.validate[io.flow.dependency.v0.models.Library])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        libraryForm: io.flow.dependency.v0.models.LibraryForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Library] = {
        val payload = play.api.libs.json.Json.toJson(libraryForm)

        _executeRequest("POST", s"/libraries", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Library", r, _.validate[io.flow.dependency.v0.models.Library])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/libraries/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object LibraryVersions extends LibraryVersions {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        libraryId: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.LibraryVersion]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          libraryId.map("library_id" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/library_versions", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.LibraryVersion]", r, _.validate[Seq[io.flow.dependency.v0.models.LibraryVersion]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.LibraryVersion] = {
        _executeRequest("GET", s"/library_versions/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.LibraryVersion", r, _.validate[io.flow.dependency.v0.models.LibraryVersion])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Memberships extends Memberships {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        organization: _root_.scala.Option[String] = None,
        userId: _root_.scala.Option[String] = None,
        role: _root_.scala.Option[io.flow.dependency.v0.models.Role] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Membership]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          organization.map("organization" -> _),
          userId.map("user_id" -> _),
          role.map("role" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/memberships", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Membership]", r, _.validate[Seq[io.flow.dependency.v0.models.Membership]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Membership] = {
        _executeRequest("GET", s"/memberships/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Membership", r, _.validate[io.flow.dependency.v0.models.Membership])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        membershipForm: io.flow.dependency.v0.models.MembershipForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Membership] = {
        val payload = play.api.libs.json.Json.toJson(membershipForm)

        _executeRequest("POST", s"/memberships", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Membership", r, _.validate[io.flow.dependency.v0.models.Membership])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/memberships/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Organizations extends Organizations {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        userId: _root_.scala.Option[String] = None,
        key: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Organization]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          userId.map("user_id" -> _),
          key.map("key" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/organizations", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Organization]", r, _.validate[Seq[io.flow.dependency.v0.models.Organization]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getUsersByUserId(
        userId: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization] = {
        _executeRequest("GET", s"/organizations/users/${_root_.io.flow.dependency.v0.PathSegment.encode(userId, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Organization", r, _.validate[io.flow.dependency.v0.models.Organization])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization] = {
        _executeRequest("GET", s"/organizations/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Organization", r, _.validate[io.flow.dependency.v0.models.Organization])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        organizationForm: io.flow.dependency.v0.models.OrganizationForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization] = {
        val payload = play.api.libs.json.Json.toJson(organizationForm)

        _executeRequest("POST", s"/organizations", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Organization", r, _.validate[io.flow.dependency.v0.models.Organization])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def putById(
        id: String,
        organizationForm: io.flow.dependency.v0.models.OrganizationForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization] = {
        val payload = play.api.libs.json.Json.toJson(organizationForm)

        _executeRequest("PUT", s"/organizations/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Organization", r, _.validate[io.flow.dependency.v0.models.Organization])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/organizations/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object ProjectBinaries extends ProjectBinaries {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        projectId: _root_.scala.Option[String] = None,
        binaryId: _root_.scala.Option[String] = None,
        isSynced: _root_.scala.Option[Boolean] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.ProjectBinary]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          projectId.map("project_id" -> _),
          binaryId.map("binary_id" -> _),
          isSynced.map("is_synced" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/project_binaries", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.ProjectBinary]", r, _.validate[Seq[io.flow.dependency.v0.models.ProjectBinary]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object ProjectDependencyResolutions extends ProjectDependencyResolutions {
      override def get(
        organization: String,
        groupId: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.ProjectDependencyResolution] = {
        _executeRequest("GET", s"/${_root_.io.flow.dependency.v0.PathSegment.encode(organization, "UTF-8")}/project/dependencies/group/${_root_.io.flow.dependency.v0.PathSegment.encode(groupId, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.ProjectDependencyResolution", r, _.validate[io.flow.dependency.v0.models.ProjectDependencyResolution])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object ProjectLibraries extends ProjectLibraries {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        projectId: _root_.scala.Option[String] = None,
        libraryId: _root_.scala.Option[String] = None,
        isSynced: _root_.scala.Option[Boolean] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.ProjectLibrary]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          projectId.map("project_id" -> _),
          libraryId.map("library_id" -> _),
          isSynced.map("is_synced" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/project_libraries", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.ProjectLibrary]", r, _.validate[Seq[io.flow.dependency.v0.models.ProjectLibrary]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Projects extends Projects {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        organization: _root_.scala.Option[String] = None,
        name: _root_.scala.Option[String] = None,
        groupId: _root_.scala.Option[String] = None,
        artifactId: _root_.scala.Option[String] = None,
        version: _root_.scala.Option[String] = None,
        libraryId: _root_.scala.Option[String] = None,
        binary: _root_.scala.Option[String] = None,
        binaryId: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Project]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          organization.map("organization" -> _),
          name.map("name" -> _),
          groupId.map("group_id" -> _),
          artifactId.map("artifact_id" -> _),
          version.map("version" -> _),
          libraryId.map("library_id" -> _),
          binary.map("binary" -> _),
          binaryId.map("binary_id" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/projects", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Project]", r, _.validate[Seq[io.flow.dependency.v0.models.Project]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project] = {
        _executeRequest("GET", s"/projects/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Project", r, _.validate[io.flow.dependency.v0.models.Project])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        projectForm: io.flow.dependency.v0.models.ProjectForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project] = {
        val payload = play.api.libs.json.Json.toJson(projectForm)

        _executeRequest("POST", s"/projects", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Project", r, _.validate[io.flow.dependency.v0.models.Project])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def putById(
        id: String,
        projectForm: io.flow.dependency.v0.models.ProjectForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project] = {
        val payload = play.api.libs.json.Json.toJson(projectForm)

        _executeRequest("PUT", s"/projects/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Project", r, _.validate[io.flow.dependency.v0.models.Project])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def patchById(
        id: String,
        projectPatchForm: io.flow.dependency.v0.models.ProjectPatchForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project] = {
        val payload = play.api.libs.json.Json.toJson(projectPatchForm)

        _executeRequest("PATCH", s"/projects/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Project", r, _.validate[io.flow.dependency.v0.models.Project])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/projects/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Recommendations extends Recommendations {
      override def get(
        organization: _root_.scala.Option[String] = None,
        projectId: _root_.scala.Option[String] = None,
        `type`: _root_.scala.Option[io.flow.dependency.v0.models.RecommendationType] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Recommendation]] = {
        val queryParameters = Seq(
          organization.map("organization" -> _),
          projectId.map("project_id" -> _),
          `type`.map("type" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/recommendations", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Recommendation]", r, _.validate[Seq[io.flow.dependency.v0.models.Recommendation]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Repositories extends Repositories {
      override def getGithub(
        owner: _root_.scala.Option[String] = None,
        name: _root_.scala.Option[String] = None,
        organizationId: _root_.scala.Option[String] = None,
        existingProject: _root_.scala.Option[Boolean] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.github.v0.models.Repository]] = {
        val queryParameters = Seq(
          owner.map("owner" -> _),
          name.map("name" -> _),
          organizationId.map("organization_id" -> _),
          existingProject.map("existing_project" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/repositories/github", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.github.v0.models.Repository]", r, _.validate[Seq[io.flow.github.v0.models.Repository]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Resolvers extends Resolvers {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        organization: _root_.scala.Option[String] = None,
        visibility: _root_.scala.Option[io.flow.dependency.v0.models.Visibility] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Resolver]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          organization.map("organization" -> _),
          visibility.map("visibility" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/resolvers", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Resolver]", r, _.validate[Seq[io.flow.dependency.v0.models.Resolver]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Resolver] = {
        _executeRequest("GET", s"/resolvers/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Resolver", r, _.validate[io.flow.dependency.v0.models.Resolver])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        resolverForm: io.flow.dependency.v0.models.ResolverForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Resolver] = {
        val payload = play.api.libs.json.Json.toJson(resolverForm)

        _executeRequest("POST", s"/resolvers", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Resolver", r, _.validate[io.flow.dependency.v0.models.Resolver])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/resolvers/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Subscriptions extends Subscriptions {
      override def get(
        id: _root_.scala.Option[String] = None,
        ids: _root_.scala.Option[Seq[String]] = None,
        userId: _root_.scala.Option[String] = None,
        identifier: _root_.scala.Option[String] = None,
        publication: _root_.scala.Option[io.flow.dependency.v0.models.Publication] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Subscription]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          userId.map("user_id" -> _),
          identifier.map("identifier" -> _),
          publication.map("publication" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          ids.getOrElse(Nil).map("ids" -> _)

        _executeRequest("GET", s"/subscriptions", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Subscription]", r, _.validate[Seq[io.flow.dependency.v0.models.Subscription]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Subscription] = {
        _executeRequest("GET", s"/subscriptions/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Subscription", r, _.validate[io.flow.dependency.v0.models.Subscription])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        subscriptionForm: io.flow.dependency.v0.models.SubscriptionForm,
        identifier: _root_.scala.Option[String] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Subscription] = {
        val payload = play.api.libs.json.Json.toJson(subscriptionForm)

        val queryParameters = Seq(
          identifier.map("identifier" -> _)
        ).flatten

        _executeRequest("POST", s"/subscriptions", body = Some(payload), queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Subscription", r, _.validate[io.flow.dependency.v0.models.Subscription])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        identifier: _root_.scala.Option[String] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        val queryParameters = Seq(
          identifier.map("identifier" -> _)
        ).flatten

        _executeRequest("DELETE", s"/subscriptions/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Syncs extends Syncs {
      override def get(
        objectId: _root_.scala.Option[String] = None,
        event: _root_.scala.Option[io.flow.dependency.v0.models.SyncEvent] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Sync]] = {
        val queryParameters = Seq(
          objectId.map("object_id" -> _),
          event.map("event" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/syncs", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Sync]", r, _.validate[Seq[io.flow.dependency.v0.models.Sync]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def postLibrariesByOrganization(
        organization: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/syncs/${_root_.io.flow.dependency.v0.PathSegment.encode(organization, "UTF-8")}/libraries", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def postBinariesById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/syncs/binaries/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def postLibrariesAndPrefixByArtifactIdPrefix(
        artifactIdPrefix: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/syncs/libraries/prefix/${_root_.io.flow.dependency.v0.PathSegment.encode(artifactIdPrefix, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def postLibrariesById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/syncs/libraries/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def postProjectsById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/syncs/projects/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Tokens extends Tokens {
      override def get(
        id: _root_.scala.Option[Seq[String]] = None,
        userId: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Token]] = {
        val queryParameters = Seq(
          userId.map("user_id" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          id.getOrElse(Nil).map("id" -> _)

        _executeRequest("GET", s"/tokens", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.dependency.v0.models.Token]", r, _.validate[Seq[io.flow.dependency.v0.models.Token]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Token] = {
        _executeRequest("GET", s"/tokens/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Token", r, _.validate[io.flow.dependency.v0.models.Token])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        tokenForm: io.flow.dependency.v0.models.TokenForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Token] = {
        val payload = play.api.libs.json.Json.toJson(tokenForm)

        _executeRequest("POST", s"/tokens", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.Token", r, _.validate[io.flow.dependency.v0.models.Token])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/tokens/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 204 => ()
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 204, 401, 404, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    object Users extends Users {
      override def get(
        id: _root_.scala.Option[String] = None,
        email: _root_.scala.Option[String] = None,
        identifier: _root_.scala.Option[String] = None,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.common.v0.models.User]] = {
        val queryParameters = Seq(
          id.map("id" -> _),
          email.map("email" -> _),
          identifier.map("identifier" -> _)
        ).flatten

        _executeRequest("GET", s"/users", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("Seq[io.flow.common.v0.models.User]", r, _.validate[Seq[io.flow.common.v0.models.User]])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.common.v0.models.User] = {
        _executeRequest("GET", s"/users/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.common.v0.models.User", r, _.validate[io.flow.common.v0.models.User])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def getIdentifierById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.UserIdentifier] = {
        _executeRequest("GET", s"/users/${_root_.io.flow.dependency.v0.PathSegment.encode(id, "UTF-8")}/identifier", requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 200 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.dependency.v0.models.UserIdentifier", r, _.validate[io.flow.dependency.v0.models.UserIdentifier])
          case r if r.getStatusCode == 401 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r if r.getStatusCode == 404 => throw io.flow.dependency.v0.errors.UnitResponse(r.getStatusCode)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 200, 401, 404", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }

      override def post(
        userForm: io.flow.dependency.v0.models.UserForm,
        requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.common.v0.models.User] = {
        val payload = play.api.libs.json.Json.toJson(userForm)

        _executeRequest("POST", s"/users", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.getStatusCode == 201 => _root_.io.flow.dependency.v0.Client.parseJson("io.flow.common.v0.models.User", r, _.validate[io.flow.common.v0.models.User])
          case r if r.getStatusCode == 422 => throw io.flow.dependency.v0.errors.GenericErrorResponse(r)
          case r => throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Unsupported response code[${r.getStatusCode}]. Expected: 201, 422", requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

    def _logRequest(request: Request): Unit = {
      if (logger.isInfoEnabled) {
        logger.info("_logRequest: " + request)
      }
    }

    def _logResponse(response: Response): Unit = {
      if (logger.isInfoEnabled) {
        logger.info("_logResponse: status=" + response.getStatusCode + ", responseBody: " + response.getResponseBody(java.nio.charset.Charset.forName("UTF-8")))
      }
    }

    def _requestBuilder(method: String, path: String, requestHeaders: Seq[(String, String)]): RequestBuilder = {
      val builder = new RequestBuilder(method)
        .setUrl(baseUrl + path)
        .addHeader("User-Agent", Constants.UserAgent)
        .addHeader("X-Apidoc-Version", Constants.Version)
        .addHeader("X-Apidoc-Version-Major", Constants.VersionMajor.toString)

      defaultHeaders.foreach { h => builder.addHeader(h._1, h._2) }
      requestHeaders.foreach { h => builder.addHeader(h._1, h._2) }

      auth.fold(builder) {
        case Authorization.Basic(username, passwordOpt) => {
          builder.setRealm(
            new Realm.Builder(username, passwordOpt.getOrElse(""))
              .setUsePreemptiveAuth(true)
              .setScheme(Realm.AuthScheme.BASIC)
              .build()
          )
        }
        case a => sys.error("Invalid authorization scheme[" + a.getClass + "]")
      }
    }

    def _executeRequest(
      method: String,
      path: String,
      queryParameters: Seq[(String, String)] = Nil,
      requestHeaders: Seq[(String, String)] = Nil,
      body: Option[play.api.libs.json.JsValue] = None
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[org.asynchttpclient.Response] = {
      val allHeaders = body match {
        case None => requestHeaders
        case Some(_) => _withJsonContentType(requestHeaders)
      }

      val request = _requestBuilder(method, path, allHeaders)

      queryParameters.foreach { pair =>
        request.addQueryParam(pair._1, pair._2)
      }

      val requestWithParamsAndBody = body.fold(request) { b =>
        val serialized = play.api.libs.json.Json.stringify(b)
        request.setBody(serialized)
      }

      val finalRequest = requestWithParamsAndBody.build()
      _logRequest(finalRequest)

      val result = scala.concurrent.Promise[org.asynchttpclient.Response]()
      asyncHttpClient.executeRequest(finalRequest,
        new AsyncCompletionHandler[Unit]() {
          override def onCompleted(r: org.asynchttpclient.Response) = {
            _logResponse(r)
            result.success(r)
          }
          override def onThrowable(t: Throwable) = result.failure(t)
        }
      )
      result.future
    }

    /**
     * Adds a Content-Type: application/json header unless the specified requestHeaders
     * already contain a Content-Type header
     */
    def _withJsonContentType(headers: Seq[(String, String)]): Seq[(String, String)] = {
      headers.find { _._1.toUpperCase == "CONTENT-TYPE" } match {
        case None => headers ++ Seq(("Content-Type" -> "application/json; charset=UTF-8"))
        case Some(_) => headers
      }
    }

  }

  object Client {

    private lazy val defaultAsyncHttpClient = {
      new DefaultAsyncHttpClient(
        new DefaultAsyncHttpClientConfig.Builder().build()
      )
    }

    def parseJson[T](
      className: String,
      r: _root_.org.asynchttpclient.Response,
      f: (play.api.libs.json.JsValue => play.api.libs.json.JsResult[T])
    ): T = {
      f(play.api.libs.json.Json.parse(r.getResponseBody(java.nio.charset.Charset.forName("UTF-8")))) match {
        case play.api.libs.json.JsSuccess(x, _) => x
        case play.api.libs.json.JsError(errors) => {
          throw io.flow.dependency.v0.errors.FailedRequest(r.getStatusCode, s"Invalid json for class[" + className + "]: " + errors.mkString(" "), requestUri = Some(r.getUri.toJavaNetURI))
        }
      }
    }

  }

  sealed trait Authorization extends _root_.scala.Product with _root_.scala.Serializable
  object Authorization {
    final case class Basic(username: String, password: Option[String] = None) extends Authorization
  }

  package interfaces {

    trait Client {
      def baseUrl: String
      def binaries: io.flow.dependency.v0.Binaries
      def binaryVersions: io.flow.dependency.v0.BinaryVersions
      def githubUsers: io.flow.dependency.v0.GithubUsers
      def githubWebhooks: io.flow.dependency.v0.GithubWebhooks
      def healthchecks: io.flow.dependency.v0.Healthchecks
      def items: io.flow.dependency.v0.Items
      def libraries: io.flow.dependency.v0.Libraries
      def libraryVersions: io.flow.dependency.v0.LibraryVersions
      def memberships: io.flow.dependency.v0.Memberships
      def organizations: io.flow.dependency.v0.Organizations
      def projectBinaries: io.flow.dependency.v0.ProjectBinaries
      def projectDependencyResolutions: io.flow.dependency.v0.ProjectDependencyResolutions
      def projectLibraries: io.flow.dependency.v0.ProjectLibraries
      def projects: io.flow.dependency.v0.Projects
      def recommendations: io.flow.dependency.v0.Recommendations
      def repositories: io.flow.dependency.v0.Repositories
      def resolvers: io.flow.dependency.v0.Resolvers
      def subscriptions: io.flow.dependency.v0.Subscriptions
      def syncs: io.flow.dependency.v0.Syncs
      def tokens: io.flow.dependency.v0.Tokens
      def users: io.flow.dependency.v0.Users
    }

  }

  trait Binaries {
    /**
     * Search binaries. Results are paginated
     *
     * @param id Find binary with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param projectId Find binaries associated with this project
     * @param name Find project with this name. Case in-sensitive. Exact match
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      projectId: _root_.scala.Option[String] = None,
      name: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Binary]]

    /**
     * Returns information about the binary with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Binary]

    /**
     * Create a new binary.
     */
    def post(
      binaryForm: io.flow.dependency.v0.models.BinaryForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Binary]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait BinaryVersions {
    /**
     * Search binary versions. Results are paginated
     *
     * @param id Find binary version with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param binaryId Find binaries associated with this binary
     * @param projectId Find binaries associated with this project
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      binaryId: _root_.scala.Option[String] = None,
      projectId: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.BinaryVersion]]

    /**
     * Returns information about the binary version with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.BinaryVersion]
  }

  trait GithubUsers {
    /**
     * Used to authenticate a user via github
     */
    def postGithub(
      githubAuthenticationForm: io.flow.dependency.v0.models.GithubAuthenticationForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.common.v0.models.User]
  }

  trait GithubWebhooks {
    /**
     * Receives a webhook on push for this particular project
     */
    def postByProjectId(
      projectId: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Healthchecks {
    def getHealthcheck(
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.healthcheck.v0.models.Healthcheck]
  }

  trait Items {
    /**
     * Returns a list of all matching items
     *
     * @param q Actual search query
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      q: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Item]]
  }

  trait Libraries {
    /**
     * Search libraries. Results are paginated
     *
     * @param id Find library with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param projectId Find binaries associated with this project
     * @param groupId Find library with this group_id. Case sensitive. Exact match
     * @param artifactId Find library with this artifact_id. Case sensitive. Exact match
     * @param resolverId Find libraries resolved with this resolver
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      projectId: _root_.scala.Option[String] = None,
      groupId: _root_.scala.Option[String] = None,
      artifactId: _root_.scala.Option[String] = None,
      resolverId: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Library]]

    /**
     * Returns information about the library with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Library]

    /**
     * Create a new library.
     */
    def post(
      libraryForm: io.flow.dependency.v0.models.LibraryForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Library]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait LibraryVersions {
    /**
     * Search library versions. Results are paginated
     *
     * @param id Find library version with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param libraryId Find binaries associated with this binary
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      libraryId: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.LibraryVersion]]

    /**
     * Returns information about the library version with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.LibraryVersion]
  }

  trait Memberships {
    /**
     * Search all memberships. Results are always paginated.
     *
     * @param id Find organization with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param organization Filter to organization with this key. Case insensitive
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      organization: _root_.scala.Option[String] = None,
      userId: _root_.scala.Option[String] = None,
      role: _root_.scala.Option[io.flow.dependency.v0.models.Role] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Membership]]

    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Membership]

    def post(
      membershipForm: io.flow.dependency.v0.models.MembershipForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Membership]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Organizations {
    /**
     * Search organizations. Results are paginated
     *
     * @param id Find organization with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param userId Find organizations that this user has access to
     * @param key Find organization with this key. Case in-sensitive. Exact match
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      userId: _root_.scala.Option[String] = None,
      key: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Organization]]

    /**
     * Returns the organization representing the individual user.
     *
     * @param userId Find organization representing this user
     */
    def getUsersByUserId(
      userId: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization]

    /**
     * Returns information about the organization with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization]

    /**
     * Create a new organization.
     */
    def post(
      organizationForm: io.flow.dependency.v0.models.OrganizationForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization]

    /**
     * Update an existing organization.
     */
    def putById(
      id: String,
      organizationForm: io.flow.dependency.v0.models.OrganizationForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Organization]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait ProjectBinaries {
    /**
     * Search project binaries. Results are paginated
     *
     * @param id Find project binary with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param projectId filter by this project
     * @param binaryId filter by this binary
     * @param isSynced If true, filter by project binaries that have been synced. False to filter by
     *        project binaries that have not yet been synced. Main purpose of this filter is
     *        to see what binaries we are still evaluating after a project is added for the
     *        first time.
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      projectId: _root_.scala.Option[String] = None,
      binaryId: _root_.scala.Option[String] = None,
      isSynced: _root_.scala.Option[Boolean] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.ProjectBinary]]
  }

  trait ProjectDependencyResolutions {
    def get(
      organization: String,
      groupId: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.ProjectDependencyResolution]
  }

  trait ProjectLibraries {
    /**
     * Search project libraries. Results are paginated
     *
     * @param id Find project library with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param projectId filter by this project
     * @param libraryId filter by this library
     * @param isSynced If true, filter by project libraries that have been synced. False to filter by
     *        project libraries that have not yet been synced. Main purpose of this filter is
     *        to see what libraries we are still evaluating after a project is added for the
     *        first time.
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      projectId: _root_.scala.Option[String] = None,
      libraryId: _root_.scala.Option[String] = None,
      isSynced: _root_.scala.Option[Boolean] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.ProjectLibrary]]
  }

  trait Projects {
    /**
     * Search projects. Results are paginated
     *
     * @param id Find project with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param organization Filter to resolvers belongs to the organization with this key
     * @param name Find project with this name. Case in-sensitive. Exact match
     * @param groupId Find projects that are dependent on a library with this group ID. Exact match
     * @param artifactId Find projects that are dependent on a library with this artifact ID. Exact match
     * @param version Find projects that are dependent on a library with this version number. Exact
     *        match
     * @param libraryId Find projects that are dependent on a library
     * @param binary Find projects that are dependent on this binary. Case in-sensitive. Exact match
     * @param binaryId Find projects that are dependent on a binary
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      organization: _root_.scala.Option[String] = None,
      name: _root_.scala.Option[String] = None,
      groupId: _root_.scala.Option[String] = None,
      artifactId: _root_.scala.Option[String] = None,
      version: _root_.scala.Option[String] = None,
      libraryId: _root_.scala.Option[String] = None,
      binary: _root_.scala.Option[String] = None,
      binaryId: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Project]]

    /**
     * Returns information about the project with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project]

    /**
     * Create a new project.
     */
    def post(
      projectForm: io.flow.dependency.v0.models.ProjectForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project]

    /**
     * Update an existing project.
     */
    def putById(
      id: String,
      projectForm: io.flow.dependency.v0.models.ProjectForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project]

    /**
     * Patch an existing project
     */
    def patchById(
      id: String,
      projectPatchForm: io.flow.dependency.v0.models.ProjectPatchForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Project]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Recommendations {
    /**
     * Returns a list of recommendations for this user
     *
     * @param organization Optionally filter to recommendations for this organization
     * @param projectId Optionally filter by project
     * @param type Optionally filter by type of recommendation.
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      organization: _root_.scala.Option[String] = None,
      projectId: _root_.scala.Option[String] = None,
      `type`: _root_.scala.Option[io.flow.dependency.v0.models.RecommendationType] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Recommendation]]
  }

  trait Repositories {
    /**
     * Returns a list of repositories from github
     *
     * @param owner Optionally filter by owner name. Case in-sensitive. Exact match
     * @param name Optionally filter by repo name. Case in-sensitive. Exact match
     * @param organizationId If specified, we enable additional filtering by this organization (see
     *        existing_project parameter).
     * @param existingProject Optionally filter by repositories that are either already mapped to existing
     *        projects or not. Requires organization_id parameter to also be specified.
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def getGithub(
      owner: _root_.scala.Option[String] = None,
      name: _root_.scala.Option[String] = None,
      organizationId: _root_.scala.Option[String] = None,
      existingProject: _root_.scala.Option[Boolean] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.github.v0.models.Repository]]
  }

  trait Resolvers {
    /**
     * Search resolvers. Results are paginated
     *
     * @param id Find resolver with this id. Exact match
     * @param ids Filter by any one of these ids
     * @param organization Filter to resolvers belongs to the organization with this key
     * @param visibility Filter based on visibility
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      organization: _root_.scala.Option[String] = None,
      visibility: _root_.scala.Option[io.flow.dependency.v0.models.Visibility] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Resolver]]

    /**
     * Returns information about the resolver with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Resolver]

    /**
     * Create a new resolver.
     */
    def post(
      resolverForm: io.flow.dependency.v0.models.ResolverForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Resolver]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Subscriptions {
    /**
     * Search subscriptions. Always paginated.
     *
     * @param id Find the subscription with this id.
     * @param ids Filter by any one of these ids
     * @param userId Find subscriptions for this user.
     * @param identifier Find subscriptions associated with this user identifier. Exact match
     * @param publication Find subscriptions for this publication.
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[String] = None,
      ids: _root_.scala.Option[Seq[String]] = None,
      userId: _root_.scala.Option[String] = None,
      identifier: _root_.scala.Option[String] = None,
      publication: _root_.scala.Option[io.flow.dependency.v0.models.Publication] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Subscription]]

    /**
     * Returns information about a specific subscription.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Subscription]

    /**
     * Create a new subscription.
     *
     * @param identifier If a user identifier is provided, authentication is bypassed
     */
    def post(
      subscriptionForm: io.flow.dependency.v0.models.SubscriptionForm,
      identifier: _root_.scala.Option[String] = None,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Subscription]

    /**
     * @param identifier If a user identifier is provided, authentication is bypassed
     */
    def deleteById(
      id: String,
      identifier: _root_.scala.Option[String] = None,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Syncs {
    /**
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      objectId: _root_.scala.Option[String] = None,
      event: _root_.scala.Option[io.flow.dependency.v0.models.SyncEvent] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Sync]]

    /**
     * Synchronize libraries for resolvers associated with this organization
     */
    def postLibrariesByOrganization(
      organization: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    def postBinariesById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    /**
     * Will sync all libraries where the artifact id starts with the specified
     * artifact_id_refix*
     */
    def postLibrariesAndPrefixByArtifactIdPrefix(
      artifactIdPrefix: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    def postLibrariesById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    def postProjectsById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Tokens {
    /**
     * @param id Filter by any one of these ids
     * @param userId Find tokens for this user.
     * @param limit The number of records to return
     * @param offset Used to paginate. First page of results is 0.
     */
    def get(
      id: _root_.scala.Option[Seq[String]] = None,
      userId: _root_.scala.Option[String] = None,
      limit: Long = 25L,
      offset: Long = 0L,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.dependency.v0.models.Token]]

    /**
     * Used to fetch one token
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Token]

    /**
     * Create a new API token for this user
     */
    def post(
      tokenForm: io.flow.dependency.v0.models.TokenForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.Token]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Users {
    /**
     * Search for a specific user. You must specify at least 1 parameter - either a id
     * or email - and will receive back either 0 or 1 users.
     *
     * @param id Find user with this id. Exact match
     * @param email Find user with this email address. Case in-sensitive. Exact match
     * @param identifier Find user associated with this randomly generated identifier. Exact match
     */
    def get(
      id: _root_.scala.Option[String] = None,
      email: _root_.scala.Option[String] = None,
      identifier: _root_.scala.Option[String] = None,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.flow.common.v0.models.User]]

    /**
     * Returns information about the user with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.common.v0.models.User]

    /**
     * Returns the latest identifier for this user. The basic use case is to enable
     * things like unsubscribe w/out login (and thus once you have an identifier, you
     * can GET /users?identifier=xxx). Identifiers are rotated regularly with last n
     * identifiers being valid (allowing eventual expiration).
     */
    def getIdentifierById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.dependency.v0.models.UserIdentifier]

    /**
     * Create a new user.
     */
    def post(
      userForm: io.flow.dependency.v0.models.UserForm,
      requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.flow.common.v0.models.User]
  }

  package errors {

    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._

    final case class GenericErrorResponse(
      response: _root_.org.asynchttpclient.Response,
      message: Option[String] = None
    ) extends Exception(message.getOrElse(s"${response.getStatusCode}: ${response.getResponseBody(java.nio.charset.Charset.forName("UTF-8"))}")) {
      lazy val genericError = _root_.io.flow.dependency.v0.Client.parseJson("io.flow.error.v0.models.GenericError", response, _.validate[io.flow.error.v0.models.GenericError])
    }

    final case class UnitResponse(status: Int) extends Exception(s"HTTP $status")

    final case class FailedRequest(responseCode: Int, message: String, requestUri: Option[_root_.java.net.URI] = None) extends _root_.java.lang.Exception(s"HTTP $responseCode: $message")

  }

  object PathSegment {
    // See https://github.com/playframework/playframework/blob/2.3.x/framework/src/play/src/main/scala/play/utils/UriEncoding.scala
    def encode(s: String, inputCharset: String): String = {
      val in = s.getBytes(inputCharset)
      val out = new java.io.ByteArrayOutputStream()
      for (b <- in) {
        val allowed = segmentChars.get(b & 0xFF)
        if (allowed) {
          out.write(b)
        } else {
          out.write('%')
          out.write(upperHex((b >> 4) & 0xF))
          out.write(upperHex(b & 0xF))
        }
      }
      out.toString("US-ASCII")
    }

    private def upperHex(x: Int): Int = {
      // Assume 0 <= x < 16
      if (x < 10) (x + '0') else (x - 10 + 'A')
    }

    private val segmentChars: java.util.BitSet = membershipTable(pchar)

    private def pchar: Seq[Char] = {
      val alphaDigit = for ((min, max) <- Seq(('a', 'z'), ('A', 'Z'), ('0', '9')); c <- min to max) yield c
      val unreserved = alphaDigit ++ Seq('-', '.', '_', '~')
      val subDelims = Seq('!', '$', '&', '\'', '(', ')', '*', '+', ',', ';', '=')
      unreserved ++ subDelims ++ Seq(':', '@')
    }

    private def membershipTable(chars: Seq[Char]): java.util.BitSet = {
      val bits = new java.util.BitSet(256)
      for (c <- chars) { bits.set(c.toInt) }
      bits
    }
  }
}