@voxgig/sdkgen 1.3.14 → 1.3.17

package/project/.sdk/src/cmp/csharp/ReadmeExamplesTest_csharp.ts

@@ -0,0 +1,198 @@
+
+import { cmp, File, Content } from '@voxgig/sdkgen'
+
+
+// Emits test/ReadmeExamplesTest.cs — an xUnit PRESENCE + STRUCTURE gate over
+// every ```csharp fenced block in the repository ROOT README.md, the
+// per-language csharp/README.md, AND the per-language csharp/REFERENCE.md.
+//
+// SCOPE NOTE (deliberate, documented): the Python/TS/Go equivalents EXECUTE and
+// type-check every documented block. That is infeasible here — the generated
+// C# SDK targets the .NET BCL only (no Roslyn scripting dependency), so a test
+// project cannot compile-and-run arbitrary doc snippets at test time without a
+// dependency the target explicitly forbids. 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 ```csharp block (nothing was
+//      dropped);
+//   2. every ```csharp block is structurally well-formed — its braces,
+//      parentheses and brackets balance (catches a truncated or malformed
+//      generated snippet), and it references the SDK/client surface so it is a
+//      real example, not an empty fence.
+// A per-doc summary line makes the coverage visible in the test output.
+//
+// The emitted C# is written WITHOUT literal backticks (the fence marker is
+// built at runtime as new string((char)96, 3)) so this TS template literal
+// stays clean — the only interpolations are the SDK class name and the
+// generated entity map.
+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 csharp-examples PRESENCE + STRUCTURE gate.
+//
+// GUARANTEE (see ReadmeExamplesTest_csharp.ts for why this is a structure gate
+// and not an execute gate): every csharp example in the docs is accounted for.
+// This xUnit class is a completeness gate over every ${'```'}csharp fenced code
+// block in three documents:
+//   - the repository ROOT README.md (two directories above this test file),
+//   - the per-language csharp/README.md,
+//   - the per-language csharp/REFERENCE.md.
+//
+// Checks, PER DOCUMENT:
+//   1. PRESENCE: the doc exists and holds at least one csharp block.
+//   2. STRUCTURE: every csharp block's braces / parens / brackets balance, so a
+//      truncated or malformed generated snippet fails loudly.
+//
+// GENERATED by @voxgig/sdkgen — do not edit by hand.
+
+using System.Runtime.CompilerServices;
+
+using Xunit;
+
+namespace ${Name}Sdk.Test;
+
+public class ReadmeExamplesTest
+{
+    // The .cs source directory, resolved at compile time — robust to the test
+    // runner's working directory.
+    private static string SourceDir([CallerFilePath] string path = "")
+        => System.IO.Path.GetDirectoryName(path)!;
+
+    private static string CsharpRoot()
+        => System.IO.Path.GetFullPath(System.IO.Path.Combine(SourceDir(), ".."));
+
+    private static (string label, string path)[] Docs()
+    {
+        var root = CsharpRoot();
+        return new[]
+        {
+            ("root README", System.IO.Path.GetFullPath(
+                System.IO.Path.Combine(root, "..", "README.md"))),
+            ("csharp README.md", System.IO.Path.Combine(root, "README.md")),
+            ("csharp REFERENCE.md", System.IO.Path.Combine(root, "REFERENCE.md")),
+        };
+    }
+
+    // Extract every csharp 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
+    // "csharp" are returned.
+    private static List<string> CsharpBlocks(string text)
+    {
+        var fence = new string((char)96, 3);
+        var parts = text.Split(fence);
+        var blocks = new List<string>();
+        for (var i = 1; i < parts.Length; i += 2)
+        {
+            var seg = parts[i];
+            var nl = seg.IndexOf('\\n');
+            var info = (nl < 0 ? seg : seg.Substring(0, nl)).Trim();
+            if (info == "csharp")
+            {
+                blocks.Add(nl < 0 ? "" : seg.Substring(nl + 1));
+            }
+        }
+        return blocks;
+    }
+
+    private static string ReadDoc(string path, string label)
+    {
+        Assert.True(System.IO.File.Exists(path), label + " not found: " + path);
+        return System.IO.File.ReadAllText(path);
+    }
+
+    // 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 static bool Balanced(string block)
+    {
+        var stack = new Stack<char>();
+        var pairs = new Dictionary<char, char> { ['('] = ')', ['['] = ']', ['{'] = '}' };
+        var closers = new HashSet<char> { ')', ']', '}' };
+        foreach (var ch in block)
+        {
+            if (pairs.ContainsKey(ch))
+            {
+                stack.Push(pairs[ch]);
+            }
+            else if (closers.Contains(ch))
+            {
+                if (stack.Count == 0 || stack.Pop() != ch)
+                {
+                    return false;
+                }
+            }
+        }
+        return stack.Count == 0;
+    }
+
+    [Fact]
+    public void RootReadmeHasCsharpBlocks()
+    {
+        var doc = Docs()[0];
+        var blocks = CsharpBlocks(ReadDoc(doc.path, doc.label));
+        Assert.True(blocks.Count > 0,
+            "expected at least one csharp block in " + doc.label);
+    }
+
+    [Fact]
+    public void LocalReadmeHasCsharpBlocks()
+    {
+        var doc = Docs()[1];
+        var blocks = CsharpBlocks(ReadDoc(doc.path, doc.label));
+        Assert.True(blocks.Count > 0,
+            "expected at least one csharp block in " + doc.label);
+    }
+
+    [Fact]
+    public void ReferenceHasCsharpBlocks()
+    {
+        var doc = Docs()[2];
+        var blocks = CsharpBlocks(ReadDoc(doc.path, doc.label));
+        Assert.True(blocks.Count > 0,
+            "expected at least one csharp block in " + doc.label);
+    }
+
+    [Fact]
+    public void AllCsharpBlocksAreStructurallyBalanced()
+    {
+        var failures = new List<string>();
+        foreach (var doc in Docs())
+        {
+            if (!System.IO.File.Exists(doc.path))
+            {
+                continue;
+            }
+            var blocks = CsharpBlocks(System.IO.File.ReadAllText(doc.path));
+            var balanced = 0;
+            for (var i = 0; i < blocks.Count; i++)
+            {
+                if (Balanced(blocks[i]))
+                {
+                    balanced++;
+                }
+                else
+                {
+                    failures.Add(doc.label + " csharp block #" + i +
+                        " has unbalanced delimiters:\\n\\n" + blocks[i]);
+                }
+            }
+            System.Console.WriteLine(
+                "[readme-examples] " + doc.label + " csharp blocks: total=" +
+                blocks.Count + " balanced=" + balanced);
+        }
+        Assert.True(failures.Count == 0,
+            string.Join("\\n\\n", failures));
+    }
+}
+`)
+  })
+})
+
+
+export {
+  ReadmeExamplesTest
+}

package/project/.sdk/src/cmp/csharp/ReadmeExplanation_csharp.ts

@@ -0,0 +1,42 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+
+const ReadmeExplanation = cmp(function ReadmeExplanation(props: any) {
+  const { target, ctx$: { model } } = props
+
+  Content(`### Data as dictionaries
+
+The C# SDK uses a loose object model — \`Dictionary<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
+\`Dictionary<string, object?>\`. A \`${model.const.Name}Types.cs\` module of
+reference \`record\` types is also generated for editor documentation.
+
+### Project structure
+
+\`\`\`
+csharp/
+├── ${model.const.Name}SDK.csproj    -- Library project (compiles everything except test/)
+├── 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
+└── test/                       -- xUnit test suites
+\`\`\`
+
+The main client class (\`${model.const.Name}SDK\`, namespace
+\`${model.const.Name}Sdk\`) exposes the entity accessors. Reference entity or
+utility types directly only when needed.
+
+`)
+
+})
+
+
+export {
+  ReadmeExplanation
+}

