@workos/oagen-emitters 0.12.4 → 0.13.0

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-nmiHN7Ko.mjs";
+import { t as workosEmittersPlugin } from "./plugin-B9F2jmwy.mjs";
 export { workosEmittersPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -40,20 +40,20 @@
   "devDependencies": {
     "@commitlint/cli": "^21.0.1",
     "@commitlint/config-conventional": "^21.0.1",
-    "@types/node": "^25.9.0",
+    "@types/node": "^25.9.1",
     "husky": "^9.1.7",
-    "oxfmt": "^0.50.0",
-    "oxlint": "^1.65.0",
+    "oxfmt": "^0.51.0",
+    "oxlint": "^1.66.0",
     "prettier": "^3.8.3",
     "tsdown": "^0.22.0",
-    "tsx": "^4.22.2",
+    "tsx": "^4.22.3",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.6"
+    "vitest": "^4.1.7"
   },
   "engines": {
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.19.1"
+    "@workos/oagen": "^0.19.5"
   }
 }

package/src/kotlin/client.ts

@@ -1,5 +1,5 @@
 import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
-import { apiClassName, packageSegment, servicePropertyName } from './naming.js';
+import { resolveApiClassName, packageSegment, servicePropertyName, buildExportedClassNameSet } from './naming.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 
 const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
