@workos/oagen-emitters 0.12.4 → 0.13.0

package/src/php/client.ts

@@ -1,6 +1,6 @@
 import type { ApiSpec, Service, EmitterContext, GeneratedFile } from '@workos/oagen';
 import { toPascalCase, toCamelCase } from '@workos/oagen';
-import { className, servicePropertyName } from './naming.js';
+import { className, servicePropertyName, buildExportedClassNameSet, resolveServiceTarget } from './naming.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 import { NON_SPEC_SERVICES } from '../shared/non-spec-services.js';
 
@@ -61,11 +61,12 @@ export function buildServiceAccessPaths(services: Service[], ctx: EmitterContext
 
 function deduplicateByMount(services: Service[], ctx: EmitterContext): { name: string; propName: string }[] {
   const seen = new Map<string, { name: string; propName: string }>();
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const service of services) {
     const target = getMountTarget(service, ctx);
     if (!seen.has(target)) {
       seen.set(target, {
-        name: className(target),
+        name: className(resolveServiceTarget(target, exportedClasses)),
         propName: servicePropertyName(target),
       });
     }

package/src/php/naming.ts

@@ -2,6 +2,10 @@ import type { Service, Operation, EmitterContext, Enum } from '@workos/oagen';
 import { toPascalCase, toCamelCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName } from '../shared/resolved-ops.js';
 import { stripUrnPrefix, applyAcronymFixes } from '../shared/naming-utils.js';
+import {
+  buildExportedClassNameSet as buildExportedClassNameSetShared,
+  resolveServiceTarget as resolveServiceTargetShared,
+} from '../shared/service-name-collision.js';
 
 /** Namespace grouping result (shared with client.ts). */
 export interface NamespaceGroup {
@@ -90,6 +94,24 @@ export function className(name: string): string {
   return result;
 }
 
+/**
+ * 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. Used in `\Service\…` files
+ * to avoid `use WorkOS\Resource\X; class X` PHP fatal errors.
+ */
+export function resolveServiceTarget(target: string, exportedClasses: Set<string>): string {
+  return resolveServiceTargetShared(target, exportedClasses, className);
+}
+
 /** PascalCase file name (without extension) — PSR-4 convention. */
 export function fileName(name: string): string {
   return className(name);

package/src/php/resources.ts

@@ -1,7 +1,7 @@
 import type { Service, Operation, Model, EmitterContext, GeneratedFile, ResolvedOperation } from '@workos/oagen';
 import { planOperation, toCamelCase, toPascalCase } from '@workos/oagen';
 import { mapTypeRef, mapTypeRefForPHPDoc } from './type-map.js';
-import { className, fieldName, resolveMethodName } from './naming.js';
+import { className, fieldName, resolveMethodName, buildExportedClassNameSet, resolveServiceTarget } from './naming.js';
 import { isListWrapperModel } from './models.js';
 import {
   groupByMount,
@@ -43,9 +43,10 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: className(s.name), operations: s.operations }));
 
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const { name: mountName, operations } of entries) {
     if (operations.length === 0) continue;
-    const resourceName = className(mountName);
+    const resourceName = className(resolveServiceTarget(mountName, exportedClasses));
     const mergedService: Service = { name: mountName, operations };
     const lines: string[] = [];
 

package/src/python/client.ts

@@ -1,6 +1,14 @@
 import type { ApiSpec, EmitterContext, GeneratedFile, Service } from '@workos/oagen';
 import { toPascalCase } from '@workos/oagen';
-import { className, resolveServiceDir, servicePropertyName, buildMountDirMap, dirToModule } from './naming.js';
+import {
+  className,
+  resolveServiceDir,
+  servicePropertyName,
+  buildMountDirMap,
+  dirToModule,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
+} from './naming.js';
 import { resolveResourceClassName, collectParameterGroupClassNames } from './resources.js';
 import { getMountTarget, groupByMount } from '../shared/resolved-ops.js';
 import { NON_SPEC_SERVICES } from '../shared/non-spec-services.js';
@@ -149,9 +157,10 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   // Import resource classes (both sync and async)
   const serviceDirMap = buildMountDirMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const service of topLevelServices) {
     const resolvedName = resolveResourceClassName(service, ctx);
-    const clsName = className(resolvedName);
+    const clsName = className(resolveServiceTarget(resolvedName, exportedClasses));
     const dirName = serviceDirMap.get(service.name) ?? resolveServiceDir(resolvedName);
     const importLine = `from .${dirToModule(dirName)}._resource import ${clsName}, Async${clsName}`;
     if (importLine.length > 88) {
@@ -185,7 +194,7 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const generatedProps = new Set<string>();
   for (const service of topLevelServices) {
     const resolvedName = resolveResourceClassName(service, ctx);
-    const clsName = className(resolvedName);
+    const clsName = className(resolveServiceTarget(resolvedName, exportedClasses));
     const prop = servicePropertyName(resolvedName);
     const readable = clsName.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
     lines.push('');
@@ -208,7 +217,7 @@ function generateWorkOSClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const asyncGeneratedProps = new Set<string>();
   for (const service of topLevelServices) {
     const resolvedName = resolveResourceClassName(service, ctx);
-    const clsName = className(resolvedName);
+    const clsName = className(resolveServiceTarget(resolvedName, exportedClasses));
     const prop = servicePropertyName(resolvedName);
     const readable = clsName.replace(/([a-z])([A-Z])/g, '$1 $2').replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2');
     lines.push('');
@@ -255,6 +264,7 @@ function generateServiceInits(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   const files: GeneratedFile[] = [];
   const topLevel = deduplicateByMount(spec.services, ctx);
   const serviceDirMap = buildMountDirMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   // Build a map from mount target -> operations so we can discover parameter
   // group dataclasses that need re-exporting from __init__.py.
@@ -262,6 +272,7 @@ function generateServiceInits(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   for (const service of topLevel) {
     const resolvedName = resolveResourceClassName(service, ctx);
+    const clsName = className(resolveServiceTarget(resolvedName, exportedClasses));
     const dirName = serviceDirMap.get(service.name) ?? resolveServiceDir(resolvedName);
     const lines: string[] = [];
 
@@ -274,7 +285,7 @@ function generateServiceInits(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
     // public re-exports. Otherwise consumers importing
     // `from workos.user_management import RoleSingle` get a private-import
     // warning under strict mode. Models barrel uses the same convention.
-    const resourceImports = [resolvedName, `Async${resolvedName}`, ...groupClassNames];
+    const resourceImports = [clsName, `Async${clsName}`, ...groupClassNames];
     const aliasedImports = resourceImports.map((n) => `${n} as ${n}`);
     lines.push(`from ._resource import ${aliasedImports.join(', ')}`);
     lines.push('from .models import *');

package/src/python/naming.ts

@@ -2,6 +2,10 @@ import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName, getMountTarget } from '../shared/resolved-ops.js';
 import { stripUrnPrefix, applyAcronymFixes } from '../shared/naming-utils.js';
+import {
+  buildExportedClassNameSet as buildExportedClassNameSetShared,
+  resolveServiceTarget as resolveServiceTargetShared,
+} from '../shared/service-name-collision.js';
 
 /**
  * Python class names that collide with builtins or typing imports.
@@ -136,6 +140,27 @@ export function resolveMethodName(op: Operation, _service: Service, ctx: Emitter
   return toSnakeCase(op.name);
 }
 
+/**
+ * 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. Feeds `className`/`fileName`
+ * so the class declaration, file, and any qualified references stay aligned.
+ *
+ * Accessor names (`servicePropertyName`) intentionally use the RAW target —
+ * `client.organization_membership` reads better than the suffixed form.
+ */
+export function resolveServiceTarget(target: string, exportedClasses: Set<string>): string {
+  return resolveServiceTargetShared(target, exportedClasses, className);
+}
+
 /** Resolve the SDK class name for a service, using resolved operations' mountOn. */
 export function resolveClassName(service: Service, ctx: EmitterContext): string {
   // Use resolved ops mountOn as canonical class name (flat pattern like PHP)

package/src/python/resources.ts

@@ -23,6 +23,8 @@ import {
   buildMountDirMap,
   dirToModule,
   relativeImportPrefix,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -1012,10 +1014,11 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : services.map((s) => ({ name: resolveClassName(s, ctx), operations: s.operations }));
 
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const { name: mountName, operations: allOperations } of entries) {
     if (allOperations.length === 0) continue;
     const dirName = moduleName(mountName);
-    const resourceClassName = className(mountName);
+    const resourceClassName = className(resolveServiceTarget(mountName, exportedClasses));
     const importPrefix = relativeImportPrefix(dirName);
 
     const lines: string[] = [];

package/src/ruby/client.ts

@@ -1,6 +1,14 @@
 import type { ApiSpec, EmitterContext, GeneratedFile, Service, Model, Enum } from '@workos/oagen';
 import { assignModelsToServices } from '@workos/oagen';
-import { servicePropertyName, resolveClassName, className, fileName, buildMountDirMap } from './naming.js';
+import {
+  servicePropertyName,
+  resolveClassName,
+  className,
+  fileName,
+  buildMountDirMap,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
+} from './naming.js';
 import { classifyUnassignedModel } from './models.js';
 import { getMountTarget } from '../shared/resolved-ops.js';
 import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
@@ -89,8 +97,12 @@ function buildInflectionMap(spec: ApiSpec, ctx: EmitterContext): Map<string, str
 
   inflections.set('workos', 'WorkOS');
 
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const service of buildTopLevelServices(spec, ctx)) {
-    const target = getMountTarget(service, ctx) || resolveClassName(service, ctx);
+    const target = resolveServiceTarget(
+      getMountTarget(service, ctx) || resolveClassName(service, ctx),
+      exportedClasses,
+    );
     const cls = className(target);
     const file = fileName(target);
     if (rubyCamelize(file) !== cls) inflections.set(file, cls);
@@ -203,10 +215,11 @@ function generateClientClass(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   lines.push('  class Client < BaseClient');
 
   const topLevelServices = buildTopLevelServices(spec, ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
   for (const service of topLevelServices) {
-    const target = getMountTarget(service, ctx) || resolveClassName(service, ctx);
-    const cls = className(target);
-    const prop = servicePropertyName(target);
+    const rawTarget = getMountTarget(service, ctx) || resolveClassName(service, ctx);
+    const cls = className(resolveServiceTarget(rawTarget, exportedClasses));
+    const prop = servicePropertyName(rawTarget);
     lines.push('');
     lines.push(`    def ${prop}`);
     lines.push(`      @${prop} ||= WorkOS::${cls}.new(self)`);

package/src/ruby/manifest.ts

@@ -7,9 +7,14 @@ import { servicePropertyName } from './naming.js';
  * Uses each resolved operation's actual mountOn (not the service default) so
  * operations remounted via operationHints land on the correct service prop.
  * Split operations emit one entry per wrapper (keyed by wrapper name + variant).
+ *
+ * The accessor (`service` field) uses the raw mountOn — accessor names stay
+ * unsuffixed even when the underlying service class gets a `Service` suffix
+ * on collision.
  */
 export function buildOperationsMap(spec: ApiSpec, ctx: EmitterContext): OperationsMap {
   void spec;
+  void ctx;
   const manifest: OperationsMap = {};
 
   for (const r of ctx.resolvedOperations ?? []) {

package/src/ruby/naming.ts

@@ -2,6 +2,10 @@ import type { Operation, Service, EmitterContext } from '@workos/oagen';
 import { toPascalCase, toSnakeCase } from '@workos/oagen';
 import { buildResolvedLookup, lookupMethodName, getMountTarget } from '../shared/resolved-ops.js';
 import { stripUrnPrefix, applyAcronymFixes } from '../shared/naming-utils.js';
+import {
+  buildExportedClassNameSet as buildExportedClassNameSetShared,
+  resolveServiceTarget as resolveServiceTargetShared,
+} from '../shared/service-name-collision.js';
 
 /**
  * Ruby class names that collide with core classes. When a model name resolves
@@ -117,6 +121,32 @@ export function moduleName(name: string): string {
   return toSnakeCase(name);
 }
 
+/**
+ * Build the set of model + enum Ruby class names that the SDK exposes under
+ * `WorkOS::`. Used to detect collisions with operation-client class names —
+ * a colliding service gets a `Service` suffix (`OrganizationMembershipService`)
+ * so it doesn't shadow the model class under Zeitwerk's collapsed namespace.
+ */
+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 name. The returned PascalCase
+ * value feeds `className`/`fileName` to derive matching class + file names
+ * (e.g. `OrganizationMembershipService` / `organization_membership_service`).
+ *
+ * Accessor names (`servicePropertyName`) intentionally use the RAW target —
+ * `client.organization_membership` is more readable than the suffixed form.
+ *
+ * The directory used by `loader.collapse` (the model home) likewise uses the
+ * raw target.
+ */
+export function resolveServiceTarget(target: string, exportedClasses: Set<string>): string {
+  return resolveServiceTargetShared(target, exportedClasses, className);
+}
+
 /**
  * PascalCase class name for a parameter-group variant. Mirrors the Python
  * convention: group "password" + variant "plaintext" → `PasswordPlaintext`.

package/src/ruby/rbi.ts

@@ -7,6 +7,9 @@ import {
   safeParamName,
   scopedGroupVariantClassName,
   resolveMethodName,
+  servicePropertyName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -129,9 +132,11 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
   }
   const groupOwners = buildGroupOwnerMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
-    const cls = className(mountTarget);
+    const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+    const cls = className(resolvedTarget);
     const lines: string[] = [];
     lines.push('# typed: strong');
     lines.push('');
@@ -143,6 +148,9 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     // layout in lib/workos/<service>.rb.
     const variants = collectVariantsForMountTarget(ctx, spec.models as Model[], mountTarget);
     for (const v of variants) {
+      // Rewrite mountTarget to the (possibly pluralized) service class so the
+      // RBI's `WorkOS::<Service>::<Variant>` reference matches the runtime.
+      v.mountTarget = resolvedTarget;
       for (const line of emitInlineVariantRbi(v)) lines.push(line);
       lines.push('');
     }
@@ -183,7 +191,8 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
         if (!owner) {
           throw new Error(`No owner mount target found for parameter group '${group.name}'`);
         }
-        const variants = group.variants.map((v) => scopedGroupVariantClassName(owner, group.name, v.name));
+        const resolvedOwner = resolveServiceTarget(owner, exportedClasses);
+        const variants = group.variants.map((v) => scopedGroupVariantClassName(resolvedOwner, group.name, v.name));
         if (variants.length === 1) return variants[0];
         return `T.any(${variants.join(', ')})`;
       };
@@ -267,7 +276,7 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     lines.push('end');
 
     files.push({
-      path: `rbi/workos/${fileName(mountTarget)}.rbi`,
+      path: `rbi/workos/${fileName(resolvedTarget)}.rbi`,
       content: lines.join('\n'),
       integrateTarget: true,
       overwriteExisting: true,
@@ -283,11 +292,9 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
     lines.push('  class Client < BaseClient');
 
     for (const [mountTarget] of groups) {
-      const cls = className(mountTarget);
-      const prop = mountTarget
-        .replace(/-/g, '_')
-        .replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`)
-        .replace(/^_/, '');
+      const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+      const cls = className(resolvedTarget);
+      const prop = servicePropertyName(mountTarget);
       lines.push(`    sig { returns(WorkOS::${cls}) }`);
       lines.push(`    def ${prop}; end`);
       lines.push('');

package/src/ruby/resources.ts

@@ -8,6 +8,8 @@ import {
   safeParamName,
   resolveMethodName,
   scopedGroupVariantClassName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import { mapTypeRefForYard } from './type-map.js';
 import {
@@ -48,10 +50,12 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
   // dispatcher and YARD `@param` reference resolves variant classes through
   // this map so cross-resource references stay consistent.
   const groupOwners = buildGroupOwnerMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
-    const cls = className(mountTarget);
-    const file = fileName(mountTarget);
+    const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+    const cls = className(resolvedTarget);
+    const file = fileName(resolvedTarget);
 
     const operations = group.operations;
     if (operations.length === 0) continue;
@@ -103,6 +107,7 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
         listWrapperModels,
         requires,
         groupOwners,
+        exportedClasses,
       });
       methodBodies.push(body);
 
@@ -182,6 +187,7 @@ function emitMethod(args: {
   listWrapperModels: Map<string, Model>;
   requires: Set<string>;
   groupOwners: Map<string, string>;
+  exportedClasses: Set<string>;
 }): string {
   const {
     op,
@@ -195,6 +201,7 @@ function emitMethod(args: {
     listWrapperModels,
     requires,
     groupOwners,
+    exportedClasses,
   } = args;
   void enumNames;
 
@@ -204,7 +211,7 @@ function emitMethod(args: {
     if (!owner) {
       throw new Error(`No owner mount target found for parameter group '${group.name}'`);
     }
-    return scopedGroupVariantClassName(owner, group.name, variantName);
+    return scopedGroupVariantClassName(resolveServiceTarget(owner, exportedClasses), group.name, variantName);
   };
 
   const plan = planOperation(op);

package/src/ruby/tests.ts

@@ -7,6 +7,8 @@ import {
   scopedGroupVariantClassName,
   servicePropertyName,
   resolveMethodName,
+  buildExportedClassNameSet,
+  resolveServiceTarget,
 } from './naming.js';
 import {
   buildResolvedLookup,
@@ -38,11 +40,13 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
   const lookup = buildResolvedLookup(ctx);
   const groupOwners = buildGroupOwnerMap(ctx);
+  const exportedClasses = buildExportedClassNameSet(ctx);
 
   for (const [mountTarget, group] of groups) {
-    const cls = className(mountTarget);
+    const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+    const cls = className(resolvedTarget);
     const prop = servicePropertyName(mountTarget);
-    const file = fileName(mountTarget);
+    const file = fileName(resolvedTarget);
 
     const lines: string[] = [];
     lines.push(`require 'test_helper'`);
@@ -85,7 +89,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
 
       const resolved = lookupResolved(op, lookup);
       const hiddenParams = buildHiddenParams(resolved);
-      const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models);
+      const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, exportedClasses);
       const bodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models);
 
       // Collect method info for the parameterized 401 test (T20).
@@ -118,7 +122,15 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
         for (let vi = 1; vi < group.variants.length; vi++) {
           const variant = group.variants[vi];
           const overrides = new Map<string, number>([[group.name, vi]]);
-          const variantCallArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, overrides);
+          const variantCallArgs = buildCallArgsStub(
+            op,
+            modelByName,
+            hiddenParams,
+            groupOwners,
+            models,
+            exportedClasses,
+            overrides,
+          );
           const variantBodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models, overrides);
           const suffix = `with_${fieldName(group.name)}_${fieldName(variant.name)}`;
           lines.push('');
@@ -338,6 +350,7 @@ function buildCallArgsStub(
   hiddenParams: Set<string>,
   groupOwners: Map<string, string>,
   models: Model[],
+  exportedClasses: Set<string>,
   variantOverrides: Map<string, number> = new Map(),
 ): string {
   const parts: string[] = [];
@@ -406,7 +419,11 @@ function buildCallArgsStub(
       if (!owner) {
         throw new Error(`No owner mount target found for parameter group '${group.name}'`);
       }
-      const variantClass = scopedGroupVariantClassName(owner, group.name, variant.name);
+      const variantClass = scopedGroupVariantClassName(
+        resolveServiceTarget(owner, exportedClasses),
+        group.name,
+        variant.name,
+      );
       const fieldStubs = variant.parameters
         .map((p) => `${fieldName(p.name)}: ${stubValueFor(pickVariantParamType(p.type, bodyFieldTypes.get(p.name)))}`)
         .join(', ');

package/src/shared/service-name-collision.ts

@@ -0,0 +1,56 @@
+import type { EmitterContext, Model, Enum } from '@workos/oagen';
+import { isListWrapperModel, isListMetadataModel } from './model-utils.js';
+
+/**
+ * Suffix applied to an operation-client class name when it collides with an
+ * exported model/enum class name in the same SDK namespace. Standardized
+ * across emitters so colliding services look the same in every language —
+ * e.g. `OrganizationMembershipService` regardless of language.
+ *
+ * Languages whose operation clients already carry a unique suffix (Go's
+ * `…Service`, Rust's `…Api`, .NET's `…Service`) skip this helper entirely.
+ */
+export const SERVICE_COLLISION_SUFFIX = 'Service';
+
+/**
+ * Build the set of model + enum class names that the SDK exports under its
+ * top-level namespace. Each emitter passes its own `classNameFn` so the
+ * comparison happens on the language-specific class-name form (e.g. Ruby's
+ * `RoleList`, Python's `RoleList`).
+ *
+ * List-wrapper and list-metadata models are excluded — they aren't exposed
+ * as user-facing types.
+ */
+export function buildExportedClassNameSet(ctx: EmitterContext, classNameFn: (name: string) => string): Set<string> {
+  const out = new Set<string>();
+  for (const model of ctx.spec.models as Model[]) {
+    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    out.add(classNameFn(model.name));
+  }
+  for (const enumDef of ctx.spec.enums as Enum[]) {
+    out.add(classNameFn(enumDef.name));
+  }
+  return out;
+}
+
+/**
+ * Resolve the PascalCase mount-target identifier for an operation client,
+ * appending `Service` when the un-suffixed class name would shadow an
+ * exported model or enum.
+ *
+ * Operates on the PascalCase target (the mount-target string the IR carries),
+ * so the returned value feeds cleanly into each language's `className` and
+ * `fileName` helpers — e.g. `OrganizationMembership` → `OrganizationMembershipService`,
+ * then `fileName` → `organization_membership_service` / `organization-membership-service`.
+ *
+ * The accessor on the client (`client.organization_membership`) is intentionally
+ * NOT suffixed — callers should keep using the raw target for `servicePropertyName`
+ * so the accessor reads naturally.
+ */
+export function resolveServiceTarget(
+  target: string,
+  exportedClasses: Set<string>,
+  classNameFn: (name: string) => string,
+): string {
+  return exportedClasses.has(classNameFn(target)) ? `${target}${SERVICE_COLLISION_SUFFIX}` : target;
+}

package/test/node/models.test.ts

@@ -590,4 +590,60 @@ describe('generateSerializers', () => {
       expect(barrel!.overwriteExisting).toBe(true);
     }
   });
+
+  it('omits deserialize half for request-body-only models', () => {
+    // `CreateOrganization` is sent as a POST body but the operation responds
+    // with a separate `Organization` model. The deserializer for the request
+    // model would be dead code AND would silently misbehave if called (the
+    // response wire shape doesn't match), so it shouldn't be emitted.
+    const models: Model[] = [
+      {
+        name: 'Organization',
+        fields: [{ name: 'id', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+      {
+        name: 'CreateOrganization',
+        fields: [{ name: 'name', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ];
+
+    const spec: ApiSpec = {
+      ...emptySpec,
+      models,
+      services: [
+        {
+          name: 'Organizations',
+          operations: [
+            {
+              name: 'createOrganization',
+              httpMethod: 'post',
+              path: '/organizations',
+              pathParams: [],
+              queryParams: [],
+              headerParams: [],
+              response: { kind: 'model', name: 'Organization' },
+              requestBody: { kind: 'model', name: 'CreateOrganization' },
+              errors: [],
+              injectIdempotencyKey: false,
+            },
+          ],
+        },
+      ],
+    };
+
+    const ctxWithModels: EmitterContext = { ...ctx, spec };
+    const result = generateSerializers(models, ctxWithModels);
+
+    const createSerializer = result.find((f) => f.path.endsWith('create-organization.serializer.ts'));
+    expect(createSerializer).toBeDefined();
+    expect(createSerializer!.content).toContain('export const serializeCreateOrganization');
+    expect(createSerializer!.content).not.toContain('export const deserializeCreateOrganization');
+
+    // Response-side model still gets both halves.
+    const orgSerializer = result.find(
+      (f) => f.path.endsWith('organization.serializer.ts') && !f.path.includes('create'),
+    );
+    expect(orgSerializer).toBeDefined();
+    expect(orgSerializer!.content).toContain('export const deserializeOrganization');
+  });
 });