@workos/oagen-emitters 0.4.0 → 0.6.0

package/src/kotlin/resources.ts

@@ -22,6 +22,7 @@ import {
   ktLiteral,
   clientFieldExpression,
   escapeReserved,
+  humanize,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -30,6 +31,8 @@ import {
   buildHiddenParams,
   getOpDefaults,
   getOpInferFromClient,
+  collectGroupedParamNames,
+  collectBodyFieldTypes,
 } from '../shared/resolved-ops.js';
 import { generateWrapperMethods } from './wrappers.js';
 import { resolveWrapperParams } from '../shared/wrapper-utils.js';
@@ -83,6 +86,15 @@ function generateApiClass(
 
   const body: string[] = [];
   const seenMethods = new Set<string>();
+  const hasAuthenticateHelper = operations.some(
+    (op) => op.path === '/user_management/authenticate' && op.httpMethod.toUpperCase() === 'POST',
+  );
+
+  if (hasAuthenticateHelper) {
+    imports.add('com.workos.common.http.bodyOf');
+    imports.add('com.workos.models.AuthenticateResponse');
+    body.push(...generateAuthenticateHelper());
+  }
 
   for (const op of operations) {
     if (isHandwrittenOverride(op)) continue;
@@ -118,13 +130,43 @@ function generateApiClass(
 
   if (body.length === 0) return null;
 
-  // Drop unused imports by peeking at the body text.
-  const bodyText = body.join('\n');
+  // Emit sealed classes for parameter groups before the API class.
+  // Parameter-group IR can lose body field type fidelity; prefer the request
+  // body model's field type when available.
+  const bodyFieldTypes = new Map<string, TypeRef>();
+  for (const op of operations) {
+    for (const [name, type] of collectBodyFieldTypes(op, ctx.spec.models)) {
+      bodyFieldTypes.set(name, type);
+    }
+  }
+  const sealedLines: string[] = [];
+  const emittedSealedClasses = new Set<string>();
+  for (const op of operations) {
+    if ((op.parameterGroups?.length ?? 0) > 0) {
+      for (const group of op.parameterGroups ?? []) {
+        // Register imports for types used in parameter group sealed classes.
+        // The body field type override may introduce enum/model types that
+        // the original IR parameter didn't reference.
+        for (const variant of group.variants) {
+          for (const p of variant.parameters) {
+            const effectiveType = bodyFieldTypes.get(p.name) ?? p.type;
+            registerTypeImports(effectiveType, imports, ctx);
+          }
+        }
+        if (emittedSealedClasses.has(group.name)) continue;
+        emittedSealedClasses.add(group.name);
+        for (const line of generateSealedClass(group, bodyFieldTypes)) sealedLines.push(line);
+      }
+    }
+  }
+
+  // Drop unused imports by peeking at the body text and sealed class text.
+  const allText = body.join('\n') + '\n' + sealedLines.join('\n');
   const filteredImports = [...imports].filter((imp) => {
     const simple = imp.slice(imp.lastIndexOf('.') + 1);
     // Skip the import if the class body never references the simple name.
-    if (simple === 'WorkOS' || simple === 'RequestConfig' || simple === 'RequestOptions') return true;
-    return new RegExp(`\\b${simple}\\b`).test(bodyText);
+    if (simple === 'WorkOS' || simple === 'RequestOptions') return true;
+    return new RegExp(`\\b${simple}\\b`).test(allText);
   });
 
   const lines: string[] = [];
@@ -132,6 +174,8 @@ function generateApiClass(
   lines.push('');
   for (const imp of filteredImports.sort()) lines.push(`import ${imp}`);
   lines.push('');
+  for (const line of sealedLines) lines.push(line);
+
   const serviceDescription = resolveServiceDescription(ctx, mountName, operations);
   if (serviceDescription) {
     const docLines = serviceDescription.trim().split('\n');
@@ -197,9 +241,13 @@ function renderMethod(
 
   const httpMethod = op.httpMethod.toUpperCase();
   const pathParams = sortPathParamsByTemplateOrder(op);
-  const queryParams = op.queryParams.filter((p) => !hidden.has(p.name));
+  const groupedParamNames = collectGroupedParamNames(op);
+  const hasGroups = (op.parameterGroups?.length ?? 0) > 0;
+  const queryParams = op.queryParams.filter((p) => !hidden.has(p.name) && !groupedParamNames.has(p.name));
   const bodyModel = resolveBodyModel(op, ctx);
-  const bodyFields = bodyModel ? bodyModel.fields.filter((f) => !hidden.has(f.name)) : [];
+  const bodyFields = bodyModel
+    ? bodyModel.fields.filter((f) => !hidden.has(f.name) && !groupedParamNames.has(f.name))
+    : [];
 
   // Track imports we need
   for (const p of [...pathParams, ...queryParams]) registerTypeImports(p.type, imports, ctx);
@@ -222,11 +270,21 @@ function renderMethod(
   const uniqueQuery = queryParams.filter((qp) => !paramNames.has(propertyName(qp.name)));
   for (const qp of uniqueQuery) paramNames.add(propertyName(qp.name));
 
+  const sharedQueryBodyParams = new Set(
+    uniqueQuery
+      .filter((qp) => bodyFields.some((bf) => bf.name === qp.name && mapTypeRef(qp.type) === mapTypeRef(bf.type)))
+      .map((qp) => qp.name),
+  );
+
   // Map body field wire name → Kotlin parameter name. When the natural name
   // collides with a path/query, prefix with `body` (e.g. slug → bodySlug).
   const bodyParamNames = new Map<string, string>();
   for (const bf of bodyFields) {
     const natural = propertyName(bf.name);
+    if (sharedQueryBodyParams.has(bf.name)) {
+      bodyParamNames.set(bf.name, natural);
+      continue;
+    }
     if (paramNames.has(natural)) {
       const renamed = `body${natural.charAt(0).toUpperCase()}${natural.slice(1)}`;
       bodyParamNames.set(bf.name, renamed);
@@ -237,12 +295,25 @@ function renderMethod(
     }
   }
 
+  const groupParamNames = assignGroupParameterNames(op, paramNames);
+
   const params: string[] = [];
   for (const pp of pathParams) params.push(`    ${propertyName(pp.name)}: String`);
 
   const sortedQuery = [...uniqueQuery].sort((a, b) => (a.required === b.required ? 0 : a.required ? -1 : 1));
   for (const qp of sortedQuery) {
-    params.push(renderParam(qp.name, qp.type, qp.required));
+    params.push(renderParam(qp.name, qp.type, qp.required, method.startsWith('list') && qp.name === 'limit'));
+  }
+
+  // Parameter group params (sealed class types)
+  for (const group of op.parameterGroups ?? []) {
+    const sealedName = sealedGroupName(group.name);
+    const prop = groupParamNames.get(group.name)!;
+    if (group.optional) {
+      params.push(`    ${prop}: ${sealedName}? = null`);
+    } else {
+      params.push(`    ${prop}: ${sealedName}`);
+    }
   }
 
   // PATCH operations use PatchField<T> for optional body fields so callers
@@ -251,6 +322,7 @@ function renderMethod(
 
   const sortedBodyFields = [...bodyFields].sort((a, b) => (a.required === b.required ? 0 : a.required ? -1 : 1));
   for (const bf of sortedBodyFields) {
+    if (sharedQueryBodyParams.has(bf.name)) continue;
     if (isPatch && !bf.required) {
       const baseType = mapTypeRef(bf.type);
       imports.add('com.workos.common.http.PatchField');
@@ -304,36 +376,75 @@ function renderMethod(
   const appendDefaultsAsQuery = !hasBody && (Object.keys(defaults).length > 0 || inferFromClient.length > 0);
   const pathExpr = buildPathExpression(op.path, pathParams);
 
+  if (
+    op.path === '/user_management/authenticate' &&
+    httpMethod === 'POST' &&
+    plan.responseModelName === 'AuthenticateResponse'
+  ) {
+    imports.add('com.workos.models.AuthenticateResponse');
+    const grantType = defaults.grant_type ?? 'authorization_code';
+    const entryLines = sortedBodyFields
+      .filter((bf) => bf.name !== 'grant_type' && bf.name !== 'client_id' && bf.name !== 'client_secret')
+      .map((bf) => `      ${ktLiteral(bf.name)} to ${bodyParamNames.get(bf.name)!}`);
+    lines.push(`    return authenticate(`);
+    lines.push(`      grantType = ${ktLiteral(grantType)},`);
+    lines.push(`      requestOptions = requestOptions,`);
+    for (let i = 0; i < entryLines.length; i++) {
+      const suffix = i === entryLines.length - 1 ? '' : ',';
+      lines.push(`${entryLines[i]}${suffix}`);
+    }
+    lines.push(`    )`);
+    lines.push('  }');
+    return lines.join('\n');
+  }
+
   if (isPaginated) {
     // Nested helper function + requestPage call; 'after' is owned by the
     // cursor logic so we skip it in the generic query loop.
-    const queryForConfig = sortedQuery.filter((p) => p.name !== 'after');
-    lines.push(`    fun configFor(afterCursor: String? = null): RequestConfig {`);
-    lines.push(`      val params = mutableListOf<Pair<String, String>>()`);
-    for (const qp of queryForConfig) for (const ln of emitQueryParam(qp, '      ')) lines.push(ln);
-    lines.push(`      val effectiveAfter = afterCursor ?: ${pickNamedQueryParam(sortedQuery, 'after')}`);
-    lines.push(`      if (effectiveAfter != null) params += "after" to effectiveAfter`);
-    lines.push(`      return RequestConfig(`);
-    lines.push(`        method = ${ktLiteral(httpMethod)},`);
-    lines.push(`        path = ${pathExpr},`);
-    lines.push(`        queryParams = params,`);
-    lines.push(`        requestOptions = requestOptions`);
-    lines.push(`      )`);
-    lines.push(`    }`);
+    // 'after' and 'before' are owned by the cursor logic. 'before' is only
+    // included on the first page — re-sending it on follow-up pages (where
+    // afterCursor is set by the pagination engine) is nonsensical and can
+    // cause empty or looping results from the server.
+    imports.add('com.workos.common.http.addIfNotNull');
+    imports.add('com.workos.common.http.addJoinedIfNotNull');
+    imports.add('com.workos.common.http.addEach');
     const itemClass = className(paginatedItemName!);
     lines.push(`    val itemType = object : TypeReference<${itemClass}>() {}`);
-    lines.push(
-      `    return workos.baseClient.requestPage(configFor(), itemType) { afterCursor -> configFor(afterCursor) }`,
-    );
+    lines.push(`    return workos.baseClient.requestPage(`);
+    lines.push(`      method = ${ktLiteral(httpMethod)},`);
+    lines.push(`      path = ${pathExpr},`);
+    lines.push(`      itemType = itemType,`);
+    lines.push(`      requestOptions = requestOptions,`);
+    lines.push(`      before = ${pickNamedQueryParam(sortedQuery, 'before')},`);
+    lines.push(`      after = ${pickNamedQueryParam(sortedQuery, 'after')}`);
+    lines.push(`    ) {`);
+    lines.push(`      val params = this`);
+    for (const qp of sortedQuery.filter((p) => p.name !== 'after' && p.name !== 'before')) {
+      for (const ln of emitQueryParam(qp, '      ')) lines.push(ln);
+    }
+    for (const group of op.parameterGroups ?? []) {
+      for (const ln of emitGroupQueryDispatch(group, groupParamNames.get(group.name)!, '      ')) lines.push(ln);
+    }
+    lines.push(`    }`);
   } else {
     // Only emit the `params` local when the method actually contributes
     // query parameters (spec-declared query, or defaults/inferFromClient
     // for GET/DELETE without a body). `RequestConfig.queryParams` defaults
     // to `emptyList()` when omitted, so we avoid dead local declarations.
-    const emitsQueryParams = sortedQuery.length > 0 || appendDefaultsAsQuery;
+    // Groups go to the body for POST/PUT/PATCH (hasBody), query otherwise.
+    const groupsGoToQuery = hasGroups && !hasBody;
+    const emitsQueryParams = sortedQuery.length > 0 || appendDefaultsAsQuery || groupsGoToQuery;
     if (emitsQueryParams) {
+      imports.add('com.workos.common.http.addIfNotNull');
+      imports.add('com.workos.common.http.addJoinedIfNotNull');
+      imports.add('com.workos.common.http.addEach');
       lines.push(`    val params = mutableListOf<Pair<String, String>>()`);
       for (const qp of sortedQuery) for (const ln of emitQueryParam(qp, '    ')) lines.push(ln);
+      if (groupsGoToQuery) {
+        for (const group of op.parameterGroups ?? []) {
+          for (const ln of emitGroupQueryDispatch(group, groupParamNames.get(group.name)!, '    ')) lines.push(ln);
+        }
+      }
       if (appendDefaultsAsQuery) {
         for (const [k, v] of Object.entries(defaults)) lines.push(`    params += ${ktLiteral(k)} to ${ktLiteral(v)}`);
         // Client-inferred fields may be nullable (e.g. clientId). Skip when
@@ -374,6 +485,15 @@ function renderMethod(
         // Empty body (POST/PUT/PATCH still require one for OkHttp).
         lines.push(`    val body = linkedMapOf<String, Any?>()`);
       }
+      // Parameter group values go into the body for POST/PUT/PATCH so
+      // sensitive fields (passwords, role slugs) never leak into the URL.
+      if (hasGroups) {
+        for (const group of op.parameterGroups ?? []) {
+          for (const ln of emitGroupBodyDispatch(group, groupParamNames.get(group.name)!, '    ')) {
+            lines.push(ln);
+          }
+        }
+      }
       lines.push(`    val config =`);
       lines.push(`      RequestConfig(`);
       lines.push(`        method = ${ktLiteral(httpMethod)},`);
@@ -449,12 +569,12 @@ function resolvePaginatedItemName(name: string | null, ctx?: EmitterContext): st
   return name;
 }
 
-function renderParam(name: string, type: TypeRef, required: boolean): string {
-  return renderParamNamed(propertyName(name), type, required);
+function renderParam(name: string, type: TypeRef, required: boolean, forceInt = false): string {
+  return renderParamNamed(propertyName(name), type, required, forceInt);
 }
 
-function renderParamNamed(kotlinName: string, type: TypeRef, required: boolean): string {
-  const mapped = required ? mapTypeRef(type) : mapTypeRefOptional(type);
+function renderParamNamed(kotlinName: string, type: TypeRef, required: boolean, forceInt = false): string {
+  const mapped = forceInt ? (required ? 'Int' : 'Int?') : required ? mapTypeRef(type) : mapTypeRefOptional(type);
   return required ? `    ${kotlinName}: ${mapped}` : `    ${kotlinName}: ${mapped} = null`;
 }
 
@@ -485,19 +605,25 @@ function buildMethodKdoc(
   // @param entry even without a description so the deprecation note is
   // surfaced in the docs.
   const paramDocs: string[] = [];
+  const seenParamDocs = new Set<string>();
+  const pushParamDoc = (name: string, description: string | undefined, deprecated?: boolean) => {
+    if (seenParamDocs.has(name)) return;
+    seenParamDocs.add(name);
+    paramDocs.push(formatParamDoc(name, description, deprecated));
+  };
   for (const pp of pathParams) {
     if (pp.description?.trim() || pp.deprecated) {
-      paramDocs.push(formatParamDoc(propertyName(pp.name), pp.description, pp.deprecated));
+      pushParamDoc(propertyName(pp.name), pp.description, pp.deprecated);
     }
   }
   for (const qp of queryParams) {
     if (qp.description?.trim() || qp.deprecated) {
-      paramDocs.push(formatParamDoc(propertyName(qp.name), qp.description, qp.deprecated));
+      pushParamDoc(propertyName(qp.name), qp.description, qp.deprecated);
     }
   }
   for (const bf of bodyFields) {
     if (bf.description?.trim() || bf.deprecated) {
-      paramDocs.push(formatParamDoc(bodyParamNames.get(bf.name)!, bf.description, bf.deprecated));
+      pushParamDoc(bodyParamNames.get(bf.name)!, bf.description, bf.deprecated);
     }
   }
 
@@ -544,17 +670,20 @@ function unwrapArray(t: TypeRef): TypeRef | null {
 
 /**
  * Serialize a single value expression for a query parameter.  For enums we
- * use `.value` so the wire name is used; for everything else `.toString()`.
+ * use `.value` so the wire name is used; for strings the value is already
+ * the right type; for everything else `.toString()`.
  */
 function valueExprForQuery(type: TypeRef): string {
   const inner = type.kind === 'nullable' ? type.inner : type;
   if (inner.kind === 'enum') return 'it.value';
+  if (inner.kind === 'primitive' && inner.type === 'string') return 'it';
   return 'it.toString()';
 }
 
 function emitQueryParam(p: Parameter, indent: string): string[] {
   const prop = propertyName(p.name);
   const rendered = queryParamToString(p.type, prop);
+  const inner = p.type.kind === 'nullable' ? p.type.inner : p.type;
   const arrayItem = unwrapArray(p.type);
   if (arrayItem) {
     // Honor `style: form, explode: false` → comma-joined. Default (explode:true
@@ -564,24 +693,26 @@ function emitQueryParam(p: Parameter, indent: string): string[] {
     const itemExpr = valueExprForQuery(arrayItem);
     if (!explode) {
       if (p.required) {
-        return [`${indent}params += ${ktLiteral(p.name)} to ${prop}.joinToString(",") { ${itemExpr} }`];
+        return [`${indent}params.addJoinedIfNotNull(${ktLiteral(p.name)}, ${prop}.map { ${itemExpr} })`];
       }
-      return [
-        `${indent}if (${prop} != null) params += ${ktLiteral(p.name)} to ${prop}.joinToString(",") { ${itemExpr} }`,
-      ];
+      return [`${indent}params.addJoinedIfNotNull(${ktLiteral(p.name)}, ${prop}?.map { ${itemExpr} })`];
     }
     if (p.required) {
-      return [`${indent}${prop}.forEach { params += ${ktLiteral(p.name)} to ${itemExpr} }`];
+      return [`${indent}params.addEach(${ktLiteral(p.name)}, ${prop}.map { ${itemExpr} })`];
     }
-    return [`${indent}if (${prop} != null) ${prop}.forEach { params += ${ktLiteral(p.name)} to ${itemExpr} }`];
+    return [`${indent}${prop}?.let { params.addEach(${ktLiteral(p.name)}, it.map { ${itemExpr} }) }`];
   }
   if (p.required) return [`${indent}params += ${ktLiteral(p.name)} to ${rendered}`];
-  return [`${indent}if (${prop} != null) params += ${ktLiteral(p.name)} to ${rendered}`];
+  if (inner.kind === 'primitive' && inner.type === 'string') {
+    return [`${indent}params.addIfNotNull(${ktLiteral(p.name)}, ${prop})`];
+  }
+  return [`${indent}${prop}?.let { params += ${ktLiteral(p.name)} to ${queryParamToString(inner, 'it')} }`];
 }
 
 function queryParamToString(type: TypeRef, varName: string): string {
   if (type.kind === 'enum') return `${varName}.value`;
   if (type.kind === 'nullable') return queryParamToString(type.inner, varName);
+  if (type.kind === 'primitive' && type.type === 'string') return varName;
   return `${varName}.toString()`;
 }
 
@@ -620,6 +751,32 @@ function pickNamedQueryParam(sorted: Parameter[], name: string): string {
   return match ? propertyName(match.name) : 'null';
 }
 
+function generateAuthenticateHelper(): string[] {
+  return [
+    '  private fun authenticate(',
+    '    grantType: String,',
+    '    requestOptions: RequestOptions?,',
+    '    vararg entries: Pair<String, Any?>',
+    '  ): AuthenticateResponse {',
+    '    val body =',
+    '      bodyOf(',
+    '        *entries,',
+    '        "grant_type" to grantType,',
+    '        "client_id" to workos.clientId,',
+    '        "client_secret" to workos.apiKey',
+    '      )',
+    '    val config =',
+    '      RequestConfig(',
+    '        method = "POST",',
+    '        path = "/user_management/authenticate",',
+    '        body = body,',
+    '        requestOptions = requestOptions',
+    '      )',
+    '    return workos.baseClient.request(config, AuthenticateResponse::class.java)',
+    '  }',
+  ];
+}
+
 function resolveBodyModel(op: Operation, ctx: EmitterContext): Model | null {
   const body = op.requestBody;
   if (!body) return null;
@@ -665,3 +822,177 @@ export function sortPathParamsByTemplateOrder(op: Operation): Parameter[] {
 function escapeKdoc(s: string): string {
   return s.replace(/\*\//g, '*\u200b/');
 }
+
+// ---------------------------------------------------------------------------
+// Mutually-exclusive parameter group support
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive a short Kotlin property name for a parameter within a variant,
+ * stripping the group name prefix to avoid stuttering.
+ */
+function deriveShortPropertyName(paramName: string, groupName: string): string {
+  const prefix = groupName + '_';
+  const stripped = paramName.startsWith(prefix) ? paramName.slice(prefix.length) : paramName;
+  return propertyName(stripped);
+}
+
+/**
+ * Generate sealed class definitions for all parameter groups in an operation.
+ *
+ * [bodyFieldTypes] is a fallback map from wire field name → TypeRef built from
+ * the body model. When the oagen core resolves parameter group variants it
+ * sometimes loses array/object types, falling back to a primitive string.
+ * Cross-referencing the body model corrects that.
+ */
+function generateSealedClass(
+  group: import('@workos/oagen').ParameterGroup,
+  bodyFieldTypes?: Map<string, TypeRef>,
+): string[] {
+  const lines: string[] = [];
+  const sealedName = sealedGroupName(group.name);
+  lines.push(`/** Mutually exclusive ${humanize(group.name)} parameter variants. */`);
+  lines.push(`sealed class ${sealedName} {`);
+  for (let vi = 0; vi < group.variants.length; vi++) {
+    const variant = group.variants[vi];
+    const variantName = className(variant.name);
+    const fields = variant.parameters.map((p) => {
+      const prop = deriveShortPropertyName(p.name, group.name);
+      // Prefer the body model's field type when available — the IR parameter
+      // group may have lost array/object type info for body fields.
+      const effectiveType = bodyFieldTypes?.get(p.name) ?? p.type;
+      return { decl: `val ${prop}: ${mapTypeRef(effectiveType)}`, name: p.name };
+    });
+    // ktlint requires blank line before each declaration inside a sealed class
+    if (vi > 0) lines.push('');
+    // ktlint class-signature rule requires multi-line constructors
+    lines.push(`  /** Variant: ${humanize(variant.name)}. */`);
+    lines.push(`  data class ${variantName}(`);
+    for (let i = 0; i < fields.length; i++) {
+      const comma = i < fields.length - 1 ? ',' : '';
+      lines.push(`    /** The ${humanize(fields[i].name)}. */`);
+      lines.push(`    ${fields[i].decl}${comma}`);
+    }
+    lines.push(`  ) : ${sealedName}()`);
+  }
+  lines.push('}');
+  lines.push('');
+  return lines;
+}
+
+/** Emit `when` dispatch that serializes a parameter group into query params. */
+function emitGroupQueryDispatch(group: import('@workos/oagen').ParameterGroup, prop: string, indent: string): string[] {
+  const sealedName = sealedGroupName(group.name);
+  const lines: string[] = [];
+
+  if (group.optional) {
+    lines.push(`${indent}if (${prop} != null) {`);
+    emitWhenBlock(lines, group, sealedName, prop, `${indent}  `);
+    lines.push(`${indent}}`);
+  } else {
+    emitWhenBlock(lines, group, sealedName, prop, indent);
+  }
+  return lines;
+}
+
+function assignGroupParameterNames(op: Operation, occupiedNames: Set<string>): Map<string, string> {
+  const names = new Map<string, string>();
+  for (const group of op.parameterGroups ?? []) {
+    const natural = propertyName(sealedGroupName(group.name));
+    const assigned = reserveUniqueGroupParameterName(natural, occupiedNames);
+    names.set(group.name, assigned);
+  }
+  return names;
+}
+
+function reserveUniqueGroupParameterName(base: string, occupiedNames: Set<string>): string {
+  if (!occupiedNames.has(base)) {
+    occupiedNames.add(base);
+    return base;
+  }
+
+  const capitalized = `${base.charAt(0).toUpperCase()}${base.slice(1)}`;
+  const prefixed = `group${capitalized}`;
+  if (!occupiedNames.has(prefixed)) {
+    occupiedNames.add(prefixed);
+    return prefixed;
+  }
+
+  let index = 2;
+  while (occupiedNames.has(`${prefixed}${index}`)) index += 1;
+  const fallback = `${prefixed}${index}`;
+  occupiedNames.add(fallback);
+  return fallback;
+}
+
+function emitWhenBlock(
+  lines: string[],
+  group: import('@workos/oagen').ParameterGroup,
+  sealedName: string,
+  prop: string,
+  indent: string,
+): void {
+  lines.push(`${indent}when (${prop}) {`);
+  for (const variant of group.variants) {
+    const variantName = className(variant.name);
+    const entries = variant.parameters.map((p) => {
+      const fieldProp = deriveShortPropertyName(p.name, group.name);
+      return `params += ${ktLiteral(p.name)} to ${prop}.${fieldProp}`;
+    });
+    if (entries.length === 1) {
+      lines.push(`${indent}  is ${sealedName}.${variantName} -> ${entries[0]}`);
+    } else {
+      lines.push(`${indent}  is ${sealedName}.${variantName} -> {`);
+      for (const e of entries) lines.push(`${indent}    ${e}`);
+      lines.push(`${indent}  }`);
+    }
+  }
+  lines.push(`${indent}}`);
+}
+
+/** Emit `when` dispatch that serializes a parameter group into the request body map. */
+function emitGroupBodyDispatch(group: import('@workos/oagen').ParameterGroup, prop: string, indent: string): string[] {
+  const sealedName = sealedGroupName(group.name);
+  const lines: string[] = [];
+
+  if (group.optional) {
+    lines.push(`${indent}if (${prop} != null) {`);
+    emitBodyWhenBlock(lines, group, sealedName, prop, `${indent}  `);
+    lines.push(`${indent}}`);
+  } else {
+    emitBodyWhenBlock(lines, group, sealedName, prop, indent);
+  }
+  return lines;
+}
+
+function sealedGroupName(name: string): string {
+  const resolved = className(name);
+  if (resolved === 'Password') return 'CreateUserPassword';
+  if (resolved === 'Role') return 'CreateUserRole';
+  return resolved;
+}
+
+function emitBodyWhenBlock(
+  lines: string[],
+  group: import('@workos/oagen').ParameterGroup,
+  sealedName: string,
+  prop: string,
+  indent: string,
+): void {
+  lines.push(`${indent}when (${prop}) {`);
+  for (const variant of group.variants) {
+    const variantName = className(variant.name);
+    const entries = variant.parameters.map((p) => {
+      const fieldProp = deriveShortPropertyName(p.name, group.name);
+      return `body[${ktLiteral(p.name)}] = ${prop}.${fieldProp}`;
+    });
+    if (entries.length === 1) {
+      lines.push(`${indent}  is ${sealedName}.${variantName} -> ${entries[0]}`);
+    } else {
+      lines.push(`${indent}  is ${sealedName}.${variantName} -> {`);
+      for (const e of entries) lines.push(`${indent}    ${e}`);
+      lines.push(`${indent}  }`);
+    }
+  }
+  lines.push(`${indent}}`);
+}