@voxgig/sdkgen 1.3.14 → 1.3.18

package/project/.sdk/src/cmp/scala/ReadmeExamplesTest_scala.ts

@@ -0,0 +1,182 @@
+
+import { cmp, File, Content } from '@voxgig/sdkgen'
+
+
+// Emits sdktest/ReadmeExamplesTest.scala — a PRESENCE + STRUCTURE gate over
+// every scala fenced block in the repository ROOT README.md, the per-language
+// scala/README.md, AND the per-language scala/REFERENCE.md. It is a
+// default-package scala-cli object exposing run(rep) and is driven by the
+// generated SdkEntityTestMain aggregator (mirrors the generated per-entity
+// test objects).
+//
+// SCOPE NOTE (deliberate, documented): the Python/TS/Go equivalents EXECUTE and
+// type-check every documented block. That is infeasible here — the generated
+// Scala SDK compiles with scala-cli only (no in-process Scala compiler wired
+// into the test runtime), so a test cannot compile-and-run arbitrary doc
+// snippets at test time. This gate therefore guarantees the weaker-but-real
+// invariant that keeps the docs honest as the generator evolves:
+//   1. every doc exists and contains at least one scala block (nothing was
+//      dropped);
+//   2. every scala block is structurally well-formed — its braces, parentheses
+//      and brackets balance (catches a truncated or malformed generated
+//      snippet).
+// A per-doc summary line makes the coverage visible in the test output.
+//
+// The emitted Scala is written WITHOUT literal backticks (the fence marker is
+// built at runtime as 96.toChar.toString.repeat(3)) so this TS template literal
+// stays clean.
+const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
+  const { target, ctx$: { model } } = props
+
+  const Name = model.const.Name
+
+  File({ name: 'ReadmeExamplesTest.' + target.ext }, () => {
+    Content(`// ${Name} SDK — documentation scala-examples PRESENCE + STRUCTURE gate.
+//
+// GUARANTEE (see ReadmeExamplesTest_scala.ts for why this is a structure gate
+// and not an execute gate): every scala example in the docs is accounted for.
+// A dependency-free scala-cli test object (default package, driven by
+// SdkEntityTestMain) over every scala fenced code block in three documents:
+//   - the repository ROOT README.md (one directory above the scala module),
+//   - the per-language scala/README.md,
+//   - the per-language scala/REFERENCE.md.
+//
+// Checks, PER DOCUMENT:
+//   1. PRESENCE: the doc exists and holds at least one scala block.
+//   2. STRUCTURE: every fence is closed (an odd number of triple-backtick
+//      markers means a fence was opened but never closed — the doc is truncated
+//      and split-based extraction would mis-segment the tail), AND every scala
+//      block's braces / parens / brackets balance, so a truncated or malformed
+//      generated snippet fails loudly.
+//
+// GENERATED by @voxgig/sdkgen — do not edit by hand.
+
+import java.nio.file.{Files, Path, Paths}
+
+object ReadmeExamplesTest {
+
+  // The three documents to scan, resolved relative to the scala module
+  // directory (the working directory when scala-cli runs the tests). Each row
+  // is {label, relative path}.
+  private def docs(): Array[Array[String]] = Array(
+    Array("root README", ".." + java.io.File.separator + "README.md"),
+    Array("scala README.md", "README.md"),
+    Array("scala REFERENCE.md", "REFERENCE.md")
+  )
+
+  // Extract every scala fenced block. Split on the triple-backtick fence:
+  // odd-indexed segments are the inside of a fenced block (info string on the
+  // first line, then the code). Only blocks whose info string is exactly
+  // "scala" are returned.
+  private def scalaBlocks(text: String): java.util.List[String] = {
+    val fence = 96.toChar.toString.repeat(3)
+    val parts = text.split(java.util.regex.Pattern.quote(fence), -1)
+    val blocks = new java.util.ArrayList[String]()
+    var i = 1
+    while (i < parts.length) {
+      val seg = parts(i)
+      val nl = seg.indexOf('\\n')
+      val info = (if (nl < 0) seg else seg.substring(0, nl)).trim()
+      if (info == "scala") {
+        blocks.add(if (nl < 0) "" else seg.substring(nl + 1))
+      }
+      i += 2
+    }
+    blocks
+  }
+
+  private def readDoc(path: Path): String =
+    new String(Files.readAllBytes(path), "UTF-8")
+
+  // True when every triple-backtick fence in the document is paired. split(-1)
+  // yields (fenceCount + 1) parts, so an even fence count (all fences closed)
+  // gives an odd number of parts. An odd fence count means a fence was opened
+  // but never closed: the block-extraction above would then treat everything
+  // after it as one big "block", and a truncated snippet that happens to
+  // balance would pass silently. Detecting it here lets the gate fail loudly.
+  private def fencesClosed(text: String): Boolean = {
+    val fence = 96.toChar.toString.repeat(3)
+    text.split(java.util.regex.Pattern.quote(fence), -1).length % 2 == 1
+  }
+
+  // True when every open/close delimiter balances (ignores the subtlety of
+  // delimiters inside string literals — a generated snippet never nests an
+  // unbalanced delimiter in a string, and this catches truncation).
+  private def balanced(block: String): Boolean = {
+    val stack = new java.util.ArrayDeque[Character]()
+    var i = 0
+    while (i < block.length) {
+      val ch = block.charAt(i)
+      ch match {
+        case '(' => stack.push(')')
+        case '[' => stack.push(']')
+        case '{' => stack.push('}')
+        case ')' | ']' | '}' =>
+          if (stack.isEmpty || stack.pop().charValue() != ch) return false
+        case _ =>
+      }
+      i += 1
+    }
+    stack.isEmpty
+  }
+
+  def run(rep: SdkTestReport): Unit = {
+    val ds = docs()
+
+    // PRESENCE: each doc exists and holds at least one scala block.
+    var di = 0
+    while (di < ds.length) {
+      val label = ds(di)(0)
+      val rel = ds(di)(1)
+      rep.scope("readme-examples.presence." + label) {
+        val path = Paths.get(rel)
+        rep.check("readme-examples.presence." + label + ".exists",
+          Files.exists(path), label + " not found: " + path)
+        if (Files.exists(path)) {
+          val blocks = scalaBlocks(readDoc(path))
+          rep.check("readme-examples.presence." + label, blocks.size() > 0,
+            "expected at least one scala block in " + label)
+        }
+      }
+      di += 1
+    }
+
+    // STRUCTURE: every scala block's delimiters balance.
+    rep.scope("readme-examples.structure") {
+      val failures = new java.util.ArrayList[String]()
+      var dj = 0
+      while (dj < ds.length) {
+        val label = ds(dj)(0)
+        val path = Paths.get(ds(dj)(1))
+        if (Files.exists(path)) {
+          val text = readDoc(path)
+          // A fence opened but never closed leaves an odd number of fence
+          // markers; fail loudly rather than trusting the mis-segmented tail.
+          if (!fencesClosed(text))
+            failures.add(label + " has an unclosed scala code fence")
+          val blocks = scalaBlocks(text)
+          var balancedCount = 0
+          var bi = 0
+          while (bi < blocks.size()) {
+            if (balanced(blocks.get(bi))) balancedCount += 1
+            else failures.add(label + " scala block #" + bi + " has unbalanced delimiters")
+            bi += 1
+          }
+          println("[readme-examples] " + label + " scala blocks: total=" +
+            blocks.size() + " balanced=" + balancedCount)
+        }
+        dj += 1
+      }
+      rep.check("readme-examples.structure", failures.isEmpty(),
+        String.join("; ", failures))
+    }
+  }
+}
+`)
+  })
+})
+
+
+export {
+  ReadmeExamplesTest
+}

