@workos/oagen-emitters 0.15.2 → 0.16.1

package/src/node/resources.ts

@@ -225,7 +225,12 @@ function ignoredResourceMethodNames(ctx: EmitterContext, resourcePath: string):
   const methods = new Set<string>();
   for (const block of content.matchAll(/@oagen-ignore-start[\s\S]*?@oagen-ignore-end/g)) {
     for (const line of block[0].split('\n')) {
-      const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*\(/);
+      // Match the method name followed by `(` or by `<` — the latter covers
+      // generic methods (`getProfile<T extends ...>(...)`), including
+      // multi-line type-parameter lists where the line ends right after `<`.
+      // Matching only up to the opening bracket sidesteps balancing nested
+      // angle brackets like `<T extends Record<string, unknown> = ...>`.
+      const match = line.match(/^\s{2}(?:(?:public|private|protected)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*[<(]/);
       if (match) methods.add(match[1]);
     }
   }
@@ -310,6 +315,18 @@ function renderOptionsParam(param: OptionsObjectParam): string {
   return `options${param.optional ? '?' : ''}: ${param.type}`;
 }
 
+/**
+ * Whether a baseline-derived type reference is a plain TypeScript identifier
+ * that can appear in a named import. Baseline (live-SDK) method params can
+ * carry inline object-literal TYPES (e.g. `{ intent: GenerateLinkIntent; ... }`);
+ * treating that literal text as a type NAME would slugify it into a filename
+ * and emit a named import of a brace-expression — both invalid. Literal types
+ * are kept inline in the emitted signature instead and never imported.
+ */
+function isValidTypeIdentifier(name: string): boolean {
+  return /^[A-Za-z_$][\w$]*$/.test(name);
+}
+
 function autoPaginatableItemType(returnType: string | undefined): string | undefined {
   // Match both AutoPaginatable<T> and the legacy List<T> pattern so baseline
   // item types are extracted even when the hand-written code predates AutoPaginatable.
@@ -933,6 +950,9 @@ function generateResourceClass(service: Service, ctx: EmitterContext): Generated
 
   const importedTypeNames = new Set<string>();
   for (const optionType of optionObjectTypes) {
+    // Inline object-literal types from the baseline surface are rendered
+    // inline in the method signature — they have no importable name or file.
+    if (!isValidTypeIdentifier(optionType)) continue;
     if (importedTypeNames.has(optionType)) continue;
     importedTypeNames.add(optionType);
     const sourceFile = baselineTypeSourceFile(ctx, optionType);
@@ -1675,7 +1695,17 @@ function renderOptionsObjectMethod(
     const wireType = wireInterfaceName(itemType);
     const extraParams = op.queryParams.filter((p) => !PAGINATION_PARAM_NAMES.has(p.name));
     const needsWireSerializer = extraParams.some((p) => fieldName(p.name) !== wireFieldName(p.name));
-    const paginationType = needsWireSerializer ? 'PaginationOptions' : optionParam.type;
+    // When path params are destructured out of the options object, the value
+    // passed to AutoPaginatable (and to fetchAndDeserialize) is the REST
+    // object — typed Omit<FullOptions, pathFields> — not the full options
+    // interface. Declaring the full interface as the second type argument
+    // fails TS2322 because the rest object lacks the required path-param
+    // fields, so parameterize over the rest type actually passed.
+    const restOptionsType =
+      pathBindings.length > 0
+        ? `Omit<${optionParam.type}, ${pathBindings.map((b) => `'${b}'`).join(' | ')}>`
+        : optionParam.type;
+    const paginationType = needsWireSerializer ? 'PaginationOptions' : restOptionsType;
     const returnType = needsWireSerializer
       ? `Promise<AutoPaginatable<${itemType}, ${paginationType}>>`
       : (preferredBaselineReturnType(ctx, baselineMethod?.returnType) ??
@@ -1793,7 +1823,13 @@ function renderOptionsObjectMethod(
 
     lines.push(`  async ${method}(${renderOptionsParam(optionParam)}): ${methodReturnType} {`);
     renderOptionsObjectDestructure(lines, pathBindings);
-    lines.push(`    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${queryOptionsArg});`);
+    // POST/PUT/PATCH require the entity argument even without a request body —
+    // the client signature is `post(path, entity, options?)`, so a body-less
+    // call must still pass `{}` or the generated code fails with TS2554.
+    const emptyBodyArg = httpMethodNeedsBody(op.httpMethod) ? ', {}' : '';
+    lines.push(
+      `    const { data } = await this.workos.${op.httpMethod}<${wireType}>(${pathStr}${emptyBodyArg}${queryOptionsArg});`,
+    );
     if (override?.returnExpression) {
       lines.push(`    const result = ${returnExpr};`);
       lines.push(`    return ${override.returnExpression};`);

package/src/node/tests.ts

@@ -1,6 +1,15 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import type { ApiSpec, Service, Operation, Model, TypeRef, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type {
+  ApiSpec,
+  Service,
+  Operation,
+  Model,
+  TypeRef,
+  Parameter,
+  EmitterContext,
+  GeneratedFile,
+} from '@workos/oagen';
 import { planOperation, toCamelCase, toPascalCase } from '@workos/oagen';
 import { unwrapListModel, ID_PREFIXES } from './fixtures.js';
 import {
@@ -333,6 +342,20 @@ function pathParamTestValue(param: { type: TypeRef; name?: string } | undefined,
   return 'test_id';
 }
 
+function queryParamTestValue(param: Parameter, modelMap?: Map<string, Model>): string {
+  if (param.example !== undefined) {
+    if (Array.isArray(param.example)) {
+      return `[${param.example.map((v: unknown) => (typeof v === 'string' ? `'${v}'` : String(v))).join(', ')}]`;
+    }
+    const isDateTime = param.type.kind === 'primitive' && param.type.format === 'date-time';
+    if (isDateTime && typeof param.example === 'string') {
+      return `new Date('${param.example}')`;
+    }
+    return typeof param.example === 'string' ? `'${param.example}'` : String(param.example);
+  }
+  return fixtureValueForType(param.type, param.name, 'Options', modelMap) ?? "'test'";
+}
+
 /** Build test arguments for all path params (handles multiple path params). */
 function buildTestPathArgs(op: Operation): string {
   // Detect path template variables (may be more than op.pathParams if spec is incomplete)
@@ -372,7 +395,10 @@ function renderPaginatedTest(
   const optionsArg = buildOptionsObjectTestArg(op, plan, baselineMethod, modelMap, ctx);
   const baselineItemType = autoPaginatableItemType(baselineMethod?.returnType);
   const generatedItemType = ctx ? resolveInterfaceName(itemModelName, ctx) : null;
-  const skipFieldAssertions = Boolean(baselineItemType && generatedItemType && baselineItemType !== generatedItemType);
+  const baselineHasNonPaginatableReturn = Boolean(baselineMethod?.returnType && !baselineItemType);
+  const skipFieldAssertions =
+    baselineHasNonPaginatableReturn ||
+    Boolean(baselineItemType && generatedItemType && baselineItemType !== generatedItemType);
 
   lines.push("    it('returns paginated results', async () => {");
   lines.push(`      fetchOnce(list${itemModelName}Fixture);`);
@@ -649,7 +675,7 @@ function buildOptionsObjectTestArg(
     : op.queryParams;
   for (const param of queryParams) {
     const localName = fieldName(param.name);
-    const value = fixtureValueForType(param.type, param.name, 'Options', modelMap) ?? "'test'";
+    const value = queryParamTestValue(param, modelMap);
     entries.push(`${localName}: ${value}`);
   }
 

package/src/node/utils.ts

@@ -11,12 +11,15 @@ import { mapTypeRef } from './type-map.js';
 import {
   resolveInterfaceName,
   fieldName,
+  fileName,
   resolveServiceDir,
   resolveMethodName,
   buildServiceNameMap,
 } from './naming.js';
-import { getMountTarget } from '../shared/resolved-ops.js';
-import { assignModelsToServices } from '@workos/oagen';
+import { getMountTarget, groupByMount } from '../shared/resolved-ops.js';
+import { assignModelsToServices, collectModelRefs, collectFieldDependencies } from '@workos/oagen';
+import { isNodeOwnedService } from './options.js';
+import { liveSurfaceHasExistingSdk, liveSurfaceHasFile } from './live-surface.js';
 
 /**
  * Compute a relative import path between two files within the generated SDK.
@@ -203,7 +206,7 @@ export function createServiceDirResolver(
   serviceNameMap: Map<string, string>;
   resolveDir: (irService: string | undefined) => string;
 } {
-  const modelToService = assignModelsToServices(models, services, ctx.modelHints);
+  const modelToService = assignModelsToEmittableServices(models, services, ctx);
   const serviceNameMap = buildServiceNameMap(services, ctx);
 
   // Per-name → directory override, harvested from the live SDK surface.
@@ -212,25 +215,7 @@ export function createServiceDirResolver(
   // baseline directory string (e.g., "user-management"). The override map is
   // attached by tagging the model name with a directory prefix that bypasses
   // the IR-service lookup. Concretely we keep a side map.
-  const baselineDirByModel = new Map<string, string>();
-  const recordSource = (name: string, info: { sourceFile?: string } | undefined) => {
-    const sourceFile = info?.sourceFile;
-    if (!sourceFile) return;
-    const m = sourceFile.match(/^src\/([^/]+)\//);
-    if (!m) return;
-    baselineDirByModel.set(name, m[1]);
-  };
-  // Both interfaces and type aliases can shadow IR model names — e.g.
-  // `type Role = EnvironmentRole | OrganizationRole;` is the live SDK's
-  // canonical Role definition even though the IR represents Role as a model.
-  for (const [name, info] of Object.entries(ctx.apiSurface?.interfaces ?? {})) {
-    recordSource(name, info as { sourceFile?: string });
-  }
-  for (const [name, info] of Object.entries(ctx.apiSurface?.typeAliases ?? {})) {
-    if (!baselineDirByModel.has(name)) {
-      recordSource(name, info as { sourceFile?: string });
-    }
-  }
+  const baselineDirByModel = harvestBaselineDirByModel(ctx);
 
   // Override modelToService for any IR model that has a baseline sourceFile.
   // We invent a synthetic IR-service key that maps directly to the baseline
@@ -255,6 +240,139 @@ export function createServiceDirResolver(
   return { modelToService, serviceNameMap, resolveDir };
 }
 
+/**
+ * Map baseline interface / type-alias names to the top-level `src/<dir>/`
+ * their `sourceFile` lives in. Both kinds can shadow IR model names — e.g.
+ * `type Role = EnvironmentRole | OrganizationRole;` is the live SDK's
+ * canonical Role definition even though the IR represents Role as a model.
+ */
+function harvestBaselineDirByModel(ctx: EmitterContext): Map<string, string> {
+  const baselineDirByModel = new Map<string, string>();
+  const recordSource = (name: string, info: { sourceFile?: string } | undefined) => {
+    const sourceFile = info?.sourceFile;
+    if (!sourceFile) return;
+    const m = sourceFile.match(/^src\/([^/]+)\//);
+    if (!m) return;
+    baselineDirByModel.set(name, m[1]);
+  };
+  for (const [name, info] of Object.entries(ctx.apiSurface?.interfaces ?? {})) {
+    recordSource(name, info as { sourceFile?: string });
+  }
+  for (const [name, info] of Object.entries(ctx.apiSurface?.typeAliases ?? {})) {
+    if (!baselineDirByModel.has(name)) {
+      recordSource(name, info as { sourceFile?: string });
+    }
+  }
+  return baselineDirByModel;
+}
+
+/**
+ * `assignModelsToServices` plus an owned-service correction pass.
+ *
+ * The engine's assignment is first-reference-wins: a model referenced by both
+ * Organizations and AuditLogs lands in `organizations/` even when only
+ * AuditLogs is owned this run. Against an existing SDK, `applyLiveSurface`
+ * then drops the model file (a non-owned, non-adopted directory cannot
+ * receive new paths) while the owned resource still imports
+ * `../organizations/interfaces/<model>.interface` — an import that resolves
+ * to nothing (TS2307).
+ *
+ * The correction re-homes such models to the owned service that references
+ * them, so emission and import planning agree on a directory that is allowed
+ * to receive files. It only fires when:
+ *  1. `ownedServices` is configured and the run targets an existing SDK;
+ *  2. the model has no baseline `sourceFile` (otherwise the baseline-dir
+ *     override keeps imports pointing at the on-disk location);
+ *  3. the model's computed interface path does not already exist on disk;
+ *  4. the assigned service is neither owned itself nor sharing a directory
+ *     with an owned service.
+ */
+export function assignModelsToEmittableServices(
+  models: Model[],
+  services: Service[],
+  ctx?: EmitterContext,
+): Map<string, string> {
+  const modelToService = assignModelsToServices(models, services, ctx?.modelHints);
+  if (ctx) {
+    reassignOwnedServiceDependencies(modelToService, models, services, ctx);
+  }
+  return modelToService;
+}
+
+function reassignOwnedServiceDependencies(
+  modelToService: Map<string, string>,
+  models: Model[],
+  services: Service[],
+  ctx: EmitterContext,
+): void {
+  const serviceNameMap = buildServiceNameMap(services, ctx);
+  // Ownership is a property of the MOUNT target, not the IR service: an op
+  // can live on a non-owned IR service (e.g. Organizations, because its path
+  // starts with /organizations) while being mounted on an owned service via
+  // `resolvedOperations` (e.g. AuditLogs' retention endpoints). Walking only
+  // IR services misses such ops entirely, so the models they reference stay
+  // assigned to the unemittable IR directory and are never emitted anywhere.
+  // Regroup by mount target when resolved operations exist — same as
+  // `buildGeneratedResourceModelUsage` and `computeOwnedServiceDirs`.
+  const mountGroups = groupByMount(ctx);
+  const candidateServices: Service[] =
+    mountGroups.size > 0 ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations })) : services;
+  const ownedServices = candidateServices.filter((s) => isNodeOwnedService(ctx, s.name, serviceNameMap.get(s.name)));
+  if (ownedServices.length === 0) return;
+  // Greenfield generation emits every directory; nothing is unemittable.
+  if (!liveSurfaceHasExistingSdk()) return;
+
+  const dirOf = (irService: string | undefined): string =>
+    irService ? resolveServiceDir(serviceNameMap.get(irService) ?? irService) : 'common';
+  const ownedDirs = new Set(ownedServices.map((s) => dirOf(s.name)));
+  const baselineDirByModel = harvestBaselineDirByModel(ctx);
+  const modelsByName = new Map(models.map((m) => [m.name, m]));
+
+  for (const service of ownedServices) {
+    for (const name of collectServiceModelClosure(service, modelsByName)) {
+      if (!modelsByName.has(name)) continue;
+      if (baselineDirByModel.has(name)) continue; // declared in the baseline → on disk
+      const assigned = modelToService.get(name);
+      if (assigned && isNodeOwnedService(ctx, assigned, serviceNameMap.get(assigned))) continue;
+      const assignedDir = dirOf(assigned);
+      if (ownedDirs.has(assignedDir)) continue;
+      if (liveSurfaceHasFile(`src/${assignedDir}/interfaces/${fileName(name)}.interface.ts`)) continue;
+      modelToService.set(name, service.name);
+    }
+  }
+}
+
+/** Model names referenced by a service's operations, expanded through fields. */
+function collectServiceModelClosure(service: Service, modelsByName: Map<string, Model>): Set<string> {
+  const referenced = new Set<string>();
+  const add = (ref: TypeRef | undefined): void => {
+    if (!ref) return;
+    for (const name of collectModelRefs(ref)) referenced.add(name);
+  };
+  for (const op of service.operations) {
+    add(op.requestBody);
+    add(op.response);
+    for (const param of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
+      add(param.type);
+    }
+    if (op.pagination) add(op.pagination.itemType);
+  }
+
+  const queue = [...referenced];
+  while (queue.length > 0) {
+    const name = queue.pop()!;
+    const model = modelsByName.get(name);
+    if (!model) continue;
+    for (const dep of collectFieldDependencies(model).models) {
+      if (!referenced.has(dep)) {
+        referenced.add(dep);
+        queue.push(dep);
+      }
+    }
+  }
+  return referenced;
+}
+
 /**
  * Check if baseline interface fields appear to contain generic type parameters.
  *

package/src/snippets/dotnet.ts

@@ -0,0 +1,159 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import {
+  appendAsyncSuffix,
+  className,
+  fieldName,
+  methodName,
+  trimMountedResourceFromMethod,
+} from '../dotnet/naming.js';
+
+const INDENT = '    ';
+
+export const dotnetSnippetEmitter: SnippetEmitter = {
+  language: 'dotnet',
+  fileExtension: 'cs',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    // Mirror the .NET SDK's naming pipeline directly from the resolved op:
+    // PascalCase → trim mount-target resource → append Async. We avoid
+    // calling back into resolveMethodName so the snippet emitter does not
+    // re-validate the whole resolved-ops set on every invocation.
+    const rawMethodName =
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName;
+    const stem = trimMountedResourceFromMethod(methodName(rawMethodName), resolved.mountOn);
+    const method = appendAsyncSuffix(stem);
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const accessor = className(resolved.mountOn);
+  // Options class follows the `{Resource}{Method}Options` convention used by
+  // the SDK (e.g. OrganizationsCreateOptions). The method here already had its
+  // resource prefix trimmed and Async suffix appended, so reconstruct.
+  const stem = method.replace(/Async$/, '');
+  const optsType = `${accessor}${stem}Options`;
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let optionsArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    optionsArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    optionsArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const lines: string[] = [];
+  lines.push('using WorkOS;');
+  lines.push('');
+  lines.push('var client = new WorkOSClient(new WorkOSOptions');
+  lines.push('{');
+  lines.push(`${INDENT}ApiKey = "sk_example_123456789",`);
+  lines.push(`${INDENT}ClientId = "client_123456789",`);
+  lines.push('});');
+  lines.push('');
+
+  const callParts: string[] = [];
+  for (const p of pathArgs) callParts.push(renderValue(p.value));
+  if (optionsArgs.length > 0) callParts.push(renderOptions(optsType, optionsArgs));
+
+  const lhs = `await client.${accessor}.${method}`;
+  if (callParts.length === 0) {
+    lines.push(`${lhs}();`);
+  } else if (callParts.length === 1) {
+    lines.push(`${lhs}(${indentContinuationLines(callParts[0]!, INDENT)});`);
+  } else {
+    lines.push(`${lhs}(`);
+    for (let i = 0; i < callParts.length; i++) {
+      const trailing = i < callParts.length - 1 ? ',' : '';
+      lines.push(`${INDENT}${indentContinuationLines(callParts[i]!, INDENT)}${trailing}`);
+    }
+    lines.push(');');
+  }
+
+  return lines.join('\n');
+}
+
+function renderOptions(typeName: string, args: SnippetArg[]): string {
+  const lines: string[] = [`new ${typeName}`, '{'];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]!;
+    const field = fieldName(a.wireName);
+    const value = renderValue(a.value);
+    const trailing = i < args.length - 1 ? ',' : ',';
+    lines.push(`${INDENT}${field} = ${indentContinuationLines(value, INDENT)}${trailing}`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// C# 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 csharpString(value);
+  if (Array.isArray(value)) return renderArray(value);
+  if (typeof value === 'object') return renderDict(value as Record<string, unknown>);
+  return 'null';
+}
+
+function csharpString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderArray(items: unknown[]): string {
+  if (items.length === 0) return 'new[] { }';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `new[] { ${rendered.join(', ')} }`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['new[]', '{'];
+  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 {
+  // Plain dictionary literal — the dotnet SDK exposes models, but the snippet
+  // doesn't know which model class corresponds to each nested object. Emit a
+  // Dictionary<string, object> initializer that the SDK serializer can handle
+  // or a developer can replace with the typed model.
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'new Dictionary<string, object>()';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const lines: string[] = ['new Dictionary<string, object>', '{'];
+  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/go.ts

@@ -0,0 +1,148 @@
+import type { EmitterContext, ExampleBuilder, ResolvedOperation, SnippetArg, SnippetEmitter } from '@workos/oagen';
+import { collectSnippetArgs, collectWrapperArgs } from '@workos/oagen';
+import { className, fieldName, methodName, trimMountedResourceFromMethod } from '../go/naming.js';
+
+const INDENT = '\t';
+
+export const goSnippetEmitter: SnippetEmitter = {
+  language: 'go',
+  fileExtension: 'go',
+
+  renderOperation(resolved, ctx, examples) {
+    if (resolved.urlBuilder) return null;
+
+    // Mirror the Go SDK's naming pipeline: PascalCase the resolved method
+    // name (or the wrapper name for split ops), then trim any mount-target
+    // resource words from the end so `CreateOrganization` on `Organizations`
+    // becomes `Create`. We compute these directly from the resolved op so
+    // the snippet emitter does not depend on a fresh `buildResolvedLookup`
+    // (which would re-validate the entire spec for uniqueness).
+    const rawMethodName =
+      resolved.wrappers && resolved.wrappers.length > 0 ? resolved.wrappers[0]!.name : resolved.methodName;
+    const method = trimMountedResourceFromMethod(methodName(rawMethodName), resolved.mountOn);
+
+    return renderCall(resolved, ctx, examples, method);
+  },
+};
+
+function renderCall(
+  resolved: ResolvedOperation,
+  ctx: EmitterContext,
+  examples: ExampleBuilder,
+  method: string,
+): string {
+  const accessorMethod = className(resolved.mountOn);
+  const optsTypeName = `${accessorMethod}${method}Params`;
+
+  let args: SnippetArg[];
+  let pathArgs: SnippetArg[];
+  let bodyAndQueryArgs: SnippetArg[];
+
+  if (resolved.wrappers && resolved.wrappers.length > 0) {
+    args = collectWrapperArgs(resolved.wrappers[0]!, ctx, examples);
+    pathArgs = [];
+    bodyAndQueryArgs = args;
+  } else {
+    const collected = collectSnippetArgs(resolved, ctx, examples);
+    args = collected.args;
+    pathArgs = args.filter((a) => a.source === 'path');
+    bodyAndQueryArgs = args.filter((a) => a.source !== 'path');
+  }
+
+  const lines: string[] = [];
+  lines.push('package main');
+  lines.push('');
+  lines.push('import (');
+  lines.push(`${INDENT}"context"`);
+  lines.push('');
+  lines.push(`${INDENT}"github.com/workos/workos-go/v9"`);
+  lines.push(')');
+  lines.push('');
+  lines.push('func main() {');
+  lines.push(`${INDENT}client := workos.NewClient("sk_example_123456789")`);
+  lines.push('');
+
+  // Build the method call. Go SDK methods take (ctx, positional path params..., *OptsStruct).
+  const callParts: string[] = ['context.Background()'];
+  for (const p of pathArgs) {
+    callParts.push(renderValue(p.value));
+  }
+
+  if (bodyAndQueryArgs.length === 0) {
+    lines.push(`${INDENT}_, err := client.${accessorMethod}().${method}(${callParts.join(', ')})`);
+  } else {
+    const optsLines = buildOptsStruct(optsTypeName, bodyAndQueryArgs);
+    callParts.push(optsLines);
+    const joined = callParts.length === 2 ? callParts.join(', ') : callParts.join(', ');
+    lines.push(`${INDENT}_, err := client.${accessorMethod}().${method}(${joined})`);
+  }
+  lines.push(`${INDENT}if err != nil {`);
+  lines.push(`${INDENT}${INDENT}panic(err)`);
+  lines.push(`${INDENT}}`);
+  lines.push('}');
+
+  return lines.join('\n');
+}
+
+function buildOptsStruct(typeName: string, args: SnippetArg[]): string {
+  const lines: string[] = [`&workos.${typeName}{`];
+  for (const a of args) {
+    const field = fieldName(a.wireName);
+    const value = renderValue(a.value);
+    const indentedValue = indentContinuationLines(value, `${INDENT}${INDENT}`);
+    lines.push(`${INDENT}${INDENT}${field}: ${indentedValue},`);
+  }
+  lines.push(`${INDENT}}`);
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Go 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 goString(value);
+  if (Array.isArray(value)) return renderSlice(value);
+  if (typeof value === 'object') return renderStruct(value as Record<string, unknown>);
+  return 'nil';
+}
+
+function goString(s: string): string {
+  return `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function renderSlice(items: unknown[]): string {
+  if (items.length === 0) return '[]any{}';
+  const rendered = items.map((v) => renderValue(v));
+  const oneline = `[]any{${rendered.join(', ')}}`;
+  if (oneline.length <= 80 && rendered.every((r) => !r.includes('\n'))) return oneline;
+  const lines: string[] = ['[]any{'];
+  for (const r of rendered) {
+    lines.push(`${INDENT}${indentContinuationLines(r, INDENT)},`);
+  }
+  lines.push('}');
+  return lines.join('\n');
+}
+
+function renderStruct(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj);
+  if (entries.length === 0) return 'map[string]any{}';
+  const rendered = entries.map(([k, v]) => ({ key: k, value: renderValue(v) }));
+  const oneline = `map[string]any{${rendered.map((e) => `"${e.key}": ${e.value}`).join(', ')}}`;
+  if (oneline.length <= 80 && rendered.every((e) => !e.value.includes('\n'))) return oneline;
+  const lines: string[] = ['map[string]any{'];
+  for (const e of rendered) {
+    lines.push(`${INDENT}"${e.key}": ${indentContinuationLines(e.value, INDENT)},`);
+  }
+  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/index.ts

@@ -0,0 +1,8 @@
+export { rubySnippetEmitter } from './ruby.js';
+export { pythonSnippetEmitter } from './python.js';
+export { phpSnippetEmitter } from './php.js';
+export { goSnippetEmitter } from './go.js';
+export { dotnetSnippetEmitter } from './dotnet.js';
+export { kotlinSnippetEmitter } from './kotlin.js';
+export { rustSnippetEmitter } from './rust.js';
+export { workosSnippetsPlugin } from './plugin.js';