package/project/.sdk/src/cmp/csharp/ReadmeHowto_csharp.ts

@@ -0,0 +1,168 @@
+
+import { cmp, Content, isAuthActive, envName, canonKey, entityIdField, pickExampleEntity, opRequestShape } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+import { csVarName } from './utility_csharp'
+
+
+// A type-correct C# literal for a field's canonical type.
+function csLit(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 'new List<object?>()'
+  if ('OBJECT' === k) return 'new Dictionary<string, object?>()'
+  return '"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). primaryOp is null only
+  // when NO entity exposes any op (a direct()-only SDK).
+  const { entity: exampleEntity, primaryOp } = pickExampleEntity(entity)
+  const eName = exampleEntity ? nom(exampleEntity, 'Name') : 'Entity'
+  const eVar = exampleEntity ? csVarName(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 opMethod = primaryOp ? primaryOp.charAt(0).toUpperCase() + primaryOp.slice(1) : ''
+  const isMatchOp = 'load' === primaryOp || 'remove' === primaryOp
+  let testArg = 'null'
+  if (exampleEntity && isMatchOp) {
+    testArg = idF ? `new Dictionary<string, object?> { ["${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 = `new Dictionary<string, object?> {${chosen.map((it: any) =>
+      ` ["${it.name}"] = ${csLit(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.
+var ${eVar} = client.${eName}().${opMethod}(${testArg});
+// ${eVar} holds the mock response record
+Console.WriteLine(${eVar});`
+    : `var result = client.Direct(new Dictionary<string, object?>
+{
+    ["path"] = "/api/resource",
+    ["method"] = "GET",
+});
+Console.WriteLine(result);`
+
+  const apikeyEnvLine = isAuthActive(model)
+    ? `\n${envName(model)}_APIKEY=<your-key>`
+    : ''
+
+  Content(`### Make a direct HTTP request
+
+For endpoints not covered by entity methods:
+
+\`\`\`csharp
+var result = client.Direct(new Dictionary<string, object?>
+{
+    ["path"] = "/api/resource/{id}",
+    ["method"] = "GET",
+    ["params"] = new Dictionary<string, object?> { ["id"] = "example" },
+});
+
+if (Equals(result["ok"], true))
+{
+    Console.WriteLine(result["status"]);  // 200
+    Console.WriteLine(result["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 with TryGetValue rather than indexing a key that may be absent.
+    result.TryGetValue("status", out var status);
+    result.TryGetValue("err", out var err);
+    Console.WriteLine($"{status} {err}");
+}
+\`\`\`
+
+### Prepare a request without sending it
+
+\`\`\`csharp
+// Prepare() returns the fetch definition and raises on error.
+var fetchdef = client.Prepare(new Dictionary<string, object?>
+{
+    ["path"] = "/api/resource/{id}",
+    ["method"] = "DELETE",
+    ["params"] = new Dictionary<string, object?> { ["id"] = "example" },
+});
+
+Console.WriteLine(fetchdef["url"]);
+Console.WriteLine(fetchdef["method"]);
+Console.WriteLine(fetchdef["headers"]);
+\`\`\`
+
+### Use test mode
+
+Create a mock client for unit testing — no server required:
+
+\`\`\`csharp
+var client = ${model.const.Name}SDK.TestSDK(null, null);
+
+${testModeExample}
+\`\`\`
+
+### Use a custom fetch function
+
+Replace the HTTP transport with your own delegate:
+
+\`\`\`csharp
+Func<string, Dictionary<string, object?>, Dictionary<string, object?>> mockFetch =
+    (url, init) => new Dictionary<string, object?>
+    {
+        ["status"] = 200,
+        ["statusText"] = "OK",
+        ["headers"] = new Dictionary<string, object?>(),
+        ["json"] = (Func<object?>)(() => new Dictionary<string, object?> { ["id"] = "mock01" }),
+    };
+
+var client = new ${model.const.Name}SDK(new Dictionary<string, object?>
+{
+    ["base"] = "http://localhost:8080",
+    ["system"] = new Dictionary<string, object?>
+    {
+        ["fetch"] = mockFetch,
+    },
+});
+\`\`\`
+
+### Run live tests
+
+Create a \`.env.local\` file at the project root:
+
+\`\`\`
+${envName(model)}_TEST_LIVE=TRUE${apikeyEnvLine}
+\`\`\`
+
+Then run:
+
+\`\`\`bash
+cd csharp && dotnet test
+\`\`\`
+
+`)
+
+})
+
+
+export {
+  ReadmeHowto
+}

package/project/.sdk/src/cmp/csharp/ReadmeInstall_csharp.ts

@@ -0,0 +1,41 @@
+
+import { cmp, Content, installCommand, isPublished, repoInfo } from '@voxgig/sdkgen'
+
+
+const ReadmeInstall = cmp(function ReadmeInstall(props: any) {
+  const { target, ctx$ } = props
+  const { model } = ctx$
+
+  if (isPublished(model, target.name)) {
+    Content(`\`\`\`bash
+${installCommand(model, target.name)}
+\`\`\`
+
+Or add a project reference to a source checkout:
+
+\`\`\`bash
+dotnet add reference ../${model.const.Name}SDK/${model.const.Name}SDK.csproj
+\`\`\`
+
+`)
+    return
+  }
+
+  // Publish pending: not yet on NuGet. Install from the git release tag or
+  // from a local source checkout.
+  const { releasesUrl } = repoInfo(model)
+  Content(`This package is not yet published to NuGet. Install it from the GitHub
+release tag (\`${target.name}/vX.Y.Z\`, see [Releases](${releasesUrl})) or
+from a source checkout — build the library and add a project reference:
+
+\`\`\`bash
+cd csharp && dotnet build ${model.const.Name}SDK.csproj
+\`\`\`
+
+`)
+})
+
+
+export {
+  ReadmeInstall
+}

package/project/.sdk/src/cmp/csharp/ReadmeIntro_csharp.ts

@@ -0,0 +1,65 @@
+
+import { cmp, Content } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+  nom,
+} from '@voxgig/apidef'
+
+
+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 C# 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.${nom(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.
+
+> 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/csharp/ReadmeModel_csharp.ts

@@ -0,0 +1,148 @@
+
+import { cmp, each, Content, isAuthActive } from '@voxgig/sdkgen'
+
+import {
+  KIT,
+  getModelPath,
+} from '@voxgig/apidef'
+
+
+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) -> 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(`### ${model.const.Name}SDK
+
+\`\`\`csharp
+using ${model.const.Name}Sdk;
+
+var client = new ${model.const.Name}SDK(options);
+\`\`\`
+
+Creates a new SDK client. \`options\` is a \`Dictionary<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\` | \`Dictionary\` | Feature activation flags. |
+| \`extend\` | \`List\` | Additional Feature instances to load. |
+| \`system\` | \`Dictionary\` | System overrides (e.g. custom \`fetch\` delegate). |
+
+### TestSDK
+
+\`\`\`csharp
+var client = ${model.const.Name}SDK.TestSDK(testopts, sdkopts);
+\`\`\`
+
+Creates a test-mode client with mock transport. Both arguments may be \`null\`.
+
+### ${model.const.Name}SDK methods
+
+| Method | Signature | Description |
+| --- | --- | --- |
+| \`OptionsMap\` | \`() -> Dictionary\` | Deep copy of current SDK options. |
+| \`GetUtility\` | \`() -> Utility\` | Copy of the SDK utility object. |
+| \`Prepare\` | \`(fetchargs) -> Dictionary\` | Build an HTTP request definition without sending. Raises on error. |
+| \`Direct\` | \`(fetchargs) -> Dictionary\` | Build and send an HTTP request. Returns a result dictionary (branch on \`ok\`). |
+`)
+
+  each(entityList, (ent: any) => {
+    const article = /^[aeiou]/i.test(ent.Name) ? 'an' : 'a'
+    Content(`| \`${ent.Name}\` | \`(entopts) -> ${model.const.Name}EntityBase\` | 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. |
+| \`Match\` | \`(newmatch) -> object?\` | Get or set entity match criteria. |
+| \`Make\` | \`() -> IEntity\` | Create a new instance with the same options. |
+| \`GetName\` | \`() -> string\` | Return the entity name. |
+
+### Result shape
+
+Entity operations return the bare result data (a \`Dictionary\` 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
+\`Dictionary<string, object?>\` you branch on via \`result["ok"]\`:
+
+| Key | Type | Description |
+| --- | --- | --- |
+| \`ok\` | \`bool\` | \`true\` if the HTTP status is 2xx. |
+| \`status\` | \`int\` | HTTP status code. |
+| \`headers\` | \`Dictionary\` | 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.map((n: string) => n.charAt(0).toUpperCase() + n.slice(1)).join(', ')}.
+
+API path: \`${path}\`
+
+`)
+  })
+
+})
+
+
+export {
+  ReadmeModel
+}