package/project/.sdk/src/cmp/scala/ReadmeExplanation_scala.ts

@@ -0,0 +1,49 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+import { scalaPackage } from './utility_scala'
+
+
+const ReadmeExplanation = cmp(function ReadmeExplanation(props: any) {
+  const { target, ctx$: { model } } = props
+
+  const pkg = scalaPackage(model)
+
+  Content(`### Data as maps
+
+The Scala SDK uses a loose object model — \`java.util.Map[String, Object]\`
+throughout — rather than a bespoke typed class per endpoint. This mirrors the
+dynamic nature of the API and keeps the SDK flexible: no regeneration is
+needed when the API schema changes.
+
+Use \`Helpers.toMapAny(value)\` to safely coerce a value to a
+\`java.util.Map[String, Object]\`. A \`${model.const.Name}Types.scala\` module of
+reference \`case class\` types is also generated for editor documentation.
+
+### Project structure
+
+\`\`\`
+scala/
+├── project.scala               -- scala-cli project config (Scala 3, no deps)
+├── core/                        -- Main SDK client, config, entity base, error type
+├── entity/                      -- Entity implementations
+├── feature/                     -- Built-in features (Base, Test, Log, ...)
+├── utility/                     -- Utility functions and the vendored struct library
+└── sdktest/                     -- Generated per-entity tests (scala-cli mains)
+\`\`\`
+
+The main client class (\`${model.const.Name}SDK\`, package \`${pkg}.core\`)
+exposes the entity accessors. Reference entity or utility types directly only
+when needed. The SDK is a dependency-free scala-cli project: JSON parsing is
+the vendored \`utility/Json.java\`, HTTP transport is the JDK
+\`java.net.http.HttpClient\`, and the struct library is inlined under
+\`utility/struct\`.
+
+`)
+
+})
+
+
+export {
+  ReadmeExplanation
+}

