@voxgig/sdkgen 1.3.14 → 1.3.17

package/src/helpers/canonType.ts

@@ -1,20 +1,22 @@
 // Canonical type-sentinel -> language primitive type mapper.
 //
-// SOURCE OF TRUTH for the sentinel set: @voxgig/apidef
-//   ~/Projects/voxgig/apidef ts/src/utility.ts  ->  `const VALID_CANON`
-// (around line 908). VALID_CANON maps an OpenAPI type NAME -> a `$SENTINEL`
-// string (e.g. 'string' -> `$STRING`). The model stores those sentinels on
-// every `fields[].type` and op `points[].args.params[].type`.
+// SOURCE OF TRUTH for the sentinel set: @voxgig/apidef (`VALID_CANON` +
+// `CANON_ONE`, exported from the package). VALID_CANON maps an OpenAPI type
+// NAME -> a `$SENTINEL` string (e.g. 'string' -> `$STRING`). The model stores
+// those sentinels on every `fields[].type` and op `points[].args.params[].type`.
+// A multi-type (OpenAPI `type: [a, b]`) is stored as the ARRAY-shaped union
+// sentinel `['`$ONE`', [member, ...]]` (see canonToType below).
 //
 // This table maps the SENTINEL the other way -> a concrete primitive type in
 // each target language, so the typed-model generators (EntityTypes_<lang>.ts)
-// can turn the model's field/param sentinels into real language types.
+// and the README type columns (ReadmeRef_<lang>.ts / ReadmeEntity_<lang>.ts)
+// can turn the model's field/param sentinels into real language types. It is
+// the SINGLE mapping per language: components must not keep local copies.
 //
-// Kept as a small duplicate here (rather than importing VALID_CANON) because
-// VALID_CANON is name->sentinel, is not exported from @voxgig/apidef, and would
-// need inverting; a sentinel->type table is what every language generator
-// actually needs. If VALID_CANON gains a new sentinel, add a row below (all
-// languages) and keep the two in sync.
+// Kept as a small mirror here (rather than importing VALID_CANON at runtime)
+// because apidef is a peer dependency and the table is the INVERSE direction;
+// `ts/test/canontype.test.ts` asserts this table covers apidef's exported
+// sentinel vocabulary whenever apidef is installed, so drift fails the suite.
 //
 // KNOWN GAPS (papered over sanely, documented for the port):
 //  - Unknown / missing sentinel  -> the language's "any" (never throws).
@@ -25,30 +27,99 @@
 //    language's open record/map type.
 //  - No enum/format/nullability beyond the `req` flag.
 
-// Target languages sdkgen supports (go-cli / go-mcp reuse 'go').
-type CanonLang = 'ts' | 'js' | 'py' | 'php' | 'rb' | 'lua' | 'go'
+// Target languages sdkgen supports (go-cli / go-mcp reuse 'go'). The targets
+// with a fully dynamic value model (clojure, haskell, ocaml, perl, zig) have
+// no column: they emit no typed models and document types via the language's
+// dynamic Value/map vocabulary.
+type CanonLang =
+  | 'ts' | 'js' | 'py' | 'php' | 'rb' | 'lua' | 'go'
+  | 'csharp' | 'java' | 'kotlin' | 'scala' | 'swift' | 'dart'
+  | 'rust' | 'c' | 'cpp' | 'elixir'
 
 // Bare sentinel key (backticks + leading `$` stripped, upper-cased)
 // -> per-language primitive type name.
 //
