@workos/oagen-emitters 0.3.0 → 0.5.0

package/src/go/tests.ts

@@ -152,6 +152,7 @@ function generateServiceTest(
 
   // Deduplicate test functions by method name
   const emittedTestMethods = new Set<string>();
+  const resolvedLookupMain = buildResolvedLookup(ctx);
   for (const op of service.operations) {
     const plan = planOperation(op);
     const method = resolveGoMethodName(op, resolvedName, ctx);
@@ -162,7 +163,38 @@ function generateServiceTest(
     if (emittedTestMethods.has(method)) continue;
     emittedTestMethods.add(method);
 
+    // Skip operations with wrapper splits — the parent method isn't emitted
+    // (see src/go/resources.ts), only the typed wrappers are tested below.
+    const resolvedMain = lookupResolved(op, resolvedLookupMain);
+    if ((resolvedMain?.wrappers?.length ?? 0) > 0) continue;
+
     const testName = `Test${accessorName}_${method}`;
+    const isUrlBuilder = resolvedMain?.urlBuilder ?? false;
+
+    if (isUrlBuilder) {
+      // URL-builder methods return a string synchronously without making
+      // an HTTP request. Assert the URL contains the expected path.
+      const expectedPath = buildExpectedPath(op);
+      // Call args: no ctx, path params (if any), then params struct.
+      const callArgs: string[] = [];
+      for (const p of sortPathParamsByTemplateOrder(op)) {
+        callArgs.push(`"test_${p.name}"`);
+      }
+      const hidden = buildHiddenParams(resolvedMain);
+      const hasVisibleQueryParams = op.queryParams.filter((qp) => !hidden.has(qp.name)).length > 0;
+      if (hasVisibleQueryParams) {
+        const pName = paramsStructName(resolvedName, method);
+        callArgs.push(`&${ctx.namespace}.${pName}{}`);
+      }
+      lines.push(`func ${testName}(t *testing.T) {`);
+      lines.push(`\tclient := ${ctx.namespace}.NewClient("sk_test", ${ctx.namespace}.WithClientID("client_test"))`);
+      lines.push(`\turl := client.${accessorName}().${method}(${callArgs.join(', ')})`);
+      lines.push('\trequire.NotEmpty(t, url)');
+      lines.push(`\trequire.Contains(t, url, "${expectedPath}")`);
+      lines.push('}');
+      lines.push('');
+      continue;
+    }
 
     if (isPaginated && op.pagination) {
       // Pagination test
@@ -371,7 +403,7 @@ function generateServiceTest(
       if (emittedTestMethods.has(wrapperMethod)) continue;
       emittedTestMethods.add(wrapperMethod);
 
-      const wrapperParamsStruct = `${wrapperMethod}Params`;
+      const wrapperParamsStruct = paramsStructName(resolvedName, wrapperMethod);
       const responseType = wrapper.responseModelName;
       const testName = `Test${accessorName}_${wrapperMethod}`;
       const fixturePath = responseType ? `testdata/${fileName(responseType)}.json` : null;
@@ -398,8 +430,12 @@ function generateServiceTest(
     }
   }
 
-  // Error test (one per file: 401)
-  const sampleOp = service.operations[0];
+  // Error test (one per file: 401). Skip wrapper-split ops (parent method
+  // isn't emitted) and URL-builder ops (no HTTP call to error-test against).
+  const sampleOp = service.operations.find((o) => {
+    const r = lookupResolved(o, resolvedLookupMain);
+    return (r?.wrappers?.length ?? 0) === 0 && !(r?.urlBuilder ?? false);
+  });
   if (sampleOp) {
     const plan = planOperation(sampleOp);
     const method = resolveGoMethodName(sampleOp, resolvedName, ctx);

package/src/go/type-map.ts

@@ -13,8 +13,10 @@ export function mapTypeRef(ref: TypeRef, asPointer = false): string {
     enum: (r) => className(r.name),
     union: (_r, variants) => joinUnionVariants(_r, variants),
     nullable: (_ref, inner) => {
-      // If inner is already a pointer type (model), don't double-pointer
-      if (inner.startsWith('*')) return inner;
+      // Slices, maps, and pointer types (models) don't get pointer-wrapped:
+      // nil slice/map + omitempty already handles absence, and double-pointers
+      // are confusing at the call site.
+      if (inner.startsWith('*') || inner.startsWith('[]') || inner.startsWith('map[')) return inner;
       return `*${inner}`;
     },
     literal: (r) => {
@@ -43,7 +45,10 @@ export function mapTypeRefValue(ref: TypeRef): string {
     model: (r) => className(r.name),
     enum: (r) => className(r.name),
     union: (_r, variants) => joinUnionVariants(_r, variants),
-    nullable: (_ref, inner) => `*${inner}`,
+    nullable: (_ref, inner) => {
+      if (inner.startsWith('*') || inner.startsWith('[]') || inner.startsWith('map[')) return inner;
+      return `*${inner}`;
+    },
     literal: (r) => {
       if (r.value === null) return 'interface{}';
       if (typeof r.value === 'string') return 'string';

package/src/go/wrappers.ts

@@ -5,7 +5,7 @@ import {
   methodName as goMethodName,
   unexportedName,
 } from './naming.js';
-import { sortPathParamsByTemplateOrder } from './resources.js';
+import { sortPathParamsByTemplateOrder, paramsStructName } from './resources.js';
 import { resolveWrapperParams, formatWrapperDescription, type ResolvedWrapperParam } from '../shared/wrapper-utils.js';
 import { lowerFirstForDoc, fieldDocComment } from '../shared/naming-utils.js';
 
@@ -20,6 +20,7 @@ import { lowerFirstForDoc, fieldDocComment } from '../shared/naming-utils.js';
  */
 export function generateWrapperMethods(
   serviceType: string,
+  mountName: string,
   resolvedOp: ResolvedOperation,
   ctx: EmitterContext,
 ): string[] {
@@ -30,20 +31,72 @@ export function generateWrapperMethods(
   for (const wrapper of resolvedOp.wrappers) {
     const wrapperParams = resolveWrapperParams(wrapper, ctx);
     lines.push('');
-    emitWrapperParamsStruct(lines, wrapper, wrapperParams);
+    emitWrapperParamsStruct(lines, mountName, wrapper, wrapperParams);
     lines.push('');
-    emitWrapperMethod(lines, serviceType, resolvedOp, wrapper, wrapperParams);
+    emitWrapperBodyStruct(lines, wrapper, wrapperParams);
+    lines.push('');
+    emitWrapperMethod(lines, serviceType, mountName, resolvedOp, wrapper, wrapperParams);
   }
 
   return lines;
 }
 
+/** Unexported struct name used as the typed JSON body for a wrapper method. */
+function wrapperBodyStructName(wrapper: ResolvedWrapper): string {
+  return `${unexportedName(goMethodName(wrapper.name))}Body`;
+}
+
+/**
+ * Emit the private body struct used to serialize the JSON request for a
+ * wrapper method. Fields come from: constant defaults, required exposed
+ * params, client-inferred fields, and optional exposed params (in that
+ * order to match how bodies are constructed at call sites).
+ */
+function emitWrapperBodyStruct(lines: string[], wrapper: ResolvedWrapper, wrapperParams: ResolvedWrapperParam[]): void {
+  const structName = wrapperBodyStructName(wrapper);
+  lines.push(`// ${structName} is the JSON request body for ${goMethodName(wrapper.name)}.`);
+  lines.push(`type ${structName} struct {`);
+
+  // Constant defaults (always sent — no omitempty so the wire format is deterministic)
+  for (const [key, value] of Object.entries(wrapper.defaults)) {
+    const goField = goFieldName(key);
+    const goType = typeof value === 'boolean' ? 'bool' : typeof value === 'number' ? 'int' : 'string';
+    lines.push(`\t${goField} ${goType} \`json:"${key}"\``);
+  }
+
+  // Required exposed params
+  for (const { paramName, field, isOptional } of wrapperParams) {
+    if (isOptional) continue;
+    const goField = goFieldName(paramName);
+    const goType = field ? resolveSimpleGoType(field.type) : 'string';
+    lines.push(`\t${goField} ${goType} \`json:"${paramName}"\``);
+  }
+
+  // Inferred fields (from client config) — omit when empty
+  for (const inferred of wrapper.inferFromClient) {
+    const goField = goFieldName(inferred);
+    lines.push(`\t${goField} string \`json:"${inferred},omitempty"\``);
+  }
+
+  // Optional exposed params
+  for (const { paramName, field, isOptional } of wrapperParams) {
+    if (!isOptional) continue;
+    const goField = goFieldName(paramName);
+    const baseType = field ? resolveSimpleGoType(field.type) : 'string';
+    const optType = baseType.startsWith('*') || baseType.startsWith('[]') ? baseType : `*${baseType}`;
+    lines.push(`\t${goField} ${optType} \`json:"${paramName},omitempty"\``);
+  }
+
+  lines.push('}');
+}
+
 function emitWrapperParamsStruct(
   lines: string[],
+  mountName: string,
   wrapper: ResolvedWrapper,
   wrapperParams: ResolvedWrapperParam[],
 ): void {
-  const structName = `${goMethodName(wrapper.name)}Params`;
+  const structName = paramsStructName(mountName, goMethodName(wrapper.name));
 
   lines.push(`// ${structName} contains the parameters for ${goMethodName(wrapper.name)}.`);
   lines.push(`type ${structName} struct {`);
@@ -73,13 +126,14 @@ function emitWrapperParamsStruct(
 function emitWrapperMethod(
   lines: string[],
   serviceType: string,
+  mountName: string,
   resolvedOp: ResolvedOperation,
   wrapper: ResolvedWrapper,
   wrapperParams: ResolvedWrapperParam[],
 ): void {
   const op = resolvedOp.operation;
   const method = goMethodName(wrapper.name);
-  const paramsStruct = `${method}Params`;
+  const paramsStruct = paramsStructName(mountName, method);
 
   // Return type
   const responseType = wrapper.responseModelName ? goClassName(wrapper.responseModelName) : null;
@@ -104,38 +158,37 @@ function emitWrapperMethod(
     lines.push(`func (s *${serviceType}) ${method}(${sigParams.join(', ')}) error {`);
   }
 
-  // Build body map with defaults + exposed params
-  lines.push('\tbody := map[string]interface{}{');
+  // Build typed body struct — defaults + required params set at literal,
+  // inferred + optional fields assigned after (conditional on presence).
+  const bodyType = wrapperBodyStructName(wrapper);
+  lines.push(`\tbody := ${bodyType}{`);
 
   // Constant defaults (e.g., grant_type)
   for (const [key, value] of Object.entries(wrapper.defaults)) {
-    lines.push(`\t\t"${key}": ${goLiteral(value)},`);
+    lines.push(`\t\t${goFieldName(key)}: ${goLiteral(value)},`);
   }
 
   // Required exposed params
   for (const { paramName, isOptional } of wrapperParams) {
     if (isOptional) continue;
     const goField = goFieldName(paramName);
-    lines.push(`\t\t"${paramName}": params.${goField},`);
+    lines.push(`\t\t${goField}: params.${goField},`);
   }
 
   lines.push('\t}');
 
-  // Inferred fields from client config
-  for (const field of wrapper.inferFromClient) {
-    const expr = clientFieldExpression(field);
-    lines.push(`\tif ${expr} != "" {`);
-    lines.push(`\t\tbody["${field}"] = ${expr}`);
-    lines.push('\t}');
+  // Inferred fields from client config — omitempty handles the unset case
+  for (const inferred of wrapper.inferFromClient) {
+    const goField = goFieldName(inferred);
+    lines.push(`\tbody.${goField} = ${clientFieldExpression(inferred)}`);
   }
 
-  // Optional exposed params
+  // Optional exposed params copy through as pointers — encoding/json +
+  // omitempty will drop nil fields on the wire.
   for (const { paramName, isOptional } of wrapperParams) {
     if (!isOptional) continue;
     const goField = goFieldName(paramName);
-    lines.push(`\tif params.${goField} != nil {`);
-    lines.push(`\t\tbody["${paramName}"] = *params.${goField}`);
-    lines.push('\t}');
+    lines.push(`\tbody.${goField} = params.${goField}`);
   }
 
   // Build path expression
@@ -145,7 +198,7 @@ function emitWrapperMethod(
     const fmtArgs: string[] = [];
     for (const p of sortPathParamsByTemplateOrder(op)) {
       fmtStr = fmtStr.replace(`{${p.name}}`, '%s');
-      fmtArgs.push(lowerFirstSafe(goFieldName(p.name)));
+      fmtArgs.push(`url.PathEscape(string(${lowerFirstSafe(goFieldName(p.name))}))`);
     }
     pathExpr = `fmt.Sprintf("${fmtStr}", ${fmtArgs.join(', ')})`;
   } else {
@@ -207,7 +260,12 @@ function resolveSimpleGoType(ref: any): string {
         return 'interface{}';
     }
   }
-  if (ref.kind === 'nullable') return `*${resolveSimpleGoType(ref.inner)}`;
+  if (ref.kind === 'nullable') {
+    const inner = resolveSimpleGoType(ref.inner);
+    // Slices, maps, and pointer types don't get pointer-wrapped (mirrors type-map.ts).
+    if (inner.startsWith('*') || inner.startsWith('[]') || inner.startsWith('map[')) return inner;
+    return `*${inner}`;
+  }
   if (ref.kind === 'array') return `[]${resolveSimpleGoType(ref.items)}`;
   if (ref.kind === 'model') return `*${goClassName(ref.name)}`;
   if (ref.kind === 'enum') return goClassName(ref.name);

package/src/index.ts

@@ -2,3 +2,18 @@ export { nodeEmitter } from './node/index.js';
 export { pythonEmitter } from './python/index.js';
 export { phpEmitter } from './php/index.js';
 export { goEmitter } from './go/index.js';
+export { dotnetEmitter } from './dotnet/index.js';
+export { kotlinEmitter } from './kotlin/index.js';
+export { rubyEmitter } from './ruby/index.js';
+
+export { nodeExtractor } from './compat/extractors/node.js';
+export { rubyExtractor } from './compat/extractors/ruby.js';
+export { pythonExtractor } from './compat/extractors/python.js';
+export { phpExtractor } from './compat/extractors/php.js';
+export { goExtractor } from './compat/extractors/go.js';
+export { rustExtractor } from './compat/extractors/rust.js';
+export { kotlinExtractor } from './compat/extractors/kotlin.js';
+export { dotnetExtractor } from './compat/extractors/dotnet.js';
+export { elixirExtractor } from './compat/extractors/elixir.js';
+
+export { workosEmittersPlugin } from './plugin.js';

package/src/kotlin/client.ts

@@ -0,0 +1,58 @@
+import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
+import { apiClassName, packageSegment, servicePropertyName } from './naming.js';
+import { getMountTarget } from '../shared/resolved-ops.js';
+
+const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
+
+/**
+ * Generate service accessor properties for the hand-maintained `WorkOS` class.
+ *
+ * Each accessor is a `val` property with a custom getter that delegates to
+ * `WorkOS.service(...)` for lazy, cached construction. The generated file
+ * contains a `WorkOS` class stub with only these properties — the oagen
+ * merger deep-merges them into the existing hand-written `WorkOS.kt`.
+ *
+ * Accessors use fully-qualified type names so the merger doesn't need to
+ * inject imports into the hand-written file.
+ */
+export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+  const targets = deduplicateByMount(spec.services, ctx);
+  if (targets.length === 0) return [];
+
+  const accessorLines: string[] = [];
+  for (const mount of targets) {
+    const apiCls = apiClassName(mount);
+    const fqn = `com.workos.${packageSegment(mount)}.${apiCls}`;
+    const prop = servicePropertyName(mount);
+    accessorLines.push('');
+    accessorLines.push(`  /** Lazily-constructed [${fqn}] accessor for this [WorkOS] client. */`);
+    accessorLines.push(`  val ${prop}: ${fqn}`);
+    accessorLines.push('    get() =');
+    accessorLines.push('      service(');
+    accessorLines.push(`        ${fqn}::class`);
+    accessorLines.push('      ) {');
+    accessorLines.push(`        ${fqn}(this)`);
+    accessorLines.push('      }');
+  }
+
+  const lines: string[] = [];
+  lines.push('package com.workos');
+  lines.push('');
+  lines.push('open class WorkOS {');
+  for (const line of accessorLines) lines.push(line);
+  lines.push('}');
+  lines.push('');
+
+  return [
+    {
+      path: `${KOTLIN_SRC_PREFIX}com/workos/WorkOS.kt`,
+      content: lines.join('\n'),
+    },
+  ];
+}
+
+function deduplicateByMount(services: Service[], ctx: EmitterContext): string[] {
+  const targets = new Set<string>();
+  for (const s of services) targets.add(getMountTarget(s, ctx));
+  return [...targets].sort();
+}

package/src/kotlin/enums.ts

@@ -0,0 +1,189 @@
+import type { Enum, EmitterContext, GeneratedFile } from '@workos/oagen';
+import { className, ktStringLiteral } from './naming.js';
+
+const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
+const ENUMS_PACKAGE = 'com.workos.types';
+const ENUMS_DIR = 'com/workos/types';
+
+/**
+ * Mapping from an IR enum name to its canonical enum name. When two enums
+ * share identical sorted wire values the shorter-named one is canonical and
+ * the others become `typealias` files. Downstream consumers (type-map,
+ * resources) use this map to resolve references to the canonical class.
+ */
+export const enumCanonicalMap = new Map<string, string>();
+
+/**
+ * Generate Kotlin `enum class` types from the IR enums. Each enum is emitted
+ * to its own file under `com.workos.types`, annotated with Jackson
+ * `@JsonValue` on the wire value. An `Unknown` sentinel is always the first
+ * constant so that responses with new variants still deserialize instead of
+ * throwing.
+ *
+ * Enums with identical sets of wire values are deduplicated: the one with the
+ * shortest PascalCase name becomes canonical and the rest emit `typealias`
+ * files pointing at the canonical class.
+ */
+export function generateEnums(enums: Enum[], _ctx: EmitterContext): GeneratedFile[] {
+  if (enums.length === 0) return [];
+
+  // Reset the canonical map on every generation run (guards against re-entry).
+  enumCanonicalMap.clear();
+
+  // --- Dedup: group enums by a hash of their sorted wire values. ---
+  const hashGroups = new Map<string, Enum[]>();
+  for (const enumDef of enums) {
+    if (enumDef.values.length === 0) continue;
+    const hash = enumWireHash(enumDef);
+    if (!hashGroups.has(hash)) hashGroups.set(hash, []);
+    hashGroups.get(hash)!.push(enumDef);
+  }
+
+  // Within each group, pick the shortest className as canonical.
+  const aliasOf = new Map<string, string>(); // enum name → canonical enum name
+  for (const [, group] of hashGroups) {
+    if (group.length <= 1) continue;
+    if (group.every(isSharedSortOrderEnum)) {
+      const [canonical, ...rest] = [...group].sort((a, b) => a.name.localeCompare(b.name));
+      enumCanonicalMap.set(canonical.name, canonical.name);
+      for (const enumDef of rest) enumCanonicalMap.set(enumDef.name, 'SortOrder');
+      continue;
+    }
+    const sorted = [...group].sort(
+      (a, b) =>
+        className(a.name).length - className(b.name).length || className(a.name).localeCompare(className(b.name)),
+    );
+    const canonical = sorted[0];
+    for (let i = 1; i < sorted.length; i++) {
+      aliasOf.set(sorted[i].name, canonical.name);
+      enumCanonicalMap.set(sorted[i].name, canonical.name);
+    }
+  }
+
+  const files: GeneratedFile[] = [];
+
+  for (const enumDef of enums) {
+    if (enumDef.values.length === 0) continue;
+
+    const typeName = canonicalEnumTypeName(enumDef);
+
+    // Non-canonical enum: emit a typealias instead of a full enum class.
+    const sharedSortEmitter = isSharedSortOrderEnum(enumDef) && enumCanonicalMap.get(enumDef.name) === enumDef.name;
+    const canonicalName = sharedSortEmitter
+      ? undefined
+      : (aliasOf.get(enumDef.name) ?? enumCanonicalMap.get(enumDef.name));
+    if (canonicalName) {
+      const canonicalType = className(canonicalName);
+      // Skip when different IR names collapse to the same output name
+      if (typeName === canonicalType) continue;
+      const aliasLine = `typealias ${typeName} = ${canonicalType}`;
+      // ktlint enforces a 140-char max line length. When the typealias
+      // exceeds that, add a @file:Suppress to avoid an unfixable violation.
+      const suppressLine = aliasLine.length > 140 ? `@file:Suppress("ktlint:standard:max-line-length")\n\n` : '';
+      const aliasContent = [
+        `${suppressLine}package ${ENUMS_PACKAGE}`,
+        '',
+        `/** Alias for [${canonicalType}]. */`,
+        aliasLine,
+        '',
+      ].join('\n');
+      files.push({
+        path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
+        content: aliasContent,
+        overwriteExisting: true,
+      });
+      continue;
+    }
+
+    const lines: string[] = [];
+    lines.push(`package ${ENUMS_PACKAGE}`);
+    lines.push('');
+    lines.push('import com.fasterxml.jackson.annotation.JsonEnumDefaultValue');
+    lines.push('import com.fasterxml.jackson.annotation.JsonValue');
+    lines.push('');
+    // Replace the tautological "Foo enum." docstring with a slightly more
+    // informative summary. `Unknown` is emitted as the forward-compatibility
+    // sentinel for values the server introduces after this SDK was built.
+    lines.push(`/** Enumeration of valid ${typeName} values returned or accepted by the API. */`);
+    lines.push(`enum class ${typeName}(`);
+    lines.push('  /** The wire value sent to and received from the API. */');
+    lines.push('  @JsonValue val value: String');
+    lines.push(') {');
+    // `@JsonEnumDefaultValue` makes Jackson's
+    // READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE feature map unrecognized
+    // wire values onto `Unknown` instead of throwing — required for forward
+    // compatibility when the API introduces new variants.
+    lines.push('  @JsonEnumDefaultValue');
+    lines.push(`  Unknown(${ktStringLiteral('unknown')}),`);
+
+    const seenNames = new Set<string>(['Unknown']);
+    const seenWire = new Set<string>(['unknown']);
+    const members: string[] = [];
+
+    for (const v of enumDef.values) {
+      const wire = String(v.value);
+      if (seenWire.has(wire)) continue;
+      seenWire.add(wire);
+
+      let memberName = className(wire);
+      if (!memberName || /^[0-9]/.test(memberName)) memberName = `Value${memberName || wire}`;
+      if (memberName === typeName || seenNames.has(memberName)) {
+        let suffix = 2;
+        while (seenNames.has(`${memberName}${suffix}`)) suffix += 1;
+        memberName = `${memberName}${suffix}`;
+      }
+      seenNames.add(memberName);
+
+      if (v.description?.trim()) {
+        members.push(`  /** ${escapeKdoc(v.description.split('\n')[0].trim())} */`);
+      }
+      if (v.deprecated) {
+        members.push('  @Deprecated("Deprecated enum value")');
+      }
+      members.push(`  ${memberName}(${ktStringLiteral(wire)})`);
+    }
+
+    for (let i = 0; i < members.length; i++) {
+      const isLast = i === members.length - 1;
+      const line = members[i];
+      const trimmedStart = line.trimStart();
+      if (trimmedStart.startsWith('/**') || trimmedStart.startsWith('@')) {
+        lines.push(line);
+        continue;
+      }
+      lines.push(isLast ? line : `${line},`);
+    }
+
+    lines.push('}');
+    lines.push('');
+
+    files.push({
+      path: `${KOTLIN_SRC_PREFIX}${ENUMS_DIR}/${typeName}.kt`,
+      content: lines.join('\n'),
+      overwriteExisting: true,
+    });
+  }
+
+  return files;
+}
+
+function canonicalEnumTypeName(enumDef: Enum): string {
+  return isSharedSortOrderEnum(enumDef) ? 'SortOrder' : className(enumDef.name);
+}
+
+function isSharedSortOrderEnum(enumDef: Enum): boolean {
+  const wireValues = [...new Set(enumDef.values.map((value) => String(value.value).toLowerCase()))].sort();
+  return wireValues.length === 2 && wireValues[0] === 'asc' && wireValues[1] === 'desc';
+}
+
+/** Hash an enum by its sorted wire values so identical enums collide. */
+function enumWireHash(enumDef: Enum): string {
+  return [...enumDef.values]
+    .map((v) => String(v.value))
+    .sort()
+    .join('|');
+}
+
+function escapeKdoc(s: string): string {
+  return s.replace(/\*\//g, '*\u200b/');
+}

package/src/kotlin/index.ts

@@ -0,0 +1,92 @@
+import type {
+  Emitter,
+  EmitterContext,
+  FormatCommand,
+  GeneratedFile,
+  ApiSpec,
+  Model,
+  Enum,
+  Service,
+} from '@workos/oagen';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { generateModels } from './models.js';
+import { generateEnums } from './enums.js';
+import { generateResources } from './resources.js';
+import { generateClient } from './client.js';
+import { generateTests } from './tests.js';
+import { generateManifest } from './manifest.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
+
+/** Ensure every generated file ends with a trailing newline. */
+function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
+  for (const f of files) {
+    if (f.content && !f.content.endsWith('\n')) {
+      f.content += '\n';
+    }
+  }
+  return files;
+}
+
+export const kotlinEmitter: Emitter = {
+  language: 'kotlin',
+
+  generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
+    const enriched = enrichModelsFromSpec(models);
+    return ensureTrailingNewlines(generateModels(enriched, ctx));
+  },
+
+  generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
+    // Merge synthetic enums produced during model enrichment (inline oneOf
+    // definitions) so they get proper enum class files.
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
+  },
+
+  generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
+    return ensureTrailingNewlines(generateResources(services, ctx));
+  },
+
+  generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return ensureTrailingNewlines(generateClient(spec, ctx));
+  },
+
+  generateErrors(_ctx: EmitterContext): GeneratedFile[] {
+    // Exception hierarchy is hand-maintained in workos-kotlin (see Phase 2).
+    return [];
+  },
+
+  generateTypeSignatures(): GeneratedFile[] {
+    return [];
+  },
+
+  generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    // Pass enriched models so round-trip tests see the full field set
+    // (including optional oneOf-enriched fields) and can filter accurately.
+    const enrichedModels = enrichModelsFromSpec(spec.models);
+    const enrichedSpec: ApiSpec = { ...spec, models: enrichedModels };
+    return ensureTrailingNewlines(generateTests(enrichedSpec, { ...ctx, spec: enrichedSpec }));
+  },
+
+  generateManifest(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
+    return ensureTrailingNewlines(generateManifest(spec, ctx));
+  },
+
+  fileHeader(): string {
+    return '// This file is auto-generated by oagen. Do not edit.';
+  },
+
+  formatCommand(targetDir: string): FormatCommand | null {
+    // ktlint enforces a 140-char max line length that cannot be auto-corrected
+    // by the Gradle plugin alone, but `./gradlew ktlintFormat` fixes most
+    // violations (trailing whitespace, import ordering, etc.) across all
+    // generated files. The file list appended by oagen is ignored — Gradle
+    // reformats the whole source set.
+    if (!fs.existsSync(path.join(targetDir, 'gradlew'))) return null;
+    return {
+      cmd: 'bash',
+      args: ['-c', `cd ${JSON.stringify(targetDir)} && ./gradlew ktlintFormat --quiet 2>/dev/null; true`, '--'],
+    };
+  },
+};