package/project/.sdk/src/cmp/scala/ReadmeHowto_scala.ts

@@ -0,0 +1,155 @@
+
+import { cmp, Content, isAuthActive, envName, canonKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import { scalaVarName } from './utility_scala'
+
+
+// A type-correct Scala literal for a field's canonical type.
+function scalaLit(type: any): string {
+  const k = canonKey(type)
+  if ('INTEGER' === k) return '1L'
+  if ('NUMBER' === k) return '1.0'
+  if ('BOOLEAN' === k) return 'true'
+  if ('ARRAY' === k) return 'java.util.List.of()'
+  if ('OBJECT' === k) return 'java.util.Map.of()'
+  return '"example"'
+}
+
+
+const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
+  const { target, ctx$: { model } } = props
+
+  const SDK = model.const.Name + 'SDK'
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  // Pick an entity with a real op (prefer a read op). primaryOp is null only
+  // when NO entity exposes any op (a direct()-only SDK).
+  const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
+  const eVar = exampleEntity ? scalaVarName(exampleEntity.name) : 'entity'
+  const accessor = exampleEntity ? scalaVarName(exampleEntity.name) : 'entity'
+  // Model-driven id key: null when the entity has no id-like field, so a
+  // match op takes an empty match.
+  const idF = exampleEntity ? entityIdField(exampleEntity) : null
+  const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
+  let testArg = 'null'
+  if (exampleEntity && isMatchOp) {
+    testArg = idF ? `java.util.Map.of("${idF}", "test01")` : 'null'
+  } else if (exampleEntity && ('create' === primaryOp || 'update' === primaryOp)) {
+    const items = opRequestShape(exampleEntity, primaryOp).items
+      .filter((it: any) => it.name !== idF && it.name !== 'id')
+    const required = items.filter((it: any) => !it.optional)
+    const chosen = required.length ? required : items.slice(0, 3)
+    testArg = `java.util.Map.of(${chosen.map((it: any) =>
+      `"${it.name}", ${scalaLit(it.type)}`).join(', ')})`
+  }
+
+  // The op-driven test-mode line, shown only when the SDK has an entity op.
+  // A direct()-only SDK (no ops anywhere) shows a direct() call instead.
+  const testModeExample = primaryOp
+    ? `// Entity ops return the bare record and raise on error.
+val ${eVar} = client.${accessor}(null).${primaryOp}(${testArg}, null)
+// ${eVar} holds the mock response record
+println(${eVar})`
+    : `val result = client.direct(java.util.Map.of(
+    "path", "/api/resource",
+    "method", "GET"))
+println(result)`
+
+  const apikeyEnvLine = isAuthActive(model)
+    ? `\n${envName(model)}_APIKEY=<your-key>`
+    : ''
+
+  Content(`### Make a direct HTTP request
+
+For endpoints not covered by entity methods:
+
+\`\`\`scala
+val result = client.direct(java.util.Map.of(
+    "path", "/api/resource/{id}",
+    "method", "GET",
+    "params", java.util.Map.of("id", "example")))
+
+if (java.lang.Boolean.TRUE == result.get("ok")) {
+    println(result.get("status"))  // 200
+    println(result.get("data"))    // response body
+}
+else {
+    // A non-2xx response carries status + data (the error body); a
+    // transport-level failure carries err instead. Only one is present, so
+    // read both — an absent key simply reads as null.
+    println("status=" + result.get("status") + " err=" + result.get("err"))
+}
+\`\`\`
+
+### Prepare a request without sending it
+
+\`\`\`scala
+// prepare() returns the fetch definition and raises on error.
+val fetchdef = client.prepare(java.util.Map.of(
+    "path", "/api/resource/{id}",
+    "method", "DELETE",
+    "params", java.util.Map.of("id", "example")))
+
+println(fetchdef.get("url"))
+println(fetchdef.get("method"))
+println(fetchdef.get("headers"))
+\`\`\`
+
+### Use test mode
+
+Create a mock client for unit testing — no server required:
+
+\`\`\`scala
+val client = ${SDK}.testSDK(null, null)
+
+${testModeExample}
+\`\`\`
+
+### Use a custom fetch function
+
+Replace the HTTP transport with your own \`BiFunction\`:
+
+\`\`\`scala
+val mockFetch: java.util.function.BiFunction[String, java.util.Map[String, Object], Object] =
+    (url, init) => {
+        val res = new java.util.LinkedHashMap[String, Object]()
+        res.put("status", java.lang.Integer.valueOf(200))
+        res.put("statusText", "OK")
+        res.put("headers", new java.util.LinkedHashMap[String, Object]())
+        res.put("json", (() => java.util.Map.of("id", "mock01")): java.util.function.Supplier[Object])
+        res
+    }
+
+val options = new java.util.LinkedHashMap[String, Object]()
+options.put("base", "http://localhost:8080")
+options.put("system", java.util.Map.of("fetch", mockFetch))
+val client = new ${SDK}(options)
+\`\`\`
+
+### Run live tests
+
+Create a \`.env.local\` file at the project root:
+
+\`\`\`
+${envName(model)}_TEST_LIVE=TRUE${apikeyEnvLine}
+\`\`\`
+
+Then run:
+
+\`\`\`bash
+cd scala && make test
+\`\`\`
+
+`)
+
+})
+
+
+export {
+  ReadmeHowto
+}

