@workos/oagen-emitters 0.15.2 → 0.16.0

package/src/snippets/php.ts

@@ -0,0 +1,149 @@
+import type { SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import { fieldName, servicePropertyName } from '../php/naming.js';
+
+const INDENT = '    ';
+
+export const phpSnippetEmitter: SnippetEmitter = {
+  language: 'php',
+  fileExtension: 'php',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    const accessor = servicePropertyName(resolved.mountOn);
+    const method = fieldName(
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName,
+    );
+
+    let args: SnippetArg[];
+    let collisionNames: Set<string>;
+    if (resolved.wrappers && resolved.wrappers.length > 0) {
+      args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+      collisionNames = new Set();
+    } else {
+      const collected = collectSnippetArgs(resolved, ctx, examples);
+      args = collected.args;
+      collisionNames = collected.collisionNames;
+    }
+
+    return renderCall(accessor, method, toPhpArgs(args, collisionNames));
+  },
+};
+
+interface PhpArg {
+  keyword: string;
+  value: string;
+}
+
+function toPhpArgs(args: SnippetArg[], collisions: Set<string>): PhpArg[] {
+  const seen = new Set<string>();
+  const out: PhpArg[] = [];
+  for (const a of args) {
+    const keyword = phpKeyword(a, collisions);
+    if (seen.has(keyword)) continue;
+    seen.add(keyword);
+    out.push({ keyword, value: renderValue(a.value) });
+  }
+  return out;
+}
+
+function phpKeyword(arg: SnippetArg, collisions: Set<string>): string {
+  const base = fieldName(arg.wireName);
+  if (arg.source === 'body' && collisions.has(arg.wireName)) return `body${capitalize(base)}`;
+  return base;
+}
+
+function capitalize(s: string): string {
+  return s.length === 0 ? s : s[0]!.toUpperCase() + s.slice(1);
+}
+
+function renderCall(accessor: string, method: string, args: PhpArg[]): string {
+  const lines: string[] = [];
+  lines.push('<?php');
+  lines.push('');
+  lines.push('use WorkOS\\WorkOS;');
+  lines.push('');
+  lines.push('$workos = new WorkOS(');
+  lines.push(`${INDENT}apiKey: 'sk_example_123456789',`);
+  lines.push(`${INDENT}clientId: 'client_123456789',`);
+  lines.push(');');
+  lines.push('');
+
+  const target = `$workos->${accessor}()->${method}`;
+  if (args.length === 0) {
+    lines.push(`${target}();`);
+    return lines.join('\n');
+  }
+
+  if (args.length === 1 && !args[0]!.value.includes('\n')) {
+    const a = args[0]!;
+    lines.push(`${target}(${a.keyword}: ${a.value});`);
+    return lines.join('\n');
+  }
+
+  lines.push(`${target}(`);
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    const trailing = i < args.length - 1 ? ',' : ',';
+    const valueIndented = indentContinuationLines(a.value, INDENT);
+    lines.push(`${INDENT}${a.keyword}: ${valueIndented}${trailing}`);
+  }
+  lines.push(');');
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// PHP literal rendering
+// ---------------------------------------------------------------------------
+
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'null';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return phpString(value);
+  if (Array.isArray(value)) return renderArray(value);
+  if (typeof value === 'object') return renderAssoc(value as Record<string, unknown>);
+  return 'null';
+}
+
+function phpString(s: string): string {
+  return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+function renderArray(items: unknown[]): string {
+  if (items.length === 0) return '[]';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `[${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+function renderAssoc(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return '[]';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `[${rendered.map((e) => `'${e.key}' => ${e.value}`).join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+  const lines: string[] = ['['];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}'${e.key}' => ${indentContinuationLines(e.value, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}

package/src/snippets/plugin.ts

@@ -0,0 +1,36 @@
+import type { SnippetEmitter } from '@workos/oagen';
+import { dotnetSnippetEmitter } from './dotnet.js';
+import { goSnippetEmitter } from './go.js';
+import { kotlinSnippetEmitter } from './kotlin.js';
+import { phpSnippetEmitter } from './php.js';
+import { pythonSnippetEmitter } from './python.js';
+import { rubySnippetEmitter } from './ruby.js';
+import { rustSnippetEmitter } from './rust.js';
+
+/**
+ * Bundle of snippet emitters for every WorkOS SDK language we currently
+ * generate call-site samples for. Node is intentionally absent — the docs
+ * pipeline still owns hand-authored TypeScript samples there.
+ *
+ * ```ts
+ * import { runSnippetEmitters, workosSnippetsPlugin } from '@workos/oagen-emitters';
+ *
+ * const snippets = runSnippetEmitters(workosSnippetsPlugin.snippets, ctx);
+ * ```
+ *
+ * Each entry mirrors a published WorkOS SDK and reuses that emitter's naming
+ * helpers (`src/<lang>/naming.ts`), so generated samples stay in lockstep
+ * with the SDK they document — method names, mount-target casing, parameter
+ * names, and reserved-word handling all match what the real SDK exposes.
+ */
+export const workosSnippetsPlugin: { snippets: SnippetEmitter[] } = {
+  snippets: [
+    rubySnippetEmitter,
+    pythonSnippetEmitter,
+    phpSnippetEmitter,
+    goSnippetEmitter,
+    dotnetSnippetEmitter,
+    kotlinSnippetEmitter,
+    rustSnippetEmitter,
+  ],
+};

package/src/snippets/python.ts

@@ -0,0 +1,135 @@
+import type { SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs, toSnakeCase } from '@workos/oagen';
+import { fieldName, safeParamName } from '../python/naming.js';
+
+const INDENT = '    ';
+
+export const pythonSnippetEmitter: SnippetEmitter = {
+  language: 'python',
+  fileExtension: 'py',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    const accessor = toSnakeCase(resolved.mountOn);
+
+    if (resolved.wrappers && resolved.wrappers.length > 0) {
+      const wrapper = resolved.wrappers[0]!;
+      const args = collectWrapperArgs(wrapper, ctx, examples);
+      return renderCall(accessor, wrapper.name, toPyArgs(args, new Set()));
+    }
+
+    const { args, collisionNames } = collectSnippetArgs(resolved, ctx, examples);
+    return renderCall(accessor, resolved.methodName, toPyArgs(args, collisionNames));
+  },
+};
+
+interface PyArg {
+  keyword: string;
+  value: string;
+}
+
+function toPyArgs(args: SnippetArg[], collisionNames: Set<string>): PyArg[] {
+  const seen = new Set<string>();
+  const out: PyArg[] = [];
+  for (const a of args) {
+    const keyword = pythonKeyword(a, collisionNames);
+    if (seen.has(keyword)) continue;
+    seen.add(keyword);
+    out.push({ keyword, value: renderValue(a.value) });
+  }
+  return out;
+}
+
+function pythonKeyword(arg: SnippetArg, collisions: Set<string>): string {
+  if (arg.source === 'body') {
+    const base = fieldName(arg.wireName);
+    return collisions.has(arg.wireName) ? `body_${base}` : base;
+  }
+  return safeParamName(arg.wireName);
+}
+
+function renderCall(accessor: string, method: string, args: PyArg[]): string {
+  const lines: string[] = [];
+  lines.push('from workos import WorkOSClient');
+  lines.push('');
+  lines.push('client = WorkOSClient(api_key="sk_example_123456789", client_id="client_123456789")');
+  lines.push('');
+
+  const target = `client.${accessor}.${method}`;
+  if (args.length === 0) {
+    lines.push(`${target}()`);
+    return lines.join('\n');
+  }
+
+  if (args.length === 1 && !args[0]!.value.includes('\n')) {
+    const a = args[0]!;
+    lines.push(`${target}(${a.keyword}=${a.value})`);
+    return lines.join('\n');
+  }
+
+  lines.push(`${target}(`);
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    const trailing = i < args.length - 1 ? ',' : '';
+    const valueIndented = indentContinuationLines(a.value, INDENT);
+    lines.push(`${INDENT}${a.keyword}=${valueIndented}${trailing}`);
+  }
+  lines.push(')');
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Python literal rendering
+// ---------------------------------------------------------------------------
+
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'None';
+  if (typeof value === 'boolean') return value ? 'True' : 'False';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return pythonString(value);
+  if (Array.isArray(value)) return renderArray(value);
+  if (typeof value === 'object') return renderDict(value as Record<string, unknown>);
+  return 'None';
+}
+
+function pythonString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderArray(items: unknown[]): string {
+  if (items.length === 0) return '[]';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `[${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : '';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+function renderDict(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return '{}';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `{${rendered.map((e) => `"${e.key}": ${e.value}`).join(', ')}}`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+
+  const lines: string[] = ['{'];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : '';
+    lines.push(`${INDENT}"${e.key}": ${indentContinuationLines(e.value, INDENT)}${trailing}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}

package/src/snippets/ruby.ts

@@ -0,0 +1,152 @@
+import type { EmitterContext, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs, toSnakeCase } from '@workos/oagen';
+import { buildExportedClassNameSet, fieldName, resolveServiceTarget, safeParamName } from '../ruby/naming.js';
+
+const INDENT = '  ';
+
+export const rubySnippetEmitter: SnippetEmitter = {
+  language: 'ruby',
+  fileExtension: 'rb',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    const accessor = serviceAccessor(resolved.mountOn, ctx);
+
+    if (resolved.wrappers && resolved.wrappers.length > 0) {
+      const wrapper = resolved.wrappers[0]!;
+      const args = collectWrapperArgs(wrapper, ctx, examples);
+      return renderCall(accessor, wrapper.name, toRubyArgs(args, new Set()));
+    }
+
+    const { args, collisionNames } = collectSnippetArgs(resolved, ctx, examples);
+    return renderCall(accessor, resolved.methodName, toRubyArgs(args, collisionNames));
+  },
+};
+
+interface RubyArg {
+  keyword: string;
+  value: string;
+}
+
+function toRubyArgs(args: SnippetArg[], collisionNames: Set<string>): RubyArg[] {
+  const seen = new Set<string>();
+  const out: RubyArg[] = [];
+  for (const a of args) {
+    const keyword = rubyKeyword(a, collisionNames);
+    if (seen.has(keyword)) continue;
+    seen.add(keyword);
+    out.push({ keyword, value: renderValue(a.value) });
+  }
+  return out;
+}
+
+function rubyKeyword(arg: SnippetArg, collisions: Set<string>): string {
+  if (arg.source === 'body') {
+    const base = fieldName(arg.wireName);
+    return collisions.has(arg.wireName) ? `body_${base}` : base;
+  }
+  // path / query
+  return safeParamName(arg.wireName);
+}
+
+function renderCall(accessor: string, method: string, args: RubyArg[]): string {
+  const lines: string[] = [];
+  lines.push('require "workos"');
+  lines.push('');
+  lines.push('WorkOS.configure do |config|');
+  lines.push(`${INDENT}config.api_key = "sk_example_123456789"`);
+  lines.push('end');
+  lines.push('');
+
+  const target = `WorkOS.client.${accessor}.${method}`;
+  if (args.length === 0) {
+    lines.push(target);
+    return lines.join('\n');
+  }
+
+  if (args.length === 1 && !args[0]!.value.includes('\n')) {
+    const a = args[0]!;
+    lines.push(`${target}(${a.keyword}: ${a.value})`);
+    return lines.join('\n');
+  }
+
+  lines.push(`${target}(`);
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    const trailing = i < args.length - 1 ? ',' : '';
+    const valueIndented = indentContinuationLines(a.value, INDENT);
+    lines.push(`${INDENT}${a.keyword}: ${valueIndented}${trailing}`);
+  }
+  lines.push(')');
+
+  return lines.join('\n');
+}
+
+function serviceAccessor(mountOn: string, ctx: EmitterContext): string {
+  // The accessor uses the raw mount target (no `Service` suffix) to match
+  // the `client.organization_membership` style documented in workos-ruby.
+  void resolveServiceTarget(mountOn, buildExportedClassNameSet(ctx));
+  return toSnakeCase(mountOn);
+}
+
+// ---------------------------------------------------------------------------
+// Ruby literal rendering
+// ---------------------------------------------------------------------------
+
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'nil';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return rubyString(value);
+  if (Array.isArray(value)) return renderArray(value);
+  if (typeof value === 'object') return renderHash(value as Record<string, unknown>);
+  return 'nil';
+}
+
+function rubyString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderArray(items: unknown[]): string {
+  if (items.length === 0) return '[]';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `[${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : '';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+function renderHash(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return '{}';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneLineParts = rendered.map((e) => `${formatInlineKey(e.key)} ${e.value}`);
+  const oneline = `{ ${oneLineParts.join(', ')} }`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+
+  const lines: string[] = ['{'];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : '';
+    lines.push(`${INDENT}${formatInlineKey(e.key)} ${indentContinuationLines(e.value, INDENT)}${trailing}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function formatInlineKey(name: string): string {
+  if (/^[a-z_][a-zA-Z0-9_]*$/.test(name)) return `${name}:`;
+  return `"${name.replace(/"/g, '\\"')}" =>`;
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}

package/src/snippets/rust.ts

@@ -0,0 +1,189 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import { fieldName, methodName, moduleName, resourceAccessorName, typeName } from '../rust/naming.js';
+
+const INDENT = '    ';
+
+export const rustSnippetEmitter: SnippetEmitter = {
+  language: 'rust',
+  fileExtension: 'rs',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    const method = methodName(
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName,
+    );
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const accessor = resourceAccessorName(resolved.mountOn);
+  const modulePath = moduleName(resolved.mountOn);
+  const paramsStructName = `${typeName(
+    resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName,
+  )}Params`;
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let structArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    structArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    structArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const imports: string[] = ['use workos::Client;'];
+  if (structArgs.length > 0) {
+    imports.push(`use workos::${modulePath}::${paramsStructName};`);
+  }
+
+  const lines: string[] = [];
+  lines.push(...imports);
+  lines.push('');
+  lines.push('#[tokio::main]');
+  lines.push('async fn main() -> Result<(), workos::Error> {');
+  lines.push(`${INDENT}let client = Client::builder()`);
+  lines.push(`${INDENT}${INDENT}.api_key("sk_example_123456789")`);
+  lines.push(`${INDENT}${INDENT}.client_id("client_123456789")`);
+  lines.push(`${INDENT}${INDENT}.build();`);
+  lines.push('');
+
+  const callParts: string[] = [];
+  for (const p of pathArgs) {
+    const v = p.value;
+    if (typeof v === 'string') callParts.push(rustString(v));
+    else callParts.push(renderValue(v));
+  }
+  if (structArgs.length > 0) {
+    callParts.push(renderStructLiteral(paramsStructName, structArgs));
+  }
+
+  const callLines: string[] = [`${INDENT}let _result = client`, `${INDENT}${INDENT}.${accessor}()`];
+  if (callParts.length === 0) {
+    callLines.push(`${INDENT}${INDENT}.${method}()`);
+  } else if (callParts.length === 1 && !callParts[0]!.includes('\n')) {
+    callLines.push(`${INDENT}${INDENT}.${method}(${callParts[0]})`);
+  } else {
+    callLines.push(`${INDENT}${INDENT}.${method}(`);
+    for (let i = 0; i < callParts.length; i++) {
+      const trailing = i < callParts.length - 1 ? ',' : '';
+      const indented = indentContinuationLines(callParts[i]!, `${INDENT}${INDENT}${INDENT}`);
+      callLines.push(`${INDENT}${INDENT}${INDENT}${indented}${trailing}`);
+    }
+    callLines.push(`${INDENT}${INDENT})`);
+  }
+  callLines.push(`${INDENT}${INDENT}.await?;`);
+  lines.push(...callLines);
+
+  lines.push('');
+  lines.push(`${INDENT}Ok(())`);
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+function renderStructLiteral(structName: string, args: SnippetArg[]): string {
+  const lines: string[] = [`${structName} {`];
+  for (const a of args) {
+    const field = fieldName(a.wireName);
+    const value = renderStructValue(a.value);
+    lines.push(`${INDENT}${field}: ${indentContinuationLines(value, INDENT)},`);
+  }
+  lines.push(`${INDENT}..Default::default()`);
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Rust literal rendering
+// ---------------------------------------------------------------------------
+
+/** Top-level value rendering (no `.into()` wrap — used for path params etc.). */
+function renderValue(value: unknown): string {
+  if (value === null || value === undefined) return 'None';
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (typeof value === 'number') return String(value);
+  if (typeof value === 'string') return rustString(value);
+  if (Array.isArray(value)) return renderVec(value);
+  if (typeof value === 'object') return renderInlineObject(value as Record<string, unknown>);
+  return 'None';
+}
+
+/** Struct-field rendering: wraps strings with `.into()` so `String` fields accept &str. */
+function renderStructValue(value: unknown): string {
+  if (typeof value === 'string') return `${rustString(value)}.into()`;
+  if (Array.isArray(value)) return renderVecStructValues(value);
+  return renderValue(value);
+}
+
+function rustString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderVec(items: unknown[]): string {
+  if (items.length === 0) return 'vec![]';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `vec![${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['vec!['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+function renderVecStructValues(items: unknown[]): string {
+  if (items.length === 0) return 'vec![]';
+  const rendered = items.map((v) => renderStructValue(v));
+  const oneline = `vec![${rendered.join(', ')}]`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['vec!['];
+  for (let i = 0; i < rendered.length; i++) {
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${indentContinuationLines(rendered[i]!, INDENT)}${trailing}`);
+  }
+  lines.push(']');
+  return lines.join('\n');
+}
+
+/** Render a plain object as a generic `serde_json::json!({...})` literal. The
+ *  snippet doesn't know the exact Rust struct corresponding to each nested
+ *  object, so we fall back to a serde-friendly literal a developer can swap
+ *  for the concrete struct (e.g. `OrganizationDomainData { ... }`). */
+function renderInlineObject(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'serde_json::json!({})';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `serde_json::json!({ ${rendered.map((e) => `"${e.key}": ${e.value}`).join(', ')} })`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+  const lines: string[] = ['serde_json::json!({'];
+  for (let i = 0; i < rendered.length; i++) {
+    const e = rendered[i]!;
+    const trailing = i < rendered.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}"${e.key}": ${indentContinuationLines(e.value, INDENT)}${trailing}`);
+  }
+  lines.push('})');
+  return lines.join('\n');
+}
+
+function indentContinuationLines(s: string, indent: string): string {
+  if (!s.includes('\n')) return s;
+  const lines = s.split('\n');
+  return lines.map((line, i) => (i === 0 ? line : `${indent}${line}`)).join('\n');
+}