/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.0.5
 * User agent: apibuilder app.apibuilder.io/januar/apidoc-api/0.0.5/flow_erm_schema
 */
package januar.apidoc.apidoc.api.v0.erm

import io.flow.event.relation.mapper.schema.ErmSpec
import io.apibuilder.spec.v0.models.{Enum, EnumValue, Field, Model, Union, UnionType}
import januar.apidoc.apidoc.api.v0.models.Application
import januar.apidoc.apidoc.api.v0.models.ApplicationForm
import januar.apidoc.apidoc.api.v0.models.ApplicationSummary
import januar.apidoc.apidoc.api.v0.models.Attribute
import januar.apidoc.apidoc.api.v0.models.AttributeForm
import januar.apidoc.apidoc.api.v0.models.AttributeSummary
import januar.apidoc.apidoc.api.v0.models.AttributeValue
import januar.apidoc.apidoc.api.v0.models.AttributeValueForm
import januar.apidoc.apidoc.api.v0.models.Change
import januar.apidoc.apidoc.api.v0.models.ChangeVersion
import januar.apidoc.apidoc.api.v0.models.CleartextToken
import januar.apidoc.apidoc.api.v0.models.Code
import januar.apidoc.apidoc.api.v0.models.Diff
import januar.apidoc.apidoc.api.v0.models.DiffBreaking
import januar.apidoc.apidoc.api.v0.models.DiffNonBreaking
import januar.apidoc.apidoc.api.v0.models.Domain
import januar.apidoc.apidoc.api.v0.models.EmailVerificationConfirmationForm
import januar.apidoc.apidoc.api.v0.models.Error
import januar.apidoc.apidoc.api.v0.models.GeneratorForm
import januar.apidoc.apidoc.api.v0.models.GeneratorService
import januar.apidoc.apidoc.api.v0.models.GeneratorServiceForm
import januar.apidoc.apidoc.api.v0.models.GeneratorWithService
import januar.apidoc.apidoc.api.v0.models.Item
import januar.apidoc.apidoc.api.v0.models.ItemDetail
import januar.apidoc.apidoc.api.v0.models.Membership
import januar.apidoc.apidoc.api.v0.models.MembershipRequest
import januar.apidoc.apidoc.api.v0.models.MoveForm
import januar.apidoc.apidoc.api.v0.models.Organization
import januar.apidoc.apidoc.api.v0.models.OrganizationForm
import januar.apidoc.apidoc.api.v0.models.Original
import januar.apidoc.apidoc.api.v0.models.OriginalForm
import januar.apidoc.apidoc.api.v0.models.OriginalType
import januar.apidoc.apidoc.api.v0.models.PasswordReset
import januar.apidoc.apidoc.api.v0.models.PasswordResetRequest
import januar.apidoc.apidoc.api.v0.models.PasswordResetSuccess
import januar.apidoc.apidoc.api.v0.models.Publication
import januar.apidoc.apidoc.api.v0.models.Subscription
import januar.apidoc.apidoc.api.v0.models.SubscriptionForm
import januar.apidoc.apidoc.api.v0.models.Token
import januar.apidoc.apidoc.api.v0.models.TokenForm
import januar.apidoc.apidoc.api.v0.models.User
import januar.apidoc.apidoc.api.v0.models.UserForm
import januar.apidoc.apidoc.api.v0.models.UserSummary
import januar.apidoc.apidoc.api.v0.models.UserUpdateForm
import januar.apidoc.apidoc.api.v0.models.Validation
import januar.apidoc.apidoc.api.v0.models.Version
import januar.apidoc.apidoc.api.v0.models.VersionForm
import januar.apidoc.apidoc.api.v0.models.Visibility
import januar.apidoc.apidoc.api.v0.models.Watch
import januar.apidoc.apidoc.api.v0.models.WatchForm

object GeneratedErmSchema {