@@ -23,8 +23,9 @@ export function generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFil
 
   const imports = new Set<string>();
   const accessorLines: string[] = [];
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const mount of targets) {
-    const apiCls = apiClassName(mount);
+    const apiCls = resolveApiClassName(mount, exportedClasses);
     const fqn = `com.workos.${packageSegment(mount)}.${apiCls}`;
     imports.add(fqn);
     const prop = servicePropertyName(mount);

package/src/kotlin/naming.ts

@@ -1,4 +1,8 @@
 import type { Operation, Service, EmitterContext, TypeRef } from '@workos/oagen';
+import {
+  buildExportedClassNameSet as buildExportedClassNameSetShared,
+  resolveServiceTarget as resolveServiceTargetShared,
+} from '../shared/service-name-collision.js';
 import { toPascalCase, toCamelCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName, getMountTarget } from '../shared/resolved-ops.js';
 import { stripUrnPrefix } from '../shared/naming-utils.js';
@@ -73,6 +77,36 @@ export function apiClassName(name: string): string {
   return className(name);
 }
 
+/**
+ * Resolve the Kotlin service class name with the collision suffix applied
+ * when needed. Wraps `apiClassName` so callers don't need to thread the
+ * exported-classes set through unrelated emission logic.
+ */
+export function resolveApiClassName(name: string, exportedClasses: Set<string>): string {
+  return apiClassName(resolveServiceTarget(name, exportedClasses));
+}
+
+/**
+ * Build the set of model + enum class names exported by the SDK. Used to
+ * detect collisions with operation-client class names — a colliding service
+ * gets a `Service` suffix appended.
+ */
+export function buildExportedClassNameSet(ctx: EmitterContext): Set<string> {
+  return buildExportedClassNameSetShared(ctx, className);
+}
+
+/**
+ * Resolve a service's mount-target identifier, appending `Service` on
+ * collision with an exported model/enum class. Kotlin sees the collision
+ * when a service class shares a simple name with an imported model class
+ * (e.g. `com.workos.models.OrganizationMembership` vs
+ * `com.workos.organizationmembership.OrganizationMembership`) — the file's
+ * local declaration shadows the import for unqualified references.
+ */
+export function resolveServiceTarget(target: string, exportedClasses: Set<string>): string {
+  return resolveServiceTargetShared(target, exportedClasses, className);
+}
+
 /** Accessor property exposed on the WorkOS client (camelCase). */
 export function servicePropertyName(name: string): string {
   return toCamelCase(name);

package/src/kotlin/resources.ts

@@ -16,7 +16,7 @@ import { enumCanonicalMap } from './enums.js';
 import {
   className,
   propertyName,
-  apiClassName,
+  resolveApiClassName,
   packageSegment,
   resolveMethodName,
   ktLiteral,
@@ -24,6 +24,7 @@ import {
   escapeReserved,
   humanize,
   maybeShortenEnumParamDescription,
+  buildExportedClassNameSet,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -96,13 +97,14 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
 
   const files: GeneratedFile[] = [];
   const resolvedLookup = buildResolvedLookup(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountName, group] of mountGroups) {
     const classCode = generateApiClass(mountName, group.operations, ctx, resolvedLookup);
     if (!classCode) continue;
     const pkg = packageSegment(mountName);
     files.push({
-      path: `${KOTLIN_SRC_PREFIX}com/workos/${pkg}/${apiClassName(mountName)}.kt`,
+      path: `${KOTLIN_SRC_PREFIX}com/workos/${pkg}/${resolveApiClassName(mountName, exportedClasses)}.kt`,
       content: classCode,
       overwriteExisting: true,
     });
@@ -118,7 +120,7 @@ function generateApiClass(
   resolvedLookup: Map<string, ResolvedOperation>,
 ): string | null {
   if (operations.length === 0) return null;
-  const apiClass = apiClassName(mountName);
+  const apiClass = resolveApiClassName(mountName, buildExportedClassNameSet(ctx));
   const pkg = `com.workos.${packageSegment(mountName)}`;
 
   const imports = new Set<string>();

package/src/kotlin/tests.ts

@@ -10,7 +10,15 @@ import type {
   ResolvedWrapper,
 } from '@workos/oagen';
 import { planOperation } from '@workos/oagen';
-import { apiClassName, packageSegment, resolveMethodName, ktStringLiteral, className, propertyName } from './naming.js';
+import {
+  resolveApiClassName,
+  packageSegment,
+  resolveMethodName,
+  ktStringLiteral,
+  className,
+  propertyName,
+  buildExportedClassNameSet,
+} from './naming.js';
 import { mapTypeRef } from './type-map.js';
 import {
   groupByMount,
@@ -70,12 +78,13 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const mountGroups = groupByMount(ctx);
   const resolvedLookup = buildResolvedLookup(ctx);
 
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const [mountName, group] of mountGroups) {
     const content = generateServiceTestClass(mountName, group.operations, ctx, resolvedLookup);
     if (!content) continue;
     const pkg = packageSegment(mountName);
     files.push({
-      path: `${TEST_PREFIX}com/workos/${pkg}/${apiClassName(mountName)}Test.kt`,
+      path: `${TEST_PREFIX}com/workos/${pkg}/${resolveApiClassName(mountName, exportedClasses)}Test.kt`,
       content,
       overwriteExisting: true,
     });
@@ -203,7 +212,7 @@ function generateServiceTestClass(
   }
 
   const pkg = packageSegment(mountName);
-  const apiCls = apiClassName(mountName);
+  const apiCls = resolveApiClassName(mountName, buildExportedClassNameSet(ctx));
 
   // If any operation would emit a disabled placeholder test, preregister
   // the `Disabled` import before we serialize the header.

package/src/node/client.ts

@@ -2,7 +2,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import type { ApiSpec, AuthScheme, EmitterContext, GeneratedFile } from '@workos/oagen';
 
-import { fileName, servicePropertyName, resolveInterfaceName, wireInterfaceName } from './naming.js';
+import {
+  fileName,
+  servicePropertyName,
+  resolveInterfaceName,
+  wireInterfaceName,
+  resolveServiceName,
+} from './naming.js';
 import { isInlineEnum } from './type-map.js';
 import {
   docComment,
@@ -89,7 +95,10 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   for (const service of spec.services) {
     if (coveredServices.has(service.name)) continue;
     const resolvedName = resolveResourceClassName(service, ctx);
-    const propName = servicePropertyName(resolvedName);
+    // Accessor name uses the un-suffixed service name so that the public API
+    // stays `client.organizationMembership` even when the class itself was
+    // renamed to `OrganizationMembershipService` to avoid a model collision.
+    const propName = servicePropertyName(resolveServiceName(service, ctx));
     if (existingProps.has(propName)) continue;
     // Propagate `@deprecated` from the service class to the property so
     // IDEs surface the strikethrough at `workos.xyz` access sites, not

package/src/node/field-plan.ts

@@ -666,6 +666,10 @@ interface SerializerContext {
   resolveDir: (irService: string | undefined) => string;
   dedup: Map<string, string>;
   skippedSerializeModels: Set<string>;
+  /** Models reachable from any response — anything outside this set is
+   *  request-only and won't have a `deserialize<X>` emitted. `undefined`
+   *  means "no usage info available, assume deserialize exists". */
+  responseReachableModels: Set<string> | undefined;
   ctx: EmitterContext;
 }
 
@@ -723,6 +727,10 @@ export function buildSerializerImports(
     const canon = sctx.dedup.get(dep);
     const depSkipSerialize =
       sctx.skippedSerializeModels.has(dep) || (canon != null && sctx.skippedSerializeModels.has(canon));
+    const depSkipDeserialize =
+      sctx.responseReachableModels !== undefined &&
+      !sctx.responseReachableModels.has(dep) &&
+      (canon == null || !sctx.responseReachableModels.has(canon));
 
     // Decide whether this serializer is reachable at runtime:
     //   - file on disk → honor what it exports (hasDeser/hasSer)
@@ -759,8 +767,11 @@ export function buildSerializerImports(
       continue;
     }
 
+    if (depSkipSerialize && depSkipDeserialize) continue;
     if (depSkipSerialize) {
       lines.push(`import { deserialize${depName} } from '${rel}';`);
+    } else if (depSkipDeserialize) {
+      lines.push(`import { serialize${depName} } from '${rel}';`);
     } else {
       lines.push(`import { deserialize${depName}, serialize${depName} } from '${rel}';`);
     }
@@ -821,27 +832,30 @@ export function emitSerializerBody(
   baselineResponse: BaselineInterface | undefined,
   skipFormatFields: Set<string>,
   shouldSkipSerialize: boolean,
+  shouldSkipDeserialize: boolean,
   ctx: EmitterContext,
 ): string[] {
   const lines: string[] = [];
 
-  const seenDeserFields = new Set<string>();
-  const deserParamPrefix = model.fields.length === 0 ? '_' : '';
-  lines.push(`export const deserialize${domainName} = ${typeParams.decl}(`);
-  lines.push(`  ${deserParamPrefix}response: ${responseName}${typeParams.usage},`);
-  lines.push(`): ${domainName}${typeParams.usage} => ({`);
-  for (const field of model.fields) {
-    const domain = fieldName(field.name);
-    if (seenDeserFields.has(domain)) continue;
-    seenDeserFields.add(domain);
-    const plan = planDeserializeField(field, baselineDomain, baselineResponse, skipFormatFields, ctx);
-    if (!plan.skip) lines.push(plan.line);
+  if (!shouldSkipDeserialize) {
+    const seenDeserFields = new Set<string>();
+    const deserParamPrefix = model.fields.length === 0 ? '_' : '';
+    lines.push(`export const deserialize${domainName} = ${typeParams.decl}(`);
+    lines.push(`  ${deserParamPrefix}response: ${responseName}${typeParams.usage},`);
+    lines.push(`): ${domainName}${typeParams.usage} => ({`);
+    for (const field of model.fields) {
+      const domain = fieldName(field.name);
+      if (seenDeserFields.has(domain)) continue;
+      seenDeserFields.add(domain);
+      const plan = planDeserializeField(field, baselineDomain, baselineResponse, skipFormatFields, ctx);
+      if (!plan.skip) lines.push(plan.line);
+    }
+    lines.push('});');
   }
-  lines.push('});');
 
   if (!shouldSkipSerialize) {
+    if (!shouldSkipDeserialize) lines.push('');
     const serParamPrefix = model.fields.length === 0 ? '_' : '';
-    lines.push('');
     lines.push(`export const serialize${domainName} = ${typeParams.decl}(`);
     lines.push(`  ${serParamPrefix}model: ${domainName}${typeParams.usage},`);
     lines.push(`): ${responseName}${typeParams.usage} => ({`);

package/src/node/manifest.ts

@@ -1,6 +1,5 @@
 import type { ApiSpec, EmitterContext, OperationsMap } from '@workos/oagen';
-import { resolveMethodName, servicePropertyName } from './naming.js';
-import { resolveResourceClassName } from './resources.js';
+import { resolveMethodName, servicePropertyName, resolveServiceName } from './naming.js';
 import { buildResolvedLookup, lookupResolved } from '../shared/resolved-ops.js';
 
 export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
@@ -8,7 +7,10 @@ export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): Operatio
   const resolvedLookup = buildResolvedLookup(ctx);
 
   for (const service of spec.services) {
-    const serviceProp = servicePropertyName(resolveResourceClassName(service, ctx));
+    // Accessor name reflects the un-suffixed service mount target so the
+    // manifest matches `client.organizationMembership` (not the suffixed
+    // class name used to dodge model collisions).
+    const serviceProp = servicePropertyName(resolveServiceName(service, ctx));
     for (const op of service.operations) {
       const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
       const method = resolveMethodName(op, service, ctx);

package/src/node/models.ts

@@ -61,6 +61,10 @@ interface SharedModelContext {
 interface GeneratedResourceModelUsage {
   interfaceRoots: Set<string>;
   serializerRoots: Set<string>;
+  /** Models that are directly used as a request body. Drive `serialize<X>`. */
+  requestRoots: Set<string>;
+  /** Models that are directly used as a response body. Drive `deserialize<X>`. */
+  responseRoots: Set<string>;
 }
 
 function buildSharedContext(models: Model[], ctx: EmitterContext): SharedModelContext {
@@ -655,6 +659,14 @@ export function generateSerializers(
   const serializerEligibleModels = resourceUsage
     ? expandModelRoots(resourceUsage.serializerRoots, projectedByName)
     : undefined;
+  // Models reachable from any response — only these need a `deserialize<X>`.
+  // A model used solely as a request body (e.g. `CreateWebhookEndpoint`)
+  // would otherwise emit a deserializer with a partial response shape that
+  // silently misbehaves if called. Undefined means "no resource usage info,
+  // emit both halves" (standalone generation, smoke tests).
+  const responseReachableModels = resourceUsage
+    ? expandModelRoots(resourceUsage.responseRoots, projectedByName)
+    : undefined;
 
   const serializerReachable = computeNonEventReachable(ctx.spec.services, models);
 
@@ -765,9 +777,19 @@ export function generateSerializers(
       if (domainName === canonDomainName) continue;
       const rel = relativeImport(serializerPath, canonSerializerPath);
       const canonSkipSerialize = skippedSerializeModels.has(canonicalName) || skippedSerializeModels.has(model.name);
-      const reexportContent = canonSkipSerialize
-        ? `export { deserialize${canonDomainName} as deserialize${domainName} } from '${rel}';`
-        : `export { deserialize${canonDomainName} as deserialize${domainName}, serialize${canonDomainName} as serialize${domainName} } from '${rel}';`;
+      const canonSkipDeserialize =
+        responseReachableModels !== undefined &&
+        !responseReachableModels.has(canonicalName) &&
+        !responseReachableModels.has(model.name);
+      if (canonSkipSerialize && canonSkipDeserialize) continue;
+      const parts: string[] = [];
+      if (!canonSkipDeserialize) {
+        parts.push(`deserialize${canonDomainName} as deserialize${domainName}`);
+      }
+      if (!canonSkipSerialize) {
+        parts.push(`serialize${canonDomainName} as serialize${domainName}`);
+      }
+      const reexportContent = `export { ${parts.join(', ')} } from '${rel}';`;
       files.push({
         path: serializerPath,
         content: reexportContent,
@@ -787,8 +809,21 @@ export function generateSerializers(
 
     const skipFormatFields = buildSkipFormatFields(model, baselineDomain);
     const shouldSkipSerialize = skippedSerializeModels.has(model.name);
-
-    const sctx = { modelToService, resolveDir, dedup, skippedSerializeModels, ctx };
+    // Skip `deserialize<X>` when the model never appears as a response (and
+    // we have usage info to verify that — `undefined` means "emit both halves
+    // conservatively"). Cuts unused, partially-typed deserializers like
+    // `deserializeCreateWebhookEndpoint` from request-body-only models.
+    const shouldSkipDeserialize = responseReachableModels !== undefined && !responseReachableModels.has(model.name);
+    if (shouldSkipSerialize && shouldSkipDeserialize) continue;
+
+    const sctx = {
+      modelToService,
+      resolveDir,
+      dedup,
+      skippedSerializeModels,
+      responseReachableModels,
+      ctx,
+    };
     const lines = [
       ...buildSerializerImports(model, serializerPath, dirName, domainName, responseName, sctx),
       ...emitSerializerBody(
@@ -800,6 +835,7 @@ export function generateSerializers(
         baselineResponse,
         skipFormatFields,
         shouldSkipSerialize,
+        shouldSkipDeserialize,
         ctx,
       ),
     ];
@@ -812,6 +848,10 @@ export function generateSerializers(
   }
 
   (ctx as any)._skippedSerializeModels = skippedSerializeModels;
+  // Surface the response-reachable set so the serializer-roundtrip test
+  // generator can fall back to a deserialize-skipped path for request-only
+  // models (where `deserialize<X>` was deliberately not emitted).
+  (ctx as any)._responseReachableModels = responseReachableModels;
 
   // Emit a `serializers/index.ts` barrel per directory that received serializer
   // files in this pass. Mirrors the per-service `interfaces/index.ts` barrel so
@@ -882,6 +922,8 @@ function buildGeneratedResourceModelUsage(
   const modelMap = new Map(models.map((model) => [model.name, model]));
   const interfaceRoots = new Set<string>();
   const serializerRoots = new Set<string>();
+  const requestRoots = new Set<string>();
+  const responseRoots = new Set<string>();
   const resolvedLookup = buildResolvedLookup(ctx);
   const mountGroups = groupByMount(ctx);
   const services: Service[] =
@@ -924,16 +966,19 @@ function buildGeneratedResourceModelUsage(
           if (unwrapped) itemName = unwrapped.name;
           interfaceRoots.add(itemName);
           serializerRoots.add(itemName);
+          responseRoots.add(itemName);
         }
       } else if (plan.responseModelName) {
         interfaceRoots.add(plan.responseModelName);
         serializerRoots.add(plan.responseModelName);
+        responseRoots.add(plan.responseModelName);
       }
 
       const bodyInfo = extractRequestBodyModels(op, ctx);
       for (const name of bodyInfo) {
         interfaceRoots.add(name);
         serializerRoots.add(name);
+        requestRoots.add(name);
       }
 
       for (const param of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
@@ -945,6 +990,7 @@ function buildGeneratedResourceModelUsage(
         for (const name of collectWrapperResponseModels(resolved)) {
           interfaceRoots.add(name);
           serializerRoots.add(name);
+          responseRoots.add(name);
         }
         for (const wrapper of resolved.wrappers ?? []) {
           for (const { field } of resolveWrapperParams(wrapper, ctx)) {
@@ -955,7 +1001,7 @@ function buildGeneratedResourceModelUsage(
     }
   }
 
-  return { interfaceRoots, serializerRoots };
+  return { interfaceRoots, serializerRoots, requestRoots, responseRoots };
 }
 
 function extractRequestBodyModels(op: Operation, ctx: EmitterContext): string[] {

package/src/node/naming.ts

@@ -2,6 +2,10 @@ import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toCamelCase, toKebabCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName } from '../shared/resolved-ops.js';
 import { stripUrnPrefix } from '../shared/naming-utils.js';
+import {
+  buildExportedClassNameSet as buildExportedClassNameSetShared,
+  resolveServiceTarget as resolveServiceTargetShared,
+} from '../shared/service-name-collision.js';
 
 /** Strip spec-noise suffixes (e.g., "Dto") from an IR name. */
 export function stripNoiseSuffixes(name: string): string {
@@ -117,6 +121,26 @@ export function resolveServiceName(service: Service, ctx: EmitterContext): strin
   return resolveClassName(service, ctx);
 }
 
+/**
+ * Build the set of model + enum class names exported by the SDK. Used to
+ * detect collisions with operation-client class names — a colliding service
+ * gets a `Service` suffix appended.
+ */
+export function buildExportedClassNameSet(ctx: EmitterContext): Set<string> {
+  return buildExportedClassNameSetShared(ctx, className);
+}
+
+/**
+ * Resolve a service's mount-target identifier, appending `Service` on
+ * collision with an exported model/enum class. The result feeds `className`
+ * and `fileName` so both the `export class` declaration and its file name
+ * stay aligned (e.g. `OrganizationMembershipService` /
+ * `organization-membership-service.ts`).
+ */
+export function resolveServiceTarget(target: string, exportedClasses: Set<string>): string {
+  return resolveServiceTargetShared(target, exportedClasses, className);
+}
+
 /**
  * Build a map from IR service name -> resolved service name.
  */

package/src/node/resources.ts

@@ -53,6 +53,8 @@ import {
   resolveInterfaceName,
   resolveServiceName,
   wireInterfaceName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import {
   docComment,
@@ -102,21 +104,31 @@ export function hasCompatibleConstructor(className: string, ctx: EmitterContext)
  */
 export function resolveResourceClassName(service: Service, ctx: EmitterContext): string {
   const overlayName = resolveServiceName(service, ctx);
+  let base: string;
   if (hasCompatibleConstructor(overlayName, ctx)) {
-    return overlayName;
-  }
-  // Incompatible constructor — fall back to IR name
-  const irName = toPascalCase(service.name);
-  if (irName === overlayName) {
-    return irName + 'Endpoints';
-  }
-  return irName;
+    base = overlayName;
+  } else {
+    // Incompatible constructor — fall back to IR name, with `Endpoints` suffix
+    // if it would collide with the overlay name.
+    const irName = toPascalCase(service.name);
+    base = irName === overlayName ? `${irName}Endpoints` : irName;
+  }
+  // Cross-language `Service` suffix when the chosen class name would shadow
+  // an exported model/enum (e.g. tag `OrganizationMembership` + schema
+  // `OrganizationMembership`).
+  return resolveServiceTarget(base, buildExportedClassNameSet(ctx));
 }
 
 export function resolveResourceDir(service: Service, ctx: EmitterContext): string {
   const resolvedName = resolveResourceClassName(service, ctx);
   if (resolvedName === 'WebhooksEndpoints') return 'webhooks';
-  return resolveServiceDir(resolvedName);
+  // Drop the collision-`Service` suffix when picking the directory so the
+  // resource and its model-interfaces share a folder (e.g.
+  // `organization-membership/` houses both `OrganizationMembershipService`
+  // and `OrganizationMembership`'s interface files).
+  const overlayName = resolveServiceName(service, ctx);
+  const dirBase = resolvedName === `${overlayName}Service` ? overlayName : resolvedName;
+  return resolveServiceDir(dirBase);
 }
 
 /** Standard pagination query params handled by PaginationOptions — not imported individually. */

package/src/node/tests.ts

@@ -11,6 +11,7 @@ import {
   servicePropertyName,
   resolveMethodName,
   resolveInterfaceName,
+  resolveServiceName,
   wireInterfaceName,
 } from './naming.js';
 import { generateFixtures } from './fixtures.js';
@@ -142,7 +143,9 @@ function generateServiceTest(
   const resolvedName = resolveResourceClassName(service, ctx);
   const serviceDir = resolveResourceDir(service, ctx);
   const serviceClass = resolvedName;
-  const serviceProp = mountAccessors?.get(service.name) ?? servicePropertyName(resolvedName);
+  // Accessor stays un-suffixed so `client.organizationMembership` resolves even
+  // when the class was renamed to dodge a model-name collision.
+  const serviceProp = mountAccessors?.get(service.name) ?? servicePropertyName(resolveServiceName(service, ctx));
   const testPath = `src/${serviceDir}/${fileName(resolvedName)}.spec.ts`;
 
   const plans = service.operations.map((op) => ({
@@ -838,18 +841,33 @@ function buildTestPayload(
   }
   if (!model) return null;
 
-  const fields = model.fields.filter((f) => f.required);
+  const requiredFields = model.fields.filter((f) => f.required);
   // Only use fields that we can generate deterministic values for (primitives, enums, and nested models)
-  const usableFields = fields.filter((f) => fixtureValueForType(f.type, f.name, model.name, modelMap) !== null);
-
-  // Only generate a typed payload when ALL required fields have fixture values.
-  // A partial payload missing required fields would fail TypeScript type checking.
-  if (usableFields.length === 0 || usableFields.length < fields.length) return null;
+  const usableRequired = requiredFields.filter(
+    (f) => fixtureValueForType(f.type, f.name, model.name, modelMap) !== null,
+  );
+
+  let chosenFields: typeof model.fields;
+  if (requiredFields.length > 0) {
+    // Only generate a typed payload when ALL required fields have fixture values.
+    // A partial payload missing required fields would fail TypeScript type checking.
+    if (usableRequired.length < requiredFields.length) return null;
+    chosenFields = usableRequired;
+  } else {
+    // All-optional model (e.g. PATCH `Update<X>` bodies). Pick the first few
+    // optional fields with available fixture values so the test asserts the
+    // wire format instead of falling back to `expect(fetchBody()).toBeDefined()`.
+    const usableOptional = model.fields.filter(
+      (f) => !f.required && fixtureValueForType(f.type, f.name, model.name, modelMap) !== null,
+    );
+    if (usableOptional.length === 0) return null;
+    chosenFields = usableOptional.slice(0, 2);
+  }
 
   const camelEntries: string[] = [];
   const snakeEntries: string[] = [];
 
-  for (const field of usableFields) {
+  for (const field of chosenFields) {
     const camelValue = fixtureValueForType(field.type, field.name, model.name, modelMap)!;
     const wireValue = fixtureValueForType(field.type, field.name, model.name, modelMap, true)!;
     const camelKey = fieldName(field.name);
@@ -935,6 +953,10 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
   // Use the skipped-serialize set computed by the serializer generator.
   // It's stashed on the context during generateSerializers.
   const serializeSkipped: Set<string> = (ctx as any)._skippedSerializeModels ?? new Set<string>();
+  // Response-reachable models — anything outside this set is request-only
+  // and has no `deserialize<X>` to test. `undefined` means "no usage info,
+  // assume deserialize exists" (standalone generation, smoke tests).
+  const responseReachableModels: Set<string> | undefined = (ctx as any)._responseReachableModels;
 
   // Group eligible models by service directory for one test file per service
   const modelsByDir = new Map<string, Model[]>();
@@ -958,6 +980,7 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     const interfaceImports: string[] = [];
     const fixtureImports: string[] = [];
     const deserializeOnlyModels = new Set<string>();
+    const serializeOnlyModels = new Set<string>();
 
     for (const model of models) {
       const domainName = resolveInterfaceName(model.name, ctx);
@@ -966,13 +989,24 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
       const serializerPath = `src/${modelDir}/serializers/${fileName(model.name)}.serializer.ts`;
       const interfacePath = `src/${modelDir}/interfaces/${fileName(model.name)}.interface.ts`;
       const fixturePath = `src/${modelDir}/fixtures/${fileName(model.name)}.json`;
-      const deserializeOnly = serializeSkipped.has(model.name) || fixtureIsHandOwned(fixturePath, ctx);
+      // Request-only models (e.g. `CreateWebhookEndpoint`) have no
+      // `deserialize<X>` emitted, so they can only be tested via serialize.
+      // This check has to come first: a hand-owned fixture would otherwise
+      // route through the deserialize-only branch, which then imports a
+      // function that doesn't exist.
+      const isRequestOnly = responseReachableModels !== undefined && !responseReachableModels.has(model.name);
+      const deserializeOnly =
+        !isRequestOnly && (serializeSkipped.has(model.name) || fixtureIsHandOwned(fixturePath, ctx));
+      const serializeOnly = isRequestOnly;
       if (deserializeOnly) deserializeOnlyModels.add(model.name);
+      if (serializeOnly) serializeOnlyModels.add(model.name);
 
       if (deserializeOnly) {
         serializerImports.push(
           `import { deserialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`,
         );
+      } else if (serializeOnly) {
+        serializerImports.push(`import { serialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`);
       } else {
         serializerImports.push(
           `import { deserialize${domainName}, serialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`,
@@ -1009,6 +1043,15 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
         lines.push('    expect(deserialized).toBeDefined();');
         lines.push('  });');
         lines.push('});');
+      } else if (serializeOnlyModels.has(model.name)) {
+        // Serialize-only test for request-body-only models without a deserializer.
+        lines.push(`describe('${domainName}Serializer', () => {`);
+        lines.push("  it('serializes correctly', () => {");
+        lines.push(`    const fixture = ${fixtureName} as ${wireName};`);
+        lines.push(`    const serialized = serialize${domainName}(fixture as any);`);
+        lines.push('    expect(serialized).toBeDefined();');
+        lines.push('  });');
+        lines.push('});');
       } else {
         // Round-trip test
         lines.push(`describe('${domainName}Serializer', () => {`);