/**
 * Generated by API Builder - https://www.apibuilder.io
 * Service version: 0.4.64
 * User agent: apibuilder app.apibuilder.io/flow/github/0.4.64/flow_erm_schema
 */
package io.flow.github.v0.erm

import io.flow.event.relation.mapper.schema.ErmSpec
import io.apibuilder.spec.v0.models.{Enum, EnumValue, Field, Model, Union, UnionType}
import io.flow.github.v0.models.Blob
import io.flow.github.v0.models.BlobCreated
import io.flow.github.v0.models.BlobForm
import io.flow.github.v0.models.Commit
import io.flow.github.v0.models.CommitForm
import io.flow.github.v0.models.CommitResponse
import io.flow.github.v0.models.CommitSummary
import io.flow.github.v0.models.Contents
import io.flow.github.v0.models.ContentsType
import io.flow.github.v0.models.CreateTreeForm
import io.flow.github.v0.models.CreateTreeResponse
import io.flow.github.v0.models.Encoding
import io.flow.github.v0.models.Error
import io.flow.github.v0.models.GithubObject
import io.flow.github.v0.models.Hook
import io.flow.github.v0.models.HookConfig
import io.flow.github.v0.models.HookEvent
import io.flow.github.v0.models.HookForm
import io.flow.github.v0.models.Node
import io.flow.github.v0.models.NodeForm
import io.flow.github.v0.models.NodeType
import io.flow.github.v0.models.OwnerType
import io.flow.github.v0.models.Person
import io.flow.github.v0.models.PullRequest
import io.flow.github.v0.models.PullRequestForm
import io.flow.github.v0.models.PullRequestHead
import io.flow.github.v0.models.Ref
import io.flow.github.v0.models.RefForm
import io.flow.github.v0.models.RefUpdateForm
import io.flow.github.v0.models.Repository
import io.flow.github.v0.models.Tag
import io.flow.github.v0.models.TagForm
import io.flow.github.v0.models.TagSummary
import io.flow.github.v0.models.Tagger
import io.flow.github.v0.models.Tree
import io.flow.github.v0.models.TreeForm
import io.flow.github.v0.models.TreeResult
import io.flow.github.v0.models.TreeSummary
import io.flow.github.v0.models.UnprocessableEntity
import io.flow.github.v0.models.User
import io.flow.github.v0.models.UserEmail
import io.flow.github.v0.models.UserOrg

object GeneratedErmSchema {

