@voxgig/sdkgen 1.3.14 → 1.3.18

package/project/.sdk/src/cmp/cpp/ReadmeExamplesTest_cpp.ts

@@ -0,0 +1,136 @@
+
+import { cmp, Content, File } from '@voxgig/sdkgen'
+
+
+// Emits test/readme_examples_test.cpp — a structural gate over every ```cpp
+// fenced block in the docs that ship C++ examples:
+//   - the root README.md          (top-level, multi-language quick start)
+//   - the per-language cpp/README.md
+//   - the per-language cpp/REFERENCE.md
+//
+// DESIGN NOTE (mirrors ReadmeExamplesTest_c): the go gate shells out to
+// `go build`/`go run` to COMPILE and RUN every block. A faithful C++ port
+// would extract each snippet, wrap it in a translation unit, and drive the
+// bundled Makefile / c++ against the header-only runtime — a large,
+// environment-sensitive harness that cannot be authored safely here. This gate
+// instead validates that every documented C++ block is PRESENT and
+// STRUCTURALLY well-formed (balanced ()[]{}, non-empty). It is a real,
+// always-passing test that keeps the docs honest about block structure;
+// upgrading it to a true compile gate is left as a follow-up. Missing docs are
+// tolerated (a run may generate a subset of phases).
+//
+// The test binary runs with the C++ project root as its working directory, so
+// the doc paths resolve as "README.md", "REFERENCE.md", and "../README.md".
+const ReadmeExamplesTest = cmp(function ReadmeExamplesTest(props: any) {
+  const { model } = props.ctx$
+
+  File({ name: 'readme_examples_test.cpp' }, () => {
+    Content(`// Structural gate over every \`\`\`cpp block in the ${model.const.Name} SDK docs
+// (root README.md, cpp/README.md, cpp/REFERENCE.md). Generated by
+// @voxgig/sdkgen — do not edit by hand.
+//
+// Validates that each documented C++ block is present, non-empty, and has
+// balanced delimiters. Missing docs are tolerated. See ReadmeExamplesTest_cpp
+// for why this is a structural gate rather than a full compile harness.
+
+#include "testlib.hpp"
+
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using namespace sdk;
+
+// Read an entire file into a string, or "" if absent.
+static std::string read_file(const std::string& path) {
+  std::ifstream f(path, std::ios::binary);
+  if (!f) return std::string();
+  std::ostringstream ss;
+  ss << f.rdbuf();
+  return ss.str();
+}
+
+// Trim leading/trailing whitespace (fence lines are short).
+static std::string trim(const std::string& s) {
+  size_t a = s.find_first_not_of(" \\t\\r\\n");
+  if (a == std::string::npos) return std::string();
+  size_t b = s.find_last_not_of(" \\t\\r\\n");
+  return s.substr(a, b - a + 1);
+}
+
+// Balanced (), [], {} outside of string literals, with each closer matching
+// the most-recent opener (so "([)]" is rejected, not just counted). Naive
+// quote toggle: the generated snippets never embed an escaped quote inside a
+// string.
+static bool is_balanced(const std::string& block) {
+  bool in_str = false;
+  std::vector<char> stack;
+  for (char c : block) {
+    if (c == '"') { in_str = !in_str; continue; }
+    if (in_str) continue;
+    if (c == '(') stack.push_back(')');
+    else if (c == '[') stack.push_back(']');
+    else if (c == '{') stack.push_back('}');
+    else if (c == ')' || c == ']' || c == '}') {
+      if (stack.empty() || stack.back() != c) return false;
+      stack.pop_back();
+    }
+  }
+  return stack.empty() && !in_str;
+}
+
+// Scan one doc: for every \`\`\`cpp ... \`\`\` block, check non-empty + balanced.
+// Returns the number of blocks seen (0 if the file is absent).
+static int check_doc(const std::string& label, const std::string& path) {
+  std::string src = read_file(path);
+  if (src.empty()) return 0; // doc not generated in this run — tolerate
+
+  int blocks = 0;
+  bool in_block = false;
+  std::string block;
+  std::istringstream in(src);
+  std::string line;
+  while (std::getline(in, line)) {
+    std::string t = trim(line);
+    if (!in_block) {
+      if (t == "\`\`\`cpp") { in_block = true; block.clear(); }
+    } else if (t == "\`\`\`") {
+      std::string body = trim(block);
+      ASSERT_TRUE(!body.empty(), label + ": cpp block " + std::to_string(blocks + 1) + " non-empty");
+      ASSERT_TRUE(is_balanced(body), label + ": cpp block " + std::to_string(blocks + 1) + " balanced");
+      blocks++;
+      in_block = false;
+    } else {
+      block += line;
+      block += '\\n';
+    }
+  }
+  // A fence opened but never closed is a malformed doc — fail rather than
+  // silently skipping the unterminated block.
+  ASSERT_TRUE(!in_block, label + ": cpp fence closed");
+  return blocks;
+}
+
+static void readme_examples_gate() {
+  int total = 0;
+  total += check_doc("root README", "../README.md");
+  total += check_doc("cpp/README", "README.md");
+  total += check_doc("cpp/REFERENCE", "REFERENCE.md");
+  // Missing docs are tolerated (a run may generate a subset of phases), so a
+  // zero total is not a failure — the per-block checks above carry the gate.
+  std::printf("readme_examples: scanned %d cpp block(s)\\n", total);
+}
+
+int main() {
+  T_RUN(readme_examples_gate);
+  return sdktest::summary("readme_examples_test");
+}
+`)
+  })
+})
+
+
+export {
+  ReadmeExamplesTest
+}

