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

  /**
   * Represents a single diff in an application
   */
  sealed trait Diff extends _root_.scala.Product with _root_.scala.Serializable {
    def diffType: DiffType
  }

  /**
   * Defines the valid type values for the type Diff
   */
  sealed trait DiffType extends _root_.scala.Product with _root_.scala.Serializable

  object DiffType {

    case object DiffBreaking extends DiffType { override def toString = "diff_breaking" }
    case object DiffNonBreaking extends DiffType { override def toString = "diff_non_breaking" }

    final case class UNDEFINED(override val toString: String) extends DiffType

    val all: scala.List[DiffType] = scala.List(DiffBreaking, DiffNonBreaking)

    private val byName: Map[String, DiffType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): DiffType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[DiffType] = byName.get(value.toLowerCase)

  }

  /**
   * Identifies the specific type of item that was indexed by search
   */
  sealed trait ItemDetail extends _root_.scala.Product with _root_.scala.Serializable {
    def itemDetailType: ItemDetailType
  }

  /**
   * Defines the valid type values for the type ItemDetail
   */
  sealed trait ItemDetailType extends _root_.scala.Product with _root_.scala.Serializable

  object ItemDetailType {

    /**
     * Represents that the item indexed was an application
     */
    case object ApplicationSummary extends ItemDetailType { override def toString = "application_summary" }

    final case class UNDEFINED(override val toString: String) extends ItemDetailType

    val all: scala.List[ItemDetailType] = scala.List(ApplicationSummary)

    private val byName: Map[String, ItemDetailType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): ItemDetailType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[ItemDetailType] = byName.get(value.toLowerCase)

  }
  /**
   * An application has a name and multiple versions of its API.
   *
   * @param guid Internal unique identifier for this application.
   * @param name The unique name for this application.
   * @param key Used as a unique key in the URL path. Key is automatically derived from the
   *        application name.
   * @param visibility Controls who is able to view this application
   */

  final case class Application(
    guid: _root_.java.util.UUID,
    organization: io.apibuilder.common.v0.models.Reference,
    name: String,
    key: String,
    visibility: io.apibuilder.api.v0.models.Visibility,
    description: _root_.scala.Option[String] = None,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * @param key Defaults to a key generated from the application name
   */

  final case class ApplicationForm(
    name: String,
    key: _root_.scala.Option[String] = None,
    description: _root_.scala.Option[String] = None,
    visibility: io.apibuilder.api.v0.models.Visibility
  )

  /**
   * Summary of an application sufficient for display and links
   */

  final case class ApplicationSummary(
    guid: _root_.java.util.UUID,
    organization: io.apibuilder.common.v0.models.Reference,
    key: String
  ) extends ItemDetail {
    override val itemDetailType: ItemDetailType = ItemDetailType.ApplicationSummary
  }

  /**
   * Attributes are globally unique key which allow users to specify additional
   * content to pass in to the code generators.
   *
   * @param guid Internal unique identifier for this attribute.
   * @param name The name of the attribute. Globally unique and an 'identifier' (lower case, url
   *        safe, etc.)
   * @param description Optional description - a good description here will indicate which code
   *        generators it applies to and what effect it will have on those code generators.
   */

  final case class Attribute(
    guid: _root_.java.util.UUID,
    name: String,
    description: _root_.scala.Option[String] = None,
    audit: io.apibuilder.common.v0.models.Audit
  )

  final case class AttributeForm(
    name: String,
    description: _root_.scala.Option[String] = None
  )

  /**
   * @param guid Internal unique identifier for this attribute.
   * @param name The name of the attribute. Globally unique and an 'identifier' (lower case, url
   *        safe, etc.)
   */

  final case class AttributeSummary(
    guid: _root_.java.util.UUID,
    name: String
  )

  /**
   * Attribute values can be set at different levels. Initially we support setting
   * organization wide attributes, but in the future plan to support setting
   * attribute values with each version of the application.
   *
   * @param guid Internal unique identifier for this attribute value.
   */

  final case class AttributeValue(
    guid: _root_.java.util.UUID,
    attribute: io.apibuilder.api.v0.models.AttributeSummary,
    value: String,
    audit: io.apibuilder.common.v0.models.Audit
  )

  final case class AttributeValueForm(
    value: String
  )

  /**
   * Represents the result of a successful authorization
   */

  final case class Authentication(
    user: io.apibuilder.api.v0.models.User,
    session: io.apibuilder.api.v0.models.Session
  )

  /**
   * Represents a single change from one version of a service to another
   *
   * @param changedAt Records the timestamp of when the actual change occurred (vs. when we created
   *        the changed record)
   * @param changedBy Records who made the actual change
   */

  final case class Change(
    guid: _root_.java.util.UUID,
    organization: io.apibuilder.common.v0.models.Reference,
    application: io.apibuilder.common.v0.models.Reference,
    fromVersion: io.apibuilder.api.v0.models.ChangeVersion,
    toVersion: io.apibuilder.api.v0.models.ChangeVersion,
    diff: io.apibuilder.api.v0.models.Diff,
    changedAt: _root_.org.joda.time.DateTime,
    changedBy: io.apibuilder.api.v0.models.UserSummary,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * Represents a simpler model of a version specifically for the use case of
   * displaying changes
   */

  final case class ChangeVersion(
    guid: _root_.java.util.UUID,
    version: String
  )

  /**
   * Separate resource used only for the few actions that require the full token.
   *
   * @param token The actual token. Guaranteed to be globally unique.
   */

  final case class CleartextToken(
    token: String
  )

  /**
   * Generated source code.
   *
   * @param source The actual source code.
   * @param files A collection of source files
   */

  final case class Code(
    generator: io.apibuilder.api.v0.models.GeneratorWithService,
    @deprecated("Use files instead") source: String,
    files: Seq[io.apibuilder.generator.v0.models.File] = Nil
  )

  /**
   * Represents a single breaking diff of an application version. A breaking diff
   * indicates that it is possible for an existing client to now experience an error
   * or invalid data due to the diff.
   */

  final case class DiffBreaking(
    description: String
  ) extends Diff {
    override val diffType: DiffType = DiffType.DiffBreaking
  }

  /**
   * Represents a single NON breaking diff of an application version.
   */

  final case class DiffNonBreaking(
    description: String
  ) extends Diff {
    override val diffType: DiffType = DiffType.DiffNonBreaking
  }

  /**
   * Represents a single domain name (e.g. www.apibuilder.io). When a new user
   * registers and confirms their email, we automatically associate that user with a
   * member of the organization associated with their domain. For example, if you
   * confirm your account with an email address of example@somedomain.com, we will
   * automatically create a membership request on your behalf to join the
   * organization with domain somedomain.com.
   *
   * @param name The domain name
   */

  final case class Domain(
    name: String
  )

  /**
   * Data used to confirm an email address. The token is an internal unique
   * identifier used to lookup the specific email address and user account for which
   * we sent an email verification email.
   */

  final case class EmailVerificationConfirmationForm(
    token: String
  )

  /**
   * @param code Machine readable code for this specific error message
   * @param message Description of the error
   */

  final case class Error(
    code: String,
    message: String
  )

  final case class GeneratorForm(
    serviceGuid: _root_.java.util.UUID,
    generator: io.apibuilder.generator.v0.models.Generator
  )

  /**
   * Defines a service that provides one or more code generators
   */

  final case class GeneratorService(
    guid: _root_.java.util.UUID,
    uri: String,
    audit: io.apibuilder.common.v0.models.Audit
  )

  final case class GeneratorServiceForm(
    uri: String
  )

  /**
   * Wraps a service and a generator providing easier access for applications.
   */

  final case class GeneratorWithService(
    service: io.apibuilder.api.v0.models.GeneratorService,
    generator: io.apibuilder.generator.v0.models.Generator
  )

  /**
   * When searching for content, the results of the search will be a list of items.
   * Each item will have enough information to render for the user, including a type
   * and item_guid to enable creating the appropriate link.
   *
   * @param guid Unique identifer for this item. By using a UUID, you can combine with the type
   *        to figure out the URI for the resource
   */

  final case class Item(
    guid: _root_.java.util.UUID,
    detail: io.apibuilder.api.v0.models.ItemDetail,
    label: String,
    description: _root_.scala.Option[String] = None
  )

  /**
   * A membership represents a user in a specific role to an organization.
   * Memberships cannot be created directly. Instead you first create a membership
   * request, then that request is either accepted or declined.
   *
   * @param guid Internal unique identifier for this membership.
   * @param role The role this user plays for this organization. Typically member or admin.
   */

  final case class Membership(
    guid: _root_.java.util.UUID,
    user: io.apibuilder.api.v0.models.User,
    organization: io.apibuilder.api.v0.models.Organization,
    role: String,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * A membership request represents a user requesting to join an organization with a
   * specific role (e.g. as a member or an admin). Membership requests can be
   * reviewed by any current admin of the organization who can either accept or
   * decline the request.
   *
   * @param guid Internal unique identifier for this membership request.
   * @param role The requested role for membership to this organization. Typically member or
   *        admin.
   */

  final case class MembershipRequest(
    guid: _root_.java.util.UUID,
    user: io.apibuilder.api.v0.models.User,
    organization: io.apibuilder.api.v0.models.Organization,
    role: String,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * @param orgKey The key of the organization to which we are moving this item
   */

  final case class MoveForm(
    orgKey: String
  )

  /**
   * An organization is used to group a set of applications together.
   *
   * @param guid Internal unique identifier for this organization.
   * @param key Used as a unique key in the URL path. Key is automatically derived from the
   *        organization name.
   * @param name The name of this organization.
   * @param namespace Global namespace for this organization.
   */

  final case class Organization(
    guid: _root_.java.util.UUID,
    key: String,
    name: String,
    namespace: String,
    visibility: io.apibuilder.api.v0.models.Visibility,
    domains: Seq[io.apibuilder.api.v0.models.Domain] = Nil,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * @param key Defaults to a url friendy version of the name
   * @param namespace Global namespace for this organization.
   * @param visibility Public organizations will be listed in apibuilder directory. Organizations with
   *        visibility organization will only be visible to members of that org.
   */

  final case class OrganizationForm(
    name: String,
    key: _root_.scala.Option[String] = None,
    namespace: String,
    visibility: io.apibuilder.api.v0.models.Visibility = io.apibuilder.api.v0.models.Visibility.Organization,
    domains: _root_.scala.Option[Seq[String]] = None
  )

  /**
   * Represents the original input used to create an application version
   */

  final case class Original(
    `type`: io.apibuilder.api.v0.models.OriginalType,
    data: String
  )

  /**
   * @param `type` If not specified, we set the type by inspecting the data
   */

  final case class OriginalForm(
    `type`: _root_.scala.Option[io.apibuilder.api.v0.models.OriginalType] = None,
    data: String
  )

  /**
   * Allows a user to change their password with authentication from a token.
   *
   * @param token Unique one time use token to change a password
   */

  final case class PasswordReset(
    token: String,
    password: String
  )

  /**
   * Create a password reset request - e.g. an email containing a one time URL to
   * change a password
   *
   * @param email The email address for which we generate the password reset.
   */

  final case class PasswordResetRequest(
    email: String
  )

  /**
   * Represents a user sessions (e.g. user logged into site)
   *
   * @param id Cryptographically secure session id
   */

  final case class Session(
    id: String,
    expiresAt: _root_.org.joda.time.DateTime
  )

  /**
   * Represents a user that is currently subscribed to a publication
   *
   * @param guid Internal unique identifier for this subscription record
   */

  final case class Subscription(
    guid: _root_.java.util.UUID,
    organization: io.apibuilder.api.v0.models.Organization,
    user: io.apibuilder.api.v0.models.User,
    publication: io.apibuilder.api.v0.models.Publication,
    audit: io.apibuilder.common.v0.models.Audit
  )

  final case class SubscriptionForm(
    organizationKey: String,
    userGuid: _root_.java.util.UUID,
    publication: io.apibuilder.api.v0.models.Publication
  )

  /**
   * A token gives a user access to the API.
   *
   * @param guid Internal unique identifier for this token.
   * @param user The user to which this token belongs.
   * @param maskedToken The masked from of the token.
   * @param description optional description to help the user manage the token.
   */

  final case class Token(
    guid: _root_.java.util.UUID,
    user: io.apibuilder.api.v0.models.User,
    maskedToken: String,
    description: _root_.scala.Option[String] = None,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * @param userGuid The user for which we are creating the token.
   */

  final case class TokenForm(
    userGuid: _root_.java.util.UUID,
    description: _root_.scala.Option[String] = None
  )

  /**
   * A user is a top level person interacting with the api doc server.
   *
   * @param guid Internal unique identifier for this user.
   * @param nickname Public unique identifier for this user.
   */

  final case class User(
    guid: _root_.java.util.UUID,
    email: String,
    nickname: String,
    name: _root_.scala.Option[String] = None,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * @param nickname Defaults to a unique identifier based on email address
   */

  final case class UserForm(
    email: String,
    password: String,
    nickname: _root_.scala.Option[String] = None,
    name: _root_.scala.Option[String] = None
  )

  /**
   * Summary of a user sufficient for display
   */

  final case class UserSummary(
    guid: _root_.java.util.UUID,
    nickname: String
  )

  final case class UserUpdateForm(
    email: String,
    nickname: String,
    name: _root_.scala.Option[String] = None
  )

  /**
   * Used only to validate json files - used as a resource where http status code
   * defines success
   *
   * @param valid If true, the json schema is valid. If false, there is at least one validation
   *        error.
   * @param errors Contains any validation errors that result from parsing the json document. If
   *        empty, the document is valid.
   */

  final case class Validation(
    valid: Boolean,
    errors: Seq[String] = Nil
  )

  /**
   * Represents a unique version of the application.
   *
   * @param guid Internal unique identifier for this version.
   * @param version The tag for this version. Can be anything, but if semver style version number is
   *        used, we automatically correctly sort by version number to find latest.
   *        Otherwise latest version is considered to be the most recently created.
   * @param original The original uploaded file describing this version, if available
   * @param service spec/spec.json description of this API
   */

  final case class Version(
    guid: _root_.java.util.UUID,
    organization: io.apibuilder.common.v0.models.Reference,
    application: io.apibuilder.common.v0.models.Reference,
    version: String,
    original: _root_.scala.Option[io.apibuilder.api.v0.models.Original] = None,
    service: io.apibuilder.spec.v0.models.Service,
    audit: io.apibuilder.common.v0.models.Audit
  )

  /**
   * @param visibility If provided, updates the visibility for all versions of this application
   */

  final case class VersionForm(
    originalForm: io.apibuilder.api.v0.models.OriginalForm,
    visibility: _root_.scala.Option[io.apibuilder.api.v0.models.Visibility] = None
  )

  /**
   * Users can watch individual applications which enables features like receiving an
   * email notification when there is a new version of an application.
   *
   * @param guid Internal unique identifier for this watch
   */

  final case class Watch(
    guid: _root_.java.util.UUID,
    user: io.apibuilder.api.v0.models.User,
    organization: io.apibuilder.api.v0.models.Organization,
    application: io.apibuilder.api.v0.models.Application,
    audit: io.apibuilder.common.v0.models.Audit
  )

  final case class WatchForm(
    userGuid: _root_.java.util.UUID,
    organizationKey: String,
    applicationKey: String
  )

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union Diff, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class DiffUndefinedType(
    description: String
  ) extends Diff {
    override val diffType: DiffType = DiffType.UNDEFINED(description)
  }

  /**
   * Provides future compatibility in clients - in the future, when a type is added
   * to the union ItemDetail, it will need to be handled in the client code. This
   * implementation will deserialize these future types as an instance of this class.
   *
   * @param description Information about the type that we received that is undefined in this version of
   *        the client.
   */

  final case class ItemDetailUndefinedType(
    description: String
  ) extends ItemDetail {
    override val itemDetailType: ItemDetailType = ItemDetailType.UNDEFINED(description)
  }
  sealed trait OriginalType extends _root_.scala.Product with _root_.scala.Serializable

  object OriginalType {

    /**
     * The original is in the api.json format
     */
    case object ApiJson extends OriginalType {
      override def toString = "api_json"
    }
    /**
     * The original is in Avro Idl format
     */
    case object AvroIdl extends OriginalType {
      override def toString = "avro_idl"
    }
    /**
     * This is the canonical service spec for apibuilder itself. See
     * https://www.apibuilder.io/apicollective/apibuilder-spec/latest#model-service
     */
    case object ServiceJson extends OriginalType {
      override def toString = "service_json"
    }
    /**
     * The original in the Swagger JSON or YAML format
     */
    case object Swagger extends OriginalType {
      override def toString = "swagger"
    }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends OriginalType

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[OriginalType] = scala.List(ApiJson, AvroIdl, ServiceJson, Swagger)

    private
    val byName: Map[String, OriginalType] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): OriginalType = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[OriginalType] = byName.get(value.toLowerCase)

  }

  /**
   * A publication represents something that a user can subscribe to. An example
   * would be subscribing to an email alert whenever a new version of an application
   * is created.
   */
  sealed trait Publication extends _root_.scala.Product with _root_.scala.Serializable

  object Publication {

    /**
     * For organizations for which I am an administrator, email me whenever a user
     * applies to join the org.
     */
    case object MembershipRequestsCreate extends Publication {
      override def toString = "membership_requests.create"
    }
    /**
     * For organizations for which I am a member, email me whenever a user joins the
     * org.
     */
    case object MembershipsCreate extends Publication {
      override def toString = "memberships.create"
    }
    /**
     * For organizations for which I am a member, email me whenever an application is
     * created.
     */
    case object ApplicationsCreate extends Publication {
      override def toString = "applications.create"
    }
    /**
     * For applications that I watch, email me whenever a version is created.
     */
    case object VersionsCreate extends Publication {
      override def toString = "versions.create"
    }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Publication

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Publication] = scala.List(MembershipRequestsCreate, MembershipsCreate, ApplicationsCreate, VersionsCreate)

    private
    val byName: Map[String, Publication] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Publication = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Publication] = byName.get(value.toLowerCase)

  }

  /**
   * Controls who is able to view this version
   */
  sealed trait Visibility extends _root_.scala.Product with _root_.scala.Serializable

  object Visibility {

    /**
     * Only the creator can view this application
     */
    case object User extends Visibility {
      override def toString = "user"
    }
    /**
     * Any member of the organization can view this application
     */
    case object Organization extends Visibility {
      override def toString = "organization"
    }
    /**
     * Anybody, including non logged in users, can view this application
     */
    case object Public extends Visibility {
      override def toString = "public"
    }
    /**
     * UNDEFINED captures values that are sent either in error or
     * that were added by the server after this library was
     * generated. We want to make it easy and obvious to users of
     * this library to handle this case gracefully.
     *
     * We use all CAPS for the variable name to avoid collisions
     * with the camel cased values above.
     */
    final case class UNDEFINED(override val toString: String) extends Visibility

    /**
     * all returns a list of all the valid, known values. We use
     * lower case to avoid collisions with the camel cased values
     * above.
     */
    val all: scala.List[Visibility] = scala.List(User, Organization, Public)

    private
    val byName: Map[String, Visibility] = all.map(x => x.toString.toLowerCase -> x).toMap

    def apply(value: String): Visibility = fromString(value).getOrElse(UNDEFINED(value))

    def fromString(value: String): _root_.scala.Option[Visibility] = byName.get(value.toLowerCase)

  }

}

package io.apibuilder.api.v0.models {

  package object json {
    import play.api.libs.json.__
    import play.api.libs.json.JsString
    import play.api.libs.json.Writes
    import play.api.libs.functional.syntax._
    import io.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[v0] implicit val jsonReadsUUID: play.api.libs.json.Reads[_root_.java.util.UUID] = __.read[String].map { str =>
      _root_.java.util.UUID.fromString(str)
    }

    private[v0] implicit val jsonWritesUUID: play.api.libs.json.Writes[_root_.java.util.UUID] = (x: _root_.java.util.UUID) => play.api.libs.json.JsString(x.toString)

    private[v0] implicit val jsonReadsJodaDateTime: play.api.libs.json.Reads[_root_.org.joda.time.DateTime] = __.read[String].map { str =>
      _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseDateTime(str)
    }

    private[v0] implicit val jsonWritesJodaDateTime: play.api.libs.json.Writes[_root_.org.joda.time.DateTime] = (x: _root_.org.joda.time.DateTime) => {
      play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(x))
    }

    private[v0] implicit val jsonReadsJodaLocalDate: play.api.libs.json.Reads[_root_.org.joda.time.LocalDate] = __.read[String].map { str =>
      _root_.org.joda.time.format.ISODateTimeFormat.dateTimeParser.parseLocalDate(str)
    }

    private[v0] implicit val jsonWritesJodaLocalDate: play.api.libs.json.Writes[_root_.org.joda.time.LocalDate] = (x: _root_.org.joda.time.LocalDate) => {
      play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.date.print(x))
    }

    implicit val jsonReadsApibuilderApiOriginalType: play.api.libs.json.Reads[io.apibuilder.api.v0.models.OriginalType] = new play.api.libs.json.Reads[io.apibuilder.api.v0.models.OriginalType] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.OriginalType] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.OriginalType(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.OriginalType(v))
              case _: play.api.libs.json.JsError =>
                (js \ "original_type").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.OriginalType(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesApibuilderApiOriginalType(obj: io.apibuilder.api.v0.models.OriginalType) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectOriginalType(obj: io.apibuilder.api.v0.models.OriginalType) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesApibuilderApiOriginalType: play.api.libs.json.Writes[OriginalType] = {
      (obj: io.apibuilder.api.v0.models.OriginalType) => {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiOriginalType(obj)
      }
    }

    implicit val jsonReadsApibuilderApiPublication: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Publication] = new play.api.libs.json.Reads[io.apibuilder.api.v0.models.Publication] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.Publication] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Publication(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Publication(v))
              case _: play.api.libs.json.JsError =>
                (js \ "publication").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Publication(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesApibuilderApiPublication(obj: io.apibuilder.api.v0.models.Publication) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectPublication(obj: io.apibuilder.api.v0.models.Publication) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesApibuilderApiPublication: play.api.libs.json.Writes[Publication] = {
      (obj: io.apibuilder.api.v0.models.Publication) => {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiPublication(obj)
      }
    }

    implicit val jsonReadsApibuilderApiVisibility: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Visibility] = new play.api.libs.json.Reads[io.apibuilder.api.v0.models.Visibility] {
      def reads(js: play.api.libs.json.JsValue): play.api.libs.json.JsResult[io.apibuilder.api.v0.models.Visibility] = {
        js match {
          case v: play.api.libs.json.JsString => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Visibility(v.value))
          case _ => {
            (js \ "value").validate[String] match {
              case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Visibility(v))
              case _: play.api.libs.json.JsError =>
                (js \ "visibility").validate[String] match {
                  case play.api.libs.json.JsSuccess(v, _) => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.Visibility(v))
                  case err: play.api.libs.json.JsError => err
                }
            }
          }
        }
      }
    }

    def jsonWritesApibuilderApiVisibility(obj: io.apibuilder.api.v0.models.Visibility) = {
      play.api.libs.json.JsString(obj.toString)
    }

    def jsObjectVisibility(obj: io.apibuilder.api.v0.models.Visibility) = {
      play.api.libs.json.Json.obj("value" -> play.api.libs.json.JsString(obj.toString))
    }

    implicit def jsonWritesApibuilderApiVisibility: play.api.libs.json.Writes[Visibility] = {
      (obj: io.apibuilder.api.v0.models.Visibility) => {
        io.apibuilder.api.v0.models.json.jsonWritesApibuilderApiVisibility(obj)
      }
    }

    implicit def jsonReadsApibuilderApiApplication: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Application] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
        name <- (__ \ "name").read[String]
        key <- (__ \ "key").read[String]
        visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
        description <- (__ \ "description").readNullable[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Application(guid, organization, name, key, visibility, description, audit)
    }

    def jsObjectApplication(obj: io.apibuilder.api.v0.models.Application): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
        "name" -> play.api.libs.json.JsString(obj.name),
        "key" -> play.api.libs.json.JsString(obj.key),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiApplication: play.api.libs.json.Writes[Application] = {
      (obj: io.apibuilder.api.v0.models.Application) => {
        io.apibuilder.api.v0.models.json.jsObjectApplication(obj)
      }
    }

    implicit def jsonReadsApibuilderApiApplicationForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.ApplicationForm] = {
      for {
        name <- (__ \ "name").read[String]
        key <- (__ \ "key").readNullable[String]
        description <- (__ \ "description").readNullable[String]
        visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
      } yield ApplicationForm(name, key, description, visibility)
    }

    def jsObjectApplicationForm(obj: io.apibuilder.api.v0.models.ApplicationForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "name" -> play.api.libs.json.JsString(obj.name),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString)
      ) ++ (obj.key match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("key" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiApplicationForm: play.api.libs.json.Writes[ApplicationForm] = {
      (obj: io.apibuilder.api.v0.models.ApplicationForm) => {
        io.apibuilder.api.v0.models.json.jsObjectApplicationForm(obj)
      }
    }

    def jsonReadsApibuilderApiApplicationSummary: play.api.libs.json.Reads[io.apibuilder.api.v0.models.ApplicationSummary] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
        key <- (__ \ "key").read[String]
      } yield ApplicationSummary(guid, organization, key)
    }

    def jsObjectApplicationSummary(obj: io.apibuilder.api.v0.models.ApplicationSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
        "key" -> play.api.libs.json.JsString(obj.key)
      ) ++ play.api.libs.json.Json.obj("type" -> "application_summary")
    }

    def jsonWritesApibuilderApiApplicationSummary: play.api.libs.json.Writes[ApplicationSummary] = {
      (obj: io.apibuilder.api.v0.models.ApplicationSummary) => {
        io.apibuilder.api.v0.models.json.jsObjectApplicationSummary(obj)
      }
    }

    implicit def jsonReadsApibuilderApiAttribute: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Attribute] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        name <- (__ \ "name").read[String]
        description <- (__ \ "description").readNullable[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Attribute(guid, name, description, audit)
    }

    def jsObjectAttribute(obj: io.apibuilder.api.v0.models.Attribute): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "name" -> play.api.libs.json.JsString(obj.name),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiAttribute: play.api.libs.json.Writes[Attribute] = {
      (obj: io.apibuilder.api.v0.models.Attribute) => {
        io.apibuilder.api.v0.models.json.jsObjectAttribute(obj)
      }
    }

    implicit def jsonReadsApibuilderApiAttributeForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeForm] = {
      for {
        name <- (__ \ "name").read[String]
        description <- (__ \ "description").readNullable[String]
      } yield AttributeForm(name, description)
    }

    def jsObjectAttributeForm(obj: io.apibuilder.api.v0.models.AttributeForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "name" -> play.api.libs.json.JsString(obj.name)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiAttributeForm: play.api.libs.json.Writes[AttributeForm] = {
      (obj: io.apibuilder.api.v0.models.AttributeForm) => {
        io.apibuilder.api.v0.models.json.jsObjectAttributeForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiAttributeSummary: play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeSummary] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        name <- (__ \ "name").read[String]
      } yield AttributeSummary(guid, name)
    }

    def jsObjectAttributeSummary(obj: io.apibuilder.api.v0.models.AttributeSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "name" -> play.api.libs.json.JsString(obj.name)
      )
    }

    implicit def jsonWritesApibuilderApiAttributeSummary: play.api.libs.json.Writes[AttributeSummary] = {
      (obj: io.apibuilder.api.v0.models.AttributeSummary) => {
        io.apibuilder.api.v0.models.json.jsObjectAttributeSummary(obj)
      }
    }

    implicit def jsonReadsApibuilderApiAttributeValue: play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeValue] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        attribute <- (__ \ "attribute").read[io.apibuilder.api.v0.models.AttributeSummary]
        value <- (__ \ "value").read[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield AttributeValue(guid, attribute, value, audit)
    }

    def jsObjectAttributeValue(obj: io.apibuilder.api.v0.models.AttributeValue): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "attribute" -> io.apibuilder.api.v0.models.json.jsObjectAttributeSummary(obj.attribute),
        "value" -> play.api.libs.json.JsString(obj.value),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiAttributeValue: play.api.libs.json.Writes[AttributeValue] = {
      (obj: io.apibuilder.api.v0.models.AttributeValue) => {
        io.apibuilder.api.v0.models.json.jsObjectAttributeValue(obj)
      }
    }

    implicit def jsonReadsApibuilderApiAttributeValueForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.AttributeValueForm] = {
      (__ \ "value").read[String].map { x => AttributeValueForm(value = x) }
    }

    def jsObjectAttributeValueForm(obj: io.apibuilder.api.v0.models.AttributeValueForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "value" -> play.api.libs.json.JsString(obj.value)
      )
    }

    implicit def jsonWritesApibuilderApiAttributeValueForm: play.api.libs.json.Writes[AttributeValueForm] = {
      (obj: io.apibuilder.api.v0.models.AttributeValueForm) => {
        io.apibuilder.api.v0.models.json.jsObjectAttributeValueForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiAuthentication: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Authentication] = {
      for {
        user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
        session <- (__ \ "session").read[io.apibuilder.api.v0.models.Session]
      } yield Authentication(user, session)
    }

    def jsObjectAuthentication(obj: io.apibuilder.api.v0.models.Authentication): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
        "session" -> io.apibuilder.api.v0.models.json.jsObjectSession(obj.session)
      )
    }

    implicit def jsonWritesApibuilderApiAuthentication: play.api.libs.json.Writes[Authentication] = {
      (obj: io.apibuilder.api.v0.models.Authentication) => {
        io.apibuilder.api.v0.models.json.jsObjectAuthentication(obj)
      }
    }

    implicit def jsonReadsApibuilderApiChange: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Change] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
        application <- (__ \ "application").read[io.apibuilder.common.v0.models.Reference]
        fromVersion <- (__ \ "from_version").read[io.apibuilder.api.v0.models.ChangeVersion]
        toVersion <- (__ \ "to_version").read[io.apibuilder.api.v0.models.ChangeVersion]
        diff <- (__ \ "diff").read[io.apibuilder.api.v0.models.Diff]
        changedAt <- (__ \ "changed_at").read[_root_.org.joda.time.DateTime]
        changedBy <- (__ \ "changed_by").read[io.apibuilder.api.v0.models.UserSummary]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Change(guid, organization, application, fromVersion, toVersion, diff, changedAt, changedBy, audit)
    }

    def jsObjectChange(obj: io.apibuilder.api.v0.models.Change): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
        "application" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.application),
        "from_version" -> io.apibuilder.api.v0.models.json.jsObjectChangeVersion(obj.fromVersion),
        "to_version" -> io.apibuilder.api.v0.models.json.jsObjectChangeVersion(obj.toVersion),
        "diff" -> io.apibuilder.api.v0.models.json.jsObjectDiff(obj.diff),
        "changed_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.changedAt)),
        "changed_by" -> io.apibuilder.api.v0.models.json.jsObjectUserSummary(obj.changedBy),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiChange: play.api.libs.json.Writes[Change] = {
      (obj: io.apibuilder.api.v0.models.Change) => {
        io.apibuilder.api.v0.models.json.jsObjectChange(obj)
      }
    }

    implicit def jsonReadsApibuilderApiChangeVersion: play.api.libs.json.Reads[io.apibuilder.api.v0.models.ChangeVersion] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        version <- (__ \ "version").read[String]
      } yield ChangeVersion(guid, version)
    }

    def jsObjectChangeVersion(obj: io.apibuilder.api.v0.models.ChangeVersion): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "version" -> play.api.libs.json.JsString(obj.version)
      )
    }

    implicit def jsonWritesApibuilderApiChangeVersion: play.api.libs.json.Writes[ChangeVersion] = {
      (obj: io.apibuilder.api.v0.models.ChangeVersion) => {
        io.apibuilder.api.v0.models.json.jsObjectChangeVersion(obj)
      }
    }

    implicit def jsonReadsApibuilderApiCleartextToken: play.api.libs.json.Reads[io.apibuilder.api.v0.models.CleartextToken] = {
      (__ \ "token").read[String].map { x => CleartextToken(token = x) }
    }

    def jsObjectCleartextToken(obj: io.apibuilder.api.v0.models.CleartextToken): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "token" -> play.api.libs.json.JsString(obj.token)
      )
    }

    implicit def jsonWritesApibuilderApiCleartextToken: play.api.libs.json.Writes[CleartextToken] = {
      (obj: io.apibuilder.api.v0.models.CleartextToken) => {
        io.apibuilder.api.v0.models.json.jsObjectCleartextToken(obj)
      }
    }

    implicit def jsonReadsApibuilderApiCode: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Code] = {
      for {
        generator <- (__ \ "generator").read[io.apibuilder.api.v0.models.GeneratorWithService]
        source <- (__ \ "source").read[String]
        files <- (__ \ "files").read[Seq[io.apibuilder.generator.v0.models.File]]
      } yield Code(generator, source, files)
    }

    def jsObjectCode(obj: io.apibuilder.api.v0.models.Code): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "generator" -> io.apibuilder.api.v0.models.json.jsObjectGeneratorWithService(obj.generator),
        "source" -> play.api.libs.json.JsString(obj.source),
        "files" -> play.api.libs.json.Json.toJson(obj.files)
      )
    }

    implicit def jsonWritesApibuilderApiCode: play.api.libs.json.Writes[Code] = {
      (obj: io.apibuilder.api.v0.models.Code) => {
        io.apibuilder.api.v0.models.json.jsObjectCode(obj)
      }
    }

    def jsonReadsApibuilderApiDiffBreaking: play.api.libs.json.Reads[io.apibuilder.api.v0.models.DiffBreaking] = {
      (__ \ "description").read[String].map { x => DiffBreaking(description = x) }
    }

    def jsObjectDiffBreaking(obj: io.apibuilder.api.v0.models.DiffBreaking): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "description" -> play.api.libs.json.JsString(obj.description)
      ) ++ play.api.libs.json.Json.obj("type" -> "diff_breaking")
    }

    def jsonWritesApibuilderApiDiffBreaking: play.api.libs.json.Writes[DiffBreaking] = {
      (obj: io.apibuilder.api.v0.models.DiffBreaking) => {
        io.apibuilder.api.v0.models.json.jsObjectDiffBreaking(obj)
      }
    }

    def jsonReadsApibuilderApiDiffNonBreaking: play.api.libs.json.Reads[io.apibuilder.api.v0.models.DiffNonBreaking] = {
      (__ \ "description").read[String].map { x => DiffNonBreaking(description = x) }
    }

    def jsObjectDiffNonBreaking(obj: io.apibuilder.api.v0.models.DiffNonBreaking): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "description" -> play.api.libs.json.JsString(obj.description)
      ) ++ play.api.libs.json.Json.obj("type" -> "diff_non_breaking")
    }

    def jsonWritesApibuilderApiDiffNonBreaking: play.api.libs.json.Writes[DiffNonBreaking] = {
      (obj: io.apibuilder.api.v0.models.DiffNonBreaking) => {
        io.apibuilder.api.v0.models.json.jsObjectDiffNonBreaking(obj)
      }
    }

    implicit def jsonReadsApibuilderApiDomain: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Domain] = {
      (__ \ "name").read[String].map { x => Domain(name = x) }
    }

    def jsObjectDomain(obj: io.apibuilder.api.v0.models.Domain): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "name" -> play.api.libs.json.JsString(obj.name)
      )
    }

    implicit def jsonWritesApibuilderApiDomain: play.api.libs.json.Writes[Domain] = {
      (obj: io.apibuilder.api.v0.models.Domain) => {
        io.apibuilder.api.v0.models.json.jsObjectDomain(obj)
      }
    }

    implicit def jsonReadsApibuilderApiEmailVerificationConfirmationForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.EmailVerificationConfirmationForm] = {
      (__ \ "token").read[String].map { x => EmailVerificationConfirmationForm(token = x) }
    }

    def jsObjectEmailVerificationConfirmationForm(obj: io.apibuilder.api.v0.models.EmailVerificationConfirmationForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "token" -> play.api.libs.json.JsString(obj.token)
      )
    }

    implicit def jsonWritesApibuilderApiEmailVerificationConfirmationForm: play.api.libs.json.Writes[EmailVerificationConfirmationForm] = {
      (obj: io.apibuilder.api.v0.models.EmailVerificationConfirmationForm) => {
        io.apibuilder.api.v0.models.json.jsObjectEmailVerificationConfirmationForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiError: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Error] = {
      for {
        code <- (__ \ "code").read[String]
        message <- (__ \ "message").read[String]
      } yield Error(code, message)
    }

    def jsObjectError(obj: io.apibuilder.api.v0.models.Error): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "code" -> play.api.libs.json.JsString(obj.code),
        "message" -> play.api.libs.json.JsString(obj.message)
      )
    }

    implicit def jsonWritesApibuilderApiError: play.api.libs.json.Writes[Error] = {
      (obj: io.apibuilder.api.v0.models.Error) => {
        io.apibuilder.api.v0.models.json.jsObjectError(obj)
      }
    }

    implicit def jsonReadsApibuilderApiGeneratorForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorForm] = {
      for {
        serviceGuid <- (__ \ "service_guid").read[_root_.java.util.UUID]
        generator <- (__ \ "generator").read[io.apibuilder.generator.v0.models.Generator]
      } yield GeneratorForm(serviceGuid, generator)
    }

    def jsObjectGeneratorForm(obj: io.apibuilder.api.v0.models.GeneratorForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "service_guid" -> play.api.libs.json.JsString(obj.serviceGuid.toString),
        "generator" -> io.apibuilder.generator.v0.models.json.jsObjectGenerator(obj.generator)
      )
    }

    implicit def jsonWritesApibuilderApiGeneratorForm: play.api.libs.json.Writes[GeneratorForm] = {
      (obj: io.apibuilder.api.v0.models.GeneratorForm) => {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiGeneratorService: play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorService] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        uri <- (__ \ "uri").read[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield GeneratorService(guid, uri, audit)
    }

    def jsObjectGeneratorService(obj: io.apibuilder.api.v0.models.GeneratorService): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "uri" -> play.api.libs.json.JsString(obj.uri),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiGeneratorService: play.api.libs.json.Writes[GeneratorService] = {
      (obj: io.apibuilder.api.v0.models.GeneratorService) => {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorService(obj)
      }
    }

    implicit def jsonReadsApibuilderApiGeneratorServiceForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorServiceForm] = {
      (__ \ "uri").read[String].map { x => GeneratorServiceForm(uri = x) }
    }

    def jsObjectGeneratorServiceForm(obj: io.apibuilder.api.v0.models.GeneratorServiceForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "uri" -> play.api.libs.json.JsString(obj.uri)
      )
    }

    implicit def jsonWritesApibuilderApiGeneratorServiceForm: play.api.libs.json.Writes[GeneratorServiceForm] = {
      (obj: io.apibuilder.api.v0.models.GeneratorServiceForm) => {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorServiceForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiGeneratorWithService: play.api.libs.json.Reads[io.apibuilder.api.v0.models.GeneratorWithService] = {
      for {
        service <- (__ \ "service").read[io.apibuilder.api.v0.models.GeneratorService]
        generator <- (__ \ "generator").read[io.apibuilder.generator.v0.models.Generator]
      } yield GeneratorWithService(service, generator)
    }

    def jsObjectGeneratorWithService(obj: io.apibuilder.api.v0.models.GeneratorWithService): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "service" -> io.apibuilder.api.v0.models.json.jsObjectGeneratorService(obj.service),
        "generator" -> io.apibuilder.generator.v0.models.json.jsObjectGenerator(obj.generator)
      )
    }

    implicit def jsonWritesApibuilderApiGeneratorWithService: play.api.libs.json.Writes[GeneratorWithService] = {
      (obj: io.apibuilder.api.v0.models.GeneratorWithService) => {
        io.apibuilder.api.v0.models.json.jsObjectGeneratorWithService(obj)
      }
    }

    implicit def jsonReadsApibuilderApiItem: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Item] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        detail <- (__ \ "detail").read[io.apibuilder.api.v0.models.ItemDetail]
        label <- (__ \ "label").read[String]
        description <- (__ \ "description").readNullable[String]
      } yield Item(guid, detail, label, description)
    }

    def jsObjectItem(obj: io.apibuilder.api.v0.models.Item): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "detail" -> io.apibuilder.api.v0.models.json.jsObjectItemDetail(obj.detail),
        "label" -> play.api.libs.json.JsString(obj.label)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiItem: play.api.libs.json.Writes[Item] = {
      (obj: io.apibuilder.api.v0.models.Item) => {
        io.apibuilder.api.v0.models.json.jsObjectItem(obj)
      }
    }

    implicit def jsonReadsApibuilderApiMembership: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Membership] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
        organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
        role <- (__ \ "role").read[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Membership(guid, user, organization, role, audit)
    }

    def jsObjectMembership(obj: io.apibuilder.api.v0.models.Membership): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
        "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
        "role" -> play.api.libs.json.JsString(obj.role),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiMembership: play.api.libs.json.Writes[Membership] = {
      (obj: io.apibuilder.api.v0.models.Membership) => {
        io.apibuilder.api.v0.models.json.jsObjectMembership(obj)
      }
    }

    implicit def jsonReadsApibuilderApiMembershipRequest: play.api.libs.json.Reads[io.apibuilder.api.v0.models.MembershipRequest] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
        organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
        role <- (__ \ "role").read[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield MembershipRequest(guid, user, organization, role, audit)
    }

    def jsObjectMembershipRequest(obj: io.apibuilder.api.v0.models.MembershipRequest): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
        "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
        "role" -> play.api.libs.json.JsString(obj.role),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiMembershipRequest: play.api.libs.json.Writes[MembershipRequest] = {
      (obj: io.apibuilder.api.v0.models.MembershipRequest) => {
        io.apibuilder.api.v0.models.json.jsObjectMembershipRequest(obj)
      }
    }

    implicit def jsonReadsApibuilderApiMoveForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.MoveForm] = {
      (__ \ "org_key").read[String].map { x => MoveForm(orgKey = x) }
    }

    def jsObjectMoveForm(obj: io.apibuilder.api.v0.models.MoveForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "org_key" -> play.api.libs.json.JsString(obj.orgKey)
      )
    }

    implicit def jsonWritesApibuilderApiMoveForm: play.api.libs.json.Writes[MoveForm] = {
      (obj: io.apibuilder.api.v0.models.MoveForm) => {
        io.apibuilder.api.v0.models.json.jsObjectMoveForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiOrganization: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Organization] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        key <- (__ \ "key").read[String]
        name <- (__ \ "name").read[String]
        namespace <- (__ \ "namespace").read[String]
        visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
        domains <- (__ \ "domains").read[Seq[io.apibuilder.api.v0.models.Domain]]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Organization(guid, key, name, namespace, visibility, domains, audit)
    }

    def jsObjectOrganization(obj: io.apibuilder.api.v0.models.Organization): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "key" -> play.api.libs.json.JsString(obj.key),
        "name" -> play.api.libs.json.JsString(obj.name),
        "namespace" -> play.api.libs.json.JsString(obj.namespace),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString),
        "domains" -> play.api.libs.json.Json.toJson(obj.domains),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiOrganization: play.api.libs.json.Writes[Organization] = {
      (obj: io.apibuilder.api.v0.models.Organization) => {
        io.apibuilder.api.v0.models.json.jsObjectOrganization(obj)
      }
    }

    implicit def jsonReadsApibuilderApiOrganizationForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.OrganizationForm] = {
      for {
        name <- (__ \ "name").read[String]
        key <- (__ \ "key").readNullable[String]
        namespace <- (__ \ "namespace").read[String]
        visibility <- (__ \ "visibility").read[io.apibuilder.api.v0.models.Visibility]
        domains <- (__ \ "domains").readNullable[Seq[String]]
      } yield OrganizationForm(name, key, namespace, visibility, domains)
    }

    def jsObjectOrganizationForm(obj: io.apibuilder.api.v0.models.OrganizationForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "name" -> play.api.libs.json.JsString(obj.name),
        "namespace" -> play.api.libs.json.JsString(obj.namespace),
        "visibility" -> play.api.libs.json.JsString(obj.visibility.toString)
      ) ++ (obj.key match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("key" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.domains match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("domains" -> play.api.libs.json.Json.toJson(x))
      })
    }

    implicit def jsonWritesApibuilderApiOrganizationForm: play.api.libs.json.Writes[OrganizationForm] = {
      (obj: io.apibuilder.api.v0.models.OrganizationForm) => {
        io.apibuilder.api.v0.models.json.jsObjectOrganizationForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiOriginal: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Original] = {
      for {
        `type` <- (__ \ "type").read[io.apibuilder.api.v0.models.OriginalType]
        data <- (__ \ "data").read[String]
      } yield Original(`type`, data)
    }

    def jsObjectOriginal(obj: io.apibuilder.api.v0.models.Original): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "type" -> play.api.libs.json.JsString(obj.`type`.toString),
        "data" -> play.api.libs.json.JsString(obj.data)
      )
    }

    implicit def jsonWritesApibuilderApiOriginal: play.api.libs.json.Writes[Original] = {
      (obj: io.apibuilder.api.v0.models.Original) => {
        io.apibuilder.api.v0.models.json.jsObjectOriginal(obj)
      }
    }

    implicit def jsonReadsApibuilderApiOriginalForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.OriginalForm] = {
      for {
        `type` <- (__ \ "type").readNullable[io.apibuilder.api.v0.models.OriginalType]
        data <- (__ \ "data").read[String]
      } yield OriginalForm(`type`, data)
    }

    def jsObjectOriginalForm(obj: io.apibuilder.api.v0.models.OriginalForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "data" -> play.api.libs.json.JsString(obj.data)
      ) ++ (obj.`type` match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("type" -> play.api.libs.json.JsString(x.toString))
      })
    }

    implicit def jsonWritesApibuilderApiOriginalForm: play.api.libs.json.Writes[OriginalForm] = {
      (obj: io.apibuilder.api.v0.models.OriginalForm) => {
        io.apibuilder.api.v0.models.json.jsObjectOriginalForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiPasswordReset: play.api.libs.json.Reads[io.apibuilder.api.v0.models.PasswordReset] = {
      for {
        token <- (__ \ "token").read[String]
        password <- (__ \ "password").read[String]
      } yield PasswordReset(token, password)
    }

    def jsObjectPasswordReset(obj: io.apibuilder.api.v0.models.PasswordReset): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "token" -> play.api.libs.json.JsString(obj.token),
        "password" -> play.api.libs.json.JsString(obj.password)
      )
    }

    implicit def jsonWritesApibuilderApiPasswordReset: play.api.libs.json.Writes[PasswordReset] = {
      (obj: io.apibuilder.api.v0.models.PasswordReset) => {
        io.apibuilder.api.v0.models.json.jsObjectPasswordReset(obj)
      }
    }

    implicit def jsonReadsApibuilderApiPasswordResetRequest: play.api.libs.json.Reads[io.apibuilder.api.v0.models.PasswordResetRequest] = {
      (__ \ "email").read[String].map { x => PasswordResetRequest(email = x) }
    }

    def jsObjectPasswordResetRequest(obj: io.apibuilder.api.v0.models.PasswordResetRequest): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "email" -> play.api.libs.json.JsString(obj.email)
      )
    }

    implicit def jsonWritesApibuilderApiPasswordResetRequest: play.api.libs.json.Writes[PasswordResetRequest] = {
      (obj: io.apibuilder.api.v0.models.PasswordResetRequest) => {
        io.apibuilder.api.v0.models.json.jsObjectPasswordResetRequest(obj)
      }
    }

    implicit def jsonReadsApibuilderApiSession: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Session] = {
      for {
        id <- (__ \ "id").read[String]
        expiresAt <- (__ \ "expires_at").read[_root_.org.joda.time.DateTime]
      } yield Session(id, expiresAt)
    }

    def jsObjectSession(obj: io.apibuilder.api.v0.models.Session): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "id" -> play.api.libs.json.JsString(obj.id),
        "expires_at" -> play.api.libs.json.JsString(_root_.org.joda.time.format.ISODateTimeFormat.dateTime.print(obj.expiresAt))
      )
    }

    implicit def jsonWritesApibuilderApiSession: play.api.libs.json.Writes[Session] = {
      (obj: io.apibuilder.api.v0.models.Session) => {
        io.apibuilder.api.v0.models.json.jsObjectSession(obj)
      }
    }

    implicit def jsonReadsApibuilderApiSubscription: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Subscription] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
        user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
        publication <- (__ \ "publication").read[io.apibuilder.api.v0.models.Publication]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Subscription(guid, organization, user, publication, audit)
    }

    def jsObjectSubscription(obj: io.apibuilder.api.v0.models.Subscription): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
        "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
        "publication" -> play.api.libs.json.JsString(obj.publication.toString),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiSubscription: play.api.libs.json.Writes[Subscription] = {
      (obj: io.apibuilder.api.v0.models.Subscription) => {
        io.apibuilder.api.v0.models.json.jsObjectSubscription(obj)
      }
    }

    implicit def jsonReadsApibuilderApiSubscriptionForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.SubscriptionForm] = {
      for {
        organizationKey <- (__ \ "organization_key").read[String]
        userGuid <- (__ \ "user_guid").read[_root_.java.util.UUID]
        publication <- (__ \ "publication").read[io.apibuilder.api.v0.models.Publication]
      } yield SubscriptionForm(organizationKey, userGuid, publication)
    }

    def jsObjectSubscriptionForm(obj: io.apibuilder.api.v0.models.SubscriptionForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "organization_key" -> play.api.libs.json.JsString(obj.organizationKey),
        "user_guid" -> play.api.libs.json.JsString(obj.userGuid.toString),
        "publication" -> play.api.libs.json.JsString(obj.publication.toString)
      )
    }

    implicit def jsonWritesApibuilderApiSubscriptionForm: play.api.libs.json.Writes[SubscriptionForm] = {
      (obj: io.apibuilder.api.v0.models.SubscriptionForm) => {
        io.apibuilder.api.v0.models.json.jsObjectSubscriptionForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiToken: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Token] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
        maskedToken <- (__ \ "masked_token").read[String]
        description <- (__ \ "description").readNullable[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Token(guid, user, maskedToken, description, audit)
    }

    def jsObjectToken(obj: io.apibuilder.api.v0.models.Token): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
        "masked_token" -> play.api.libs.json.JsString(obj.maskedToken),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiToken: play.api.libs.json.Writes[Token] = {
      (obj: io.apibuilder.api.v0.models.Token) => {
        io.apibuilder.api.v0.models.json.jsObjectToken(obj)
      }
    }

    implicit def jsonReadsApibuilderApiTokenForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.TokenForm] = {
      for {
        userGuid <- (__ \ "user_guid").read[_root_.java.util.UUID]
        description <- (__ \ "description").readNullable[String]
      } yield TokenForm(userGuid, description)
    }

    def jsObjectTokenForm(obj: io.apibuilder.api.v0.models.TokenForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_guid" -> play.api.libs.json.JsString(obj.userGuid.toString)
      ) ++ (obj.description match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("description" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiTokenForm: play.api.libs.json.Writes[TokenForm] = {
      (obj: io.apibuilder.api.v0.models.TokenForm) => {
        io.apibuilder.api.v0.models.json.jsObjectTokenForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiUser: play.api.libs.json.Reads[io.apibuilder.api.v0.models.User] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        email <- (__ \ "email").read[String]
        nickname <- (__ \ "nickname").read[String]
        name <- (__ \ "name").readNullable[String]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield User(guid, email, nickname, name, audit)
    }

    def jsObjectUser(obj: io.apibuilder.api.v0.models.User): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "email" -> play.api.libs.json.JsString(obj.email),
        "nickname" -> play.api.libs.json.JsString(obj.nickname),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      ) ++ (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiUser: play.api.libs.json.Writes[User] = {
      (obj: io.apibuilder.api.v0.models.User) => {
        io.apibuilder.api.v0.models.json.jsObjectUser(obj)
      }
    }

    implicit def jsonReadsApibuilderApiUserForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.UserForm] = {
      for {
        email <- (__ \ "email").read[String]
        password <- (__ \ "password").read[String]
        nickname <- (__ \ "nickname").readNullable[String]
        name <- (__ \ "name").readNullable[String]
      } yield UserForm(email, password, nickname, name)
    }

    def jsObjectUserForm(obj: io.apibuilder.api.v0.models.UserForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "email" -> play.api.libs.json.JsString(obj.email),
        "password" -> play.api.libs.json.JsString(obj.password)
      ) ++ (obj.nickname match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("nickname" -> play.api.libs.json.JsString(x))
      }) ++
      (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiUserForm: play.api.libs.json.Writes[UserForm] = {
      (obj: io.apibuilder.api.v0.models.UserForm) => {
        io.apibuilder.api.v0.models.json.jsObjectUserForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiUserSummary: play.api.libs.json.Reads[io.apibuilder.api.v0.models.UserSummary] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        nickname <- (__ \ "nickname").read[String]
      } yield UserSummary(guid, nickname)
    }

    def jsObjectUserSummary(obj: io.apibuilder.api.v0.models.UserSummary): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "nickname" -> play.api.libs.json.JsString(obj.nickname)
      )
    }

    implicit def jsonWritesApibuilderApiUserSummary: play.api.libs.json.Writes[UserSummary] = {
      (obj: io.apibuilder.api.v0.models.UserSummary) => {
        io.apibuilder.api.v0.models.json.jsObjectUserSummary(obj)
      }
    }

    implicit def jsonReadsApibuilderApiUserUpdateForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.UserUpdateForm] = {
      for {
        email <- (__ \ "email").read[String]
        nickname <- (__ \ "nickname").read[String]
        name <- (__ \ "name").readNullable[String]
      } yield UserUpdateForm(email, nickname, name)
    }

    def jsObjectUserUpdateForm(obj: io.apibuilder.api.v0.models.UserUpdateForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "email" -> play.api.libs.json.JsString(obj.email),
        "nickname" -> play.api.libs.json.JsString(obj.nickname)
      ) ++ (obj.name match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("name" -> play.api.libs.json.JsString(x))
      })
    }

    implicit def jsonWritesApibuilderApiUserUpdateForm: play.api.libs.json.Writes[UserUpdateForm] = {
      (obj: io.apibuilder.api.v0.models.UserUpdateForm) => {
        io.apibuilder.api.v0.models.json.jsObjectUserUpdateForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiValidation: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Validation] = {
      for {
        valid <- (__ \ "valid").read[Boolean]
        errors <- (__ \ "errors").read[Seq[String]]
      } yield Validation(valid, errors)
    }

    def jsObjectValidation(obj: io.apibuilder.api.v0.models.Validation): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "valid" -> play.api.libs.json.JsBoolean(obj.valid),
        "errors" -> play.api.libs.json.Json.toJson(obj.errors)
      )
    }

    implicit def jsonWritesApibuilderApiValidation: play.api.libs.json.Writes[Validation] = {
      (obj: io.apibuilder.api.v0.models.Validation) => {
        io.apibuilder.api.v0.models.json.jsObjectValidation(obj)
      }
    }

    implicit def jsonReadsApibuilderApiVersion: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Version] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        organization <- (__ \ "organization").read[io.apibuilder.common.v0.models.Reference]
        application <- (__ \ "application").read[io.apibuilder.common.v0.models.Reference]
        version <- (__ \ "version").read[String]
        original <- (__ \ "original").readNullable[io.apibuilder.api.v0.models.Original]
        service <- (__ \ "service").read[io.apibuilder.spec.v0.models.Service]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Version(guid, organization, application, version, original, service, audit)
    }

    def jsObjectVersion(obj: io.apibuilder.api.v0.models.Version): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "organization" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.organization),
        "application" -> io.apibuilder.common.v0.models.json.jsObjectReference(obj.application),
        "version" -> play.api.libs.json.JsString(obj.version),
        "service" -> io.apibuilder.spec.v0.models.json.jsObjectService(obj.service),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      ) ++ (obj.original match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("original" -> io.apibuilder.api.v0.models.json.jsObjectOriginal(x))
      })
    }

    implicit def jsonWritesApibuilderApiVersion: play.api.libs.json.Writes[Version] = {
      (obj: io.apibuilder.api.v0.models.Version) => {
        io.apibuilder.api.v0.models.json.jsObjectVersion(obj)
      }
    }

    implicit def jsonReadsApibuilderApiVersionForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.VersionForm] = {
      for {
        originalForm <- (__ \ "original_form").read[io.apibuilder.api.v0.models.OriginalForm]
        visibility <- (__ \ "visibility").readNullable[io.apibuilder.api.v0.models.Visibility]
      } yield VersionForm(originalForm, visibility)
    }

    def jsObjectVersionForm(obj: io.apibuilder.api.v0.models.VersionForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "original_form" -> io.apibuilder.api.v0.models.json.jsObjectOriginalForm(obj.originalForm)
      ) ++ (obj.visibility match {
        case None => play.api.libs.json.Json.obj()
        case Some(x) => play.api.libs.json.Json.obj("visibility" -> play.api.libs.json.JsString(x.toString))
      })
    }

    implicit def jsonWritesApibuilderApiVersionForm: play.api.libs.json.Writes[VersionForm] = {
      (obj: io.apibuilder.api.v0.models.VersionForm) => {
        io.apibuilder.api.v0.models.json.jsObjectVersionForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiWatch: play.api.libs.json.Reads[io.apibuilder.api.v0.models.Watch] = {
      for {
        guid <- (__ \ "guid").read[_root_.java.util.UUID]
        user <- (__ \ "user").read[io.apibuilder.api.v0.models.User]
        organization <- (__ \ "organization").read[io.apibuilder.api.v0.models.Organization]
        application <- (__ \ "application").read[io.apibuilder.api.v0.models.Application]
        audit <- (__ \ "audit").read[io.apibuilder.common.v0.models.Audit]
      } yield Watch(guid, user, organization, application, audit)
    }

    def jsObjectWatch(obj: io.apibuilder.api.v0.models.Watch): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "guid" -> play.api.libs.json.JsString(obj.guid.toString),
        "user" -> io.apibuilder.api.v0.models.json.jsObjectUser(obj.user),
        "organization" -> io.apibuilder.api.v0.models.json.jsObjectOrganization(obj.organization),
        "application" -> io.apibuilder.api.v0.models.json.jsObjectApplication(obj.application),
        "audit" -> io.apibuilder.common.v0.models.json.jsObjectAudit(obj.audit)
      )
    }

    implicit def jsonWritesApibuilderApiWatch: play.api.libs.json.Writes[Watch] = {
      (obj: io.apibuilder.api.v0.models.Watch) => {
        io.apibuilder.api.v0.models.json.jsObjectWatch(obj)
      }
    }

    implicit def jsonReadsApibuilderApiWatchForm: play.api.libs.json.Reads[io.apibuilder.api.v0.models.WatchForm] = {
      for {
        userGuid <- (__ \ "user_guid").read[_root_.java.util.UUID]
        organizationKey <- (__ \ "organization_key").read[String]
        applicationKey <- (__ \ "application_key").read[String]
      } yield WatchForm(userGuid, organizationKey, applicationKey)
    }

    def jsObjectWatchForm(obj: io.apibuilder.api.v0.models.WatchForm): play.api.libs.json.JsObject = {
      play.api.libs.json.Json.obj(
        "user_guid" -> play.api.libs.json.JsString(obj.userGuid.toString),
        "organization_key" -> play.api.libs.json.JsString(obj.organizationKey),
        "application_key" -> play.api.libs.json.JsString(obj.applicationKey)
      )
    }

    implicit def jsonWritesApibuilderApiWatchForm: play.api.libs.json.Writes[WatchForm] = {
      (obj: io.apibuilder.api.v0.models.WatchForm) => {
        io.apibuilder.api.v0.models.json.jsObjectWatchForm(obj)
      }
    }

    implicit def jsonReadsApibuilderApiDiff[T <: io.apibuilder.api.v0.models.Diff]: play.api.libs.json.Reads[T] = (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "diff_breaking" => io.apibuilder.api.v0.models.json.jsonReadsApibuilderApiDiffBreaking.reads(js)
          case "diff_non_breaking" => io.apibuilder.api.v0.models.json.jsonReadsApibuilderApiDiffNonBreaking.reads(js)
          case other => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.DiffUndefinedType(other))
        }
      }
      (js \ "type").validate[String] match {
        case e: play.api.libs.json.JsError => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value).map(_.asInstanceOf[T])
      }
    }


    implicit def jsonReadsApibuilderApiDiffSeq[T <: io.apibuilder.api.v0.models.Diff]: play.api.libs.json.Reads[Seq[T]] = {
      case a: play.api.libs.json.JsArray => {
        val all: Seq[play.api.libs.json.JsResult[io.apibuilder.api.v0.models.Diff]] = a.value.map(jsonReadsApibuilderApiDiff.reads).toSeq

        all.collect { case e: play.api.libs.json.JsError => e }.toList match {
          case Nil => play.api.libs.json.JsSuccess(all.collect { case play.api.libs.json.JsSuccess(v, _) => v.asInstanceOf[T] })
          case errors => play.api.libs.json.JsError(play.api.libs.json.JsError.merge(errors.flatMap(_.errors), Nil))
        }
      }
      case other => play.api.libs.json.JsError(s"Expected array but found [" + other.getClass.getName + "]")
    }

    def jsObjectDiff(obj: io.apibuilder.api.v0.models.Diff): play.api.libs.json.JsObject = {
      obj match {
        case x: io.apibuilder.api.v0.models.DiffBreaking => io.apibuilder.api.v0.models.json.jsObjectDiffBreaking(x)
        case x: io.apibuilder.api.v0.models.DiffNonBreaking => io.apibuilder.api.v0.models.json.jsObjectDiffNonBreaking(x)
        case other => {
          sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
        }
      }
    }

    implicit def jsonWritesApibuilderApiDiff[T <: io.apibuilder.api.v0.models.Diff]: play.api.libs.json.Writes[T] = {
      (obj: io.apibuilder.api.v0.models.Diff) => {
        io.apibuilder.api.v0.models.json.jsObjectDiff(obj)
      }
    }


    implicit def jsonReadsApibuilderApiItemDetail[T <: io.apibuilder.api.v0.models.ItemDetail]: play.api.libs.json.Reads[T] = (js: play.api.libs.json.JsValue) => {
      def readDiscriminator(discriminator: String) = {
        discriminator match {
          case "application_summary" => io.apibuilder.api.v0.models.json.jsonReadsApibuilderApiApplicationSummary.reads(js)
          case other => play.api.libs.json.JsSuccess(io.apibuilder.api.v0.models.ItemDetailUndefinedType(other))
        }
      }
      (js \ "type").validate[String] match {
        case e: play.api.libs.json.JsError => e
        case s: play.api.libs.json.JsSuccess[String] => readDiscriminator(s.value).map(_.asInstanceOf[T])
      }
    }


    implicit def jsonReadsApibuilderApiItemDetailSeq[T <: io.apibuilder.api.v0.models.ItemDetail]: play.api.libs.json.Reads[Seq[T]] = {
      case a: play.api.libs.json.JsArray => {
        val all: Seq[play.api.libs.json.JsResult[io.apibuilder.api.v0.models.ItemDetail]] = a.value.map(jsonReadsApibuilderApiItemDetail.reads).toSeq

        all.collect { case e: play.api.libs.json.JsError => e }.toList match {
          case Nil => play.api.libs.json.JsSuccess(all.collect { case play.api.libs.json.JsSuccess(v, _) => v.asInstanceOf[T] })
          case errors => play.api.libs.json.JsError(play.api.libs.json.JsError.merge(errors.flatMap(_.errors), Nil))
        }
      }
      case other => play.api.libs.json.JsError(s"Expected array but found [" + other.getClass.getName + "]")
    }

    def jsObjectItemDetail(obj: io.apibuilder.api.v0.models.ItemDetail): play.api.libs.json.JsObject = {
      obj match {
        case x: io.apibuilder.api.v0.models.ApplicationSummary => io.apibuilder.api.v0.models.json.jsObjectApplicationSummary(x)
        case other => {
          sys.error(s"The type[${other.getClass.getName}] has no JSON writer")
        }
      }
    }

    implicit def jsonWritesApibuilderApiItemDetail[T <: io.apibuilder.api.v0.models.ItemDetail]: play.api.libs.json.Writes[T] = {
      (obj: io.apibuilder.api.v0.models.ItemDetail) => {
        io.apibuilder.api.v0.models.json.jsObjectItemDetail(obj)
      }
    }
  }
}