package/project/.sdk/src/cmp/scala/ReadmeInstall_scala.ts

@@ -0,0 +1,58 @@
+
+import { cmp, Content, isPublished, repoInfo } from '@voxgig/sdkgen'
+
+import { mavenGroupId } from './utility_scala'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { target, ctx$ } = props
+  const { model } = ctx$
+
+  const groupId = mavenGroupId(model)
+  const artifactId = `${model.name}-sdk`
+
+  if (isPublished(model, target.name)) {
+    Content(`Add the dependency with scala-cli:
+
+\`\`\`scala
+//> using dep "${groupId}:${artifactId}_3:0.0.1"
+\`\`\`
+
+Or, with sbt:
+
+\`\`\`scala
+libraryDependencies += "${groupId}" %% "${artifactId}" % "0.0.1"
+\`\`\`
+
+Or build from a source checkout — the SDK is a plain scala-cli project:
+
+\`\`\`bash
+cd scala && scala-cli compile .
+\`\`\`
+
+`)
+    return
+  }
+
+  // Publish pending: not yet on Maven Central. The generated SDK is a
+  // dependency-free, plain-source scala-cli project (no sbt/mill build, no
+  // third-party runtime deps), so install it from the git release tag or a
+  // local source checkout and compile with scala-cli.
+  const { releasesUrl } = repoInfo(model)
+  Content(`This package is not yet published to Maven Central. The generated SDK is a
+plain-source scala-cli project (no build tool, no third-party runtime
+dependencies). Install it from the GitHub release tag
+(\`${target.name}/vX.Y.Z\`, see [Releases](${releasesUrl})) or from a source
+checkout — compile it with scala-cli:
+
+\`\`\`bash
+cd scala && scala-cli compile .
+\`\`\`
+
+`)
+})
+
+
+export {
+  ReadmeInstall
+}