-// ONLY the `ts` column is exercised + tested today (the reference target).
-// The other columns are a starting scaffold for the per-language port; verify
-// each against that language's idioms before wiring its EntityTypes_<lang>.ts.
+// Column notes:
+//  - kotlin: every type is nullable (`?`) — the kotlin emitter drops
+//    per-member optionality because the column is already-nullable.
+//  - java/scala: boxed JVM types (nullable), so optionality needs no marker.
+//  - rust/c/cpp/swift: `Value`/`voxgig_value*`/`VMap` are the vendored
+//    dynamic value types those runtimes ship.
 const CANON_TYPE: Record<string, Record<CanonLang, string>> = {
-  STRING: { ts: 'string', js: 'string', py: 'str', php: 'string', rb: 'String', lua: 'string', go: 'string' },
-  INTEGER: { ts: 'number', js: 'number', py: 'int', php: 'int', rb: 'Integer', lua: 'number', go: 'int' },
-  NUMBER: { ts: 'number', js: 'number', py: 'float', php: 'float', rb: 'Float', lua: 'number', go: 'float64' },
-  BOOLEAN: { ts: 'boolean', js: 'boolean', py: 'bool', php: 'bool', rb: 'Boolean', lua: 'boolean', go: 'bool' },
-  NULL: { ts: 'null', js: 'null', py: 'None', php: 'null', rb: 'NilClass', lua: 'nil', go: 'any' },
-  ARRAY: { ts: 'any[]', js: 'Array', py: 'list', php: 'array', rb: 'Array', lua: 'table', go: '[]any' },
-  OBJECT: { ts: 'Record<string, any>', js: 'Object', py: 'dict', php: 'array', rb: 'Hash', lua: 'table', go: 'map[string]any' },
-  ANY: { ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object', lua: 'any', go: 'any' },
+  STRING: {
+    ts: 'string', js: 'string', py: 'str', php: 'string', rb: 'String',
+    lua: 'string', go: 'string', csharp: 'string', java: 'String',
+    kotlin: 'String?', scala: 'String', swift: 'String', dart: 'String',
+    rust: 'String', c: 'char*', cpp: 'std::string', elixir: 'String.t()',
+  },
+  INTEGER: {
+    ts: 'number', js: 'number', py: 'int', php: 'int', rb: 'Integer',
+    lua: 'number', go: 'int', csharp: 'long', java: 'Long',
+    kotlin: 'Long?', scala: 'java.lang.Long', swift: 'Int', dart: 'int',
+    rust: 'i64', c: 'int64_t', cpp: 'int64_t', elixir: 'integer()',
+  },
+  NUMBER: {
+    ts: 'number', js: 'number', py: 'float', php: 'float', rb: 'Float',
+    lua: 'number', go: 'float64', csharp: 'double', java: 'Double',
+    kotlin: 'Double?', scala: 'java.lang.Double', swift: 'Double', dart: 'num',
+    rust: 'f64', c: 'double', cpp: 'double', elixir: 'float()',
+  },
+  BOOLEAN: {
+    ts: 'boolean', js: 'boolean', py: 'bool', php: 'bool', rb: 'Boolean',
+    lua: 'boolean', go: 'bool', csharp: 'bool', java: 'Boolean',
+    kotlin: 'Boolean?', scala: 'java.lang.Boolean', swift: 'Bool', dart: 'bool',
+    rust: 'bool', c: 'bool', cpp: 'bool', elixir: 'boolean()',
+  },
+  NULL: {
+    ts: 'null', js: 'null', py: 'None', php: 'null', rb: 'NilClass',
+    lua: 'nil', go: 'any', csharp: 'object?', java: 'Object',
+    kotlin: 'Any?', scala: 'Object', swift: 'Value', dart: 'Object',
+    rust: 'Value', c: 'voxgig_value*', cpp: 'Value', elixir: 'nil',
+  },
+  ARRAY: {
+    ts: 'any[]', js: 'Array', py: 'list', php: 'array', rb: 'Array',
+    lua: 'table', go: '[]any', csharp: 'List<object?>', java: 'List<Object>',
+    kotlin: 'List<Any?>?', scala: 'java.util.List[Object]', swift: '[Value]',
+    dart: 'List<dynamic>', rust: 'Vec<Value>', c: 'voxgig_value*',
+    cpp: 'std::vector<Value>', elixir: 'list()',
+  },
+  OBJECT: {
+    ts: 'Record<string, any>', js: 'Object', py: 'dict', php: 'array',
+    rb: 'Hash', lua: 'table', go: 'map[string]any',
+    csharp: 'Dictionary<string, object?>', java: 'Map<String, Object>',
+    kotlin: 'Map<String, Any?>?', scala: 'java.util.Map[String, Object]',
+    swift: 'VMap', dart: 'Map<String, dynamic>',
+    rust: 'std::collections::HashMap<String, Value>', c: 'voxgig_value*',
+    cpp: 'std::map<std::string, Value>', elixir: 'map()',
+  },
+  ANY: {
+    ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object',
+    lua: 'any', go: 'any', csharp: 'object?', java: 'Object',
+    kotlin: 'Any?', scala: 'Object', swift: 'Value', dart: 'dynamic',
+    rust: 'Value', c: 'voxgig_value*', cpp: 'Value', elixir: 'any()',
+  },
 }
 
 // Per-language fallback for unknown / missing sentinels.
 // js uses JSDoc's `*` (any type); lua uses `any` (LuaLS).
 const CANON_ANY: Record<CanonLang, string> = {
-  ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object', lua: 'any', go: 'any',
+  ts: 'any', js: '*', py: 'Any', php: 'mixed', rb: 'Object',
+  lua: 'any', go: 'any', csharp: 'object?', java: 'Object',
+  kotlin: 'Any?', scala: 'Object', swift: 'Value', dart: 'dynamic',
+  rust: 'Value', c: 'voxgig_value*', cpp: 'Value', elixir: 'any()',
+}
+
+// Union ($ONE) member separator for languages with a native union/sum type
+// syntax. Languages absent here have no way to express an anonymous union in
+// a type position, so a $ONE sentinel degrades to that language's "any".
+// (php 8 unions exist but cannot combine with the `?` optional prefix the
+// emitters use, so php deliberately degrades to `mixed`.)
+const CANON_UNION_JOIN: Partial<Record<CanonLang, string>> = {
+  ts: ' | ',
+  js: '|',
+  py: ' | ',
+  lua: '|',
+  elixir: ' | ',
 }
 
 
@@ -64,10 +135,29 @@ function canonKey(sentinel: unknown): string {
 
 // Map a field/param type sentinel to a target-language primitive type.
 // Unknown or missing sentinel -> that language's "any" (never throws).
+//
+// The union sentinel `['`$ONE`', [member, ...]]` (apidef CANON_ONE, produced
+// for OpenAPI multi-types) renders as a joined member union in languages with
+// union syntax (see CANON_UNION_JOIN); elsewhere it degrades to "any".
+// Members may themselves be unions (handled recursively) or the literal
+// 'Any' apidef emits for an unknown member name (canonKey maps it to ANY).
 function canonToType(sentinel: unknown, lang: string): string {
   const l = lang as CanonLang
   const fallback = CANON_ANY[l] ?? 'any'
 
+  if (Array.isArray(sentinel)) {
+    if ('ONE' === canonKey(sentinel[0]) && Array.isArray(sentinel[1])) {
+      const join = CANON_UNION_JOIN[l]
+      if (null == join) {
+        return fallback
+      }
+      const members = sentinel[1].map((m: unknown) => canonToType(m, l))
+      const uniq = members.filter((m: string, i: number) => members.indexOf(m) === i)
+      return 0 === uniq.length ? fallback : uniq.join(join)
+    }
+    return fallback
+  }
+
   const row = CANON_TYPE[canonKey(sentinel)]
   if (null == row) {
     return fallback
@@ -82,6 +172,7 @@ export {
   canonKey,
   CANON_TYPE,
   CANON_ANY,
+  CANON_UNION_JOIN,
 }
 
 export type {

package/src/helpers/naming.ts

@@ -83,7 +83,54 @@ function safeVarName(name: string, lang: string): string {
 }
 
 
+// A variable name for a doc EXAMPLE entity. Doc examples bind the SDK instance
+// to `client` (e.g. `const client = ...SDK.test()`), so an entity whose
+// lowercased name is also `client` — an API with a `Client` entity — would
+// shadow it: `const client = client.Client()...` is self-referential (TS2448/
+// TS7022) and breaks the readme_examples type-check. Append `_` to keep the
+// example variable distinct from the SDK instance. Also applies the normal
+// language-reserved-word guard.
+function exampleVarName(name: string, lang: string): string {
+  const v = safeVarName(name, lang)
+  return 'client' === v ? v + '_' : v
+}
+
+
+// A valid ECMAScript identifier — the only shape `obj.name` can express.
+const JS_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+
+
+// A safe JS/TS property-access expression for a SPEC-DERIVED key: dot
+// notation when the key is a valid identifier, bracket notation otherwise.
+// OpenAPI path/query parameter names are not constrained to identifiers —
+// e.g. Evervault's `/payments/3ds-sessions/{3ds_session_id}` yields
+// `3ds_session_id`, and `params.3ds_session_id` is a syntax error (TS1434).
+// The other language targets already quote these keys (`params["..."]`);
+// this keeps ts/js in parity.
+function jsProp(obj: string, name: string): string {
+  return JS_IDENT.test(name) ? `${obj}.${name}` : `${obj}[${JSON.stringify(name)}]`
+}
+
+
+// A safe JS/TS OBJECT-LITERAL key for a spec-derived field name: bare when
+// the name is a valid identifier, single-quoted otherwise. `{ 3ds_session_id:
+// 1 }` is a syntax error (TS1351) — doc examples must quote such keys.
+function jsKey(name: string): string {
+  return JS_IDENT.test(name) ? name : `'${name}'`
+}
+
+
+// As `jsProp`, but optional-chained: `obj?.name` / `obj?.["3ds_session_id"]`.
+function jsOptProp(obj: string, name: string): string {
+  return JS_IDENT.test(name) ? `${obj}?.${name}` : `${obj}?.[${JSON.stringify(name)}]`
+}
+
+
 export {
   isReservedName,
   safeVarName,
+  exampleVarName,
+  jsProp,
+  jsOptProp,
+  jsKey,
 }

package/src/helpers/opExample.ts

@@ -52,15 +52,48 @@ function idLiteral(ent: any, op: string, idF: string | null): string {
 
 // Render a match object `{ idF: idLit }` (or empty when the entity has no id
 // key) in the target language's object syntax.
-function matchArg(lang: ExampleLang, idF: string | null, idLit: string): string {
-  if (null == idF) return 'go' === lang ? 'nil' : ''
+// Spec-derived field names are NOT constrained to be identifiers — e.g.
+// Evervault's `/payments/3ds-sessions/{3ds_session_id}` yields the match key
+// `3ds_session_id`. py/php/rb/go quote every literal key already, but ts/js
+// (`{ key: v }`) and lua (`{ key = v }`) write them bare, and a leading digit
+// or a `-` makes that a syntax error (TS1351 / Lua "'}' expected"). Quote
+// exactly those, leaving ordinary keys in the idiomatic bare form.
+const JS_IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/
+const LUA_IDENT = /^[A-Za-z_][A-Za-z0-9_]*$/
+
+// A `key<sep>value` literal pair in the target language's object syntax.
+function litPair(lang: ExampleLang, name: string, value: string): string {
   switch (lang) {
-    case 'py': return `{"${idF}": ${idLit}}`
-    case 'php': return `["${idF}" => ${idLit}]`
-    case 'rb': return `{ "${idF}" => ${idLit} }`
-    case 'lua': return `{ ${idF} = ${idLit} }`
-    case 'go': return `map[string]any{"${idF}": ${idLit}}`
-    default: return `{ ${idF}: ${idLit} }`
+    case 'py': return `"${name}": ${value}`
+    case 'php': return `"${name}" => ${value}`
+    case 'rb': return `"${name}" => ${value}`
+    case 'go': return `"${name}": ${value}`
+    case 'lua': return LUA_IDENT.test(name) ?
+      `${name} = ${value}` : `["${name}"] = ${value}`
+    default: return JS_IDENT.test(name) ?
+      `${name}: ${value}` : `'${name}': ${value}`
+  }
+}
+
+
+// The match argument for a load/remove — ALL required match params, not just
+// the primary id. A composite-match entity (e.g. Umbrella's FlatPermission,
+// `/public/database/{id}/permission/{msisdn}`) has two required path params
+// (database_id + id); emitting only `{ id }` fails the typed <Name>LoadMatch.
+// The idF field takes the specific id literal; other required fields take a
+// type-correct example value (mirrors dataArg).
+function matchArg(
+  lang: ExampleLang, ent: any, op: string, idF: string | null, idLit: string
+): string {
+  const items = opRequestShape(ent, op).items.filter((it: any) => !it.optional)
+  if (0 === items.length) return 'go' === lang ? 'nil' : ''
+  const pairs = items.map((it: any) =>
+    litPair(lang, it.name, it.name === idF ? idLit : litFor(lang, it.type)))
+  switch (lang) {
+    case 'py': return `{${pairs.join(', ')}}`
+    case 'php': return `[${pairs.join(', ')}]`
+    case 'go': return `map[string]any{${pairs.join(', ')}}`
+    default: return `{ ${pairs.join(', ')} }`
   }
 }
 
@@ -75,17 +108,7 @@ function dataArg(lang: ExampleLang, ent: any, op: string, idF: string | null): s
   // ALL required fields must appear (a typed CreateData rejects a partial); cap
   // only the optional fallback used when the op declares no required field.
   const chosen = required.length ? required : items.slice(0, 3)
-  const pairs = chosen.map((it: any) => {
-    const v = litFor(lang, it.type)
-    switch (lang) {
-      case 'py': return `"${it.name}": ${v}`
-      case 'php': return `"${it.name}" => ${v}`
-      case 'rb': return `"${it.name}" => ${v}`
-      case 'lua': return `${it.name} = ${v}`
-      case 'go': return `"${it.name}": ${v}`
-      default: return `${it.name}: ${v}`
-    }
-  })
+  const pairs = chosen.map((it: any) => litPair(lang, it.name, litFor(lang, it.type)))
   switch (lang) {
     case 'php': return `[${pairs.join(', ')}]`
     case 'lua': return `{ ${pairs.join(', ')} }`
@@ -139,7 +162,7 @@ function primaryOpCall(
   if (isList) {
     arg = 'go' === lang ? 'nil' : ''
   } else if (isMatch) {
-    arg = matchArg(lang, idF, idLit)
+    arg = matchArg(lang, ent, op, idF, idLit)
   } else if (isData) {
     arg = dataArg(lang, ent, op, idF)
   } else {

package/src/helpers/opShape.ts

@@ -305,6 +305,64 @@ function entityClassName(ent: any, entityColl: any): string {
 }
 
 
+// Cross-entity TYPE-name collision detection. entityClassNames keeps CLASS
+// names collision-free, but the DATA/op type names are the raw `<Name>` /
+// opTypeName(...) — two entities whose PascalCase Name coincides (e.g.
+// `foo-bar` vs `foo_bar`), or a data-type name equal to another entity's
+// op-type name, emit DUPLICATE top-level type declarations: a redeclaration
+// compile error in go/rust/c/cpp/csharp and the JVM containers, silent
+// merging in ts. The names cannot be auto-renamed here — the generated
+// entity classes and op fragments reference them by token — so the guard
+// surfaces the collision loudly instead. Returns the sorted duplicate names
+// (empty when clean). Callers must have derived `Name` on each entity
+// (every EntityTypes emitter does).
+//
+// Memoised per entity-collection object, like entityClassNames.
+const _typeCollisionCache = new WeakMap<object, string[]>()
+
+function entityTypeCollisions(entityColl: any): string[] {
+  const cached = _typeCollisionCache.get(entityColl)
+  if (null != cached) {
+    return cached
+  }
+
+  const counts: Record<string, number> = {}
+  const bump = (n: string) => { counts[n] = (counts[n] || 0) + 1 }
+
+  each(entityColl)
+    .filter((e: any) => e && null != e.name && null != e.Name)
+    .forEach((e: any) => {
+      bump(e.Name)
+      for (const op of ['load', 'list', 'create', 'update', 'remove']) {
+        if (e.op && e.op[op]) {
+          bump(opTypeName(e.Name, op))
+        }
+      }
+    })
+
+  const out = Object.keys(counts).filter((n) => 1 < counts[n]).sort()
+  _typeCollisionCache.set(entityColl, out)
+  return out
+}
+
+
+// Emitter convenience: warn (once per collection per target run) when the
+// generated typed model would contain duplicate top-level type names.
+function warnEntityTypeCollisions(entityColl: any, log: any, lang: string): string[] {
+  const dups = entityTypeCollisions(entityColl)
+  if (0 < dups.length && log && log.warn) {
+    log.warn({
+      point: 'entity-types-name-collision', lang, names: dups,
+      note: `${lang}: duplicate generated type name(s) ${dups.join(', ')} — ` +
+        `two entities produce the same PascalCase type name; rename one ` +
+        `entity (or alias it) in the model or the generated typed model ` +
+        `will not compile in statically-typed targets`,
+    })
+  }
+  return dups
+}
+
+
 // Pick a representative entity for a single illustrative snippet (e.g. the
 // README's test-mode example): the first ACTIVE entity that exposes a read
 // op (list/load) so the snippet is meaningful, else the first with ANY
@@ -315,16 +373,55 @@ function entityClassName(ent: any, entityColl: any): string {
 // for deterministic output.
 function pickExampleEntity(entity: any): { entity: any, primaryOp: string | null } {
   const actives = each(entity).filter((e: any) => e && e.active !== false)
-  const readable = actives.find((e: any) => {
+  const readable = actives.filter((e: any) => {
     const op = entityPrimaryOp(e)
     return 'list' === op || 'load' === op
   })
-  const withOp = actives.find((e: any) => null != entityPrimaryOp(e))
-  const chosen = readable || withOp || actives[0] || null
+  const withOp = actives.filter((e: any) => null != entityPrimaryOp(e))
+  // Prefer a readable entity, then any entity with an op, then anything at all.
+  // WITHIN the chosen tier pick an entity of MEDIAN "size" — median name length
+  // and median field count — so the generated README/examples showcase a
+  // representative entity, not the alphabetically-first one (often a degenerate
+  // stub with a terse name and no fields) nor an atypically sprawling one.
+  const pool = readable.length ? readable : (withOp.length ? withOp : actives)
+  const chosen = pickMedianEntity(pool)
   return { entity: chosen, primaryOp: null == chosen ? null : entityPrimaryOp(chosen) }
 }
 
 
+// The pool entity closest to the median on both axes (name length, field
+// count). Distance on each axis is normalised by that axis's own median so the
+// two are comparable, then summed. Ties keep the pool's existing key-sorted
+// order (each() is byte-stable), so the pick is deterministic.
+function pickMedianEntity(pool: any[]): any {
+  if (0 === pool.length) return null
+  if (1 === pool.length) return pool[0]
+  const fieldCount = (e: any): number => (e && e.fields ? each(e.fields).length : 0)
+  const nameLen = (e: any): number => (e && e.name ? String(e.name).length : 0)
+  const medName = medianOf(pool.map(nameLen))
+  const medField = medianOf(pool.map(fieldCount))
+  let best = pool[0]
+  let bestScore = Infinity
+  for (const e of pool) {
+    const score =
+      Math.abs(nameLen(e) - medName) / (medName || 1) +
+      Math.abs(fieldCount(e) - medField) / (medField || 1)
+    if (score < bestScore) {
+      bestScore = score
+      best = e
+    }
+  }
+  return best
+}
+
+
+function medianOf(xs: number[]): number {
+  const s = xs.slice().sort((a, b) => a - b)
+  const m = Math.floor(s.length / 2)
+  return 0 === s.length ? 0 : (s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2)
+}
+
+
 // The id field on the entity's DATA type (its fields[]), or null. DISTINCT from
 // entityIdField (the load-MATCH key): an API can model a load match that carries
 // an `id` param while the response entity itself has no `id` field, so `.id`
@@ -356,6 +453,8 @@ export {
   entityPrimaryOp,
   pickExampleEntity,
   entityClassName,
+  entityTypeCollisions,
+  warnEntityTypeCollisions,
 }
 
 export type {

package/src/sdkgen.ts

@@ -51,8 +51,8 @@ import { getMatchEntries } from './helpers/getMatchEntries'
 import { collectDeps } from './helpers/collectDeps'
 import type { DepEntry } from './helpers/collectDeps'
 import { canonToType, canonKey } from './helpers/canonType'
-import { OP_SUFFIX, opTypeName, opParams, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName } from './helpers/opShape'
-import { isReservedName, safeVarName } from './helpers/naming'
+import { OP_SUFFIX, opTypeName, opParams, opRequestShape, entityIdField, entityDataIdField, entityOps, entityPrimaryOp, pickExampleEntity, entityClassName, entityTypeCollisions, warnEntityTypeCollisions } from './helpers/opShape'
+import { isReservedName, safeVarName, exampleVarName, jsProp, jsOptProp, jsKey } from './helpers/naming'
 import {
   packageName,
   installCommand,
@@ -471,8 +471,14 @@ export {
   entityPrimaryOp,
   pickExampleEntity,
   entityClassName,
+  entityTypeCollisions,
+  warnEntityTypeCollisions,
   isReservedName,
   safeVarName,
+  exampleVarName,
+  jsProp,
+  jsOptProp,
+  jsKey,
 
   packageName,
   installCommand,

package/src/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "compilerOptions": {
     "esModuleInterop": true,
+    "composite": true,
     "module": "nodenext",
     "noEmitOnError": true,
     "skipLibCheck": true,
@@ -10,6 +11,7 @@
     "sourceMap": true,
     "strict": true,
     "target": "es2021",
+    "types": ["node"],
     "declaration": true,
     "declarationDir": "../dist"
   }

package/project/.sdk/tm/zig/build.zig.zon

@@ -1,11 +0,0 @@
-.{
-    .name = "voxgig_sdk",
-    .version = "0.0.1",
-    .dependencies = .{},
-    .paths = .{
-        "src",
-        "test",
-        "build.zig",
-        "build.zig.zon",
-    },
-}