/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.1-dev
 * User agent: apibuilder app.apibuilder.io/secret/apibuilder-api/0.0.1-dev/http4s_0_22
 */
package com.afrosoft.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
   * @param lastUpdatedAt The updated_at of this application or created_at of it's latest version
   */

  final case class Application(
    guid: _root_.java.util.UUID,
    organization: io.apibuilder.common.v0.models.Reference,
    name: String,
    key: String,
    visibility: com.afrosoft.apibuilder.api.v0.models.Visibility,
    description: _root_.scala.Option[String] = None,
    lastUpdatedAt: _root_.java.time.Instant,
    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: com.afrosoft.apibuilder.api.v0.models.Visibility
  )

  /**
   * @param guid Internal unique identifier for this application.
   * @param key Used as a unique key in the URL path. Key is automatically derived from the
   *        application name.
   */

  final case class ApplicationMetadata(
    guid: _root_.java.util.UUID,
    key: String
  )

  /**
   * Describes the versions associated with a given application
   */

  final case class ApplicationMetadataVersion(
    version: String
  )

  /**
   * 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: com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.User,
    session: com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.ChangeVersion,
    toVersion: com.afrosoft.apibuilder.api.v0.models.ChangeVersion,
    diff: com.afrosoft.apibuilder.api.v0.models.Diff,
    changedAt: _root_.java.time.Instant,
    changedBy: com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.GeneratorWithService,
    @deprecated("Use files instead") source: String,
    files: Seq[io.apibuilder.generator.v0.models.File] = Nil
  )

  final case class CodeForm(
    attributes: Seq[io.apibuilder.generator.v0.models.Attribute]
  )

  /**
   * 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: com.afrosoft.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: com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.User,
    organization: com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.User,
    organization: com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.Visibility,
    domains: Seq[com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.Visibility = com.afrosoft.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`: com.afrosoft.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[com.afrosoft.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_.java.time.Instant
  )

  /**
   * 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: com.afrosoft.apibuilder.api.v0.models.Organization,
    user: com.afrosoft.apibuilder.api.v0.models.User,
    publication: com.afrosoft.apibuilder.api.v0.models.Publication,
    audit: io.apibuilder.common.v0.models.Audit
  )

  final case class SubscriptionForm(
    organizationKey: String,
    userGuid: _root_.java.util.UUID,
    publication: com.afrosoft.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: com.afrosoft.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[com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.OriginalForm,
    visibility: _root_.scala.Option[com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.User,
    organization: com.afrosoft.apibuilder.api.v0.models.Organization,
    application: com.afrosoft.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 AppSortBy extends _root_.scala.Product with _root_.scala.Serializable

  object AppSortBy {

    case object Name extends AppSortBy { override def toString = "name" }
    case object CreatedAt extends AppSortBy { override def toString = "created_at" }
    case object UpdatedAt extends AppSortBy { override def toString = "updated_at" }
    case object Visibility extends AppSortBy { override def toString = "visibility" }
    /**
     * 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 AppSortBy

    /**
     * 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[AppSortBy] = scala.List(Name, CreatedAt, UpdatedAt, Visibility)

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

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

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

  }

  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)

  }

  sealed trait SortOrder extends _root_.scala.Product with _root_.scala.Serializable

  object SortOrder {

    case object Asc extends SortOrder { override def toString = "asc" }
    case object Desc extends SortOrder { override def toString = "desc" }
    /**
     * 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 SortOrder

    /**
     * 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[SortOrder] = scala.List(Asc, Desc)

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

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

    def fromString(value: String): _root_.scala.Option[SortOrder] = 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 com.afrosoft.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 com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.AppSortBy] =
      Decoder.decodeString.map(com.afrosoft.apibuilder.api.v0.models.AppSortBy(_))

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

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

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

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

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

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

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

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

    implicit val jsonEncoderApibuilderApiVisibility: Encoder[com.afrosoft.apibuilder.api.v0.models.Visibility] =
      Encoder.encodeString.contramap[com.afrosoft.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.User]
        session <- c.downField("session").as[com.afrosoft.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 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[com.afrosoft.apibuilder.api.v0.models.ChangeVersion]
        toVersion <- c.downField("to_version").as[com.afrosoft.apibuilder.api.v0.models.ChangeVersion]
        diff <- c.downField("diff").as[com.afrosoft.apibuilder.api.v0.models.Diff]
        changedAt <- c.downField("changed_at").as[_root_.java.time.Instant]
        changedBy <- c.downField("changed_by").as[com.afrosoft.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[com.afrosoft.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]
      } yield {
        DiffBreaking(
          description = description
        )
      }
    }

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

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

    implicit def encodeApibuilderApiDiffNonBreaking: Encoder[DiffNonBreaking] = Encoder.instance { t =>
      Json.fromFields(Seq(
        Some("description" -> t.description.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.User]
        organization <- c.downField("organization").as[com.afrosoft.apibuilder.api.v0.models.Organization]
        role <- c.downField("role").as[String]
        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[com.afrosoft.apibuilder.api.v0.models.User]
        organization <- c.downField("organization").as[com.afrosoft.apibuilder.api.v0.models.Organization]
        role <- c.downField("role").as[String]
        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[com.afrosoft.apibuilder.api.v0.models.Visibility]
        domains <- c.downField("domains").as[Seq[com.afrosoft.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.Organization]
        user <- c.downField("user").as[com.afrosoft.apibuilder.api.v0.models.User]
        publication <- c.downField("publication").as[com.afrosoft.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.OriginalForm]
        visibility <- c.downField("visibility").as[Option[com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.User]
        organization <- c.downField("organization").as[com.afrosoft.apibuilder.api.v0.models.Organization]
        application <- c.downField("application").as[com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.DiffBreaking]
        case Right(Some(s)) if s == "diff_non_breaking" => c.as[com.afrosoft.apibuilder.api.v0.models.DiffNonBreaking]
        case Right(Some(s)) => Right(com.afrosoft.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: com.afrosoft.apibuilder.api.v0.models.DiffBreaking => t.asJson.mapObject(obj => ("type", Json.fromString("diff_breaking")) +: obj)
      case t: com.afrosoft.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[com.afrosoft.apibuilder.api.v0.models.ApplicationSummary]
        case Right(Some(s)) => Right(com.afrosoft.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: com.afrosoft.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")
    }
  }
}