/**
  * Generated by API Builder - https://www.apibuilder.io
  * Service version: 0.16.74
  * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-api/0.16.74/play_2_6
  */
package io.apibuilder.api.v0 {

  object Constants {

    val BaseUrl = "https://api.apibuilder.io"
    val Namespace = "io.apibuilder.api.v0"
    val UserAgent = "apibuilder app.apibuilder.io/apicollective/apibuilder-api/0.16.74/play_2_6"
    val Version = "0.16.74"
    val VersionMajor = 0

  }

  class Client(
      ws: play.api.libs.ws.WSClient,
      val baseUrl: String = "https://api.apibuilder.io",
      auth: scala.Option[io.apibuilder.api.v0.Authorization] = None,
      defaultHeaders: Seq[(String, String)] = Nil
  ) extends interfaces.Client {
    import io.apibuilder.api.v0.models.json._
    import io.apibuilder.common.v0.models.json._
    import io.apibuilder.generator.v0.models.json._
    import io.apibuilder.spec.v0.models.json._

    private val logger = play.api.Logger("io.apibuilder.api.v0.Client")

    logger.info(s"Initializing io.apibuilder.api.v0.Client for url $baseUrl")

    def applications: Applications = Applications

    def attributes: Attributes = Attributes

    def authentications: Authentications = Authentications

    def batchDownloadApplications: BatchDownloadApplications = BatchDownloadApplications

    def changes: Changes = Changes

    def code: Code = Code

    def domains: Domains = Domains

    def emailVerificationConfirmationForms: EmailVerificationConfirmationForms = EmailVerificationConfirmationForms

    def generatorServices: GeneratorServices = GeneratorServices

    def generatorWithServices: GeneratorWithServices = GeneratorWithServices

    def healthchecks: Healthchecks = Healthchecks

    def items: Items = Items

    def membershipRequests: MembershipRequests = MembershipRequests

    def memberships: Memberships = Memberships

    def organizations: Organizations = Organizations

    def passwordResetRequests: PasswordResetRequests = PasswordResetRequests

    def passwordResets: PasswordResets = PasswordResets

    def subscriptions: Subscriptions = Subscriptions

    def tokens: Tokens = Tokens

    def users: Users = Users

    def validations: Validations = Validations

    def versions: Versions = Versions

    def watches: Watches = Watches

    object Applications extends Applications {
      override def getMetadataAndVersionsByApplicationKey(
          orgKey: String,
          applicationKey: String,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.ApplicationMetadataVersion]] = {
        val queryParameters = Seq(
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/metadata/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/versions",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.ApplicationMetadataVersion]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.ApplicationMetadataVersion]]
            )
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 401, 404")
        }
      }

      override def getMetadataAndVersionsAndLatestTxtByApplicationKey(
          orgKey: String,
          applicationKey: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[String] = {
        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/metadata/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/versions/latest.txt",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 => _root_.io.apibuilder.api.v0.Client.parseJson("String", r, _.validate[String])
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 401, 404")
        }
      }

      override def get(
          orgKey: String,
          name: _root_.scala.Option[String] = None,
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          key: _root_.scala.Option[String] = None,
          hasVersion: _root_.scala.Option[Boolean] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          sortBy: _root_.scala.Option[io.apibuilder.api.v0.models.AppSortBy] = None,
          order: _root_.scala.Option[io.apibuilder.api.v0.models.SortOrder] = None,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Application]] = {
        val queryParameters = Seq(
          name.map("name" -> _),
          guid.map("guid" -> _.toString),
          key.map("key" -> _),
          hasVersion.map("has_version" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString),
          sortBy.map("sort_by" -> _.toString),
          order.map("order" -> _.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.Application]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.Application]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def post(
          orgKey: String,
          applicationForm: io.apibuilder.api.v0.models.ApplicationForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Application] = {
        val payload = play.api.libs.json.Json.toJson(applicationForm)

        _executeRequest(
          "POST",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Application",
              r,
              _.validate[io.apibuilder.api.v0.models.Application]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def putByApplicationKey(
          orgKey: String,
          applicationKey: String,
          applicationForm: io.apibuilder.api.v0.models.ApplicationForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Application] = {
        val payload = play.api.libs.json.Json.toJson(applicationForm)

        _executeRequest(
          "PUT",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Application",
              r,
              _.validate[io.apibuilder.api.v0.models.Application]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def deleteByApplicationKey(
          orgKey: String,
          applicationKey: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest(
          "DELETE",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }

      override def postMoveByApplicationKey(
          orgKey: String,
          applicationKey: String,
          moveForm: io.apibuilder.api.v0.models.MoveForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Application] = {
        val payload = play.api.libs.json.Json.toJson(moveForm)

        _executeRequest(
          "POST",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/move",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Application",
              r,
              _.validate[io.apibuilder.api.v0.models.Application]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }
    }

    object Attributes extends Attributes {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          name: _root_.scala.Option[String] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Attribute]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          name.map("name" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/attributes", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.Attribute]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.Attribute]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByName(
          name: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Attribute] = {
        _executeRequest(
          "GET",
          s"/attributes/${play.utils.UriEncoding.encodePathSegment(name, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Attribute", r, _.validate[io.apibuilder.api.v0.models.Attribute])
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def post(
          attributeForm: io.apibuilder.api.v0.models.AttributeForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Attribute] = {
        val payload = play.api.libs.json.Json.toJson(attributeForm)

        _executeRequest("POST", s"/attributes", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 201 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Attribute", r, _.validate[io.apibuilder.api.v0.models.Attribute])
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 201, 401, 409")
        }
      }

      override def deleteByName(
          name: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest(
          "DELETE",
          s"/attributes/${play.utils.UriEncoding.encodePathSegment(name, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object Authentications extends Authentications {
      override def getSessionById(
          id: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication] = {
        _executeRequest(
          "GET",
          s"/authentications/session/${play.utils.UriEncoding.encodePathSegment(id, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Authentication",
              r,
              _.validate[io.apibuilder.api.v0.models.Authentication]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object BatchDownloadApplications extends BatchDownloadApplications {
      override def post(
          orgKey: String,
          batchDownloadApplicationsForm: io.apibuilder.api.v0.models.BatchDownloadApplicationsForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.BatchDownloadApplications] = {
        val payload = play.api.libs.json.Json.toJson(batchDownloadApplicationsForm)

        _executeRequest(
          "POST",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/batch/download/applications",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 201 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.BatchDownloadApplications",
              r,
              _.validate[io.apibuilder.api.v0.models.BatchDownloadApplications]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 201, 409")
        }
      }
    }

    object Changes extends Changes {
      override def get(
          orgKey: _root_.scala.Option[String] = None,
          applicationKey: _root_.scala.Option[String] = None,
          from: _root_.scala.Option[String] = None,
          to: _root_.scala.Option[String] = None,
          `type`: _root_.scala.Option[String] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Change]] = {
        val queryParameters = Seq(
          orgKey.map("org_key" -> _),
          applicationKey.map("application_key" -> _),
          from.map("from" -> _),
          to.map("to" -> _),
          `type`.map("type" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/changes", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.Change]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.Change]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Code extends Code {
      override def postForm(
          orgKey: String,
          applicationKey: String,
          version: String,
          codeForm: io.apibuilder.api.v0.models.CodeForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.generator.v0.models.InvocationForm] = {
        val payload = play.api.libs.json.Json.toJson(codeForm)

        _executeRequest(
          "POST",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding.encodePathSegment(version, "UTF-8")}/form",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.generator.v0.models.InvocationForm",
              r,
              _.validate[io.apibuilder.generator.v0.models.InvocationForm]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def getByGeneratorKey(
          orgKey: String,
          applicationKey: String,
          version: String,
          generatorKey: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Code] = {
        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(version, "UTF-8")}/${play.utils.UriEncoding.encodePathSegment(generatorKey, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Code", r, _.validate[io.apibuilder.api.v0.models.Code])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def postByGeneratorKey(
          orgKey: String,
          applicationKey: String,
          version: String,
          generatorKey: String,
          codeForm: io.apibuilder.api.v0.models.CodeForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Code] = {
        val payload = play.api.libs.json.Json.toJson(codeForm)

        _executeRequest(
          "POST",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(version, "UTF-8")}/${play.utils.UriEncoding.encodePathSegment(generatorKey, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Code", r, _.validate[io.apibuilder.api.v0.models.Code])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }
    }

    object Domains extends Domains {
      override def post(
          orgKey: String,
          domain: io.apibuilder.api.v0.models.Domain,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Domain] = {
        val payload = play.api.libs.json.Json.toJson(domain)

        _executeRequest(
          "POST",
          s"/domains/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Domain", r, _.validate[io.apibuilder.api.v0.models.Domain])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def deleteByName(
          orgKey: String,
          name: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest(
          "DELETE",
          s"/domains/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(name, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object EmailVerificationConfirmationForms extends EmailVerificationConfirmationForms {
      override def post(
          emailVerificationConfirmationForm: io.apibuilder.api.v0.models.EmailVerificationConfirmationForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        val payload = play.api.libs.json.Json.toJson(emailVerificationConfirmationForm)

        _executeRequest(
          "POST",
          s"/email_verification_confirmations",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 409")
        }
      }
    }

    object GeneratorServices extends GeneratorServices {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          uri: _root_.scala.Option[String] = None,
          generatorKey: _root_.scala.Option[String] = None,
          limit: Long = 100L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.GeneratorService]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          uri.map("uri" -> _),
          generatorKey.map("generator_key" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/generator_services",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.GeneratorService]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.GeneratorService]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.GeneratorService] = {
        _executeRequest("GET", s"/generator_services/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.GeneratorService",
              r,
              _.validate[io.apibuilder.api.v0.models.GeneratorService]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def post(
          generatorServiceForm: io.apibuilder.api.v0.models.GeneratorServiceForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.GeneratorService] = {
        val payload = play.api.libs.json.Json.toJson(generatorServiceForm)

        _executeRequest("POST", s"/generator_services", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.GeneratorService",
              r,
              _.validate[io.apibuilder.api.v0.models.GeneratorService]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def deleteByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/generator_services/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object GeneratorWithServices extends GeneratorWithServices {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          serviceGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          serviceUri: _root_.scala.Option[String] = None,
          attributeName: _root_.scala.Option[String] = None,
          key: _root_.scala.Option[String] = None,
          limit: Long = 100L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.GeneratorWithService]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          serviceGuid.map("service_guid" -> _.toString),
          serviceUri.map("service_uri" -> _),
          attributeName.map("attribute_name" -> _),
          key.map("key" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/generators", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.GeneratorWithService]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.GeneratorWithService]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByKey(
          key: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.GeneratorWithService] = {
        _executeRequest(
          "GET",
          s"/generators/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.GeneratorWithService",
              r,
              _.validate[io.apibuilder.api.v0.models.GeneratorWithService]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

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

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

        _executeRequest("GET", s"/items", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("Seq[io.apibuilder.api.v0.models.Item]", r, _.validate[Seq[io.apibuilder.api.v0.models.Item]])
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Item] = {
        _executeRequest("GET", s"/items/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Item", r, _.validate[io.apibuilder.api.v0.models.Item])
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object MembershipRequests extends MembershipRequests {
      override def get(
          orgGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          orgKey: _root_.scala.Option[String] = None,
          userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          role: _root_.scala.Option[io.apibuilder.common.v0.models.MembershipRole] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.MembershipRequest]] = {
        val queryParameters = Seq(
          orgGuid.map("org_guid" -> _.toString),
          orgKey.map("org_key" -> _),
          userGuid.map("user_guid" -> _.toString),
          role.map("role" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/membership_requests",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.MembershipRequest]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.MembershipRequest]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def post(
          orgGuid: _root_.java.util.UUID,
          userGuid: _root_.java.util.UUID,
          role: io.apibuilder.common.v0.models.MembershipRole,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.MembershipRequest] = {
        val payload = play.api.libs.json.Json.obj(
          "org_guid" -> play.api.libs.json.Json.toJson(orgGuid),
          "user_guid" -> play.api.libs.json.Json.toJson(userGuid),
          "role" -> play.api.libs.json.Json.toJson(role)
        )

        _executeRequest("POST", s"/membership_requests", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.MembershipRequest",
              r,
              _.validate[io.apibuilder.api.v0.models.MembershipRequest]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def postAcceptByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/membership_requests/${guid}/accept", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 409")
        }
      }

      override def postDeclineByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("POST", s"/membership_requests/${guid}/decline", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 409")
        }
      }
    }

    object Memberships extends Memberships {
      override def get(
          orgGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          orgKey: _root_.scala.Option[String] = None,
          userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          role: _root_.scala.Option[io.apibuilder.common.v0.models.MembershipRole] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Membership]] = {
        val queryParameters = Seq(
          orgGuid.map("org_guid" -> _.toString),
          orgKey.map("org_key" -> _),
          userGuid.map("user_guid" -> _.toString),
          role.map("role" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/memberships", queryParameters = queryParameters, requestHeaders = requestHeaders)
          .map {
            case r if r.status == 200 =>
              _root_.io.apibuilder.api.v0.Client.parseJson(
                "Seq[io.apibuilder.api.v0.models.Membership]",
                r,
                _.validate[Seq[io.apibuilder.api.v0.models.Membership]]
              )
            case r =>
              throw io.apibuilder.api.v0.errors
                .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
          }
      }

      override def getByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Membership] = {
        _executeRequest("GET", s"/memberships/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Membership",
              r,
              _.validate[io.apibuilder.api.v0.models.Membership]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def deleteByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/memberships/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object Organizations extends Organizations {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          key: _root_.scala.Option[String] = None,
          name: _root_.scala.Option[String] = None,
          namespace: _root_.scala.Option[String] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Organization]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          userGuid.map("user_guid" -> _.toString),
          key.map("key" -> _),
          name.map("name" -> _),
          namespace.map("namespace" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/organizations", queryParameters = queryParameters, requestHeaders = requestHeaders)
          .map {
            case r if r.status == 200 =>
              _root_.io.apibuilder.api.v0.Client.parseJson(
                "Seq[io.apibuilder.api.v0.models.Organization]",
                r,
                _.validate[Seq[io.apibuilder.api.v0.models.Organization]]
              )
            case r =>
              throw io.apibuilder.api.v0.errors
                .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
          }
      }

      override def getByKey(
          key: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Organization] = {
        _executeRequest(
          "GET",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Organization",
              r,
              _.validate[io.apibuilder.api.v0.models.Organization]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

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

        _executeRequest("POST", s"/organizations", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Organization",
              r,
              _.validate[io.apibuilder.api.v0.models.Organization]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

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

        _executeRequest(
          "PUT",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Organization",
              r,
              _.validate[io.apibuilder.api.v0.models.Organization]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def deleteByKey(
          key: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest(
          "DELETE",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }

      override def getAttributesByKey(
          key: String,
          name: _root_.scala.Option[String] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.AttributeValue]] = {
        val queryParameters = Seq(
          name.map("name" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}/attributes",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.AttributeValue]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.AttributeValue]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getAttributesByKeyAndName(
          key: String,
          name: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.AttributeValue] = {
        _executeRequest(
          "GET",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}/attributes/${play.utils.UriEncoding
            .encodePathSegment(name, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.AttributeValue",
              r,
              _.validate[io.apibuilder.api.v0.models.AttributeValue]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def putAttributesByKeyAndName(
          key: String,
          name: String,
          attributeValueForm: io.apibuilder.api.v0.models.AttributeValueForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.AttributeValue] = {
        val payload = play.api.libs.json.Json.toJson(attributeValueForm)

        _executeRequest(
          "PUT",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}/attributes/${play.utils.UriEncoding
            .encodePathSegment(name, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.AttributeValue",
              r,
              _.validate[io.apibuilder.api.v0.models.AttributeValue]
            )
          case r if r.status == 201 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.AttributeValue",
              r,
              _.validate[io.apibuilder.api.v0.models.AttributeValue]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 201, 404, 409")
        }
      }

      override def deleteAttributesByKeyAndName(
          key: String,
          name: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest(
          "DELETE",
          s"/organizations/${play.utils.UriEncoding.encodePathSegment(key, "UTF-8")}/attributes/${play.utils.UriEncoding
            .encodePathSegment(name, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object PasswordResetRequests extends PasswordResetRequests {
      override def post(
          passwordResetRequest: io.apibuilder.api.v0.models.PasswordResetRequest,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        val payload = play.api.libs.json.Json.toJson(passwordResetRequest)

        _executeRequest("POST", s"/password_reset_requests", body = Some(payload), requestHeaders = requestHeaders)
          .map {
            case r if r.status == 204 => ()
            case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
            case r =>
              throw io.apibuilder.api.v0.errors
                .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 409")
          }
      }
    }

    object PasswordResets extends PasswordResets {
      override def post(
          passwordReset: io.apibuilder.api.v0.models.PasswordReset,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication] = {
        val payload = play.api.libs.json.Json.toJson(passwordReset)

        _executeRequest("POST", s"/password_resets", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Authentication",
              r,
              _.validate[io.apibuilder.api.v0.models.Authentication]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }
    }

    object Subscriptions extends Subscriptions {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          organizationKey: _root_.scala.Option[String] = None,
          userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          publication: _root_.scala.Option[io.apibuilder.api.v0.models.Publication] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Subscription]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          organizationKey.map("organization_key" -> _),
          userGuid.map("user_guid" -> _.toString),
          publication.map("publication" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/subscriptions", queryParameters = queryParameters, requestHeaders = requestHeaders)
          .map {
            case r if r.status == 200 =>
              _root_.io.apibuilder.api.v0.Client.parseJson(
                "Seq[io.apibuilder.api.v0.models.Subscription]",
                r,
                _.validate[Seq[io.apibuilder.api.v0.models.Subscription]]
              )
            case r =>
              throw io.apibuilder.api.v0.errors
                .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
          }
      }

      override def getByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Subscription] = {
        _executeRequest("GET", s"/subscriptions/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Subscription",
              r,
              _.validate[io.apibuilder.api.v0.models.Subscription]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

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

        _executeRequest("POST", s"/subscriptions", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 201 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Subscription",
              r,
              _.validate[io.apibuilder.api.v0.models.Subscription]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 201, 409")
        }
      }

      override def deleteByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/subscriptions/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object Tokens extends Tokens {
      override def getUsersByUserGuid(
          userGuid: _root_.java.util.UUID,
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Token]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/tokens/users/${userGuid}",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.Token]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.Token]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getCleartextByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.CleartextToken] = {
        _executeRequest("GET", s"/tokens/${guid}/cleartext", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.CleartextToken",
              r,
              _.validate[io.apibuilder.api.v0.models.CleartextToken]
            )
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

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

        _executeRequest("POST", s"/tokens", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 201 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Token", r, _.validate[io.apibuilder.api.v0.models.Token])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 201, 409")
        }
      }

      override def deleteByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/tokens/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    object Users extends Users {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          email: _root_.scala.Option[String] = None,
          nickname: _root_.scala.Option[String] = None,
          token: _root_.scala.Option[String] = None,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.User]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          email.map("email" -> _),
          nickname.map("nickname" -> _),
          token.map("token" -> _)
        ).flatten

        _executeRequest("GET", s"/users", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("Seq[io.apibuilder.api.v0.models.User]", r, _.validate[Seq[io.apibuilder.api.v0.models.User]])
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.User] = {
        _executeRequest("GET", s"/users/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.User", r, _.validate[io.apibuilder.api.v0.models.User])
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def postAuthenticate(
          email: String,
          password: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication] = {
        val payload = play.api.libs.json.Json.obj(
          "email" -> play.api.libs.json.Json.toJson(email),
          "password" -> play.api.libs.json.Json.toJson(password)
        )

        _executeRequest("POST", s"/users/authenticate", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Authentication",
              r,
              _.validate[io.apibuilder.api.v0.models.Authentication]
            )
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def postAuthenticateGithub(
          token: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication] = {
        val payload = play.api.libs.json.Json.obj(
          "token" -> play.api.libs.json.Json.toJson(token)
        )

        _executeRequest("POST", s"/users/authenticate_github", body = Some(payload), requestHeaders = requestHeaders)
          .map {
            case r if r.status == 200 =>
              _root_.io.apibuilder.api.v0.Client.parseJson(
                "io.apibuilder.api.v0.models.Authentication",
                r,
                _.validate[io.apibuilder.api.v0.models.Authentication]
              )
            case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
            case r =>
              throw io.apibuilder.api.v0.errors
                .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
          }
      }

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

        _executeRequest("POST", s"/users", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.User", r, _.validate[io.apibuilder.api.v0.models.User])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def putByGuid(
          guid: _root_.java.util.UUID,
          userUpdateForm: io.apibuilder.api.v0.models.UserUpdateForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.User] = {
        val payload = play.api.libs.json.Json.toJson(userUpdateForm)

        _executeRequest("PUT", s"/users/${guid}", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.User", r, _.validate[io.apibuilder.api.v0.models.User])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }
    }

    object Validations extends Validations {
      override def post(
          value: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Validation] = {
        val payload = play.api.libs.json.Json.toJson(value)

        _executeRequest("POST", s"/validations", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "io.apibuilder.api.v0.models.Validation",
              r,
              _.validate[io.apibuilder.api.v0.models.Validation]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }
    }

    object Versions extends Versions {
      override def getByApplicationKey(
          orgKey: String,
          applicationKey: String,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Version]] = {
        val queryParameters = Seq(
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.Version]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.Version]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByApplicationKeyAndVersion(
          orgKey: String,
          applicationKey: String,
          version: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Version] = {
        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding.encodePathSegment(version, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Version", r, _.validate[io.apibuilder.api.v0.models.Version])
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def postByVersion(
          orgKey: String,
          version: String,
          versionForm: io.apibuilder.api.v0.models.VersionForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Version] = {
        val payload = play.api.libs.json.Json.toJson(versionForm)

        _executeRequest(
          "POST",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(version, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Version", r, _.validate[io.apibuilder.api.v0.models.Version])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def putByApplicationKeyAndVersion(
          orgKey: String,
          applicationKey: String,
          version: String,
          versionForm: io.apibuilder.api.v0.models.VersionForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[io.apibuilder.api.v0.models.Version] = {
        val payload = play.api.libs.json.Json.toJson(versionForm)

        _executeRequest(
          "PUT",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding.encodePathSegment(version, "UTF-8")}",
          body = Some(payload),
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Version", r, _.validate[io.apibuilder.api.v0.models.Version])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 409")
        }
      }

      override def deleteByApplicationKeyAndVersion(
          orgKey: String,
          applicationKey: String,
          version: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest(
          "DELETE",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding.encodePathSegment(version, "UTF-8")}",
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }

      override def getExampleByApplicationKeyAndVersionAndTypeName(
          orgKey: String,
          applicationKey: String,
          version: String,
          typeName: String,
          subTypeName: _root_.scala.Option[String] = None,
          optionalFields: _root_.scala.Option[Boolean] = None,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[_root_.play.api.libs.json.JsObject] = {
        val queryParameters = Seq(
          subTypeName.map("sub_type_name" -> _),
          optionalFields.map("optional_fields" -> _.toString)
        ).flatten

        _executeRequest(
          "GET",
          s"/${play.utils.UriEncoding.encodePathSegment(orgKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(applicationKey, "UTF-8")}/${play.utils.UriEncoding
            .encodePathSegment(version, "UTF-8")}/example/${play.utils.UriEncoding.encodePathSegment(typeName, "UTF-8")}",
          queryParameters = queryParameters,
          requestHeaders = requestHeaders
        ).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("_root_.play.api.libs.json.JsObject", r, _.validate[_root_.play.api.libs.json.JsObject])
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }
    }

    object Watches extends Watches {
      override def get(
          guid: _root_.scala.Option[_root_.java.util.UUID] = None,
          userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          organizationKey: _root_.scala.Option[String] = None,
          applicationKey: _root_.scala.Option[String] = None,
          limit: Long = 25L,
          offset: Long = 0L,
          requestHeaders: Seq[(String, String)] = Nil
      )(
          implicit ec: scala.concurrent.ExecutionContext
      ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Watch]] = {
        val queryParameters = Seq(
          guid.map("guid" -> _.toString),
          userGuid.map("user_guid" -> _.toString),
          organizationKey.map("organization_key" -> _),
          applicationKey.map("application_key" -> _),
          Some("limit" -> limit.toString),
          Some("offset" -> offset.toString)
        ).flatten

        _executeRequest("GET", s"/watches", queryParameters = queryParameters, requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client.parseJson(
              "Seq[io.apibuilder.api.v0.models.Watch]",
              r,
              _.validate[Seq[io.apibuilder.api.v0.models.Watch]]
            )
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
        }
      }

      override def getByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Watch] = {
        _executeRequest("GET", s"/watches/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 200 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Watch", r, _.validate[io.apibuilder.api.v0.models.Watch])
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200, 404")
        }
      }

      override def getCheck(
          userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
          organizationKey: String,
          applicationKey: String,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Boolean] = {
        val queryParameters = Seq(
          userGuid.map("user_guid" -> _.toString),
          Some("organization_key" -> organizationKey),
          Some("application_key" -> applicationKey)
        ).flatten

        _executeRequest("GET", s"/watches/check", queryParameters = queryParameters, requestHeaders = requestHeaders)
          .map {
            case r if r.status == 200 => _root_.io.apibuilder.api.v0.Client.parseJson("Boolean", r, _.validate[Boolean])
            case r =>
              throw io.apibuilder.api.v0.errors
                .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 200")
          }
      }

      override def post(
          watchForm: io.apibuilder.api.v0.models.WatchForm,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Watch] = {
        val payload = play.api.libs.json.Json.toJson(watchForm)

        _executeRequest("POST", s"/watches", body = Some(payload), requestHeaders = requestHeaders).map {
          case r if r.status == 201 =>
            _root_.io.apibuilder.api.v0.Client
              .parseJson("io.apibuilder.api.v0.models.Watch", r, _.validate[io.apibuilder.api.v0.models.Watch])
          case r if r.status == 409 => throw io.apibuilder.api.v0.errors.ErrorsResponse(r)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 201, 409")
        }
      }

      override def deleteByGuid(
          guid: _root_.java.util.UUID,
          requestHeaders: Seq[(String, String)] = Nil
      )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit] = {
        _executeRequest("DELETE", s"/watches/${guid}", requestHeaders = requestHeaders).map {
          case r if r.status == 204 => ()
          case r if r.status == 401 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r if r.status == 404 => throw io.apibuilder.api.v0.errors.UnitResponse(r.status)
          case r =>
            throw io.apibuilder.api.v0.errors
              .FailedRequest(r.status, s"Unsupported response code[${r.status}]. Expected: 204, 401, 404")
        }
      }
    }

    def _requestHolder(path: String): play.api.libs.ws.WSRequest = {

      val holder = ws
        .url(baseUrl + path)
        .addHttpHeaders(
          "User-Agent" -> Constants.UserAgent,
          "X-Apidoc-Version" -> Constants.Version,
          "X-Apidoc-Version-Major" -> Constants.VersionMajor.toString
        )
        .addHttpHeaders(defaultHeaders: _*)
      auth.fold(holder) {
        case Authorization.Basic(username, password) => {
          holder.withAuth(username, password.getOrElse(""), play.api.libs.ws.WSAuthScheme.BASIC)
        }
      }
    }

    def _logRequest(method: String, req: play.api.libs.ws.WSRequest): play.api.libs.ws.WSRequest = {
      val queryComponents = for {
        (name, values) <- req.queryString
        value <- values
      } yield s"$name=$value"
      val url = s"${req.url}${queryComponents.mkString("?", "&", "")}"
      auth.fold(logger.info(s"curl -X $method '$url'")) { _ =>
        logger.info(s"curl -X $method -u '[REDACTED]:' '$url'")
      }
      req
    }

    def _executeRequest(
        method: String,
        path: String,
        queryParameters: Seq[(String, String)] = Nil,
        requestHeaders: Seq[(String, String)] = Nil,
        body: Option[play.api.libs.json.JsValue] = None
    ): scala.concurrent.Future[play.api.libs.ws.WSResponse] = {
      method.toUpperCase match {
        case "GET" => {
          _logRequest(
            "GET",
            _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)
          ).get()
        }
        case "POST" => {
          _logRequest(
            "POST",
            _requestHolder(path)
              .addHttpHeaders(_withJsonContentType(requestHeaders): _*)
              .addQueryStringParameters(queryParameters: _*)
          ).post(body.getOrElse(play.api.libs.json.Json.obj()))
        }
        case "PUT" => {
          _logRequest(
            "PUT",
            _requestHolder(path)
              .addHttpHeaders(_withJsonContentType(requestHeaders): _*)
              .addQueryStringParameters(queryParameters: _*)
          ).put(body.getOrElse(play.api.libs.json.Json.obj()))
        }
        case "PATCH" => {
          _logRequest(
            "PATCH",
            _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)
          ).patch(body.getOrElse(play.api.libs.json.Json.obj()))
        }
        case "DELETE" => {
          _logRequest(
            "DELETE",
            _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)
          ).delete()
        }
        case "HEAD" => {
          _logRequest(
            "HEAD",
            _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)
          ).head()
        }
        case "OPTIONS" => {
          _logRequest(
            "OPTIONS",
            _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)
          ).options()
        }
        case _ => {
          _logRequest(
            method,
            _requestHolder(path).addHttpHeaders(requestHeaders: _*).addQueryStringParameters(queryParameters: _*)
          )
          sys.error("Unsupported method[%s]".format(method))
        }
      }
    }

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

  }

  object Client {

    def parseJson[T](
        className: String,
        r: play.api.libs.ws.WSResponse,
        f: (play.api.libs.json.JsValue => play.api.libs.json.JsResult[T])
    ): T = {
      f(play.api.libs.json.Json.parse(r.body)) match {
        case play.api.libs.json.JsSuccess(x, _) => x
        case play.api.libs.json.JsError(errors) => {
          throw io.apibuilder.api.v0.errors
            .FailedRequest(r.status, s"Invalid json for class[" + className + "]: " + errors.mkString(" "))
        }
      }
    }

  }

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

  package interfaces {

    trait Client {
      def baseUrl: String
      def applications: io.apibuilder.api.v0.Applications
      def attributes: io.apibuilder.api.v0.Attributes
      def authentications: io.apibuilder.api.v0.Authentications
      def batchDownloadApplications: io.apibuilder.api.v0.BatchDownloadApplications
      def changes: io.apibuilder.api.v0.Changes
      def code: io.apibuilder.api.v0.Code
      def domains: io.apibuilder.api.v0.Domains
      def emailVerificationConfirmationForms: io.apibuilder.api.v0.EmailVerificationConfirmationForms
      def generatorServices: io.apibuilder.api.v0.GeneratorServices
      def generatorWithServices: io.apibuilder.api.v0.GeneratorWithServices
      def healthchecks: io.apibuilder.api.v0.Healthchecks
      def items: io.apibuilder.api.v0.Items
      def membershipRequests: io.apibuilder.api.v0.MembershipRequests
      def memberships: io.apibuilder.api.v0.Memberships
      def organizations: io.apibuilder.api.v0.Organizations
      def passwordResetRequests: io.apibuilder.api.v0.PasswordResetRequests
      def passwordResets: io.apibuilder.api.v0.PasswordResets
      def subscriptions: io.apibuilder.api.v0.Subscriptions
      def tokens: io.apibuilder.api.v0.Tokens
      def users: io.apibuilder.api.v0.Users
      def validations: io.apibuilder.api.v0.Validations
      def versions: io.apibuilder.api.v0.Versions
      def watches: io.apibuilder.api.v0.Watches
    }

  }

  trait Applications {

    /**
      * Returns the versions assocoated with the specified application. The latest
      * version is the first result returned.
      *
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def getMetadataAndVersionsByApplicationKey(
        orgKey: String,
        applicationKey: String,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.ApplicationMetadataVersion]]

    /**
      * Returns the latest version number as a string
      */
    def getMetadataAndVersionsAndLatestTxtByApplicationKey(
        orgKey: String,
        applicationKey: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[String]

    /**
      * Search all applications. Results are always paginated.
      *
      * @param orgKey The organization key for which to search applications
      * @param name The name of an application. Case in-sensitive. Exact match
      * @param guid The guid of an application. Exact match
      * @param key The key of an application. Case in-sensitive. Exact match
      * @param hasVersion If true, we return applications that have at least one version. If false, we
      *        return applications that have no versions in the system
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        orgKey: String,
        name: _root_.scala.Option[String] = None,
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        key: _root_.scala.Option[String] = None,
        hasVersion: _root_.scala.Option[Boolean] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        sortBy: _root_.scala.Option[io.apibuilder.api.v0.models.AppSortBy] = None,
        order: _root_.scala.Option[io.apibuilder.api.v0.models.SortOrder] = None,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Application]]

    /**
      * Create an application.
      */
    def post(
        orgKey: String,
        applicationForm: io.apibuilder.api.v0.models.ApplicationForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Application]

    /**
      * Updates an application.
      */
    def putByApplicationKey(
        orgKey: String,
        applicationKey: String,
        applicationForm: io.apibuilder.api.v0.models.ApplicationForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Application]

    /**
      * Deletes a specific application and its associated versions.
      */
    def deleteByApplicationKey(
        orgKey: String,
        applicationKey: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    /**
      * Moves application to a new organization.
      */
    def postMoveByApplicationKey(
        orgKey: String,
        applicationKey: String,
        moveForm: io.apibuilder.api.v0.models.MoveForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Application]
  }

  trait Attributes {

    /**
      * Search all attributes. Results are always paginated.
      *
      * @param guid Find the watch with this guid.
      * @param name Find attributes 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(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        name: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Attribute]]

    /**
      * Returns the attribute with this name.
      */
    def getByName(
        name: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Attribute]

    /**
      * Create a new attribute.
      */
    def post(
        attributeForm: io.apibuilder.api.v0.models.AttributeForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Attribute]

    /**
      * Deletes the attribute with this name. Only the user who created an attribute can
      * delete it.
      */
    def deleteByName(
        name: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Authentications {
    def getSessionById(
        id: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication]
  }

  trait BatchDownloadApplications {

    /**
      * Retrieve multiple applications in one api call.
      */
    def post(
        orgKey: String,
        batchDownloadApplicationsForm: io.apibuilder.api.v0.models.BatchDownloadApplicationsForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.BatchDownloadApplications]
  }

  trait Changes {

    /**
      * @param orgKey Filter changes to those made for the organization with this key.
      * @param applicationKey Filter changes to those made for the application with this key.
      * @param from Filter changes to those made from this version.
      * @param to Filter changes to those made to this version.
      * @param type The type of diff to return.
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        orgKey: _root_.scala.Option[String] = None,
        applicationKey: _root_.scala.Option[String] = None,
        from: _root_.scala.Option[String] = None,
        to: _root_.scala.Option[String] = None,
        `type`: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Change]]
  }

  trait Code {

    /**
      * Create an invocation form. This is useful primarily for debugging when you want
      * to see exactly what content is being forwarded to the generator
      */
    def postForm(
        orgKey: String,
        applicationKey: String,
        version: String,
        codeForm: io.apibuilder.api.v0.models.CodeForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.generator.v0.models.InvocationForm]

    /**
      * Generate code for a specific version of an application.
      *
      * @param orgKey The organization key for which to generate code
      * @param applicationKey The application key for which to generate code
      * @param version The version of this application. Can be 'latest'
      * @param generatorKey The key of the generator to invoke
      */
    def getByGeneratorKey(
        orgKey: String,
        applicationKey: String,
        version: String,
        generatorKey: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Code]

    /**
      * Generate code for a specific version of an application.
      *
      * @param orgKey The organization key for which to generate code
      * @param applicationKey The application key for which to generate code
      * @param version The version of this application. Can be 'latest'
      * @param generatorKey The key of the generator to invoke
      */
    def postByGeneratorKey(
        orgKey: String,
        applicationKey: String,
        version: String,
        generatorKey: String,
        codeForm: io.apibuilder.api.v0.models.CodeForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Code]
  }

  trait Domains {

    /**
      * Add a domain to this organization
      */
    def post(
        orgKey: String,
        domain: io.apibuilder.api.v0.models.Domain,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Domain]

    /**
      * Remove this domain from this organization
      */
    def deleteByName(
        orgKey: String,
        name: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait EmailVerificationConfirmationForms {

    /**
      * Validate an email address using a token.
      */
    def post(
        emailVerificationConfirmationForm: io.apibuilder.api.v0.models.EmailVerificationConfirmationForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait GeneratorServices {

    /**
      * List all generator services
      *
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        uri: _root_.scala.Option[String] = None,
        generatorKey: _root_.scala.Option[String] = None,
        limit: Long = 100L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.GeneratorService]]

    def getByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.GeneratorService]

    def post(
        generatorServiceForm: io.apibuilder.api.v0.models.GeneratorServiceForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.GeneratorService]

    /**
      * Deletes a generator service.
      */
    def deleteByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait GeneratorWithServices {

    /**
      * List all available generators
      *
      * @param guid Filter to generator with this guid
      * @param serviceGuid Filter to generator from this service
      * @param serviceUri Filter to generator from this service URI
      * @param attributeName Filter to generators that use this attribute
      * @param key Filter to generator with this key
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        serviceGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        serviceUri: _root_.scala.Option[String] = None,
        attributeName: _root_.scala.Option[String] = None,
        key: _root_.scala.Option[String] = None,
        limit: Long = 100L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.GeneratorWithService]]

    def getByKey(
        key: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.GeneratorWithService]
  }

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

  trait Items {

    /**
      * @param q The search query. At the moment, we do case insensitive exact match search.
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        q: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Item]]

    def getByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Item]
  }

  trait MembershipRequests {

    /**
      * Search all membership requests. Results are always paginated.
      *
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        orgGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        orgKey: _root_.scala.Option[String] = None,
        userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        role: _root_.scala.Option[io.apibuilder.common.v0.models.MembershipRole] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.MembershipRequest]]

    /**
      * Create a membership request
      */
    def post(
        orgGuid: _root_.java.util.UUID,
        userGuid: _root_.java.util.UUID,
        role: io.apibuilder.common.v0.models.MembershipRole,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.MembershipRequest]

    /**
      * Accepts this membership request. User will become a member of the specified
      * organization.
      */
    def postAcceptByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    /**
      * Declines this membership request. User will NOT become a member of the specified
      * organization.
      */
    def postDeclineByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Memberships {

    /**
      * Search all memberships. Results are always paginated.
      *
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        orgGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        orgKey: _root_.scala.Option[String] = None,
        userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        role: _root_.scala.Option[io.apibuilder.common.v0.models.MembershipRole] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Membership]]

    def getByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Membership]

    def deleteByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Organizations {

    /**
      * Search all organizations. Results are always paginated.
      *
      * @param guid Finds the organization with this guid, if any
      * @param userGuid If specified, restricts to organizations that this user is specifically a member
      *        of (e.g. will exclude public organizations with which the user does not have a
      *        direct membership).
      * @param key Find organizations with this key. Case in-sensitive. Exact match
      * @param name Find organizations with this name. Case in-sensitive. Exact match
      * @param namespace Find organizations with this namespace. 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(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        key: _root_.scala.Option[String] = None,
        name: _root_.scala.Option[String] = None,
        namespace: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Organization]]

    /**
      * Returns the organization with this key.
      */
    def getByKey(
        key: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Organization]

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

    /**
      * Update an organization.
      */
    def putByKey(
        key: String,
        organizationForm: io.apibuilder.api.v0.models.OrganizationForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Organization]

    /**
      * Deletes an organization and all of its associated applications.
      */
    def deleteByKey(
        key: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    /**
      * Returns all attribute values for this organization. Results are always
      * paginated.
      *
      * @param name Find the values for the attribute with this name.
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def getAttributesByKey(
        key: String,
        name: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.AttributeValue]]

    /**
      * Returns the attribute value with this name.
      */
    def getAttributesByKeyAndName(
        key: String,
        name: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.AttributeValue]

    /**
      * Create or update a new attribute value.
      */
    def putAttributesByKeyAndName(
        key: String,
        name: String,
        attributeValueForm: io.apibuilder.api.v0.models.AttributeValueForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.AttributeValue]

    /**
      * Deletes the attribute value with the specified name. Only the user who created
      * an attribute value can delete it.
      */
    def deleteAttributesByKeyAndName(
        key: String,
        name: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait PasswordResetRequests {

    /**
      * Create a new password reset. This will send the user an email with a link to
      * reset their password.
      */
    def post(
        passwordResetRequest: io.apibuilder.api.v0.models.PasswordResetRequest,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait PasswordResets {

    /**
      * Change the password for this token. If the token is invalid, has been used, or
      * otherwise no longer can be applied, errors will be returned as 409s. A 204
      * represents that the user has successfully changed their password.
      */
    def post(
        passwordReset: io.apibuilder.api.v0.models.PasswordReset,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication]
  }

  trait Subscriptions {

    /**
      * Search subscriptions. Always paginated.
      *
      * @param guid Find the subscription with this guid.
      * @param organizationKey Find subscriptions for this organization.
      * @param userGuid Find subscriptions for this user.
      * @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(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        organizationKey: _root_.scala.Option[String] = None,
        userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        publication: _root_.scala.Option[io.apibuilder.api.v0.models.Publication] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Subscription]]

    /**
      * Returns information about a specific subscription.
      */
    def getByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Subscription]

    /**
      * Create a new subscription.
      */
    def post(
        subscriptionForm: io.apibuilder.api.v0.models.SubscriptionForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Subscription]

    def deleteByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Tokens {

    /**
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def getUsersByUserGuid(
        userGuid: _root_.java.util.UUID,
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Token]]

    /**
      * Used to fetch the clear text token.
      */
    def getCleartextByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.CleartextToken]

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

    def deleteByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  trait Users {

    /**
      * Search for a specific user. You must specify at least 1 parameter - either a
      * guid, email or token - and will receive back either 0 or 1 users.
      *
      * @param guid Find user with this guid. Exact match
      * @param email Find user with this email address. Case in-sensitive. Exact match
      * @param nickname Find user with the specified nickname. For users that register via GitHub, this
      *        will be their GitHub username. Case in-sensitive. Exact match
      * @param token Find the user with this API token. Exact match
      */
    def get(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        email: _root_.scala.Option[String] = None,
        nickname: _root_.scala.Option[String] = None,
        token: _root_.scala.Option[String] = None,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.User]]

    /**
      * Returns information about the user with this guid.
      */
    def getByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.User]

    /**
      * Used to authenticate a user with an email address and password. Successful
      * authentication returns an instance of the user model. Failed authorizations of
      * any kind are returned as a generic error with code user_authorization_failed.
      */
    def postAuthenticate(
        email: String,
        password: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication]

    /**
      * Used to authenticate a user using a github access token. This is equivalent to
      * running the following command to get the user info: curl -H 'Authorization:
      * Bearer code' https://api.github.com/user
      *
      * @param token The GitHub assigned oauth token
      */
    def postAuthenticateGithub(
        token: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(
        implicit ec: scala.concurrent.ExecutionContext
    ): scala.concurrent.Future[io.apibuilder.api.v0.models.Authentication]

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

    /**
      * Updates information about the user with the specified guid.
      */
    def putByGuid(
        guid: _root_.java.util.UUID,
        userUpdateForm: io.apibuilder.api.v0.models.UserUpdateForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.User]
  }

  trait Validations {
    def post(
        value: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Validation]
  }

  trait Versions {

    /**
      * Search all versions of this application. Results are always paginated.
      *
      * @param orgKey The organization key for which to search versions
      * @param applicationKey The application key for which to search versions
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def getByApplicationKey(
        orgKey: String,
        applicationKey: String,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Version]]

    /**
      * Retrieve a specific version of an application.
      *
      * @param version The version of tthis application to download, or the keyword latest to get the
      *        latest version
      */
    def getByApplicationKeyAndVersion(
        orgKey: String,
        applicationKey: String,
        version: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Version]

    /**
      * Create a new version for an application
      */
    def postByVersion(
        orgKey: String,
        version: String,
        versionForm: io.apibuilder.api.v0.models.VersionForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Version]

    /**
      * Upsert a version of an application
      */
    def putByApplicationKeyAndVersion(
        orgKey: String,
        applicationKey: String,
        version: String,
        versionForm: io.apibuilder.api.v0.models.VersionForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Version]

    /**
      * Deletes a specific version.
      */
    def deleteByApplicationKeyAndVersion(
        orgKey: String,
        applicationKey: String,
        version: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]

    /**
      * Generates an example JSON document of the type with the specified name.
      *
      * @param version The version of this application to download, or the keyword latest to get the
      *        latest version
      * @param typeName The name of the type (e.g. model name) for which you would like to generate a
      *        sample json document
      * @param subTypeName The name of the sub-type for which you would like to generate a sample json
      *        document, e.g. a specific type of a union
      * @param optionalFields If true, we generate sample data for all optional fields. Otherwise the
      *        generated sample will contain only required fields, where applicable
      */
    def getExampleByApplicationKeyAndVersionAndTypeName(
        orgKey: String,
        applicationKey: String,
        version: String,
        typeName: String,
        subTypeName: _root_.scala.Option[String] = None,
        optionalFields: _root_.scala.Option[Boolean] = None,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[_root_.play.api.libs.json.JsObject]
  }

  trait Watches {

    /**
      * Search attributes. Always paginated.
      *
      * @param guid Find the watch with this guid.
      * @param userGuid Find attributes for this user.
      * @param organizationKey Find attributes for this organization.
      * @param applicationKey Find attributes for this application.
      * @param limit The number of records to return
      * @param offset Used to paginate. First page of results is 0.
      */
    def get(
        guid: _root_.scala.Option[_root_.java.util.UUID] = None,
        userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        organizationKey: _root_.scala.Option[String] = None,
        applicationKey: _root_.scala.Option[String] = None,
        limit: Long = 25L,
        offset: Long = 0L,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Seq[io.apibuilder.api.v0.models.Watch]]

    /**
      * Returns information about a specific watch.
      */
    def getByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Watch]

    /**
      * Quick check if a user is watching a specific application.
      *
      * @param userGuid The user for which we are checking. API returns false if the user guid is not
      *        provided
      */
    def getCheck(
        userGuid: _root_.scala.Option[_root_.java.util.UUID] = None,
        organizationKey: String,
        applicationKey: String,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Boolean]

    /**
      * Create a new watch.
      */
    def post(
        watchForm: io.apibuilder.api.v0.models.WatchForm,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[io.apibuilder.api.v0.models.Watch]

    def deleteByGuid(
        guid: _root_.java.util.UUID,
        requestHeaders: Seq[(String, String)] = Nil
    )(implicit ec: scala.concurrent.ExecutionContext): scala.concurrent.Future[Unit]
  }

  package errors {

    import io.apibuilder.api.v0.models.json._
    import io.apibuilder.common.v0.models.json._
    import io.apibuilder.generator.v0.models.json._
    import io.apibuilder.spec.v0.models.json._

    final case class ErrorsResponse(
        response: play.api.libs.ws.WSResponse,
        message: Option[String] = None
    ) extends Exception(message.getOrElse(s"${response.status}: ${response.body}")) {
      lazy val errors = _root_.io.apibuilder.api.v0.Client.parseJson(
        "Seq[io.apibuilder.api.v0.models.Error]",
        response,
        _.validate[Seq[io.apibuilder.api.v0.models.Error]]
      )
    }

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

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

  }

}