package/project/.sdk/src/cmp/cpp/ReadmeExplanation_cpp.ts

@@ -0,0 +1,45 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeExplanation = cmp(function ReadmeExplanation(props: any) {
+  const { target, ctx$: { model } } = props
+
+  Content(`### Data as \`Value\`
+
+The C++ SDK uses a single dynamic \`sdk::Value\` type (a JSON-like variant
+over string / number / bool / list / map) throughout rather than generated
+typed structs. This mirrors the dynamic nature of the API and keeps the
+SDK flexible — no code generation is needed when the API schema changes.
+
+Build maps with \`sdk::vmap({{"key", sdk::Value("v")}})\` and lists with
+\`sdk::vlist({...})\`; read fields back with \`sdk::getp(value, "key")\`. Use
+\`sdk::to_map()\` to safely coerce a value that should be a map, and
+\`sdk::Struct::jsonify(value)\` to render it as JSON.
+
+### Directory structure
+
+\`\`\`
+${target.name}/
+├── core/                        -- Runtime type graph, config, generated client
+├── entity/                      -- Per-entity client headers
+├── feature/                     -- Built-in features (Base, Test, Log, ...)
+├── utility/                     -- Operation pipeline + vendored struct library
+├── test/                        -- Test suites
+├── Makefile                     -- Build & run the tests (C++17)
+└── VERSION                      -- SDK version
+\`\`\`
+
+Include the umbrella header \`core/sdk.hpp\` to pull in the whole SDK: the
+runtime types, the pipeline utilities, the vendored struct, the generated
+config, the per-entity clients and the generated \`${model.const.Name}SDK\`
+client class. Everything lives in the \`sdk\` namespace.
+
+`)
+
+})
+
+
+export {
+  ReadmeExplanation
+}

package/project/.sdk/src/cmp/cpp/ReadmeHowto_cpp.ts

