/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.14.3-46-g35788525
 * User agent: apibuilder app.apibuilder.io/apicollective/apibuilder-api/0.14.3-46-g35788525/flow_erm_schema
 */
package io.apibuilder.api.v0.erm

import io.flow.event.relation.mapper.schema.ErmSpec
import io.apibuilder.spec.v0.models.{Enum, EnumValue, Field, Model, Union, UnionType}
import io.apibuilder.api.v0.models.Application
import io.apibuilder.api.v0.models.ApplicationForm
import io.apibuilder.api.v0.models.ApplicationMetadata
import io.apibuilder.api.v0.models.ApplicationMetadataVersion
import io.apibuilder.api.v0.models.ApplicationSummary
import io.apibuilder.api.v0.models.Attribute
import io.apibuilder.api.v0.models.AttributeForm
import io.apibuilder.api.v0.models.AttributeSummary
import io.apibuilder.api.v0.models.AttributeValue
import io.apibuilder.api.v0.models.AttributeValueForm
import io.apibuilder.api.v0.models.Authentication
import io.apibuilder.api.v0.models.Change
import io.apibuilder.api.v0.models.ChangeVersion
import io.apibuilder.api.v0.models.CleartextToken
import io.apibuilder.api.v0.models.Code
import io.apibuilder.api.v0.models.Diff
import io.apibuilder.api.v0.models.DiffBreaking
import io.apibuilder.api.v0.models.DiffNonBreaking
import io.apibuilder.api.v0.models.Domain
import io.apibuilder.api.v0.models.EmailVerificationConfirmationForm
import io.apibuilder.api.v0.models.Error
import io.apibuilder.api.v0.models.GeneratorForm
import io.apibuilder.api.v0.models.GeneratorService
import io.apibuilder.api.v0.models.GeneratorServiceForm
import io.apibuilder.api.v0.models.GeneratorWithService
import io.apibuilder.api.v0.models.Item
import io.apibuilder.api.v0.models.ItemDetail
import io.apibuilder.api.v0.models.Membership
import io.apibuilder.api.v0.models.MembershipRequest
import io.apibuilder.api.v0.models.MoveForm
import io.apibuilder.api.v0.models.Organization
import io.apibuilder.api.v0.models.OrganizationForm
import io.apibuilder.api.v0.models.Original
import io.apibuilder.api.v0.models.OriginalForm
import io.apibuilder.api.v0.models.OriginalType
import io.apibuilder.api.v0.models.PasswordReset
import io.apibuilder.api.v0.models.PasswordResetRequest
import io.apibuilder.api.v0.models.Publication
import io.apibuilder.api.v0.models.Session
import io.apibuilder.api.v0.models.Subscription
import io.apibuilder.api.v0.models.SubscriptionForm
import io.apibuilder.api.v0.models.Token
import io.apibuilder.api.v0.models.TokenForm
import io.apibuilder.api.v0.models.User
import io.apibuilder.api.v0.models.UserForm
import io.apibuilder.api.v0.models.UserSummary
import io.apibuilder.api.v0.models.UserUpdateForm
import io.apibuilder.api.v0.models.Validation
import io.apibuilder.api.v0.models.Version
import io.apibuilder.api.v0.models.VersionForm
import io.apibuilder.api.v0.models.Visibility
import io.apibuilder.api.v0.models.Watch
import io.apibuilder.api.v0.models.WatchForm
import io.apibuilder.common.v0.models.Audit
import io.apibuilder.common.v0.models.Reference
import io.apibuilder.common.v0.models.ReferenceGuid
import io.apibuilder.generator.v0.models.File
import io.apibuilder.generator.v0.models.Generator
import io.apibuilder.spec.v0.models.Annotation
import io.apibuilder.spec.v0.models.Apidoc
import io.apibuilder.spec.v0.models.Body
import io.apibuilder.spec.v0.models.Contact
import io.apibuilder.spec.v0.models.Deprecation
import io.apibuilder.spec.v0.models.Enum
import io.apibuilder.spec.v0.models.EnumValue
import io.apibuilder.spec.v0.models.Field
import io.apibuilder.spec.v0.models.Header
import io.apibuilder.spec.v0.models.Import
import io.apibuilder.spec.v0.models.Info
import io.apibuilder.spec.v0.models.Interface
import io.apibuilder.spec.v0.models.License
import io.apibuilder.spec.v0.models.Model
import io.apibuilder.spec.v0.models.Operation
import io.apibuilder.spec.v0.models.Parameter
import io.apibuilder.spec.v0.models.Resource
import io.apibuilder.spec.v0.models.Response
import io.apibuilder.spec.v0.models.Service
import io.apibuilder.spec.v0.models.Union
import io.apibuilder.spec.v0.models.UnionType