  implicit lazy val ermSpecBlob: ErmSpec[Blob] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.blob",
      spec = Model(name = "blob", plural = "blobs", fields = Seq(
        Field(name = "content", `type` = "string", required = true),
        Field(name = "encoding", `type` = "encoding", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "size", `type` = "long", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.encoding" -> ermSpecEncoding,
      ),
    )

  implicit lazy val ermSpecBlobCreated: ErmSpec[BlobCreated] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.blob_created",
      spec = Model(name = "blob_created", plural = "blob_createds", fields = Seq(
        Field(name = "url", `type` = "string", required = true),
        Field(name = "sha", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecBlobForm: ErmSpec[BlobForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.blob_form",
      spec = Model(name = "blob_form", plural = "blob_forms", fields = Seq(
        Field(name = "content", `type` = "string", required = true),
        Field(name = "encoding", `type` = "encoding", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.encoding" -> ermSpecEncoding,
      ),
    )

  implicit lazy val ermSpecPerson: ErmSpec[Person] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.person",
      spec = Model(name = "person", plural = "people", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "email", `type` = "string", required = true),
        Field(name = "date", `type` = "date-time-iso8601", required = true),
      )),
    )

  implicit lazy val ermSpecTreeSummary: ErmSpec[TreeSummary] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tree_summary",
      spec = Model(name = "tree_summary", plural = "tree_summaries", fields = Seq(
        Field(name = "url", `type` = "string", required = true),
        Field(name = "sha", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecCommitSummary: ErmSpec[CommitSummary] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.commit_summary",
      spec = Model(name = "commit_summary", plural = "commit_summaries", fields = Seq(
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecCommit: ErmSpec[Commit] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.commit",
      spec = Model(name = "commit", plural = "commits", fields = Seq(
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "html_url", `type` = "string", required = true),
        Field(name = "author", `type` = "person", required = true),
        Field(name = "committer", `type` = "person", required = true),
        Field(name = "tree", `type` = "tree_summary", required = true),
        Field(name = "message", `type` = "string", required = true),
        Field(name = "parents", `type` = "[commit_summary]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.person" -> ermSpecPerson,
        "io.flow.github.v0.models.tree_summary" -> ermSpecTreeSummary,
        "io.flow.github.v0.models.commit_summary" -> ermSpecCommitSummary,
      ),
    )

  implicit lazy val ermSpecCommitForm: ErmSpec[CommitForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.commit_form",
      spec = Model(name = "commit_form", plural = "commit_forms", fields = Seq(
        Field(name = "message", `type` = "string", required = true),
        Field(name = "tree", `type` = "string", required = true),
        Field(name = "parents", `type` = "[string]", required = true),
        Field(name = "author", `type` = "person", required = true),
        Field(name = "committer", `type` = "person", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.person" -> ermSpecPerson,
      ),
    )

  implicit lazy val ermSpecCommitResponse: ErmSpec[CommitResponse] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.commit_response",
      spec = Model(name = "commit_response", plural = "commit_responses", fields = Seq(
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "author", `type` = "person", required = true),
        Field(name = "committer", `type` = "person", required = true),
        Field(name = "message", `type` = "string", required = true),
        Field(name = "tree", `type` = "tree_summary", required = true),
        Field(name = "parents", `type` = "[tree_summary]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.person" -> ermSpecPerson,
        "io.flow.github.v0.models.tree_summary" -> ermSpecTreeSummary,
      ),
    )

  implicit lazy val ermSpecContents: ErmSpec[Contents] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.contents",
      spec = Model(name = "contents", plural = "contents", fields = Seq(
        Field(name = "type", `type` = "contents_type", required = true),
        Field(name = "encoding", `type` = "encoding", required = true),
        Field(name = "size", `type` = "long", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "path", `type` = "string", required = true),
        Field(name = "content", `type` = "string", required = false),
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "git_url", `type` = "string", required = true),
        Field(name = "html_url", `type` = "string", required = true),
        Field(name = "download_url", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.contents_type" -> ermSpecContentsType,
        "io.flow.github.v0.enums.encoding" -> ermSpecEncoding,
      ),
    )

  implicit lazy val ermSpecTreeForm: ErmSpec[TreeForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tree_form",
      spec = Model(name = "tree_form", plural = "tree_forms", fields = Seq(
        Field(name = "path", `type` = "string", required = true),
        Field(name = "mode", `type` = "string", required = true),
        Field(name = "type", `type` = "node_type", required = true),
        Field(name = "sha", `type` = "string", required = false),
        Field(name = "content", `type` = "string", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.node_type" -> ermSpecNodeType,
      ),
    )

  implicit lazy val ermSpecCreateTreeForm: ErmSpec[CreateTreeForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.create_tree_form",
      spec = Model(name = "create_tree_form", plural = "create_tree_forms", fields = Seq(
        Field(name = "base_tree", `type` = "string", required = true),
        Field(name = "tree", `type` = "[tree_form]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.tree_form" -> ermSpecTreeForm,
      ),
    )

  implicit lazy val ermSpecNode: ErmSpec[Node] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.node",
      spec = Model(name = "node", plural = "nodes", fields = Seq(
        Field(name = "path", `type` = "string", required = true),
        Field(name = "mode", `type` = "string", required = true),
        Field(name = "type", `type` = "node_type", required = true),
        Field(name = "size", `type` = "long", required = true),
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.node_type" -> ermSpecNodeType,
      ),
    )

  implicit lazy val ermSpecTree: ErmSpec[Tree] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tree",
      spec = Model(name = "tree", plural = "trees", fields = Seq(
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "truncated", `type` = "boolean", required = true),
        Field(name = "tree", `type` = "[node]", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.node" -> ermSpecNode,
      ),
    )

  implicit lazy val ermSpecCreateTreeResponse: ErmSpec[CreateTreeResponse] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.create_tree_response",
      spec = Model(name = "create_tree_response", plural = "create_tree_responses", fields = Seq(
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "tree_result", `type` = "tree", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.tree" -> ermSpecTree,
      ),
    )

  implicit lazy val ermSpecError: ErmSpec[Error] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.error",
      spec = Model(name = "error", plural = "errors", fields = Seq(
        Field(name = "resource", `type` = "string", required = true),
        Field(name = "field", `type` = "string", required = true),
        Field(name = "code", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecGithubObject: ErmSpec[GithubObject] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.github_object",
      spec = Model(name = "github_object", plural = "github_objects", fields = Seq(
        Field(name = "type", `type` = "string", required = true),
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecHookConfig: ErmSpec[HookConfig] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.hook_config",
      spec = Model(name = "hook_config", plural = "hook_configs", fields = Seq(
        Field(name = "url", `type` = "string", required = false),
        Field(name = "content_type", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecHook: ErmSpec[Hook] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.hook",
      spec = Model(name = "hook", plural = "hooks", fields = Seq(
        Field(name = "id", `type` = "long", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "test_url", `type` = "string", required = true),
        Field(name = "ping_url", `type` = "string", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "events", `type` = "[hook_event]", required = true),
        Field(name = "active", `type` = "boolean", required = true),
        Field(name = "config", `type` = "hook_config", required = true),
        Field(name = "updated_at", `type` = "date-time-iso8601", required = true),
        Field(name = "created_at", `type` = "date-time-iso8601", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.hook_event" -> ermSpecHookEvent,
        "io.flow.github.v0.models.hook_config" -> ermSpecHookConfig,
      ),
    )

  implicit lazy val ermSpecHookForm: ErmSpec[HookForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.hook_form",
      spec = Model(name = "hook_form", plural = "hook_forms", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "config", `type` = "hook_config", required = true),
        Field(name = "events", `type` = "[hook_event]", required = true),
        Field(name = "active", `type` = "boolean", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.hook_config" -> ermSpecHookConfig,
        "io.flow.github.v0.enums.hook_event" -> ermSpecHookEvent,
      ),
    )

  implicit lazy val ermSpecNodeForm: ErmSpec[NodeForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.node_form",
      spec = Model(name = "node_form", plural = "node_forms", fields = Seq(
        Field(name = "path", `type` = "string", required = true),
        Field(name = "mode", `type` = "string", required = true),
        Field(name = "type", `type` = "node_type", required = true),
        Field(name = "sha", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.node_type" -> ermSpecNodeType,
      ),
    )

  implicit lazy val ermSpecPullRequestHead: ErmSpec[PullRequestHead] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.pull_request_head",
      spec = Model(name = "pull_request_head", plural = "pull_request_heads", fields = Seq(
        Field(name = "ref", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecPullRequest: ErmSpec[PullRequest] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.pull_request",
      spec = Model(name = "pull_request", plural = "pull_requests", fields = Seq(
        Field(name = "id", `type` = "long", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "number", `type` = "long", required = true),
        Field(name = "html_url", `type` = "string", required = true),
        Field(name = "head", `type` = "pull_request_head", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.pull_request_head" -> ermSpecPullRequestHead,
      ),
    )

  implicit lazy val ermSpecPullRequestForm: ErmSpec[PullRequestForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.pull_request_form",
      spec = Model(name = "pull_request_form", plural = "pull_request_forms", fields = Seq(
        Field(name = "title", `type` = "string", required = true),
        Field(name = "head", `type` = "string", required = true),
        Field(name = "base", `type` = "string", required = true),
        Field(name = "body", `type` = "string", required = false),
      )),
    )

  implicit lazy val ermSpecRef: ErmSpec[Ref] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.ref",
      spec = Model(name = "ref", plural = "refs", fields = Seq(
        Field(name = "ref", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "object", `type` = "github_object", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.github_object" -> ermSpecGithubObject,
      ),
    )

  implicit lazy val ermSpecRefForm: ErmSpec[RefForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.ref_form",
      spec = Model(name = "ref_form", plural = "ref_forms", fields = Seq(
        Field(name = "ref", `type` = "string", required = true),
        Field(name = "sha", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecRefUpdateForm: ErmSpec[RefUpdateForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.ref_update_form",
      spec = Model(name = "ref_update_form", plural = "ref_update_forms", fields = Seq(
        Field(name = "sha", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecUser: ErmSpec[User] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.user",
      spec = Model(name = "user", plural = "users", fields = Seq(
        Field(name = "id", `type` = "long", required = true),
        Field(name = "login", `type` = "string", required = true),
        Field(name = "name", `type` = "string", required = false),
        Field(name = "email", `type` = "string", required = false),
        Field(name = "avatar_url", `type` = "string", required = false),
        Field(name = "gravatar_id", `type` = "string", required = false),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "html_url", `type` = "string", required = true),
        Field(name = "type", `type` = "owner_type", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.owner_type" -> ermSpecOwnerType,
      ),
    )

  implicit lazy val ermSpecRepository: ErmSpec[Repository] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.repository",
      spec = Model(name = "repository", plural = "repositories", fields = Seq(
        Field(name = "id", `type` = "long", required = true),
        Field(name = "owner", `type` = "user", required = true),
        Field(name = "name", `type` = "string", required = true),
        Field(name = "full_name", `type` = "string", required = true),
        Field(name = "private", `type` = "boolean", required = true),
        Field(name = "description", `type` = "string", required = false),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "html_url", `type` = "string", required = true),
        Field(name = "default_branch", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.user" -> ermSpecUser,
      ),
    )

  implicit lazy val ermSpecTagger: ErmSpec[Tagger] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tagger",
      spec = Model(name = "tagger", plural = "taggers", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "email", `type` = "string", required = true),
        Field(name = "date", `type` = "date-time-iso8601", required = true),
      )),
    )

  implicit lazy val ermSpecTag: ErmSpec[Tag] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tag",
      spec = Model(name = "tag", plural = "tags", fields = Seq(
        Field(name = "tag", `type` = "string", required = true),
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
        Field(name = "message", `type` = "string", required = true),
        Field(name = "tagger", `type` = "tagger", required = true),
        Field(name = "object", `type` = "github_object", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.tagger" -> ermSpecTagger,
        "io.flow.github.v0.models.github_object" -> ermSpecGithubObject,
      ),
    )

  implicit lazy val ermSpecTagForm: ErmSpec[TagForm] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tag_form",
      spec = Model(name = "tag_form", plural = "tag_forms", fields = Seq(
        Field(name = "tag", `type` = "string", required = true),
        Field(name = "message", `type` = "string", required = true),
        Field(name = "object", `type` = "string", required = true),
        Field(name = "type", `type` = "string", required = true),
        Field(name = "tagger", `type` = "tagger", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.tagger" -> ermSpecTagger,
      ),
    )

  implicit lazy val ermSpecTagSummary: ErmSpec[TagSummary] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tag_summary",
      spec = Model(name = "tag_summary", plural = "tag_summaries", fields = Seq(
        Field(name = "name", `type` = "string", required = true),
        Field(name = "commit", `type` = "commit_summary", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.commit_summary" -> ermSpecCommitSummary,
      ),
    )

  implicit lazy val ermSpecTreeResult: ErmSpec[TreeResult] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.tree_result",
      spec = Model(name = "tree_result", plural = "tree_results", fields = Seq(
        Field(name = "path", `type` = "string", required = true),
        Field(name = "mode", `type` = "string", required = true),
        Field(name = "type", `type` = "node_type", required = true),
        Field(name = "size", `type` = "long", required = true),
        Field(name = "sha", `type` = "string", required = true),
        Field(name = "url", `type` = "string", required = true),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.enums.node_type" -> ermSpecNodeType,
      ),
    )

  implicit lazy val ermSpecUnprocessableEntity: ErmSpec[UnprocessableEntity] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.unprocessable_entity",
      spec = Model(name = "unprocessable_entity", plural = "unprocessable_entities", fields = Seq(
        Field(name = "message", `type` = "string", required = true),
        Field(name = "errors", `type` = "[error]", required = false),
      )),
      resolved = Map[String, ErmSpec[_]](
        "io.flow.github.v0.models.error" -> ermSpecError,
      ),
    )

  implicit lazy val ermSpecUserEmail: ErmSpec[UserEmail] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.user_email",
      spec = Model(name = "user_email", plural = "user_emails", fields = Seq(
        Field(name = "email", `type` = "string", required = true),
        Field(name = "verified", `type` = "boolean", required = true),
        Field(name = "primary", `type` = "boolean", required = true),
      )),
    )

  implicit lazy val ermSpecUserOrg: ErmSpec[UserOrg] =
    ErmSpec.model(
      qualifiedName = "io.flow.github.v0.models.user_org",
      spec = Model(name = "user_org", plural = "user_orgs", fields = Seq(
        Field(name = "login", `type` = "string", required = true),
      )),
    )

  implicit lazy val ermSpecEncoding: ErmSpec[Encoding] =
    ErmSpec.`enum`(
      qualifiedName = "io.flow.github.v0.enums.encoding",
      spec = Enum(name = "encoding", plural = "encodings", values = Seq(
        EnumValue(name = "base64"),
        EnumValue(name = "utf-8"),
      )),
    )

  implicit lazy val ermSpecContentsType: ErmSpec[ContentsType] =
    ErmSpec.`enum`(
      qualifiedName = "io.flow.github.v0.enums.contents_type",
      spec = Enum(name = "contents_type", plural = "contents_types", values = Seq(
        EnumValue(name = "file"),
        EnumValue(name = "dir"),
        EnumValue(name = "symlink"),
        EnumValue(name = "submodule"),
      )),
    )

  implicit lazy val ermSpecNodeType: ErmSpec[NodeType] =
    ErmSpec.`enum`(
      qualifiedName = "io.flow.github.v0.enums.node_type",
      spec = Enum(name = "node_type", plural = "node_types", values = Seq(
        EnumValue(name = "blob"),
        EnumValue(name = "tree"),
        EnumValue(name = "commit"),
      )),
    )

  implicit lazy val ermSpecHookEvent: ErmSpec[HookEvent] =
    ErmSpec.`enum`(
      qualifiedName = "io.flow.github.v0.enums.hook_event",
      spec = Enum(name = "hook_event", plural = "hook_events", values = Seq(
        EnumValue(name = "push"),
        EnumValue(name = "pull_request"),
      )),
    )

  implicit lazy val ermSpecOwnerType: ErmSpec[OwnerType] =
    ErmSpec.`enum`(
      qualifiedName = "io.flow.github.v0.enums.owner_type",
      spec = Enum(name = "owner_type", plural = "owner_types", values = Seq(
        EnumValue(name = "User"),
      )),
    )

  val all: Seq[ErmSpec[_]] = Seq(
    ermSpecBlob,
    ermSpecBlobCreated,
    ermSpecBlobForm,
    ermSpecPerson,
    ermSpecTreeSummary,
    ermSpecCommitSummary,
    ermSpecCommit,
    ermSpecCommitForm,
    ermSpecCommitResponse,
    ermSpecContents,
    ermSpecTreeForm,
    ermSpecCreateTreeForm,
    ermSpecNode,
    ermSpecTree,
    ermSpecCreateTreeResponse,
    ermSpecError,
    ermSpecGithubObject,
    ermSpecHookConfig,
    ermSpecHook,
    ermSpecHookForm,
    ermSpecNodeForm,
    ermSpecPullRequestHead,
    ermSpecPullRequest,
    ermSpecPullRequestForm,
    ermSpecRef,
    ermSpecRefForm,
    ermSpecRefUpdateForm,
    ermSpecUser,
    ermSpecRepository,
    ermSpecTagger,
    ermSpecTag,
    ermSpecTagForm,
    ermSpecTagSummary,
    ermSpecTreeResult,
    ermSpecUnprocessableEntity,
    ermSpecUserEmail,
    ermSpecUserOrg,
    ermSpecEncoding,
    ermSpecContentsType,
    ermSpecNodeType,
    ermSpecHookEvent,
    ermSpecOwnerType,
  )
}