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

  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_.java.time.Instant
  )

  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_.java.time.Instant
  )

  /**
   * @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 io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import io.flow.common.v0.models.json._
    import io.flow.dependency.v0.models.json._
    import io.flow.error.v0.models.json._
    import io.flow.github.v0.models.json._
    import io.flow.healthcheck.v0.models.json._

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package io.flow.dependency.v0 {
import cats.effect._
import cats.implicits._
import io.circe.syntax._

  object Constants {

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

  }

  class Client[F[_]: Concurrent](
    val baseUrl: org.http4s.Uri,
    auth: scala.Option[io.flow.dependency.v0.Authorization] = None,
    defaultHeaders: Seq[(String, String)] = Nil,
    httpClient: org.http4s.client.Client[F]
  ) extends interfaces.Client[F] {
    import org.http4s.Response
    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 binaries: Binaries[F] = Binaries

    def binaryVersions: BinaryVersions[F] = BinaryVersions

    def githubUsers: GithubUsers[F] = GithubUsers

    def githubWebhooks: GithubWebhooks[F] = GithubWebhooks

    def healthchecks: Healthchecks[F] = Healthchecks

    def items: Items[F] = Items

    def libraries: Libraries[F] = Libraries

    def libraryVersions: LibraryVersions[F] = LibraryVersions

    def memberships: Memberships[F] = Memberships

    def organizations: Organizations[F] = Organizations

    def projectBinaries: ProjectBinaries[F] = ProjectBinaries

    def projectDependencyResolutions: ProjectDependencyResolutions[F] = ProjectDependencyResolutions

    def projectLibraries: ProjectLibraries[F] = ProjectLibraries

    def projects: Projects[F] = Projects

    def recommendations: Recommendations[F] = Recommendations

    def repositories: Repositories[F] = Repositories

    def resolvers: Resolvers[F] = Resolvers

    def subscriptions: Subscriptions[F] = Subscriptions

    def syncs: Syncs[F] = Syncs

    def tokens: Tokens[F] = Tokens

    def users: Users[F] = Users

    object Binaries extends Binaries[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Binary]] = {
        val urlPath = Seq("binaries")

        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[Unit, Seq[io.flow.dependency.v0.models.Binary]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Binary]]("Seq[io.flow.dependency.v0.models.Binary]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Binary] = {
        val urlPath = Seq("binaries", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Binary]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Binary]("io.flow.dependency.v0.models.Binary", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        binaryForm: io.flow.dependency.v0.models.BinaryForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Binary] = {
        val urlPath = Seq("binaries")

        val (payload, formPayload) = (Some(binaryForm), None)

        _executeRequest[io.flow.dependency.v0.models.BinaryForm, io.flow.dependency.v0.models.Binary]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Binary]("io.flow.dependency.v0.models.Binary", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("binaries", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object BinaryVersions extends BinaryVersions[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.BinaryVersion]] = {
        val urlPath = Seq("binary_versions")

        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[Unit, Seq[io.flow.dependency.v0.models.BinaryVersion]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.BinaryVersion]]("Seq[io.flow.dependency.v0.models.BinaryVersion]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.BinaryVersion] = {
        val urlPath = Seq("binary_versions", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.BinaryVersion]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.BinaryVersion]("io.flow.dependency.v0.models.BinaryVersion", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }
    }

    object GithubUsers extends GithubUsers[F] {
      override def postGithub(
        githubAuthenticationForm: io.flow.dependency.v0.models.GithubAuthenticationForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.common.v0.models.User] = {
        val urlPath = Seq("authentications", "github")

        val (payload, formPayload) = (Some(githubAuthenticationForm), None)

        _executeRequest[io.flow.dependency.v0.models.GithubAuthenticationForm, io.flow.common.v0.models.User]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.common.v0.models.User]("io.flow.common.v0.models.User", r)
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 422"))
        }
      }
    }

    object GithubWebhooks extends GithubWebhooks[F] {
      override def postByProjectId(
        projectId: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("webhooks", "github", projectId)

        _executeRequest[Unit, Unit]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204"))
        }
      }
    }

    object Healthchecks extends Healthchecks[F] {
      override def getHealthcheck(
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.healthcheck.v0.models.Healthcheck] = {
        val urlPath = Seq("_internal_", "healthcheck")

        _executeRequest[Unit, io.flow.healthcheck.v0.models.Healthcheck]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.healthcheck.v0.models.Healthcheck]("io.flow.healthcheck.v0.models.Healthcheck", r)
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200"))
        }
      }
    }

    object Items extends Items[F] {
      override def get(
        q: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Seq[io.flow.dependency.v0.models.Item]] = {
        val urlPath = Seq("items")

        val queryParameters = Seq(
          q.map("q" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.flow.dependency.v0.models.Item]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Item]]("Seq[io.flow.dependency.v0.models.Item]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }
    }

    object Libraries extends Libraries[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Library]] = {
        val urlPath = Seq("libraries")

        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[Unit, Seq[io.flow.dependency.v0.models.Library]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Library]]("Seq[io.flow.dependency.v0.models.Library]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Library] = {
        val urlPath = Seq("libraries", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Library]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Library]("io.flow.dependency.v0.models.Library", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        libraryForm: io.flow.dependency.v0.models.LibraryForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Library] = {
        val urlPath = Seq("libraries")

        val (payload, formPayload) = (Some(libraryForm), None)

        _executeRequest[io.flow.dependency.v0.models.LibraryForm, io.flow.dependency.v0.models.Library]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Library]("io.flow.dependency.v0.models.Library", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("libraries", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object LibraryVersions extends LibraryVersions[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.LibraryVersion]] = {
        val urlPath = Seq("library_versions")

        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[Unit, Seq[io.flow.dependency.v0.models.LibraryVersion]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.LibraryVersion]]("Seq[io.flow.dependency.v0.models.LibraryVersion]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.LibraryVersion] = {
        val urlPath = Seq("library_versions", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.LibraryVersion]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.LibraryVersion]("io.flow.dependency.v0.models.LibraryVersion", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }
    }

    object Memberships extends Memberships[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Membership]] = {
        val urlPath = Seq("memberships")

        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[Unit, Seq[io.flow.dependency.v0.models.Membership]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Membership]]("Seq[io.flow.dependency.v0.models.Membership]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Membership] = {
        val urlPath = Seq("memberships", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Membership]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Membership]("io.flow.dependency.v0.models.Membership", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        membershipForm: io.flow.dependency.v0.models.MembershipForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Membership] = {
        val urlPath = Seq("memberships")

        val (payload, formPayload) = (Some(membershipForm), None)

        _executeRequest[io.flow.dependency.v0.models.MembershipForm, io.flow.dependency.v0.models.Membership]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Membership]("io.flow.dependency.v0.models.Membership", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 404, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("memberships", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object Organizations extends Organizations[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Organization]] = {
        val urlPath = Seq("organizations")

        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[Unit, Seq[io.flow.dependency.v0.models.Organization]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Organization]]("Seq[io.flow.dependency.v0.models.Organization]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getUsersByUserId(
        userId: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Organization] = {
        val urlPath = Seq("organizations", "users", userId)

        _executeRequest[Unit, io.flow.dependency.v0.models.Organization]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Organization]("io.flow.dependency.v0.models.Organization", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Organization] = {
        val urlPath = Seq("organizations", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Organization]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Organization]("io.flow.dependency.v0.models.Organization", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        organizationForm: io.flow.dependency.v0.models.OrganizationForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Organization] = {
        val urlPath = Seq("organizations")

        val (payload, formPayload) = (Some(organizationForm), None)

        _executeRequest[io.flow.dependency.v0.models.OrganizationForm, io.flow.dependency.v0.models.Organization]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Organization]("io.flow.dependency.v0.models.Organization", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def putById(
        id: String,
        organizationForm: io.flow.dependency.v0.models.OrganizationForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Organization] = {
        val urlPath = Seq("organizations", id)

        val (payload, formPayload) = (Some(organizationForm), None)

        _executeRequest[io.flow.dependency.v0.models.OrganizationForm, io.flow.dependency.v0.models.Organization]("PUT", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Organization]("io.flow.dependency.v0.models.Organization", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("organizations", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object ProjectBinaries extends ProjectBinaries[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.ProjectBinary]] = {
        val urlPath = Seq("project_binaries")

        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[Unit, Seq[io.flow.dependency.v0.models.ProjectBinary]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.ProjectBinary]]("Seq[io.flow.dependency.v0.models.ProjectBinary]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }
    }

    object ProjectDependencyResolutions extends ProjectDependencyResolutions[F] {
      override def get(
        organization: String,
        groupId: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.ProjectDependencyResolution] = {
        val urlPath = Seq(organization, "project", "dependencies", "group", groupId)

        _executeRequest[Unit, io.flow.dependency.v0.models.ProjectDependencyResolution]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.ProjectDependencyResolution]("io.flow.dependency.v0.models.ProjectDependencyResolution", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }
    }

    object ProjectLibraries extends ProjectLibraries[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.ProjectLibrary]] = {
        val urlPath = Seq("project_libraries")

        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[Unit, Seq[io.flow.dependency.v0.models.ProjectLibrary]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.ProjectLibrary]]("Seq[io.flow.dependency.v0.models.ProjectLibrary]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }
    }

    object Projects extends Projects[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Project]] = {
        val urlPath = Seq("projects")

        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[Unit, Seq[io.flow.dependency.v0.models.Project]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Project]]("Seq[io.flow.dependency.v0.models.Project]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Project] = {
        val urlPath = Seq("projects", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Project]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Project]("io.flow.dependency.v0.models.Project", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        projectForm: io.flow.dependency.v0.models.ProjectForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Project] = {
        val urlPath = Seq("projects")

        val (payload, formPayload) = (Some(projectForm), None)

        _executeRequest[io.flow.dependency.v0.models.ProjectForm, io.flow.dependency.v0.models.Project]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Project]("io.flow.dependency.v0.models.Project", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def putById(
        id: String,
        projectForm: io.flow.dependency.v0.models.ProjectForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Project] = {
        val urlPath = Seq("projects", id)

        val (payload, formPayload) = (Some(projectForm), None)

        _executeRequest[io.flow.dependency.v0.models.ProjectForm, io.flow.dependency.v0.models.Project]("PUT", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Project]("io.flow.dependency.v0.models.Project", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 422"))
        }
      }

      override def patchById(
        id: String,
        projectPatchForm: io.flow.dependency.v0.models.ProjectPatchForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Project] = {
        val urlPath = Seq("projects", id)

        val (payload, formPayload) = (Some(projectPatchForm), None)

        _executeRequest[io.flow.dependency.v0.models.ProjectPatchForm, io.flow.dependency.v0.models.Project]("PATCH", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Project]("io.flow.dependency.v0.models.Project", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("projects", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object Recommendations extends Recommendations[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Recommendation]] = {
        val urlPath = Seq("recommendations")

        val queryParameters = Seq(
          organization.map("organization" -> _),
          projectId.map("project_id" -> _),
          `type`.map("type" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.flow.dependency.v0.models.Recommendation]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Recommendation]]("Seq[io.flow.dependency.v0.models.Recommendation]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }
    }

    object Repositories extends Repositories[F] {
      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
      ): F[Seq[io.flow.github.v0.models.Repository]] = {
        val urlPath = Seq("repositories", "github")

        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[Unit, Seq[io.flow.github.v0.models.Repository]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.github.v0.models.Repository]]("Seq[io.flow.github.v0.models.Repository]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 422"))
        }
      }
    }

    object Resolvers extends Resolvers[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Resolver]] = {
        val urlPath = Seq("resolvers")

        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[Unit, Seq[io.flow.dependency.v0.models.Resolver]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Resolver]]("Seq[io.flow.dependency.v0.models.Resolver]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Resolver] = {
        val urlPath = Seq("resolvers", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Resolver]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Resolver]("io.flow.dependency.v0.models.Resolver", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        resolverForm: io.flow.dependency.v0.models.ResolverForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Resolver] = {
        val urlPath = Seq("resolvers")

        val (payload, formPayload) = (Some(resolverForm), None)

        _executeRequest[io.flow.dependency.v0.models.ResolverForm, io.flow.dependency.v0.models.Resolver]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Resolver]("io.flow.dependency.v0.models.Resolver", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("resolvers", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object Subscriptions extends Subscriptions[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Subscription]] = {
        val urlPath = Seq("subscriptions")

        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[Unit, Seq[io.flow.dependency.v0.models.Subscription]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Subscription]]("Seq[io.flow.dependency.v0.models.Subscription]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Subscription] = {
        val urlPath = Seq("subscriptions", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Subscription]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Subscription]("io.flow.dependency.v0.models.Subscription", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        subscriptionForm: io.flow.dependency.v0.models.SubscriptionForm,
        identifier: _root_.scala.Option[String] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Subscription] = {
        val urlPath = Seq("subscriptions")

        val (payload, formPayload) = (Some(subscriptionForm), None)

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

        _executeRequest[io.flow.dependency.v0.models.SubscriptionForm, io.flow.dependency.v0.models.Subscription]("POST", path = urlPath, body = payload, formBody = formPayload, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Subscription]("io.flow.dependency.v0.models.Subscription", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def deleteById(
        id: String,
        identifier: _root_.scala.Option[String] = None,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("subscriptions", id)

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

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object Syncs extends Syncs[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Sync]] = {
        val urlPath = Seq("syncs")

        val queryParameters = Seq(
          objectId.map("object_id" -> _),
          event.map("event" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest[Unit, Seq[io.flow.dependency.v0.models.Sync]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Sync]]("Seq[io.flow.dependency.v0.models.Sync]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def postLibrariesByOrganization(
        organization: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("syncs", organization, "libraries")

        _executeRequest[Unit, Unit]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 404"))
        }
      }

      override def postBinariesById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("syncs", "binaries", id)

        _executeRequest[Unit, Unit]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 404"))
        }
      }

      override def postLibrariesAndPrefixByArtifactIdPrefix(
        artifactIdPrefix: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("syncs", "libraries", "prefix", artifactIdPrefix)

        _executeRequest[Unit, Unit]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 404"))
        }
      }

      override def postLibrariesById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("syncs", "libraries", id)

        _executeRequest[Unit, Unit]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 404"))
        }
      }

      override def postProjectsById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("syncs", "projects", id)

        _executeRequest[Unit, Unit]("POST", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 404"))
        }
      }
    }

    object Tokens extends Tokens[F] {
      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
      ): F[Seq[io.flow.dependency.v0.models.Token]] = {
        val urlPath = Seq("tokens")

        val queryParameters = Seq(
          userId.map("user_id" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten ++
          id.getOrElse(Nil).map("id" -> _)

        _executeRequest[Unit, Seq[io.flow.dependency.v0.models.Token]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.dependency.v0.models.Token]]("Seq[io.flow.dependency.v0.models.Token]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Token] = {
        val urlPath = Seq("tokens", id)

        _executeRequest[Unit, io.flow.dependency.v0.models.Token]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Token]("io.flow.dependency.v0.models.Token", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        tokenForm: io.flow.dependency.v0.models.TokenForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.Token] = {
        val urlPath = Seq("tokens")

        val (payload, formPayload) = (Some(tokenForm), None)

        _executeRequest[io.flow.dependency.v0.models.TokenForm, io.flow.dependency.v0.models.Token]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.Token]("io.flow.dependency.v0.models.Token", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 401, 422"))
        }
      }

      override def deleteById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[Unit] = {
        val urlPath = Seq("tokens", id)

        _executeRequest[Unit, Unit]("DELETE", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 204 => Concurrent[F].pure(())
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 204, 401, 404, 422"))
        }
      }
    }

    object Users extends Users[F] {
      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
      ): F[Seq[io.flow.common.v0.models.User]] = {
        val urlPath = Seq("users")

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

        _executeRequest[Unit, Seq[io.flow.common.v0.models.User]]("GET", path = urlPath, queryParameters = queryParameters, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, Seq[io.flow.common.v0.models.User]]("Seq[io.flow.common.v0.models.User]", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 422"))
        }
      }

      override def getById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.common.v0.models.User] = {
        val urlPath = Seq("users", id)

        _executeRequest[Unit, io.flow.common.v0.models.User]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.common.v0.models.User]("io.flow.common.v0.models.User", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def getIdentifierById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.dependency.v0.models.UserIdentifier] = {
        val urlPath = Seq("users", id, "identifier")

        _executeRequest[Unit, io.flow.dependency.v0.models.UserIdentifier]("GET", path = urlPath, requestHeaders = requestHeaders) {
          case r if r.status.code == 200 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.dependency.v0.models.UserIdentifier]("io.flow.dependency.v0.models.UserIdentifier", r)
          case r if r.status.code == 401 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r if r.status.code == 404 => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.UnitResponse(r.status.code))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 200, 401, 404"))
        }
      }

      override def post(
        userForm: io.flow.dependency.v0.models.UserForm,
        requestHeaders: Seq[(String, String)] = Nil
      ): F[io.flow.common.v0.models.User] = {
        val urlPath = Seq("users")

        val (payload, formPayload) = (Some(userForm), None)

        _executeRequest[io.flow.dependency.v0.models.UserForm, io.flow.common.v0.models.User]("POST", path = urlPath, body = payload, formBody = formPayload, requestHeaders = requestHeaders) {
          case r if r.status.code == 201 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.common.v0.models.User]("io.flow.common.v0.models.User", r)
          case r if r.status.code == 422 => _root_.io.flow.dependency.v0.Client.parseJson[F, io.flow.error.v0.models.GenericError]("io.flow.error.v0.models.GenericError", r).flatMap(body => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.GenericErrorResponse(r.headers, r.status.code, None, body)))
          case r => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Unsupported response code[${r.status.code}]. Expected: 201, 422"))
        }
      }
    }

    private lazy val defaultApiHeaders = Seq(
      ("User-Agent", Constants.UserAgent),
      ("X-Apidoc-Version", Constants.Version),
      ("X-Apidoc-Version-Major", Constants.VersionMajor.toString)
    )

    def apiHeaders: Seq[(String, String)] = defaultApiHeaders

    def modifyRequest(request: org.http4s.Request[F]): org.http4s.Request[F] = request

    implicit def circeJsonEncoder[F[_]: Concurrent, A](implicit encoder: io.circe.Encoder[A]) = org.http4s.circe.jsonEncoderOf[F, A]

    def _executeRequest[T, U](
      method: String,
      path: Seq[String],
      queryParameters: Seq[(String, String)] = Nil,
      requestHeaders: Seq[(String, String)] = Nil,
      body: Option[T] = None,
      formBody : Option[org.http4s.UrlForm] = None
    )(handler: org.http4s.Response[F] => F[U]
    )(implicit encoder: io.circe.Encoder[T]): F[U] = {
      import org.http4s.QueryParamEncoder._

      val m = org.http4s.Method.fromString(method) match {
        case Right(m) => m
        case Left(e) => sys.error(e.toString)
      }

      val headers = org.http4s.Headers((
        apiHeaders ++
        defaultHeaders ++
        requestHeaders
      ).groupBy(_._1).map { case (k, l) => org.http4s.Header.Raw(org.typelevel.ci.CIString(k), l.last._2) }.toList)

      val queryMap = queryParameters.groupBy(_._1).map { case (k, v) => k -> v.map(_._2) }
      val uri = path.foldLeft(baseUrl){ case (uri, segment) => uri / segment }.setQueryParams(queryMap)

      val request = org.http4s.Request[F](method = m,
                                       uri = uri,
                                       headers = headers)

      val reqAndMaybeAuth = auth.fold(request) {
        case Authorization.Basic(username, passwordOpt) => {
          val userpass = s"$username:${passwordOpt.getOrElse("")}"
          val token = java.util.Base64.getEncoder.encodeToString(userpass.getBytes(java.nio.charset.StandardCharsets.ISO_8859_1))
          request.putHeaders(org.http4s.Header.Raw(org.typelevel.ci.CIString("Authorization"), s"Basic $token"))
        }
        case a => sys.error("Invalid authorization scheme[" + a.getClass + "]")
      }

      val reqAndMaybeAuthAndBody =
        if (formBody.nonEmpty) formBody.fold(reqAndMaybeAuth)(reqAndMaybeAuth.withEntity)
        else body.fold(reqAndMaybeAuth)(reqAndMaybeAuth.withEntity)

      httpClient.fetch(modifyRequest(reqAndMaybeAuthAndBody))(handler)
    }
  }

  object Client {
    import cats.effect._

    implicit def circeJsonDecoder[F[_]: Concurrent, A](implicit decoder: io.circe.Decoder[A]) = org.http4s.circe.jsonOf[F, A]

    def parseJson[F[_]: Concurrent, T](
      className: String,
      r: org.http4s.Response[F]
    )(implicit decoder: io.circe.Decoder[T]): F[T] = r.attemptAs[T].value.flatMap {
      case Right(value) => Concurrent[F].pure(value)
      case Left(error) => Concurrent[F].raiseError(new io.flow.dependency.v0.errors.FailedRequest(r.status.code, s"Invalid json for class[" + className + "]", None, error))
    }
  }

  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[F[_]] {
      def baseUrl: org.http4s.Uri
      def binaries: io.flow.dependency.v0.Binaries[F]
      def binaryVersions: io.flow.dependency.v0.BinaryVersions[F]
      def githubUsers: io.flow.dependency.v0.GithubUsers[F]
      def githubWebhooks: io.flow.dependency.v0.GithubWebhooks[F]
      def healthchecks: io.flow.dependency.v0.Healthchecks[F]
      def items: io.flow.dependency.v0.Items[F]
      def libraries: io.flow.dependency.v0.Libraries[F]
      def libraryVersions: io.flow.dependency.v0.LibraryVersions[F]
      def memberships: io.flow.dependency.v0.Memberships[F]
      def organizations: io.flow.dependency.v0.Organizations[F]
      def projectBinaries: io.flow.dependency.v0.ProjectBinaries[F]
      def projectDependencyResolutions: io.flow.dependency.v0.ProjectDependencyResolutions[F]
      def projectLibraries: io.flow.dependency.v0.ProjectLibraries[F]
      def projects: io.flow.dependency.v0.Projects[F]
      def recommendations: io.flow.dependency.v0.Recommendations[F]
      def repositories: io.flow.dependency.v0.Repositories[F]
      def resolvers: io.flow.dependency.v0.Resolvers[F]
      def subscriptions: io.flow.dependency.v0.Subscriptions[F]
      def syncs: io.flow.dependency.v0.Syncs[F]
      def tokens: io.flow.dependency.v0.Tokens[F]
      def users: io.flow.dependency.v0.Users[F]
    }

  }

  trait Binaries[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Binary]]

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

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

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait BinaryVersions[F[_]] {
    /**
     * 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
    ): F[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
    ): F[io.flow.dependency.v0.models.BinaryVersion]
  }

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

  trait GithubWebhooks[F[_]] {
    /**
     * Receives a webhook on push for this particular project
     */
    def postByProjectId(
      projectId: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait Healthchecks[F[_]] {
    def getHealthcheck(
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.flow.healthcheck.v0.models.Healthcheck]
  }

  trait Items[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Item]]
  }

  trait Libraries[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Library]]

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

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

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait LibraryVersions[F[_]] {
    /**
     * 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
    ): F[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
    ): F[io.flow.dependency.v0.models.LibraryVersion]
  }

  trait Memberships[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Membership]]

    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.flow.dependency.v0.models.Membership]

    def post(
      membershipForm: io.flow.dependency.v0.models.MembershipForm,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.flow.dependency.v0.models.Membership]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait Organizations[F[_]] {
    /**
     * 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
    ): F[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
    ): F[io.flow.dependency.v0.models.Organization]

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

    /**
     * Create a new organization.
     */
    def post(
      organizationForm: io.flow.dependency.v0.models.OrganizationForm,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[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
    ): F[io.flow.dependency.v0.models.Organization]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait ProjectBinaries[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.ProjectBinary]]
  }

  trait ProjectDependencyResolutions[F[_]] {
    def get(
      organization: String,
      groupId: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[io.flow.dependency.v0.models.ProjectDependencyResolution]
  }

  trait ProjectLibraries[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.ProjectLibrary]]
  }

  trait Projects[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Project]]

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

    /**
     * Create a new project.
     */
    def post(
      projectForm: io.flow.dependency.v0.models.ProjectForm,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[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
    ): F[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
    ): F[io.flow.dependency.v0.models.Project]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait Recommendations[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Recommendation]]
  }

  trait Repositories[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.github.v0.models.Repository]]
  }

  trait Resolvers[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Resolver]]

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

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

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait Subscriptions[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.dependency.v0.models.Subscription]]

    /**
     * Returns information about a specific subscription.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[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
    ): F[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
    ): F[Unit]
  }

  trait Syncs[F[_]] {
    /**
     * @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
    ): F[Seq[io.flow.dependency.v0.models.Sync]]

    /**
     * Synchronize libraries for resolvers associated with this organization
     */
    def postLibrariesByOrganization(
      organization: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]

    def postBinariesById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[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
    ): F[Unit]

    def postLibrariesById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]

    def postProjectsById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait Tokens[F[_]] {
    /**
     * @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
    ): F[Seq[io.flow.dependency.v0.models.Token]]

    /**
     * Used to fetch one token
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[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
    ): F[io.flow.dependency.v0.models.Token]

    def deleteById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[Unit]
  }

  trait Users[F[_]] {
    /**
     * 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
    ): F[Seq[io.flow.common.v0.models.User]]

    /**
     * Returns information about the user with this id.
     */
    def getById(
      id: String,
      requestHeaders: Seq[(String, String)] = Nil
    ): F[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
    ): F[io.flow.dependency.v0.models.UserIdentifier]

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

  package errors {

    final case class GenericErrorResponse(
      headers: org.http4s.Headers,
      status: Int,
      message: Option[String] = None,
      body: io.flow.error.v0.models.GenericError
    ) extends Exception(s"HTTP $status${message.fold("")(m => s": $m")}"){
      lazy val genericError = body
    }

    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, parent: Exception = null) extends _root_.java.lang.Exception(s"HTTP $responseCode: $message", parent)

  }
}