object GeneratedErmSchema {

  implicit lazy val ermSpecReference: ErmSpec[Reference] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.common.v0.models.reference",
      spec = Model(name = "reference", plural = "references", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "key", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecReferenceGuid: ErmSpec[ReferenceGuid] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.common.v0.models.reference_guid",
      spec = Model(name = "reference_guid", plural = "reference_guids", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
      )),
    )

  implicit lazy val ermSpecAudit: ErmSpec[Audit] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.common.v0.models.audit",
      spec = Model(name = "audit", plural = "audits", fields = Seq(
        Field(name = "created_at", `type` = "date-time-iso8601", required = true),
        Field(name = "created_by", `type` = "reference_guid", required = true),
        Field(name = "updated_at", `type` = "date-time-iso8601", required = true),
        Field(name = "updated_by", `type` = "reference_guid", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.reference_guid" -> ermSpecReferenceGuid,
      ),
    )

  implicit lazy val ermSpecApplication: ErmSpec[Application] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.api.v0.models.application",
      spec = Model(name = "application", plural = "applications", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "io.apibuilder.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 = "last_updated_at", `type` = "date-time-iso8601", required = true),
        Field(name = "audit", `type` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.reference" -> ermSpecReference,
        "io.apibuilder.api.v0.enums.visibility" -> ermSpecVisibility,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecApplicationForm: ErmSpec[ApplicationForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecApplicationMetadata: ErmSpec[ApplicationMetadata] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.api.v0.models.application_metadata",
      spec = Model(name = "application_metadata", plural = "application_metadata", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "key", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecApplicationMetadataVersion: ErmSpec[ApplicationMetadataVersion] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.api.v0.models.application_metadata_version",
      spec = Model(name = "application_metadata_version", plural = "application_metadata_versions", fields = Seq(
        Field(name = "version", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecApplicationSummary: ErmSpec[ApplicationSummary] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.reference", required = true),
        Field(name = "key", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.reference" -> ermSpecReference,
      ),
    )

  implicit lazy val ermSpecAttribute: ErmSpec[Attribute] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecAttributeForm: ErmSpec[AttributeForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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 = "audit", `type` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.attribute_summary" -> ermSpecAttributeSummary,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecAttributeValueForm: ErmSpec[AttributeValueForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 ermSpecUser: ErmSpec[User] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecSession: ErmSpec[Session] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.api.v0.models.session",
      spec = Model(name = "session", plural = "sessions", fields = Seq(
        Field(name = "id", `type` = "string", required = true),
        Field(name = "expires_at", `type` = "date-time-iso8601", required = true),
      )),
    )

  implicit lazy val ermSpecAuthentication: ErmSpec[Authentication] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.api.v0.models.authentication",
      spec = Model(name = "authentication", plural = "authentications", fields = Seq(
        Field(name = "user", `type` = "user", required = true),
        Field(name = "session", `type` = "session", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.user" -> ermSpecUser,
        "io.apibuilder.api.v0.models.session" -> ermSpecSession,
      ),
    )

  implicit lazy val ermSpecChangeVersion: ErmSpec[ChangeVersion] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.api.v0.models.change",
      spec = Model(name = "change", plural = "changes", fields = Seq(
        Field(name = "guid", `type` = "uuid", required = true),
        Field(name = "organization", `type` = "io.apibuilder.common.v0.models.reference", required = true),
        Field(name = "application", `type` = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.reference" -> ermSpecReference,
        "io.apibuilder.api.v0.models.change_version" -> ermSpecChangeVersion,
        "io.apibuilder.api.v0.unions.diff" -> ermSpecDiff,
        "io.apibuilder.api.v0.models.user_summary" -> ermSpecUserSummary,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecCleartextToken: ErmSpec[CleartextToken] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecGenerator: ErmSpec[Generator] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.generator.v0.models.generator",
      spec = Model(name = "generator", plural = "generators", fields = Seq(
        Field(name = "key", `type` = "string", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "language", `type` = "string", required = false),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "attributes", `type` = "[string]", required = true),
      )),
    )

  implicit lazy val ermSpecGeneratorWithService: ErmSpec[GeneratorWithService] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.generator.v0.models.generator", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.generator_service" -> ermSpecGeneratorService,
        "io.apibuilder.generator.v0.models.generator" -> ermSpecGenerator,
      ),
    )

  implicit lazy val ermSpecFile: ErmSpec[File] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.generator.v0.models.file",
      spec = Model(name = "file", plural = "files", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "dir", `type` = "string", required = false),
        Field(name = "contents", `type` = "string", required = true),
        Field(name = "flags", `type` = "[file_flag]", required = false),
      )),
    )

  implicit lazy val ermSpecCode: ErmSpec[Code] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "[io.apibuilder.generator.v0.models.file]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.generator_with_service" -> ermSpecGeneratorWithService,
        "io.apibuilder.generator.v0.models.file" -> ermSpecFile,
      ),
    )

  implicit lazy val ermSpecDiffBreaking: ErmSpec[DiffBreaking] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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` = "io.apibuilder.generator.v0.models.generator", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.generator.v0.models.generator" -> ermSpecGenerator,
      ),
    )

  implicit lazy val ermSpecGeneratorServiceForm: ErmSpec[GeneratorServiceForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.unions.item_detail" -> ermSpecItemDetail,
      ),
    )

  implicit lazy val ermSpecOrganization: ErmSpec[Organization] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.enums.visibility" -> ermSpecVisibility,
        "io.apibuilder.api.v0.models.domain" -> ermSpecDomain,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecMembership: ErmSpec[Membership] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.user" -> ermSpecUser,
        "io.apibuilder.api.v0.models.organization" -> ermSpecOrganization,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecMembershipRequest: ErmSpec[MembershipRequest] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.user" -> ermSpecUser,
        "io.apibuilder.api.v0.models.organization" -> ermSpecOrganization,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecMoveForm: ErmSpec[MoveForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecOriginal: ErmSpec[Original] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.enums.original_type" -> ermSpecOriginalType,
      ),
    )

  implicit lazy val ermSpecOriginalForm: ErmSpec[OriginalForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.enums.original_type" -> ermSpecOriginalType,
      ),
    )

  implicit lazy val ermSpecPasswordReset: ErmSpec[PasswordReset] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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 ermSpecSubscription: ErmSpec[Subscription] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.organization" -> ermSpecOrganization,
        "io.apibuilder.api.v0.models.user" -> ermSpecUser,
        "io.apibuilder.api.v0.enums.publication" -> ermSpecPublication,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecSubscriptionForm: ErmSpec[SubscriptionForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.enums.publication" -> ermSpecPublication,
      ),
    )

  implicit lazy val ermSpecToken: ErmSpec[Token] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.user" -> ermSpecUser,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecTokenForm: ErmSpec[TokenForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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 = "io.apibuilder.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 ermSpecApidoc: ErmSpec[Apidoc] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.apidoc",
      spec = Model(name = "apidoc", plural = "apidocs", fields = Seq(
        Field(name = "version", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecLicense: ErmSpec[License] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.license",
      spec = Model(name = "license", plural = "licenses", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecContact: ErmSpec[Contact] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.contact",
      spec = Model(name = "contact", plural = "contacts", fields = Seq(
        Field(name = "name", `type` = "string", required = false),
        Field(name = "url", `type` = "string", required = false),
        Field(name = "email", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecInfo: ErmSpec[Info] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.info",
      spec = Model(name = "info", plural = "infoes", fields = Seq(
        Field(name = "license", `type` = "license", required = false),
        Field(name = "contact", `type` = "contact", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.license" -> ermSpecLicense,
        "io.apibuilder.spec.v0.models.contact" -> ermSpecContact,
      ),
    )

  implicit lazy val ermSpecDeprecation: ErmSpec[Deprecation] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.deprecation",
      spec = Model(name = "deprecation", plural = "deprecations", fields = Seq(
        Field(name = "description", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecHeader: ErmSpec[Header] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.header",
      spec = Model(name = "header", plural = "headers", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "type", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "required", `type` = "boolean", required = true),
        Field(name = "default", `type` = "string", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecAnnotation: ErmSpec[Annotation] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.annotation",
      spec = Model(name = "annotation", plural = "annotations", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
      ),
    )

  implicit lazy val ermSpecImport: ErmSpec[Import] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.import",
      spec = Model(name = "import", plural = "imports", fields = Seq(
        Field(name = "uri", `type` = "string", required = true),
        Field(name = "namespace", `type` = "string", required = true),
        Field(name = "organization", `type` = "organization", required = true),
        Field(name = "application", `type` = "application", required = true),
        Field(name = "version", `type` = "string", required = true),
        Field(name = "enums", `type` = "[string]", required = true),
        Field(name = "interfaces", `type` = "[string]", required = true),
        Field(name = "unions", `type` = "[string]", required = true),
        Field(name = "models", `type` = "[string]", required = true),
        Field(name = "annotations", `type` = "[annotation]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.organization" -> ermSpecOrganization,
        "io.apibuilder.api.v0.models.application" -> ermSpecApplication,
        "io.apibuilder.spec.v0.models.annotation" -> ermSpecAnnotation,
      ),
    )

  implicit lazy val ermSpecEnumValue: ErmSpec[EnumValue] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.enum_value",
      spec = Model(name = "enum_value", plural = "enum_values", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = true),
        Field(name = "value", `type` = "string", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecEnum: ErmSpec[Enum] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.enum",
      spec = Model(name = "enum", plural = "enums", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "plural", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "values", `type` = "[enum_value]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.enum_value" -> ermSpecEnumValue,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecField: ErmSpec[Field] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.field",
      spec = Model(name = "field", plural = "fields", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "type", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "default", `type` = "string", required = false),
        Field(name = "required", `type` = "boolean", required = true),
        Field(name = "minimum", `type` = "long", required = false),
        Field(name = "maximum", `type` = "long", required = false),
        Field(name = "example", `type` = "string", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = true),
        Field(name = "annotations", `type` = "[string]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecInterface: ErmSpec[Interface] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.interface",
      spec = Model(name = "interface", plural = "interfaces", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "plural", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "fields", `type` = "[field]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.field" -> ermSpecField,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecUnionType: ErmSpec[UnionType] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.union_type",
      spec = Model(name = "union_type", plural = "union_types", fields = Seq(
        Field(name = "type", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "fields", `type` = "[field]", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = true),
        Field(name = "default", `type` = "boolean", required = false),
        Field(name = "discriminator_value", `type` = "string", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.field" -> ermSpecField,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecUnion: ErmSpec[Union] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.union",
      spec = Model(name = "union", plural = "unions", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "plural", `type` = "string", required = true),
        Field(name = "discriminator", `type` = "string", required = false),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "types", `type` = "[union_type]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
        Field(name = "interfaces", `type` = "[string]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.union_type" -> ermSpecUnionType,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecModel: ErmSpec[Model] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.model",
      spec = Model(name = "model", plural = "models", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "plural", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "fields", `type` = "[field]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
        Field(name = "interfaces", `type` = "[string]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.field" -> ermSpecField,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecBody: ErmSpec[Body] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.body",
      spec = Model(name = "body", plural = "bodies", fields = Seq(
        Field(name = "type", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecParameter: ErmSpec[Parameter] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.parameter",
      spec = Model(name = "parameter", plural = "parameters", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "type", `type` = "string", required = true),
        Field(name = "location", `type` = "parameter_location", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "required", `type` = "boolean", required = true),
        Field(name = "default", `type` = "string", required = false),
        Field(name = "minimum", `type` = "long", required = false),
        Field(name = "maximum", `type` = "long", required = false),
        Field(name = "example", `type` = "string", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecResponse: ErmSpec[Response] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.response",
      spec = Model(name = "response", plural = "responses", fields = Seq(
        Field(name = "code", `type` = "response_code", required = true),
        Field(name = "type", `type` = "string", required = true),
        Field(name = "headers", `type` = "[header]", required = false),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "attributes", `type` = "[attribute]", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.header" -> ermSpecHeader,
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecOperation: ErmSpec[Operation] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.operation",
      spec = Model(name = "operation", plural = "operations", fields = Seq(
        Field(name = "method", `type` = "method", required = true),
        Field(name = "path", `type` = "string", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "body", `type` = "body", required = false),
        Field(name = "parameters", `type` = "[parameter]", required = true),
        Field(name = "responses", `type` = "[response]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.body" -> ermSpecBody,
        "io.apibuilder.spec.v0.models.parameter" -> ermSpecParameter,
        "io.apibuilder.spec.v0.models.response" -> ermSpecResponse,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecResource: ErmSpec[Resource] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.resource",
      spec = Model(name = "resource", plural = "resources", fields = Seq(
        Field(name = "type", `type` = "string", required = true),
        Field(name = "plural", `type` = "string", required = true),
        Field(name = "path", `type` = "string", required = false),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "deprecation", `type` = "deprecation", required = false),
        Field(name = "operations", `type` = "[operation]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.deprecation" -> ermSpecDeprecation,
        "io.apibuilder.spec.v0.models.operation" -> ermSpecOperation,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
      ),
    )

  implicit lazy val ermSpecService: ErmSpec[Service] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.spec.v0.models.service",
      spec = Model(name = "service", plural = "services", fields = Seq(
        Field(name = "apidoc", `type` = "apidoc", required = false),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "organization", `type` = "organization", required = true),
        Field(name = "application", `type` = "application", required = true),
        Field(name = "namespace", `type` = "string", required = true),
        Field(name = "version", `type` = "string", required = true),
        Field(name = "base_url", `type` = "string", required = false),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "info", `type` = "info", required = true),
        Field(name = "headers", `type` = "[header]", required = true),
        Field(name = "imports", `type` = "[import]", required = true),
        Field(name = "enums", `type` = "[enum]", required = true),
        Field(name = "interfaces", `type` = "[interface]", required = true),
        Field(name = "unions", `type` = "[union]", required = true),
        Field(name = "models", `type` = "[model]", required = true),
        Field(name = "resources", `type` = "[resource]", required = true),
        Field(name = "attributes", `type` = "[attribute]", required = true),
        Field(name = "annotations", `type` = "[annotation]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.spec.v0.models.apidoc" -> ermSpecApidoc,
        "io.apibuilder.api.v0.models.organization" -> ermSpecOrganization,
        "io.apibuilder.api.v0.models.application" -> ermSpecApplication,
        "io.apibuilder.spec.v0.models.info" -> ermSpecInfo,
        "io.apibuilder.spec.v0.models.header" -> ermSpecHeader,
        "io.apibuilder.spec.v0.models.import" -> ermSpecImport,
        "io.apibuilder.spec.v0.models.enum" -> ermSpecEnum,
        "io.apibuilder.spec.v0.models.interface" -> ermSpecInterface,
        "io.apibuilder.spec.v0.models.union" -> ermSpecUnion,
        "io.apibuilder.spec.v0.models.model" -> ermSpecModel,
        "io.apibuilder.spec.v0.models.resource" -> ermSpecResource,
        "io.apibuilder.api.v0.models.attribute" -> ermSpecAttribute,
        "io.apibuilder.spec.v0.models.annotation" -> ermSpecAnnotation,
      ),
    )

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

  implicit lazy val ermSpecVersionForm: ErmSpec[VersionForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.models.original_form" -> ermSpecOriginalForm,
        "io.apibuilder.api.v0.enums.visibility" -> ermSpecVisibility,
      ),
    )

  implicit lazy val ermSpecWatch: ErmSpec[Watch] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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` = "io.apibuilder.common.v0.models.audit", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.apibuilder.api.v0.models.user" -> ermSpecUser,
        "io.apibuilder.api.v0.models.organization" -> ermSpecOrganization,
        "io.apibuilder.api.v0.models.application" -> ermSpecApplication,
        "io.apibuilder.common.v0.models.audit" -> ermSpecAudit,
      ),
    )

  implicit lazy val ermSpecWatchForm: ErmSpec[WatchForm] =
    ErmSpec.model(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.models.diff_breaking" -> ermSpecDiffBreaking,
        "io.apibuilder.api.v0.models.diff_non_breaking" -> ermSpecDiffNonBreaking,
      ),
    )

  implicit lazy val ermSpecItemDetail: ErmSpec[ItemDetail] =
    ErmSpec.union(
      qualifiedName = "io.apibuilder.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[_]](
        "io.apibuilder.api.v0.models.application_summary" -> ermSpecApplicationSummary,
      ),
    )

  implicit lazy val ermSpecVisibility: ErmSpec[Visibility] =
    ErmSpec.`enum`(
      qualifiedName = "io.apibuilder.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 = "io.apibuilder.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"),
      )),
    )

  implicit lazy val ermSpecPublication: ErmSpec[Publication] =
    ErmSpec.`enum`(
      qualifiedName = "io.apibuilder.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(
    ermSpecReference,
    ermSpecReferenceGuid,
    ermSpecAudit,
    ermSpecApplication,
    ermSpecApplicationForm,
    ermSpecApplicationMetadata,
    ermSpecApplicationMetadataVersion,
    ermSpecApplicationSummary,
    ermSpecAttribute,
    ermSpecAttributeForm,
    ermSpecAttributeSummary,
    ermSpecAttributeValue,
    ermSpecAttributeValueForm,
    ermSpecUser,
    ermSpecSession,
    ermSpecAuthentication,
    ermSpecChangeVersion,
    ermSpecUserSummary,
    ermSpecChange,
    ermSpecCleartextToken,
    ermSpecGeneratorService,
    ermSpecGenerator,
    ermSpecGeneratorWithService,
    ermSpecFile,
    ermSpecCode,
    ermSpecDiffBreaking,
    ermSpecDiffNonBreaking,
    ermSpecDomain,
    ermSpecEmailVerificationConfirmationForm,
    ermSpecError,
    ermSpecGeneratorForm,
    ermSpecGeneratorServiceForm,
    ermSpecItem,
    ermSpecOrganization,
    ermSpecMembership,
    ermSpecMembershipRequest,
    ermSpecMoveForm,
    ermSpecOrganizationForm,
    ermSpecOriginal,
    ermSpecOriginalForm,
    ermSpecPasswordReset,
    ermSpecPasswordResetRequest,
    ermSpecSubscription,
    ermSpecSubscriptionForm,
    ermSpecToken,
    ermSpecTokenForm,
    ermSpecUserForm,
    ermSpecUserUpdateForm,
    ermSpecValidation,
    ermSpecApidoc,
    ermSpecLicense,
    ermSpecContact,
    ermSpecInfo,
    ermSpecDeprecation,
    ermSpecHeader,
    ermSpecAnnotation,
    ermSpecImport,
    ermSpecEnumValue,
    ermSpecEnum,
    ermSpecField,
    ermSpecInterface,
    ermSpecUnionType,
    ermSpecUnion,
    ermSpecModel,
    ermSpecBody,
    ermSpecParameter,
    ermSpecResponse,
    ermSpecOperation,
    ermSpecResource,
    ermSpecService,
    ermSpecVersion,
    ermSpecVersionForm,
    ermSpecWatch,
    ermSpecWatchForm,
    ermSpecDiff,
    ermSpecItemDetail,
    ermSpecVisibility,
    ermSpecOriginalType,
    ermSpecPublication,
  )
}