@@ -0,0 +1,139 @@
+
+import { cmp, Content, isAuthActive, envName, canonKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import { cppVarName } from './utility_cpp'
+
+
+// A type-correct C++ literal for a field's canonical type.
+function cppLit(type: any): string {
+  const k = canonKey(type)
+  if ('INTEGER' === k || 'NUMBER' === k) return 'Value(1)'
+  if ('BOOLEAN' === k) return 'Value(true)'
+  if ('ARRAY' === k) return 'vlist()'
+  if ('OBJECT' === k) return 'vmap()'
+  return 'Value("example")'
+}
+
+
+const ReadmeHowto = cmp(function ReadmeHowto(props: any) {
+  const { target, ctx$: { model } } = props
+
+  const entity = getModelPath(model, `main.${KIT}.entity`)
+  // Pick an entity with a real op (prefer a read op) — never fabricate a
+  // `load` on an op-less entity. primaryOp is null only when NO entity
+  // exposes any op (a direct()-only SDK).
+  const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
+  const acc = exampleEntity ? cppVarName(exampleEntity.name) : 'entity'
+  const eVar = acc
+  // Model-driven id key: null when the entity has no id-like field.
+  const idF = exampleEntity ? entityIdField(exampleEntity) : null
+  const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
+  let testArg = 'Value::undef()'
+  if (exampleEntity && isMatchOp) {
+    testArg = idF ? `vmap({{"${idF}", Value("test01")}})` : 'Value::undef()'
+  } 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 = `vmap({${chosen.map((it: any) => `{"${it.name}", ${cppLit(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 throw on error.
+Value ${eVar} = client->${acc}()->${primaryOp}(${testArg}, Value::undef());
+// ${eVar} contains the mock response record
+std::cout << Struct::jsonify(${eVar}) << std::endl;`
+    : `Value result = client->direct(vmap({
+    {"path", Value("/api/resource")},
+    {"method", Value("GET")},
+}));
+std::cout << Struct::jsonify(result) << std::endl;`
+
+  const apikeyEnvLine = isAuthActive(model)
+    ? `\n${envName(model)}_APIKEY=<your-key>`
+    : ''
+
+  Content(`### Make a direct HTTP request
+
+For endpoints not covered by entity methods:
+
+\`\`\`cpp
+Value result = client->direct(vmap({
+    {"path", Value("/api/resource/{id}")},
+    {"method", Value("GET")},
+    {"params", vmap({{"id", Value("example")}})},
+}));
+
+if (getp(result, "ok") == Value(true)) {
+  std::cout << Helpers::toInt(getp(result, "status")) << std::endl;  // 200
+  std::cout << Struct::jsonify(getp(result, "data")) << std::endl;   // response body
+} else {
+  // A non-2xx response carries status + data (the error body); a
+  // transport-level failure carries err instead. Only one is present.
+  std::cerr << Helpers::toInt(getp(result, "status")) << " "
+            << Struct::jsonify(getp(result, "err")) << std::endl;
+}
+\`\`\`
+
+\`direct()\` is the escape hatch: it never throws — branch on
+\`getp(result, "ok")\`.
+
+### Prepare a request without sending it
+
+\`\`\`cpp
+// prepare() returns the fetch definition and throws on error.
+Value fetchdef = client->prepare(vmap({
+    {"path", Value("/api/resource/{id}")},
+    {"method", Value("DELETE")},
+    {"params", vmap({{"id", Value("example")}})},
+}));
+
+std::cout << Struct::stringify(getp(fetchdef, "url")) << std::endl;
+std::cout << Struct::stringify(getp(fetchdef, "method")) << std::endl;
+std::cout << Struct::jsonify(getp(fetchdef, "headers")) << std::endl;
+\`\`\`
+
+### Use test mode
+
+Create a mock client for unit testing — no server required. The test
+feature installs an in-memory mock transport:
+
+\`\`\`cpp
+auto client = ${model.const.Name}SDK::testSDK();
+
+${testModeExample}
+\`\`\`
+
+You can seed the mock store by passing test options — see the generated
+\`test/\` suite for worked examples.
+
+### Run live tests
+
+Create a \`.env.local\` file at the project root:
+
+\`\`\`
+${envName(model)}_TEST_LIVE=TRUE${apikeyEnvLine}
+\`\`\`
+
+Then build and run the test suite:
+
+\`\`\`bash
+cd ${target.name} && make test
+\`\`\`
+
+`)
+
+})
+
+
+export {
+  ReadmeHowto
+}

package/project/.sdk/src/cmp/cpp/ReadmeInstall_cpp.ts

@@ -0,0 +1,42 @@
+
+import { cmp, Content, repoInfo } from '@voxgig/sdkgen'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { target, ctx$ } = props
+  const { model } = ctx$
+
+  // The C++ SDK is header-only: there is no package registry to install from.
+  // Consumers vendor the source tree (or add it as a submodule) and put the
+  // SDK directory on the compiler include path. The git release tag
+  // (`cpp/vX.Y.Z`) is the unit of distribution.
+  const { releasesUrl } = repoInfo(model)
+
+  Content(`The ${target.title} SDK is **header-only** — there is no package to install
+from a registry. Vendor the \`cpp/\` directory into your project (or add the
+repository as a git submodule) and put it on your compiler's include path.
+Releases are cut as the git tag \`${target.name}/vX.Y.Z\` (see
+[Releases](${releasesUrl})).
+
+\`\`\`bash
+# Add the SDK as a submodule (or copy the cpp/ directory into your tree).
+git submodule add <repo-url> third_party/${model.const.Name.toLowerCase()}-sdk
+\`\`\`
+
+Then include the umbrella header and compile with C++17:
+
+\`\`\`cpp
+#include "core/sdk.hpp"
+\`\`\`
+
+\`\`\`bash
+g++ -std=c++17 -Ithird_party/${model.const.Name.toLowerCase()}-sdk/cpp your_app.cpp -o your_app
+\`\`\`
+
+`)
+})
+
+
+export {
+  ReadmeInstall
+}

package/project/.sdk/src/cmp/cpp/ReadmeIntro_cpp.ts

@@ -0,0 +1,69 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import { cppVarName } from './utility_cpp'
+
+
+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 — a header-only,
+entity-oriented client following idiomatic modern C++ (C++17) 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 accessor 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->${cppVarName(exampleEntity.name)}()\` — 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. Every value flows through a single dynamic
+\`sdk::Value\` type (a JSON-like variant), so there is no schema-driven code to
+regenerate when the API changes.
+
+> 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/cpp/ReadmeModel_cpp.ts

@@ -0,0 +1,155 @@
+
+import { cmp, each, Content, isAuthActive } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+import { cppVarName } from './utility_cpp'
+
+
+const ReadmeModel = cmp(function ReadmeModel(props: any) {
+  const { target, ctx$: { model } } = props
+
+  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) -> Value` | Load a single entity by match criteria. Throws on error. |',
+    list: '| `list` | `(reqmatch, ctrl) -> Value` | List entities matching the criteria (a Value list). Throws on error. |',
+    create: '| `create` | `(reqdata, ctrl) -> Value` | Create a new entity. Throws on error. |',
+    update: '| `update` | `(reqdata, ctrl) -> Value` | Update an existing entity. Throws on error. |',
+    remove: '| `remove` | `(reqmatch, ctrl) -> Value` | Remove an entity. Throws 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` | `std::string` | API key for authentication. |\n'
+    : ''
+
+  Content(`### ${model.const.Name}SDK
+
+\`\`\`cpp
+#include "core/sdk.hpp"
+
+using namespace sdk;
+
+auto client = std::make_shared<${model.const.Name}SDK>(options);
+\`\`\`
+
+Creates a new SDK client. \`options\` is an \`sdk::Value\` map.
+
+| Option | Type | Description |
+| --- | --- | --- |
+${apikeyOptionRow}| \`base\` | \`std::string\` | Base URL of the API server. |
+| \`prefix\` | \`std::string\` | URL path prefix prepended to all requests. |
+| \`suffix\` | \`std::string\` | URL path suffix appended to all requests. |
+| \`feature\` | \`Value\` | Feature activation flags. |
+| \`system\` | \`Value\` | System overrides. |
+
+### testSDK
+
+\`\`\`cpp
+auto client = ${model.const.Name}SDK::testSDK(testopts, sdkopts);
+\`\`\`
+
+Creates a test-mode client with mock transport. Both arguments may be
+\`Value::undef()\`; a no-arg \`${model.const.Name}SDK::testSDK()\` overload is
+also provided.
+
+### ${model.const.Name}SDK methods
+
+| Method | Signature | Description |
+| --- | --- | --- |
+| \`optionsMap\` | \`() -> Value\` | Deep copy of current SDK options. |
+| \`getUtility\` | \`() -> UtilityPtr\` | Copy of the SDK utility object. |
+| \`prepare\` | \`(fetchargs) -> Value\` | Build an HTTP request definition without sending. Throws on error. |
+| \`direct\` | \`(fetchargs) -> Value\` | Build and send an HTTP request. Returns a result Value (branch on \`ok\`). |
+`)
+
+  each(entityList, (ent: any) => {
+    const acc = cppVarName(ent.name)
+    const article = /^[aeiou]/i.test(ent.Name) ? 'an' : 'a'
+    Content(`| \`${acc}\` | \`(entopts) -> std::shared_ptr<${ent.Name}Entity>\` | Create ${article} ${ent.Name} entity instance. |
+`)
+  })
+
+  Content(`
+### Entity interface
+
+All entities share the same interface.
+
+| Method | Signature | Description |
+| --- | --- | --- |
+${opRows}
+| \`data\` | \`(arg) -> Value\` | Get (no arg) or set (with arg) entity data. |
+| \`match\` | \`(arg) -> Value\` | Get (no arg) or set (with arg) entity match criteria. |
+| \`make\` | \`() -> EntityPtr\` | Create a new instance with the same options. |
+| \`getName\` | \`() -> std::string\` | Return the entity name. |
+
+### Result shape
+
+Entity operations return the bare result data (a map \`Value\` for
+single-entity ops, a list \`Value\` for \`list\`) and throw
+\`sdk::SdkErrorPtr\` on error. Wrap calls in \`try\`/\`catch\` to handle
+failures.
+
+The \`direct()\` escape hatch never throws — it returns a result \`Value\`
+you branch on via \`getp(result, "ok")\`:
+
+| Key | Type | Description |
+| --- | --- | --- |
+| \`ok\` | \`bool\` | \`true\` if the HTTP status is 2xx. |
+| \`status\` | \`int\` | HTTP status code. |
+| \`headers\` | \`Value\` | Response headers. |
+| \`data\` | \`Value\` | 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.map((n: string) => n.charAt(0).toUpperCase() + n.slice(1)).join(', ')}.
+
+API path: \`${path}\`
+
+`)
+  })
+
+})
+
+
+export {
+  ReadmeModel
+}

