/**
  * Generated by API Builder - https://www.apibuilder.io
  * Service version: 0.5.7
  * User agent: apibuilder app.apibuilder.io/flow/github/0.5.7/play_2_9_scala_3_controllers
  */
package io.flow.github.v0.controllers

import io.flow.github.v0.models.json._

trait BlobsController extends play.api.mvc.BaseController {

  sealed trait GetBySha extends Product with Serializable
  object GetBySha {
    final case class HTTP200(body: io.flow.github.v0.models.Blob) extends GetBySha
    case object HTTP404 extends GetBySha
    final case class Undocumented(result: play.api.mvc.Result) extends GetBySha
  }

  def getBySha(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      sha: String
  ): scala.concurrent.Future[GetBySha]
  final def getBySha(owner: String, repo: String, sha: String): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      getBySha(request, owner, repo, sha)
        .map {
          case r: GetBySha.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case GetBySha.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: GetBySha.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP201(body: io.flow.github.v0.models.BlobCreated) extends Post
    case object HTTP404 extends Post
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(
      request: play.api.mvc.Request[io.flow.github.v0.models.BlobForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.BlobForm
  ): scala.concurrent.Future[Post]
  final def post(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.BlobForm] =
    Action.async(parse.json[io.flow.github.v0.models.BlobForm]) { request =>
      post(request, owner, repo, request.body)
        .map {
          case r: Post.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case Post.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Post.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: Post.Undocumented => r.result
        }(defaultExecutionContext)
    }

}

trait CommitsController extends play.api.mvc.BaseController {

  sealed trait GetBySha extends Product with Serializable
  object GetBySha {
    final case class HTTP200(body: io.flow.github.v0.models.Commit) extends GetBySha
    case object HTTP404 extends GetBySha
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends GetBySha
    final case class Undocumented(result: play.api.mvc.Result) extends GetBySha
  }

  def getBySha(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      sha: String
  ): scala.concurrent.Future[GetBySha]
  final def getBySha(owner: String, repo: String, sha: String): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      getBySha(request, owner, repo, sha)
        .map {
          case r: GetBySha.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case GetBySha.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: GetBySha.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: GetBySha.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP201(body: io.flow.github.v0.models.CommitResponse) extends Post
    case object HTTP404 extends Post
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(
      request: play.api.mvc.Request[io.flow.github.v0.models.CommitForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.CommitForm
  ): scala.concurrent.Future[Post]
  final def post(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.CommitForm] =
    Action.async(parse.json[io.flow.github.v0.models.CommitForm]) { request =>
      post(request, owner, repo, request.body)
        .map {
          case r: Post.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case Post.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Post.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: Post.Undocumented => r.result
        }(defaultExecutionContext)
    }

}

trait ContentsController extends play.api.mvc.BaseController {

  sealed trait GetReadme extends Product with Serializable
  object GetReadme {
    final case class HTTP200(body: io.flow.github.v0.models.Contents) extends GetReadme
    case object HTTP401 extends GetReadme
    case object HTTP404 extends GetReadme
    final case class Undocumented(result: play.api.mvc.Result) extends GetReadme
  }

  def getReadme(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      ref: String
  ): scala.concurrent.Future[GetReadme]
  final def getReadme(owner: String, repo: String, ref: String): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      getReadme(request, owner, repo, ref)
        .map {
          case r: GetReadme.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case GetReadme.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
          case GetReadme.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: GetReadme.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait GetContentsByPath extends Product with Serializable
  object GetContentsByPath {
    final case class HTTP200(body: io.flow.github.v0.models.Contents) extends GetContentsByPath
    case object HTTP401 extends GetContentsByPath
    case object HTTP404 extends GetContentsByPath
    final case class Undocumented(result: play.api.mvc.Result) extends GetContentsByPath
  }

  def getContentsByPath(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      path: String,
      ref: String
  ): scala.concurrent.Future[GetContentsByPath]
  final def getContentsByPath(
      owner: String,
      repo: String,
      path: String,
      ref: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getContentsByPath(request, owner, repo, path, ref)
      .map {
        case r: GetContentsByPath.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetContentsByPath.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case GetContentsByPath.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetContentsByPath.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait HooksController extends play.api.mvc.BaseController {

  sealed trait Get extends Product with Serializable
  object Get {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.Hook]) extends Get
    case object HTTP404 extends Get
    final case class Undocumented(result: play.api.mvc.Result) extends Get
  }

  def get(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String
  ): scala.concurrent.Future[Get]
  final def get(owner: String, repo: String): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    get(request, owner, repo)
      .map {
        case r: Get.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case Get.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: Get.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetById extends Product with Serializable
  object GetById {
    final case class HTTP200(body: io.flow.github.v0.models.Hook) extends GetById
    case object HTTP404 extends GetById
    final case class Undocumented(result: play.api.mvc.Result) extends GetById
  }

  def getById(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      id: Long
  ): scala.concurrent.Future[GetById]
  final def getById(owner: String, repo: String, id: Long): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      getById(request, owner, repo, id)
        .map {
          case r: GetById.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case GetById.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: GetById.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP201(body: io.flow.github.v0.models.Hook) extends Post
    case object HTTP404 extends Post
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(
      request: play.api.mvc.Request[io.flow.github.v0.models.HookForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.HookForm
  ): scala.concurrent.Future[Post]
  final def post(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.HookForm] =
    Action.async(parse.json[io.flow.github.v0.models.HookForm]) { request =>
      post(request, owner, repo, request.body)
        .map {
          case r: Post.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case Post.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Post.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: Post.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait DeleteById extends Product with Serializable
  object DeleteById {
    case object HTTP204 extends DeleteById
    case object HTTP404 extends DeleteById
    final case class Undocumented(result: play.api.mvc.Result) extends DeleteById
  }

  def deleteById(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      id: Long
  ): scala.concurrent.Future[DeleteById]
  final def deleteById(owner: String, repo: String, id: Long): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      deleteById(request, owner, repo, id)
        .map {
          case DeleteById.HTTP204         => Status(204)(play.api.mvc.Results.EmptyContent())
          case DeleteById.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: DeleteById.Undocumented => r.result
        }(defaultExecutionContext)
    }

}

trait PullRequestsController extends play.api.mvc.BaseController {

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP201(body: io.flow.github.v0.models.PullRequest) extends Post
    case object HTTP404 extends Post
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(
      request: play.api.mvc.Request[io.flow.github.v0.models.PullRequestForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.PullRequestForm
  ): scala.concurrent.Future[Post]
  final def post(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.PullRequestForm] =
    Action.async(parse.json[io.flow.github.v0.models.PullRequestForm]) { request =>
      post(request, owner, repo, request.body)
        .map {
          case r: Post.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case Post.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Post.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: Post.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait Get extends Product with Serializable
  object Get {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.PullRequest]) extends Get
    case object HTTP404 extends Get
    final case class Undocumented(result: play.api.mvc.Result) extends Get
  }

  def get(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      page: Long
  ): scala.concurrent.Future[Get]
  final def get(owner: String, repo: String, page: Long): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async {
    request =>
      get(request, owner, repo, page)
        .map {
          case r: Get.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case Get.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Get.Undocumented => r.result
        }(defaultExecutionContext)
  }

}

trait RefsController extends play.api.mvc.BaseController {

  sealed trait Get extends Product with Serializable
  object Get {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.Ref]) extends Get
    case object HTTP404 extends Get
    final case class Undocumented(result: play.api.mvc.Result) extends Get
  }

  def get(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String
  ): scala.concurrent.Future[Get]
  final def get(owner: String, repo: String): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    get(request, owner, repo)
      .map {
        case r: Get.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case Get.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: Get.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetByRef extends Product with Serializable
  object GetByRef {
    final case class HTTP200(body: io.flow.github.v0.models.Ref) extends GetByRef
    case object HTTP404 extends GetByRef
    final case class Undocumented(result: play.api.mvc.Result) extends GetByRef
  }

  def getByRef(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      ref: String
  ): scala.concurrent.Future[GetByRef]
  final def getByRef(owner: String, repo: String, ref: String): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      getByRef(request, owner, repo, ref)
        .map {
          case r: GetByRef.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case GetByRef.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: GetByRef.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP201(body: io.flow.github.v0.models.Ref) extends Post
    case object HTTP404 extends Post
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(
      request: play.api.mvc.Request[io.flow.github.v0.models.RefForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.RefForm
  ): scala.concurrent.Future[Post]
  final def post(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.RefForm] =
    Action.async(parse.json[io.flow.github.v0.models.RefForm]) { request =>
      post(request, owner, repo, request.body)
        .map {
          case r: Post.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case Post.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Post.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: Post.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait PutByRef extends Product with Serializable
  object PutByRef {
    final case class HTTP201(body: io.flow.github.v0.models.Ref) extends PutByRef
    case object HTTP404 extends PutByRef
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends PutByRef
    final case class Undocumented(result: play.api.mvc.Result) extends PutByRef
  }

  def putByRef(
      request: play.api.mvc.Request[io.flow.github.v0.models.RefUpdateForm],
      owner: String,
      repo: String,
      ref: String,
      body: io.flow.github.v0.models.RefUpdateForm
  ): scala.concurrent.Future[PutByRef]
  final def putByRef(
      owner: String,
      repo: String,
      ref: String
  ): play.api.mvc.Action[io.flow.github.v0.models.RefUpdateForm] =
    Action.async(parse.json[io.flow.github.v0.models.RefUpdateForm]) { request =>
      putByRef(request, owner, repo, ref, request.body)
        .map {
          case r: PutByRef.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case PutByRef.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: PutByRef.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: PutByRef.Undocumented => r.result
        }(defaultExecutionContext)
    }

}

trait RepositoriesController extends play.api.mvc.BaseController {

  sealed trait GetUserAndRepos extends Product with Serializable
  object GetUserAndRepos {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.Repository]) extends GetUserAndRepos
    case object HTTP401 extends GetUserAndRepos
    final case class Undocumented(result: play.api.mvc.Result) extends GetUserAndRepos
  }

  def getUserAndRepos(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      page: Long,
      visibility: io.flow.github.v0.models.Visibility,
      affiliation: _root_.scala.Option[String],
      `type`: _root_.scala.Option[String],
      sort: String,
      direction: String
  ): scala.concurrent.Future[GetUserAndRepos]
  final def getUserAndRepos(
      page: Long,
      visibility: io.flow.github.v0.models.Visibility,
      affiliation: _root_.scala.Option[String],
      `type`: _root_.scala.Option[String],
      sort: String,
      direction: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getUserAndRepos(request, page, visibility, affiliation, `type`, sort, direction)
      .map {
        case r: GetUserAndRepos.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetUserAndRepos.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case r: GetUserAndRepos.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetUsersAndReposByUsername extends Product with Serializable
  object GetUsersAndReposByUsername {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.Repository]) extends GetUsersAndReposByUsername
    case object HTTP401 extends GetUsersAndReposByUsername
    final case class Undocumented(result: play.api.mvc.Result) extends GetUsersAndReposByUsername
  }

  def getUsersAndReposByUsername(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      username: String,
      page: Long,
      `type`: String,
      sort: String,
      direction: String
  ): scala.concurrent.Future[GetUsersAndReposByUsername]
  final def getUsersAndReposByUsername(
      username: String,
      page: Long,
      `type`: String,
      sort: String,
      direction: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getUsersAndReposByUsername(request, username, page, `type`, sort, direction)
      .map {
        case r: GetUsersAndReposByUsername.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetUsersAndReposByUsername.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case r: GetUsersAndReposByUsername.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetOrgsAndReposByOrg extends Product with Serializable
  object GetOrgsAndReposByOrg {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.Repository]) extends GetOrgsAndReposByOrg
    case object HTTP401 extends GetOrgsAndReposByOrg
    final case class Undocumented(result: play.api.mvc.Result) extends GetOrgsAndReposByOrg
  }

  def getOrgsAndReposByOrg(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      org: String,
      page: Long,
      `type`: String,
      sort: String,
      direction: String
  ): scala.concurrent.Future[GetOrgsAndReposByOrg]
  final def getOrgsAndReposByOrg(
      org: String,
      page: Long,
      `type`: String,
      sort: String,
      direction: String
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getOrgsAndReposByOrg(request, org, page, `type`, sort, direction)
      .map {
        case r: GetOrgsAndReposByOrg.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetOrgsAndReposByOrg.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case r: GetOrgsAndReposByOrg.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait TagsController extends play.api.mvc.BaseController {

  sealed trait GetTags extends Product with Serializable
  object GetTags {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.TagSummary]) extends GetTags
    case object HTTP404 extends GetTags
    final case class Undocumented(result: play.api.mvc.Result) extends GetTags
  }

  def getTags(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      page: Long,
      perPage: Long
  ): scala.concurrent.Future[GetTags]
  final def getTags(
      owner: String,
      repo: String,
      page: Long,
      perPage: Long
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getTags(request, owner, repo, page, perPage)
      .map {
        case r: GetTags.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetTags.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
        case r: GetTags.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetTagsBySha extends Product with Serializable
  object GetTagsBySha {
    final case class HTTP200(body: io.flow.github.v0.models.Tag) extends GetTagsBySha
    case object HTTP404 extends GetTagsBySha
    final case class Undocumented(result: play.api.mvc.Result) extends GetTagsBySha
  }

  def getTagsBySha(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      owner: String,
      repo: String,
      sha: String
  ): scala.concurrent.Future[GetTagsBySha]
  final def getTagsBySha(owner: String, repo: String, sha: String): play.api.mvc.Action[play.api.mvc.AnyContent] =
    Action.async { request =>
      getTagsBySha(request, owner, repo, sha)
        .map {
          case r: GetTagsBySha.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
          case GetTagsBySha.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: GetTagsBySha.Undocumented => r.result
        }(defaultExecutionContext)
    }

  sealed trait PostGitAndTags extends Product with Serializable
  object PostGitAndTags {
    final case class HTTP201(body: io.flow.github.v0.models.Tag) extends PostGitAndTags
    case object HTTP404 extends PostGitAndTags
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends PostGitAndTags
    final case class Undocumented(result: play.api.mvc.Result) extends PostGitAndTags
  }

  def postGitAndTags(
      request: play.api.mvc.Request[io.flow.github.v0.models.TagForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.TagForm
  ): scala.concurrent.Future[PostGitAndTags]
  final def postGitAndTags(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.TagForm] =
    Action.async(parse.json[io.flow.github.v0.models.TagForm]) { request =>
      postGitAndTags(request, owner, repo, request.body)
        .map {
          case r: PostGitAndTags.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case PostGitAndTags.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: PostGitAndTags.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: PostGitAndTags.Undocumented => r.result
        }(defaultExecutionContext)
    }

}

trait TreesController extends play.api.mvc.BaseController {

  sealed trait Post extends Product with Serializable
  object Post {
    final case class HTTP201(body: io.flow.github.v0.models.CreateTreeResponse) extends Post
    case object HTTP404 extends Post
    final case class HTTP422(body: io.flow.github.v0.models.UnprocessableEntity) extends Post
    final case class Undocumented(result: play.api.mvc.Result) extends Post
  }

  def post(
      request: play.api.mvc.Request[io.flow.github.v0.models.CreateTreeForm],
      owner: String,
      repo: String,
      body: io.flow.github.v0.models.CreateTreeForm
  ): scala.concurrent.Future[Post]
  final def post(owner: String, repo: String): play.api.mvc.Action[io.flow.github.v0.models.CreateTreeForm] =
    Action.async(parse.json[io.flow.github.v0.models.CreateTreeForm]) { request =>
      post(request, owner, repo, request.body)
        .map {
          case r: Post.HTTP201      => Status(201)(play.api.libs.json.Json.toJson(r.body))
          case Post.HTTP404         => Status(404)(play.api.mvc.Results.EmptyContent())
          case r: Post.HTTP422      => Status(422)(play.api.libs.json.Json.toJson(r.body))
          case r: Post.Undocumented => r.result
        }(defaultExecutionContext)
    }

}

trait UsersController extends play.api.mvc.BaseController {

  sealed trait GetUser extends Product with Serializable
  object GetUser {
    final case class HTTP200(body: io.flow.github.v0.models.User) extends GetUser
    case object HTTP401 extends GetUser
    final case class Undocumented(result: play.api.mvc.Result) extends GetUser
  }

  def getUser(request: play.api.mvc.Request[play.api.mvc.AnyContent]): scala.concurrent.Future[GetUser]
  final def getUser(): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getUser(request)
      .map {
        case r: GetUser.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetUser.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case r: GetUser.Undocumented => r.result
      }(defaultExecutionContext)
  }

  sealed trait GetUserAndOrgs extends Product with Serializable
  object GetUserAndOrgs {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.UserOrg]) extends GetUserAndOrgs
    case object HTTP401 extends GetUserAndOrgs
    final case class Undocumented(result: play.api.mvc.Result) extends GetUserAndOrgs
  }

  def getUserAndOrgs(
      request: play.api.mvc.Request[play.api.mvc.AnyContent],
      page: Long,
      perPage: _root_.scala.Option[Long]
  ): scala.concurrent.Future[GetUserAndOrgs]
  final def getUserAndOrgs(
      page: Long,
      perPage: _root_.scala.Option[Long]
  ): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    getUserAndOrgs(request, page, perPage)
      .map {
        case r: GetUserAndOrgs.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case GetUserAndOrgs.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case r: GetUserAndOrgs.Undocumented => r.result
      }(defaultExecutionContext)
  }

}

trait UserEmailsController extends play.api.mvc.BaseController {

  sealed trait Get extends Product with Serializable
  object Get {
    final case class HTTP200(body: Seq[io.flow.github.v0.models.UserEmail]) extends Get
    case object HTTP401 extends Get
    final case class Undocumented(result: play.api.mvc.Result) extends Get
  }

  def get(request: play.api.mvc.Request[play.api.mvc.AnyContent]): scala.concurrent.Future[Get]
  final def get(): play.api.mvc.Action[play.api.mvc.AnyContent] = Action.async { request =>
    get(request)
      .map {
        case r: Get.HTTP200      => Status(200)(play.api.libs.json.Json.toJson(r.body))
        case Get.HTTP401         => Status(401)(play.api.mvc.Results.EmptyContent())
        case r: Get.Undocumented => r.result
      }(defaultExecutionContext)
  }

}