/**
 * 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/http4s_0_22
 */
package io.apibuilder.api.v0.models {

  package object json {
    import io.circe.Decoder._
    import io.circe.Encoder._
    import scala.language.implicitConversions // See below - Make Scala 2.11 Either monadic
    import scala.util.Try
    import io.circe.{Json, JsonObject, Encoder, Decoder, DecodingFailure}
    import io.circe.syntax._
    import io.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._

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

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

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

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

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

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

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

    implicit val jsonDecoderApibuilderApiAppSortBy: Decoder[io.apibuilder.api.v0.models.AppSortBy] =
      Decoder.decodeString.map(io.apibuilder.api.v0.models.AppSortBy(_))

    implicit val jsonEncoderApibuilderApiAppSortBy: Encoder[io.apibuilder.api.v0.models.AppSortBy] =
      Encoder.encodeString.contramap[io.apibuilder.api.v0.models.AppSortBy](_.toString)

    implicit val jsonDecoderApibuilderApiOriginalType: Decoder[io.apibuilder.api.v0.models.OriginalType] =
      Decoder.decodeString.map(io.apibuilder.api.v0.models.OriginalType(_))

    implicit val jsonEncoderApibuilderApiOriginalType: Encoder[io.apibuilder.api.v0.models.OriginalType] =
      Encoder.encodeString.contramap[io.apibuilder.api.v0.models.OriginalType](_.toString)

    implicit val jsonDecoderApibuilderApiPublication: Decoder[io.apibuilder.api.v0.models.Publication] =
      Decoder.decodeString.map(io.apibuilder.api.v0.models.Publication(_))

    implicit val jsonEncoderApibuilderApiPublication: Encoder[io.apibuilder.api.v0.models.Publication] =
      Encoder.encodeString.contramap[io.apibuilder.api.v0.models.Publication](_.toString)

    implicit val jsonDecoderApibuilderApiSortOrder: Decoder[io.apibuilder.api.v0.models.SortOrder] =
      Decoder.decodeString.map(io.apibuilder.api.v0.models.SortOrder(_))

    implicit val jsonEncoderApibuilderApiSortOrder: Encoder[io.apibuilder.api.v0.models.SortOrder] =
      Encoder.encodeString.contramap[io.apibuilder.api.v0.models.SortOrder](_.toString)

    implicit val jsonDecoderApibuilderApiVisibility: Decoder[io.apibuilder.api.v0.models.Visibility] =
      Decoder.decodeString.map(io.apibuilder.api.v0.models.Visibility(_))

    implicit val jsonEncoderApibuilderApiVisibility: Encoder[io.apibuilder.api.v0.models.Visibility] =
      Encoder.encodeString.contramap[io.apibuilder.api.v0.models.Visibility](_.toString)

    implicit def decodeApibuilderApiApplication: Decoder[Application] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[io.apibuilder.common.v0.models.Reference]
        name <- c.downField("name").as[String]
        key <- c.downField("key").as[String]
        visibility <- c.downField("visibility").as[io.apibuilder.api.v0.models.Visibility]
        description <- c.downField("description").as[Option[String]]
        lastUpdatedAt <- c.downField("last_updated_at").as[_root_.java.time.Instant]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Application(
          guid = guid,
          organization = organization,
          name = name,
          key = key,
          visibility = visibility,
          description = description,
          lastUpdatedAt = lastUpdatedAt,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiApplication: Encoder[Application] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("name" -> t.name.asJson),
        Some("key" -> t.key.asJson),
        Some("visibility" -> t.visibility.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("last_updated_at" -> t.lastUpdatedAt.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiApplicationForm: Decoder[ApplicationForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        key <- c.downField("key").as[Option[String]]
        description <- c.downField("description").as[Option[String]]
        visibility <- c.downField("visibility").as[io.apibuilder.api.v0.models.Visibility]
      } yield {
        ApplicationForm(
          name = name,
          key = key,
          description = description,
          visibility = visibility
        )
      }
    }

    implicit def encodeApibuilderApiApplicationForm: Encoder[ApplicationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.key.map(t => "key" -> t.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("visibility" -> t.visibility.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiApplicationMetadata: Decoder[ApplicationMetadata] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        key <- c.downField("key").as[String]
      } yield {
        ApplicationMetadata(
          guid = guid,
          key = key
        )
      }
    }

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

    implicit def decodeApibuilderApiApplicationMetadataVersion: Decoder[ApplicationMetadataVersion] = Decoder.instance { c =>
     for {
        version <- c.downField("version").as[String]
      } yield {
        ApplicationMetadataVersion(
          version = version
        )
      }
    }

    implicit def encodeApibuilderApiApplicationMetadataVersion: Encoder[ApplicationMetadataVersion] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("version" -> t.version.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiApplicationSummary: Decoder[ApplicationSummary] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[io.apibuilder.common.v0.models.Reference]
        key <- c.downField("key").as[String]
      } yield {
        ApplicationSummary(
          guid = guid,
          organization = organization,
          key = key
        )
      }
    }

    implicit def encodeApibuilderApiApplicationSummary: Encoder[ApplicationSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("key" -> t.key.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiAttribute: Decoder[Attribute] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[String]]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Attribute(
          guid = guid,
          name = name,
          description = description,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiAttribute: Encoder[Attribute] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("name" -> t.name.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiAttributeForm: Decoder[AttributeForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        description <- c.downField("description").as[Option[String]]
      } yield {
        AttributeForm(
          name = name,
          description = description
        )
      }
    }

    implicit def encodeApibuilderApiAttributeForm: Encoder[AttributeForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiAttributeSummary: Decoder[AttributeSummary] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        name <- c.downField("name").as[String]
      } yield {
        AttributeSummary(
          guid = guid,
          name = name
        )
      }
    }

    implicit def encodeApibuilderApiAttributeSummary: Encoder[AttributeSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiAttributeValue: Decoder[AttributeValue] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        attribute <- c.downField("attribute").as[io.apibuilder.api.v0.models.AttributeSummary]
        value <- c.downField("value").as[String]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        AttributeValue(
          guid = guid,
          attribute = attribute,
          value = value,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiAttributeValue: Encoder[AttributeValue] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("attribute" -> t.attribute.asJson),
        Some("value" -> t.value.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiAttributeValueForm: Decoder[AttributeValueForm] = Decoder.instance { c =>
     for {
        value <- c.downField("value").as[String]
      } yield {
        AttributeValueForm(
          value = value
        )
      }
    }

    implicit def encodeApibuilderApiAttributeValueForm: Encoder[AttributeValueForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("value" -> t.value.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiAuthentication: Decoder[Authentication] = Decoder.instance { c =>
     for {
        user <- c.downField("user").as[io.apibuilder.api.v0.models.User]
        session <- c.downField("session").as[io.apibuilder.api.v0.models.Session]
      } yield {
        Authentication(
          user = user,
          session = session
        )
      }
    }

    implicit def encodeApibuilderApiAuthentication: Encoder[Authentication] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user" -> t.user.asJson),
        Some("session" -> t.session.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiBatchDownloadApplicationForm: Decoder[BatchDownloadApplicationForm] = Decoder.instance { c =>
     for {
        applicationKey <- c.downField("application_key").as[String]
        version <- c.downField("version").as[String]
      } yield {
        BatchDownloadApplicationForm(
          applicationKey = applicationKey,
          version = version
        )
      }
    }

    implicit def encodeApibuilderApiBatchDownloadApplicationForm: Encoder[BatchDownloadApplicationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("application_key" -> t.applicationKey.asJson),
        Some("version" -> t.version.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiBatchDownloadApplications: Decoder[BatchDownloadApplications] = Decoder.instance { c =>
     for {
        applications <- c.downField("applications").as[Seq[io.apibuilder.api.v0.models.Version]]
      } yield {
        BatchDownloadApplications(
          applications = applications
        )
      }
    }

    implicit def encodeApibuilderApiBatchDownloadApplications: Encoder[BatchDownloadApplications] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("applications" -> t.applications.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiBatchDownloadApplicationsForm: Decoder[BatchDownloadApplicationsForm] = Decoder.instance { c =>
     for {
        applications <- c.downField("applications").as[Seq[io.apibuilder.api.v0.models.BatchDownloadApplicationForm]]
      } yield {
        BatchDownloadApplicationsForm(
          applications = applications
        )
      }
    }

    implicit def encodeApibuilderApiBatchDownloadApplicationsForm: Encoder[BatchDownloadApplicationsForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("applications" -> t.applications.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiChange: Decoder[Change] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[io.apibuilder.common.v0.models.Reference]
        application <- c.downField("application").as[io.apibuilder.common.v0.models.Reference]
        fromVersion <- c.downField("from_version").as[io.apibuilder.api.v0.models.ChangeVersion]
        toVersion <- c.downField("to_version").as[io.apibuilder.api.v0.models.ChangeVersion]
        diff <- c.downField("diff").as[io.apibuilder.api.v0.models.Diff]
        changedAt <- c.downField("changed_at").as[_root_.java.time.Instant]
        changedBy <- c.downField("changed_by").as[io.apibuilder.api.v0.models.UserSummary]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Change(
          guid = guid,
          organization = organization,
          application = application,
          fromVersion = fromVersion,
          toVersion = toVersion,
          diff = diff,
          changedAt = changedAt,
          changedBy = changedBy,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiChange: Encoder[Change] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("from_version" -> t.fromVersion.asJson),
        Some("to_version" -> t.toVersion.asJson),
        Some("diff" -> t.diff.asJson),
        Some("changed_at" -> t.changedAt.asJson),
        Some("changed_by" -> t.changedBy.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiChangeVersion: Decoder[ChangeVersion] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        version <- c.downField("version").as[String]
      } yield {
        ChangeVersion(
          guid = guid,
          version = version
        )
      }
    }

    implicit def encodeApibuilderApiChangeVersion: Encoder[ChangeVersion] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("version" -> t.version.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiCleartextToken: Decoder[CleartextToken] = Decoder.instance { c =>
     for {
        token <- c.downField("token").as[String]
      } yield {
        CleartextToken(
          token = token
        )
      }
    }

    implicit def encodeApibuilderApiCleartextToken: Encoder[CleartextToken] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("token" -> t.token.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiCode: Decoder[Code] = Decoder.instance { c =>
     for {
        generator <- c.downField("generator").as[io.apibuilder.api.v0.models.GeneratorWithService]
        source <- c.downField("source").as[String]
        files <- c.downField("files").as[Seq[io.apibuilder.generator.v0.models.File]]
      } yield {
        Code(
          generator = generator,
          source = source,
          files = files
        )
      }
    }

    implicit def encodeApibuilderApiCode: Encoder[Code] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("generator" -> t.generator.asJson),
        Some("source" -> t.source.asJson),
        Some("files" -> t.files.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiCodeForm: Decoder[CodeForm] = Decoder.instance { c =>
     for {
        attributes <- c.downField("attributes").as[Seq[io.apibuilder.generator.v0.models.Attribute]]
      } yield {
        CodeForm(
          attributes = attributes
        )
      }
    }

    implicit def encodeApibuilderApiCodeForm: Encoder[CodeForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("attributes" -> t.attributes.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiDiffBreaking: Decoder[DiffBreaking] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
        isMaterial <- c.downField("is_material").as[Boolean]
      } yield {
        DiffBreaking(
          description = description,
          isMaterial = isMaterial
        )
      }
    }

    implicit def encodeApibuilderApiDiffBreaking: Encoder[DiffBreaking] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson),
        Some("is_material" -> t.isMaterial.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiDiffNonBreaking: Decoder[DiffNonBreaking] = Decoder.instance { c =>
     for {
        description <- c.downField("description").as[String]
        isMaterial <- c.downField("is_material").as[Boolean]
      } yield {
        DiffNonBreaking(
          description = description,
          isMaterial = isMaterial
        )
      }
    }

    implicit def encodeApibuilderApiDiffNonBreaking: Encoder[DiffNonBreaking] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.asJson),
        Some("is_material" -> t.isMaterial.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiDomain: Decoder[Domain] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
      } yield {
        Domain(
          name = name
        )
      }
    }

    implicit def encodeApibuilderApiDomain: Encoder[Domain] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiEmailVerificationConfirmationForm: Decoder[EmailVerificationConfirmationForm] = Decoder.instance { c =>
     for {
        token <- c.downField("token").as[String]
      } yield {
        EmailVerificationConfirmationForm(
          token = token
        )
      }
    }

    implicit def encodeApibuilderApiEmailVerificationConfirmationForm: Encoder[EmailVerificationConfirmationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("token" -> t.token.asJson)
      ).flatten)
    }

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

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

    implicit def decodeApibuilderApiGeneratorForm: Decoder[GeneratorForm] = Decoder.instance { c =>
     for {
        serviceGuid <- c.downField("service_guid").as[_root_.java.util.UUID]
        generator <- c.downField("generator").as[io.apibuilder.generator.v0.models.Generator]
      } yield {
        GeneratorForm(
          serviceGuid = serviceGuid,
          generator = generator
        )
      }
    }

    implicit def encodeApibuilderApiGeneratorForm: Encoder[GeneratorForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("service_guid" -> t.serviceGuid.asJson),
        Some("generator" -> t.generator.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiGeneratorService: Decoder[GeneratorService] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        uri <- c.downField("uri").as[String]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        GeneratorService(
          guid = guid,
          uri = uri,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiGeneratorService: Encoder[GeneratorService] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("uri" -> t.uri.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiGeneratorServiceForm: Decoder[GeneratorServiceForm] = Decoder.instance { c =>
     for {
        uri <- c.downField("uri").as[String]
      } yield {
        GeneratorServiceForm(
          uri = uri
        )
      }
    }

    implicit def encodeApibuilderApiGeneratorServiceForm: Encoder[GeneratorServiceForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("uri" -> t.uri.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiGeneratorWithService: Decoder[GeneratorWithService] = Decoder.instance { c =>
     for {
        service <- c.downField("service").as[io.apibuilder.api.v0.models.GeneratorService]
        generator <- c.downField("generator").as[io.apibuilder.generator.v0.models.Generator]
      } yield {
        GeneratorWithService(
          service = service,
          generator = generator
        )
      }
    }

    implicit def encodeApibuilderApiGeneratorWithService: Encoder[GeneratorWithService] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("service" -> t.service.asJson),
        Some("generator" -> t.generator.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiItem: Decoder[Item] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        detail <- c.downField("detail").as[io.apibuilder.api.v0.models.ItemDetail]
        label <- c.downField("label").as[String]
        description <- c.downField("description").as[Option[String]]
      } yield {
        Item(
          guid = guid,
          detail = detail,
          label = label,
          description = description
        )
      }
    }

    implicit def encodeApibuilderApiItem: Encoder[Item] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("detail" -> t.detail.asJson),
        Some("label" -> t.label.asJson),
        t.description.map(t => "description" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiMembership: Decoder[Membership] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[io.apibuilder.api.v0.models.User]
        organization <- c.downField("organization").as[io.apibuilder.api.v0.models.Organization]
        role <- c.downField("role").as[io.apibuilder.common.v0.models.MembershipRole]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Membership(
          guid = guid,
          user = user,
          organization = organization,
          role = role,
          audit = audit
        )
      }
    }

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

    implicit def decodeApibuilderApiMembershipRequest: Decoder[MembershipRequest] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[io.apibuilder.api.v0.models.User]
        organization <- c.downField("organization").as[io.apibuilder.api.v0.models.Organization]
        role <- c.downField("role").as[io.apibuilder.common.v0.models.MembershipRole]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        MembershipRequest(
          guid = guid,
          user = user,
          organization = organization,
          role = role,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiMembershipRequest: Encoder[MembershipRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("organization" -> t.organization.asJson),
        Some("role" -> t.role.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiMoveForm: Decoder[MoveForm] = Decoder.instance { c =>
     for {
        orgKey <- c.downField("org_key").as[String]
      } yield {
        MoveForm(
          orgKey = orgKey
        )
      }
    }

    implicit def encodeApibuilderApiMoveForm: Encoder[MoveForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("org_key" -> t.orgKey.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiOrganization: Decoder[Organization] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        key <- c.downField("key").as[String]
        name <- c.downField("name").as[String]
        namespace <- c.downField("namespace").as[String]
        visibility <- c.downField("visibility").as[io.apibuilder.api.v0.models.Visibility]
        domains <- c.downField("domains").as[Seq[io.apibuilder.api.v0.models.Domain]]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Organization(
          guid = guid,
          key = key,
          name = name,
          namespace = namespace,
          visibility = visibility,
          domains = domains,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiOrganization: Encoder[Organization] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("key" -> t.key.asJson),
        Some("name" -> t.name.asJson),
        Some("namespace" -> t.namespace.asJson),
        Some("visibility" -> t.visibility.asJson),
        Some("domains" -> t.domains.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiOrganizationForm: Decoder[OrganizationForm] = Decoder.instance { c =>
     for {
        name <- c.downField("name").as[String]
        key <- c.downField("key").as[Option[String]]
        namespace <- c.downField("namespace").as[String]
        visibility <- c.downField("visibility").as[io.apibuilder.api.v0.models.Visibility]
        domains <- c.downField("domains").as[Option[Seq[String]]]
      } yield {
        OrganizationForm(
          name = name,
          key = key,
          namespace = namespace,
          visibility = visibility,
          domains = domains
        )
      }
    }

    implicit def encodeApibuilderApiOrganizationForm: Encoder[OrganizationForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("name" -> t.name.asJson),
        t.key.map(t => "key" -> t.asJson),
        Some("namespace" -> t.namespace.asJson),
        Some("visibility" -> t.visibility.asJson),
        t.domains.map(t => "domains" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiOriginal: Decoder[Original] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[io.apibuilder.api.v0.models.OriginalType]
        data <- c.downField("data").as[String]
      } yield {
        Original(
          `type` = __type__,
          data = data
        )
      }
    }

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

    implicit def decodeApibuilderApiOriginalForm: Decoder[OriginalForm] = Decoder.instance { c =>
     for {
        __type__ <- c.downField("type").as[Option[io.apibuilder.api.v0.models.OriginalType]]
        data <- c.downField("data").as[String]
      } yield {
        OriginalForm(
          `type` = __type__,
          data = data
        )
      }
    }

    implicit def encodeApibuilderApiOriginalForm: Encoder[OriginalForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        t.`type`.map(t => "type" -> t.asJson),
        Some("data" -> t.data.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiPasswordReset: Decoder[PasswordReset] = Decoder.instance { c =>
     for {
        token <- c.downField("token").as[String]
        password <- c.downField("password").as[String]
      } yield {
        PasswordReset(
          token = token,
          password = password
        )
      }
    }

    implicit def encodeApibuilderApiPasswordReset: Encoder[PasswordReset] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("token" -> t.token.asJson),
        Some("password" -> t.password.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiPasswordResetRequest: Decoder[PasswordResetRequest] = Decoder.instance { c =>
     for {
        email <- c.downField("email").as[String]
      } yield {
        PasswordResetRequest(
          email = email
        )
      }
    }

    implicit def encodeApibuilderApiPasswordResetRequest: Encoder[PasswordResetRequest] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("email" -> t.email.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiSession: Decoder[Session] = Decoder.instance { c =>
     for {
        id <- c.downField("id").as[String]
        expiresAt <- c.downField("expires_at").as[_root_.java.time.Instant]
      } yield {
        Session(
          id = id,
          expiresAt = expiresAt
        )
      }
    }

    implicit def encodeApibuilderApiSession: Encoder[Session] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("id" -> t.id.asJson),
        Some("expires_at" -> t.expiresAt.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiSubscription: Decoder[Subscription] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[io.apibuilder.api.v0.models.Organization]
        user <- c.downField("user").as[io.apibuilder.api.v0.models.User]
        publication <- c.downField("publication").as[io.apibuilder.api.v0.models.Publication]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Subscription(
          guid = guid,
          organization = organization,
          user = user,
          publication = publication,
          audit = audit
        )
      }
    }

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

    implicit def decodeApibuilderApiSubscriptionForm: Decoder[SubscriptionForm] = Decoder.instance { c =>
     for {
        organizationKey <- c.downField("organization_key").as[String]
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
        publication <- c.downField("publication").as[io.apibuilder.api.v0.models.Publication]
      } yield {
        SubscriptionForm(
          organizationKey = organizationKey,
          userGuid = userGuid,
          publication = publication
        )
      }
    }

    implicit def encodeApibuilderApiSubscriptionForm: Encoder[SubscriptionForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("organization_key" -> t.organizationKey.asJson),
        Some("user_guid" -> t.userGuid.asJson),
        Some("publication" -> t.publication.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiToken: Decoder[Token] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[io.apibuilder.api.v0.models.User]
        maskedToken <- c.downField("masked_token").as[String]
        description <- c.downField("description").as[Option[String]]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Token(
          guid = guid,
          user = user,
          maskedToken = maskedToken,
          description = description,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiToken: Encoder[Token] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("masked_token" -> t.maskedToken.asJson),
        t.description.map(t => "description" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiTokenForm: Decoder[TokenForm] = Decoder.instance { c =>
     for {
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
        description <- c.downField("description").as[Option[String]]
      } yield {
        TokenForm(
          userGuid = userGuid,
          description = description
        )
      }
    }

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

    implicit def decodeApibuilderApiUser: Decoder[User] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        email <- c.downField("email").as[String]
        nickname <- c.downField("nickname").as[String]
        name <- c.downField("name").as[Option[String]]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        User(
          guid = guid,
          email = email,
          nickname = nickname,
          name = name,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiUser: Encoder[User] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("email" -> t.email.asJson),
        Some("nickname" -> t.nickname.asJson),
        t.name.map(t => "name" -> t.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiUserForm: Decoder[UserForm] = Decoder.instance { c =>
     for {
        email <- c.downField("email").as[String]
        password <- c.downField("password").as[String]
        nickname <- c.downField("nickname").as[Option[String]]
        name <- c.downField("name").as[Option[String]]
      } yield {
        UserForm(
          email = email,
          password = password,
          nickname = nickname,
          name = name
        )
      }
    }

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

    implicit def decodeApibuilderApiUserSummary: Decoder[UserSummary] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        nickname <- c.downField("nickname").as[String]
      } yield {
        UserSummary(
          guid = guid,
          nickname = nickname
        )
      }
    }

    implicit def encodeApibuilderApiUserSummary: Encoder[UserSummary] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("nickname" -> t.nickname.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiUserUpdateForm: Decoder[UserUpdateForm] = Decoder.instance { c =>
     for {
        email <- c.downField("email").as[String]
        nickname <- c.downField("nickname").as[String]
        name <- c.downField("name").as[Option[String]]
      } yield {
        UserUpdateForm(
          email = email,
          nickname = nickname,
          name = name
        )
      }
    }

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

    implicit def decodeApibuilderApiValidation: Decoder[Validation] = Decoder.instance { c =>
     for {
        valid <- c.downField("valid").as[Boolean]
        errors <- c.downField("errors").as[Seq[String]]
      } yield {
        Validation(
          valid = valid,
          errors = errors
        )
      }
    }

    implicit def encodeApibuilderApiValidation: Encoder[Validation] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("valid" -> t.valid.asJson),
        Some("errors" -> t.errors.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiVersion: Decoder[Version] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        organization <- c.downField("organization").as[io.apibuilder.common.v0.models.Reference]
        application <- c.downField("application").as[io.apibuilder.common.v0.models.Reference]
        version <- c.downField("version").as[String]
        original <- c.downField("original").as[Option[io.apibuilder.api.v0.models.Original]]
        service <- c.downField("service").as[io.apibuilder.spec.v0.models.Service]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Version(
          guid = guid,
          organization = organization,
          application = application,
          version = version,
          original = original,
          service = service,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiVersion: Encoder[Version] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("version" -> t.version.asJson),
        t.original.map(t => "original" -> t.asJson),
        Some("service" -> t.service.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiVersionForm: Decoder[VersionForm] = Decoder.instance { c =>
     for {
        originalForm <- c.downField("original_form").as[io.apibuilder.api.v0.models.OriginalForm]
        visibility <- c.downField("visibility").as[Option[io.apibuilder.api.v0.models.Visibility]]
      } yield {
        VersionForm(
          originalForm = originalForm,
          visibility = visibility
        )
      }
    }

    implicit def encodeApibuilderApiVersionForm: Encoder[VersionForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("original_form" -> t.originalForm.asJson),
        t.visibility.map(t => "visibility" -> t.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiWatch: Decoder[Watch] = Decoder.instance { c =>
     for {
        guid <- c.downField("guid").as[_root_.java.util.UUID]
        user <- c.downField("user").as[io.apibuilder.api.v0.models.User]
        organization <- c.downField("organization").as[io.apibuilder.api.v0.models.Organization]
        application <- c.downField("application").as[io.apibuilder.api.v0.models.Application]
        audit <- c.downField("audit").as[io.apibuilder.common.v0.models.Audit]
      } yield {
        Watch(
          guid = guid,
          user = user,
          organization = organization,
          application = application,
          audit = audit
        )
      }
    }

    implicit def encodeApibuilderApiWatch: Encoder[Watch] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("guid" -> t.guid.asJson),
        Some("user" -> t.user.asJson),
        Some("organization" -> t.organization.asJson),
        Some("application" -> t.application.asJson),
        Some("audit" -> t.audit.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiWatchForm: Decoder[WatchForm] = Decoder.instance { c =>
     for {
        userGuid <- c.downField("user_guid").as[_root_.java.util.UUID]
        organizationKey <- c.downField("organization_key").as[String]
        applicationKey <- c.downField("application_key").as[String]
      } yield {
        WatchForm(
          userGuid = userGuid,
          organizationKey = organizationKey,
          applicationKey = applicationKey
        )
      }
    }

    implicit def encodeApibuilderApiWatchForm: Encoder[WatchForm] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("user_guid" -> t.userGuid.asJson),
        Some("organization_key" -> t.organizationKey.asJson),
        Some("application_key" -> t.applicationKey.asJson)
      ).flatten)
    }

    implicit def decodeApibuilderApiDiff: Decoder[Diff] = Decoder.instance { c =>
      c.get[Option[String]]("type") match {
        case Right(Some(s)) if s == "diff_breaking" => c.as[io.apibuilder.api.v0.models.DiffBreaking]
        case Right(Some(s)) if s == "diff_non_breaking" => c.as[io.apibuilder.api.v0.models.DiffNonBreaking]
        case Right(Some(s)) => Right(io.apibuilder.api.v0.models.DiffUndefinedType(s))
        case _ => Left(DecodingFailure("Union[Diff] requires a discriminator named 'type' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeApibuilderApiDiff: Encoder[Diff] = Encoder.instance {
      case t: io.apibuilder.api.v0.models.DiffBreaking => t.asJson.mapObject(obj => ("type", Json.fromString("diff_breaking")) +: obj)
      case t: io.apibuilder.api.v0.models.DiffNonBreaking => t.asJson.mapObject(obj => ("type", Json.fromString("diff_non_breaking")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }

    implicit def decodeApibuilderApiItemDetail: Decoder[ItemDetail] = Decoder.instance { c =>
      c.get[Option[String]]("type") match {
        case Right(Some(s)) if s == "application_summary" => c.as[io.apibuilder.api.v0.models.ApplicationSummary]
        case Right(Some(s)) => Right(io.apibuilder.api.v0.models.ItemDetailUndefinedType(s))
        case _ => Left(DecodingFailure("Union[ItemDetail] requires a discriminator named 'type' - this field was not found in the Json", c.history))
      }
    }

    implicit def encodeApibuilderApiItemDetail: Encoder[ItemDetail] = Encoder.instance {
      case t: io.apibuilder.api.v0.models.ApplicationSummary => t.asJson.mapObject(obj => ("type", Json.fromString("application_summary")) +: obj)
      case other => sys.error(s"The type[${other.getClass.getName}] has no JSON encoder")
    }
  }
}