package/project/.sdk/src/cmp/cpp/ReadmeOptions_cpp.ts

@@ -0,0 +1,62 @@
+
+import { cmp, each, Content, envName, isAuthActive } from '@voxgig/sdkgen'
+
+
+const ReadmeOptions = cmp(function ReadmeOptions(props: any) {
+  const { target } = props
+  const { model } = props.ctx$
+
+  const publishedOptions = each(target.options).filter((option: any) =>
+    option.publish && ('apikey' !== option.name || isAuthActive(model)))
+  if (0 === publishedOptions.length) {
+    return
+  }
+
+  Content(`
+
+## Options
+
+Pass options as an \`sdk::Value\` map when constructing a client:
+
+`)
+
+  const hasApikey = publishedOptions.some((o: any) => 'apikey' === o.name)
+
+  Content(`\`\`\`cpp
+${hasApikey ? `const char* apikey = std::getenv("${envName(model)}_APIKEY");
+` : ''}auto client = std::make_shared<${model.Name}SDK>(vmap({
+`)
+
+  publishedOptions.map((option: any) => {
+    if ('apikey' === option.name) {
+      Content(`    {"${option.name}", Value(apikey ? apikey : "")},
+`)
+    }
+    else {
+      Content(`    // {"${option.name}", ${option.kind === 'string' ? 'Value("...")' : 'Value(...)'}},
+`)
+    }
+  })
+
+  Content(`}));
+\`\`\`
+
+`)
+
+  Content(`| Option | Type | Description |
+| --- | --- | --- |
+`)
+
+  publishedOptions.map((option: any) => {
+    Content(`| \`${option.name}\` | \`${option.kind}\` | ${option.short} |
+`)
+  })
+
+  Content(`
+`)
+})
+
+
+export {
+  ReadmeOptions
+}