@workos/oagen-emitters 0.12.5 → 0.13.0

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-Ca9LUkWW.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.5",
+  "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/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/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) => ({

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 ?? []) {