package/project/.sdk/src/cmp/scala/ReadmeIntro_scala.ts

@@ -0,0 +1,66 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import { scalaVarName } from './utility_scala'
+
+
+const ReadmeIntro = cmp(function ReadmeIntro(props: any) {
+  const { target, ctx$: { model } } = props
+  const info = (model.main && model.main.kit && model.main.kit.info) || {}
+  const tagline = info.tagline || ''
+
+  Content(`# ${model.Name} ${target.title} SDK
+
+${tagline}
+
+The ${target.title} SDK for the ${model.Name} API — an entity-oriented client following idiomatic Scala conventions.
+
+`)
+
+  // Emphasise the entity-oriented design: the SDK surfaces the API as
+  // capitalised, semantic Entities with a small, uniform verb set rather
+  // than raw URL paths and query strings. The example entity name is
+  // derived from the model, never hardcoded.
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const exampleEntity = Object.values(entity || {})
+    .find((e: any) => e.active !== false) as any
+  const example = exampleEntity
+    ? `for example \`client.${scalaVarName(exampleEntity.name)}(null)\` — each`
+    : 'each'
+
+  // Model-driven op list — only the operations the active entities actually
+  // expose (a read-only entity has just list+load); never claim
+  // create/update/remove exist when no entity has them.
+  const CANON_OPS = ['list', 'load', 'create', 'update', 'remove']
+  const opSet = new Set<string>()
+  Object.values(entity || {}).forEach((e: any) => {
+    if (!e || e.active === false) return
+    Object.keys(e.op || {}).forEach((o: string) => {
+      if (e.op[o] && e.op[o].active !== false) opSet.add(o)
+    })
+  })
+  const opNames = CANON_OPS.filter((o) => opSet.has(o))
+    .concat([...opSet].filter((o) => !CANON_OPS.includes(o)))
+  const opList = (opNames.length ? opNames : ['list', 'load'])
+    .map((o) => '`' + o + '`').join(', ')
+
+  Content(`The SDK exposes the API as capitalised, semantic **Entities** — ${example}
+carrying a small, uniform set of operations (${opList}) instead of raw URL
+paths and query strings. You work with named resources and verbs, which
+keeps the cognitive load low.
+
+> Other languages, the CLI, and MCP server live alongside this one — see
+> the [top-level README](../README.md).
+
+`)
+})
+
+
+export {
+  ReadmeIntro
+}

package/project/.sdk/src/cmp/scala/ReadmeModel_scala.ts