  implicit lazy val ermSpecApplication: ErmSpec[Application] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.application",
      spec = Model(name = "application", plural = "applications", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "com.bryzek.apidoc.common.v0.models.reference", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "key", `type` = "string", required = true),
        Field(name = "visibility", `type` = "visibility", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecApplicationForm: ErmSpec[ApplicationForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.application_form",
      spec = Model(name = "application_form", plural = "application_forms", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "key", `type` = "string", required = false),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "visibility", `type` = "visibility", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecApplicationSummary: ErmSpec[ApplicationSummary] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.application_summary",
      spec = Model(name = "application_summary", plural = "application_summaries", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "com.bryzek.apidoc.common.v0.models.reference", required = true),
        Field(name = "key", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecAttribute: ErmSpec[Attribute] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.attribute",
      spec = Model(name = "attribute", plural = "attributes", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
    )

  implicit lazy val ermSpecAttributeForm: ErmSpec[AttributeForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.attribute_form",
      spec = Model(name = "attribute_form", plural = "attribute_forms", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecAttributeSummary: ErmSpec[AttributeSummary] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.attribute_summary",
      spec = Model(name = "attribute_summary", plural = "attribute_summaries", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "name", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecAttributeValue: ErmSpec[AttributeValue] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.attribute_value",
      spec = Model(name = "attribute_value", plural = "attribute_values", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "attribute", `type` = "attribute_summary", required = true),
        Field(name = "value", `type` = "string", required = true),
        Field(name = "radomstuff", `type` = "string", required = true),
        Field(name = "radomstuff2", `type` = "string", required = false),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.attribute_summary" -> ermSpecAttributeSummary,
      ),
    )

  implicit lazy val ermSpecAttributeValueForm: ErmSpec[AttributeValueForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.attribute_value_form",
      spec = Model(name = "attribute_value_form", plural = "attribute_value_forms", fields = Seq(
        Field(name = "value", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecChangeVersion: ErmSpec[ChangeVersion] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.change_version",
      spec = Model(name = "change_version", plural = "change_versions", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "version", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecUserSummary: ErmSpec[UserSummary] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.user_summary",
      spec = Model(name = "user_summary", plural = "user_summaries", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "nickname", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecChange: ErmSpec[Change] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.change",
      spec = Model(name = "change", plural = "changes", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "com.bryzek.apidoc.common.v0.models.reference", required = true),
        Field(name = "application", `type` = "com.bryzek.apidoc.common.v0.models.reference", required = true),
        Field(name = "from_version", `type` = "change_version", required = true),
        Field(name = "to_version", `type` = "change_version", required = true),
        Field(name = "diff", `type` = "diff", required = true),
        Field(name = "changed_at", `type` = "date-time-iso8601", required = true),
        Field(name = "changed_by", `type` = "user_summary", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.change_version" -> ermSpecChangeVersion,
        "januar.apidoc.apidoc.api.v0.unions.diff" -> ermSpecDiff,
        "januar.apidoc.apidoc.api.v0.models.user_summary" -> ermSpecUserSummary,
      ),
    )

  implicit lazy val ermSpecCleartextToken: ErmSpec[CleartextToken] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.cleartext_token",
      spec = Model(name = "cleartext_token", plural = "cleartext_tokens", fields = Seq(
        Field(name = "token", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecGeneratorService: ErmSpec[GeneratorService] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.generator_service",
      spec = Model(name = "generator_service", plural = "generator_services", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "uri", `type` = "string", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
    )

  implicit lazy val ermSpecGeneratorWithService: ErmSpec[GeneratorWithService] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.generator_with_service",
      spec = Model(name = "generator_with_service", plural = "generator_with_services", fields = Seq(
        Field(name = "service", `type` = "generator_service", required = true),
        Field(name = "generator", `type` = "com.bryzek.apidoc.generator.v0.models.generator", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.generator_service" -> ermSpecGeneratorService,
      ),
    )

  implicit lazy val ermSpecCode: ErmSpec[Code] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.code",
      spec = Model(name = "code", plural = "code", fields = Seq(
        Field(name = "generator", `type` = "generator_with_service", required = true),
        Field(name = "source", `type` = "string", required = true),
        Field(name = "files", `type` = "[com.bryzek.apidoc.generator.v0.models.file]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.generator_with_service" -> ermSpecGeneratorWithService,
      ),
    )

  implicit lazy val ermSpecDiffBreaking: ErmSpec[DiffBreaking] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.diff_breaking",
      spec = Model(name = "diff_breaking", plural = "diff_breakings", fields = Seq(
        Field(name = "description", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecDiffNonBreaking: ErmSpec[DiffNonBreaking] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.diff_non_breaking",
      spec = Model(name = "diff_non_breaking", plural = "diff_non_breakings", fields = Seq(
        Field(name = "description", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecDomain: ErmSpec[Domain] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.domain",
      spec = Model(name = "domain", plural = "domains", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecEmailVerificationConfirmationForm: ErmSpec[EmailVerificationConfirmationForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.email_verification_confirmation_form",
      spec = Model(name = "email_verification_confirmation_form", plural = "email_verification_confirmation_forms", fields = Seq(
        Field(name = "token", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecError: ErmSpec[Error] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.error",
      spec = Model(name = "error", plural = "errors", fields = Seq(
        Field(name = "code", `type` = "string", required = true),
        Field(name = "message", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecGeneratorForm: ErmSpec[GeneratorForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.generator_form",
      spec = Model(name = "generator_form", plural = "generator_forms", fields = Seq(
        Field(name = "service_guid", `type` = "uuid", required = true),
        Field(name = "generator", `type` = "com.bryzek.apidoc.generator.v0.models.generator", required = true),
      )),
    )

  implicit lazy val ermSpecGeneratorServiceForm: ErmSpec[GeneratorServiceForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.generator_service_form",
      spec = Model(name = "generator_service_form", plural = "generator_service_forms", fields = Seq(
        Field(name = "uri", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecItem: ErmSpec[Item] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.item",
      spec = Model(name = "item", plural = "items", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "detail", `type` = "item_detail", required = true),
        Field(name = "label", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.unions.item_detail" -> ermSpecItemDetail,
      ),
    )

  implicit lazy val ermSpecUser: ErmSpec[User] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.user",
      spec = Model(name = "user", plural = "users", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "email", `type` = "string", required = true),
        Field(name = "nickname", `type` = "string", required = true),
        Field(name = "name", `type` = "string", required = false),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
    )

  implicit lazy val ermSpecOrganization: ErmSpec[Organization] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.organization",
      spec = Model(name = "organization", plural = "organizations", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "key", `type` = "string", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "namespace", `type` = "string", required = true),
        Field(name = "visibility", `type` = "visibility", required = true),
        Field(name = "domains", `type` = "[domain]", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.visibility" -> ermSpecVisibility,
        "januar.apidoc.apidoc.api.v0.models.domain" -> ermSpecDomain,
      ),
    )

  implicit lazy val ermSpecMembership: ErmSpec[Membership] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.membership",
      spec = Model(name = "membership", plural = "memberships", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "user", `type` = "user", required = true),
        Field(name = "organization", `type` = "organization", required = true),
        Field(name = "role", `type` = "string", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.user" -> ermSpecUser,
        "januar.apidoc.apidoc.api.v0.models.organization" -> ermSpecOrganization,
      ),
    )

  implicit lazy val ermSpecMembershipRequest: ErmSpec[MembershipRequest] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.membership_request",
      spec = Model(name = "membership_request", plural = "membership_requests", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "user", `type` = "user", required = true),
        Field(name = "organization", `type` = "organization", required = true),
        Field(name = "role", `type` = "string", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.user" -> ermSpecUser,
        "januar.apidoc.apidoc.api.v0.models.organization" -> ermSpecOrganization,
      ),
    )

  implicit lazy val ermSpecMoveForm: ErmSpec[MoveForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.move_form",
      spec = Model(name = "move_form", plural = "move_forms", fields = Seq(
        Field(name = "org_key", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecOrganizationForm: ErmSpec[OrganizationForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.organization_form",
      spec = Model(name = "organization_form", plural = "organization_forms", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "key", `type` = "string", required = false),
        Field(name = "namespace", `type` = "string", required = true),
        Field(name = "visibility", `type` = "visibility", required = true),
        Field(name = "domains", `type` = "[string]", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecOriginal: ErmSpec[Original] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.original",
      spec = Model(name = "original", plural = "originals", fields = Seq(
        Field(name = "type", `type` = "original_type", required = true),
        Field(name = "data", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.original_type" -> ermSpecOriginalType,
      ),
    )

  implicit lazy val ermSpecOriginalForm: ErmSpec[OriginalForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.original_form",
      spec = Model(name = "original_form", plural = "original_forms", fields = Seq(
        Field(name = "type", `type` = "original_type", required = false),
        Field(name = "data", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.original_type" -> ermSpecOriginalType,
      ),
    )

  implicit lazy val ermSpecPasswordReset: ErmSpec[PasswordReset] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.password_reset",
      spec = Model(name = "password_reset", plural = "password_resets", fields = Seq(
        Field(name = "token", `type` = "string", required = true),
        Field(name = "password", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecPasswordResetRequest: ErmSpec[PasswordResetRequest] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.password_reset_request",
      spec = Model(name = "password_reset_request", plural = "password_reset_requests", fields = Seq(
        Field(name = "email", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecPasswordResetSuccess: ErmSpec[PasswordResetSuccess] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.password_reset_success",
      spec = Model(name = "password_reset_success", plural = "password_reset_successes", fields = Seq(
        Field(name = "user_guid", `type` = "uuid", required = true),
      )),
    )

  implicit lazy val ermSpecSubscription: ErmSpec[Subscription] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.subscription",
      spec = Model(name = "subscription", plural = "subscriptions", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "organization", required = true),
        Field(name = "user", `type` = "user", required = true),
        Field(name = "publication", `type` = "publication", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.organization" -> ermSpecOrganization,
        "januar.apidoc.apidoc.api.v0.models.user" -> ermSpecUser,
        "januar.apidoc.apidoc.api.v0.enums.publication" -> ermSpecPublication,
      ),
    )

  implicit lazy val ermSpecSubscriptionForm: ErmSpec[SubscriptionForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.subscription_form",
      spec = Model(name = "subscription_form", plural = "subscription_forms", fields = Seq(
        Field(name = "organization_key", `type` = "string", required = true),
        Field(name = "user_guid", `type` = "uuid", required = true),
        Field(name = "publication", `type` = "publication", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.enums.publication" -> ermSpecPublication,
      ),
    )

  implicit lazy val ermSpecToken: ErmSpec[Token] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.token",
      spec = Model(name = "token", plural = "tokens", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "user", `type` = "user", required = true),
        Field(name = "masked_token", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.user" -> ermSpecUser,
      ),
    )

  implicit lazy val ermSpecTokenForm: ErmSpec[TokenForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.token_form",
      spec = Model(name = "token_form", plural = "token_forms", fields = Seq(
        Field(name = "user_guid", `type` = "uuid", required = true),
        Field(name = "description", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecUserForm: ErmSpec[UserForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.user_form",
      spec = Model(name = "user_form", plural = "user_forms", fields = Seq(
        Field(name = "email", `type` = "string", required = true),
        Field(name = "password", `type` = "string", required = true),
        Field(name = "nickname", `type` = "string", required = false),
        Field(name = "name", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecUserUpdateForm: ErmSpec[UserUpdateForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.user_update_form",
      spec = Model(name = "user_update_form", plural = "user_update_forms", fields = Seq(
        Field(name = "email", `type` = "string", required = true),
        Field(name = "nickname", `type` = "string", required = true),
        Field(name = "name", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecValidation: ErmSpec[Validation] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.validation",
      spec = Model(name = "validation", plural = "validations", fields = Seq(
        Field(name = "valid", `type` = "boolean", required = true),
        Field(name = "errors", `type` = "[string]", required = true),
      )),
    )

  implicit lazy val ermSpecVersion: ErmSpec[Version] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.version",
      spec = Model(name = "version", plural = "versions", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "com.bryzek.apidoc.common.v0.models.reference", required = true),
        Field(name = "application", `type` = "com.bryzek.apidoc.common.v0.models.reference", required = true),
        Field(name = "version", `type` = "string", required = true),
        Field(name = "original", `type` = "original", required = false),
        Field(name = "service", `type` = "com.bryzek.apidoc.spec.v0.models.service", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.original" -> ermSpecOriginal,
      ),
    )

  implicit lazy val ermSpecVersionForm: ErmSpec[VersionForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.version_form",
      spec = Model(name = "version_form", plural = "version_forms", fields = Seq(
        Field(name = "original_form", `type` = "original_form", required = true),
        Field(name = "visibility", `type` = "visibility", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.original_form" -> ermSpecOriginalForm,
        "januar.apidoc.apidoc.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecWatch: ErmSpec[Watch] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.watch",
      spec = Model(name = "watch", plural = "watches", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "user", `type` = "user", required = true),
        Field(name = "organization", `type` = "organization", required = true),
        Field(name = "application", `type` = "application", required = true),
        Field(name = "audit", `type` = "com.bryzek.apidoc.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.user" -> ermSpecUser,
        "januar.apidoc.apidoc.api.v0.models.organization" -> ermSpecOrganization,
        "januar.apidoc.apidoc.api.v0.models.application" -> ermSpecApplication,
      ),
    )

  implicit lazy val ermSpecWatchForm: ErmSpec[WatchForm] =
    ErmSpec.model(
      qualifiedName = "januar.apidoc.apidoc.api.v0.models.watch_form",
      spec = Model(name = "watch_form", plural = "watch_forms", fields = Seq(
        Field(name = "user_guid", `type` = "uuid", required = true),
        Field(name = "organization_key", `type` = "string", required = true),
        Field(name = "application_key", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecDiff: ErmSpec[Diff] =
    ErmSpec.union(
      qualifiedName = "januar.apidoc.apidoc.api.v0.unions.diff",
      spec = Union(name = "diff", plural = "diffs", discriminator = Some("type"), types = Seq(
        UnionType(`type` = "diff_breaking", discriminatorValue = Some("diff_breaking")),
        UnionType(`type` = "diff_non_breaking", discriminatorValue = Some("diff_non_breaking")),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.diff_breaking" -> ermSpecDiffBreaking,
        "januar.apidoc.apidoc.api.v0.models.diff_non_breaking" -> ermSpecDiffNonBreaking,
      ),
    )

  implicit lazy val ermSpecItemDetail: ErmSpec[ItemDetail] =
    ErmSpec.union(
      qualifiedName = "januar.apidoc.apidoc.api.v0.unions.item_detail",
      spec = Union(name = "item_detail", plural = "item_details", discriminator = Some("type"), types = Seq(
        UnionType(`type` = "application_summary", discriminatorValue = Some("application_summary")),
      )),
      resolved = Map[String, ErmSpec[_]](
        "januar.apidoc.apidoc.api.v0.models.application_summary" -> ermSpecApplicationSummary,
      ),
    )

  implicit lazy val ermSpecVisibility: ErmSpec[Visibility] =
    ErmSpec.`enum`(
      qualifiedName = "januar.apidoc.apidoc.api.v0.enums.visibility",
      spec = Enum(name = "visibility", plural = "visibilities", values = Seq(
        EnumValue(name = "user"),
        EnumValue(name = "organization"),
        EnumValue(name = "public"),
      )),
    )

  implicit lazy val ermSpecOriginalType: ErmSpec[OriginalType] =
    ErmSpec.`enum`(
      qualifiedName = "januar.apidoc.apidoc.api.v0.enums.original_type",
      spec = Enum(name = "original_type", plural = "original_types", values = Seq(
        EnumValue(name = "api_json"),
        EnumValue(name = "avro_idl"),
        EnumValue(name = "service_json"),
        EnumValue(name = "swagger_json"),
      )),
    )

  implicit lazy val ermSpecPublication: ErmSpec[Publication] =
    ErmSpec.`enum`(
      qualifiedName = "januar.apidoc.apidoc.api.v0.enums.publication",
      spec = Enum(name = "publication", plural = "publications", values = Seq(
        EnumValue(name = "membership_requests.create"),
        EnumValue(name = "memberships.create"),
        EnumValue(name = "applications.create"),
        EnumValue(name = "versions.create"),
      )),
    )

  val all: Seq[ErmSpec[_]] = Seq(
    ermSpecApplication,
    ermSpecApplicationForm,
    ermSpecApplicationSummary,
    ermSpecAttribute,
    ermSpecAttributeForm,
    ermSpecAttributeSummary,
    ermSpecAttributeValue,
    ermSpecAttributeValueForm,
    ermSpecChangeVersion,
    ermSpecUserSummary,
    ermSpecChange,
    ermSpecCleartextToken,
    ermSpecGeneratorService,
    ermSpecGeneratorWithService,
    ermSpecCode,
    ermSpecDiffBreaking,
    ermSpecDiffNonBreaking,
    ermSpecDomain,
    ermSpecEmailVerificationConfirmationForm,
    ermSpecError,
    ermSpecGeneratorForm,
    ermSpecGeneratorServiceForm,
    ermSpecItem,
    ermSpecUser,
    ermSpecOrganization,
    ermSpecMembership,
    ermSpecMembershipRequest,
    ermSpecMoveForm,
    ermSpecOrganizationForm,
    ermSpecOriginal,
    ermSpecOriginalForm,
    ermSpecPasswordReset,
    ermSpecPasswordResetRequest,
    ermSpecPasswordResetSuccess,
    ermSpecSubscription,
    ermSpecSubscriptionForm,
    ermSpecToken,
    ermSpecTokenForm,
    ermSpecUserForm,
    ermSpecUserUpdateForm,
    ermSpecValidation,
    ermSpecVersion,
    ermSpecVersionForm,
    ermSpecWatch,
    ermSpecWatchForm,
    ermSpecDiff,
    ermSpecItemDetail,
    ermSpecVisibility,
    ermSpecOriginalType,
    ermSpecPublication,
  )
}