@@ -0,0 +1,150 @@
+
+import { cmp, each, Content, isAuthActive } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import { scalaVarName } from './utility_scala'
+
+
+const ReadmeModel = cmp(function ReadmeModel(props: any) {
+  const { target, ctx$: { model } } = props
+
+  const SDK = model.const.Name + 'SDK'
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  const entityList = each(entity).filter((e: any) => e.active !== false)
+
+  // Model-driven op rows for the shared entity interface: emit a
+  // load/list/create/update/remove row only for operations at least one active
+  // entity actually exposes — never document an operation no entity has.
+  const opUnion = new Set<string>()
+  entityList.forEach((e: any) => Object.keys(e.op || {})
+    .forEach((o: string) => { if (e.op[o] && e.op[o].active !== false) opUnion.add(o) }))
+  const opRowDefs: Record<string, string> = {
+    load: '| `load` | `(reqmatch, ctrl) -> Object` | Load a single entity by match criteria. Raises on error. |',
+    list: '| `list` | `(reqmatch, ctrl) -> Object` | List entities matching the criteria (an aggregate list). Raises on error. |',
+    create: '| `create` | `(reqdata, ctrl) -> Object` | Create a new entity. Raises on error. |',
+    update: '| `update` | `(reqdata, ctrl) -> Object` | Update an existing entity. Raises on error. |',
+    remove: '| `remove` | `(reqmatch, ctrl) -> Object` | Remove an entity. Raises on error. |',
+  }
+  const opRows = ['load', 'list', 'create', 'update', 'remove']
+    .filter((o) => opUnion.has(o)).map((o) => opRowDefs[o]).join('\n')
+
+  const apikeyOptionRow = isAuthActive(model)
+    ? '| `apikey` | `String` | API key for authentication. |\n'
+    : ''
+
+  Content(`### ${SDK}
+
+\`\`\`scala
+val client = new ${SDK}(options)
+\`\`\`
+
+Creates a new SDK client. \`options\` is a \`java.util.Map[String, Object]\`.
+
+| Option | Type | Description |
+| --- | --- | --- |
+${apikeyOptionRow}| \`base\` | \`String\` | Base URL of the API server. |
+| \`prefix\` | \`String\` | URL path prefix prepended to all requests. |
+| \`suffix\` | \`String\` | URL path suffix appended to all requests. |
+| \`feature\` | \`Map\` | Feature activation flags. |
+| \`extend\` | \`List\` | Additional Feature instances to load. |
+| \`system\` | \`Map\` | System overrides (e.g. custom \`fetch\` function). |
+
+### testSDK
+
+\`\`\`scala
+val client = ${SDK}.testSDK(testopts, sdkopts)
+\`\`\`
+
+Creates a test-mode client with mock transport. Both arguments may be \`null\`.
+
+### ${SDK} methods
+
+| Method | Signature | Description |
+| --- | --- | --- |
+| \`optionsMap\` | \`() -> Map\` | Deep copy of current SDK options. |
+| \`getUtility\` | \`() -> Utility\` | Copy of the SDK utility object. |
+| \`prepare\` | \`(fetchargs) -> Map\` | Build an HTTP request definition without sending. Raises on error. |
+| \`direct\` | \`(fetchargs) -> Map\` | Build and send an HTTP request. Returns a result map (branch on \`ok\`). |
+`)
+
+  each(entityList, (ent: any) => {
+    const article = /^[aeiou]/i.test(ent.Name) ? 'an' : 'a'
+    Content(`| \`${scalaVarName(ent.name)}\` | \`(entopts) -> SdkEntity\` | Create ${article} ${ent.Name} entity instance. |
+`)
+  })
+
+  Content(`
+### Entity interface
+
+All entities share the same interface.
+
+| Method | Signature | Description |
+| --- | --- | --- |
+${opRows}
+| \`data\` | \`(newdata*) -> Object\` | Get or set entity data. |
+| \`matchArgs\` | \`(newmatch*) -> Object\` | Get or set entity match criteria. |
+| \`make\` | \`() -> Entity\` | Create a new instance with the same options. |
+| \`getName\` | \`() -> String\` | Return the entity name. |
+
+### Result shape
+
+Entity operations return the bare result data (a \`Map\` for single-entity
+ops, an aggregate \`List\` for \`list\`) as \`Object\` and raise on error. Wrap
+calls in \`try\`/\`catch\` to handle failures.
+
+The \`direct()\` escape hatch never raises — it returns a result
+\`java.util.Map[String, Object]\` you branch on via \`result.get("ok")\`:
+
+| Key | Type | Description |
+| --- | --- | --- |
+| \`ok\` | \`Boolean\` | \`true\` if the HTTP status is 2xx. |
+| \`status\` | \`Int\` | HTTP status code. |
+| \`headers\` | \`Map\` | Response headers. |
+| \`data\` | \`Object\` | Parsed JSON response body. |
+
+On error, \`ok\` is \`false\` and \`err\` contains the error value.
+
+`)
+
+  // Entities summary
+  Content(`### Entities
+
+`)
+  each(entityList, (ent: any) => {
+    const fields = ent.fields || []
+    const opnames = Object.keys(ent.op || {})
+    const ops = ent.op || {}
+    const points = each(ops).map((op: any) =>
+      op.points ? each(op.points) : []
+    ).flat()
+    const path = points.length > 0 ? (points[0] as any).orig || '' : ''
+
+    Content(`#### ${ent.Name}
+
+| Field | Description |
+| --- | --- |
+`)
+    each(fields, (field: any) => {
+      Content(`| \`${field.name}\` | ${field.short || ''} |
+`)
+    })
+
+    Content(`
+Operations: ${opnames.join(', ')}.
+
+API path: \`${path}\`
+
+`)
+  })
+
+})
+
+
+export {
+  ReadmeModel
+}