@workos/oagen-emitters 0.12.5 → 0.14.0

package/src/node/index.ts

@@ -16,6 +16,8 @@ import { generateEnums as generateEnumFiles } from './enums.js';
 import { generateResources, resolveResourceClassName, resolveResourceDir } from './resources.js';
 import { generateClient } from './client.js';
 import { generateTests as generateTestFiles } from './tests.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
+import { planDiscriminatedModels, generateDiscriminatedFiles } from './discriminated-models.js';
 import { buildLiveSurface, emptyLiveSurface, setActiveLiveSurface, type LiveSurface } from './live-surface.js';
 import {
   setBaselineSerializedNames,
@@ -214,7 +216,10 @@ function computeOwnedServiceDirs(ctx: EmitterContext): Set<string> {
   const mountGroups = groupByMount(ctx);
   const services =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
   const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 
@@ -233,7 +238,10 @@ function computeAdoptedServiceDirs(ctx: EmitterContext, surface: LiveSurface): S
   const mountGroups = groupByMount(ctx);
   const services =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
   const { resolveDir } = createServiceDirResolver(ctx.spec.models, ctx.spec.services, ctx);
 
@@ -350,19 +358,58 @@ function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface:
   return out;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields from the raw spec onto each
+ * model. `enrichModelsFromSpec` produces (a) extra optional fields on models
+ * whose schema is `allOf [base, oneOf [...]]`, and (b) synthetic models /
+ * enums for inline objects encountered inside variants (e.g. the inline
+ * `redirect_uris` item shape on `ConnectApplication`).
+ *
+ * Node, like Go / Kotlin / .NET, emits flat interfaces rather than a sum
+ * type, so on `enrichModelsFromSpec`-marked discriminated bases we restore
+ * the original IR fields — otherwise the base interface would be empty.
+ * A future change can emit a real TS discriminated union; for now the goal
+ * is parity with the other flat-emit languages so every variant field is
+ * at least reachable.
+ */
+function enrichModelsForNode(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const nodeEmitter: Emitter = {
   language: 'node',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateModelsAndSerializers(models, nodeCtx), nodeCtx, surface);
+    const enriched = enrichModelsForNode(models);
+    // Detect `allOf [base, oneOf [variant, …]]` schemas and hand them off
+    // to the discriminated-models module. Leave the model in the standard
+    // pipeline's input so its field-type deps stay reachable, but stash the
+    // name set on ctx so models.ts skips emitting an interface/serializer —
+    // the discriminated module owns those paths instead.
+    const discPlans = planDiscriminatedModels(enriched, nodeCtx);
+    (nodeCtx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames = new Set(discPlans.keys());
+    const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
+    const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
+    return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateEnumFiles(enums, nodeCtx), nodeCtx, surface);
+    const syntheticEnums = getSyntheticEnums();
+    return applyLiveSurface(generateEnumFiles([...enums, ...syntheticEnums], nodeCtx), nodeCtx, surface);
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {
@@ -374,7 +421,11 @@ export const nodeEmitter: Emitter = {
   generateClient(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateClient(spec, nodeCtx), nodeCtx, surface);
+    // `nodeCtx.spec` has the synthetic models that `enrichModelsFromSpec`
+    // produced (e.g. inline-object item types like `ConnectApplicationRedirectUri`).
+    // The `spec` param is the engine's pre-enrichment spec, so the barrel
+    // generator would miss those synthetic interfaces. Use the enriched one.
+    return applyLiveSurface(generateClient(nodeCtx.spec, nodeCtx), nodeCtx, surface);
   },
 
   // workos-node ships its own exception hierarchy under src/common/exceptions/.

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

@@ -130,6 +130,13 @@ function isSupportedFieldType(
       // silently dropped on first emission because the target interface
       // (`UserObject` under the adopted `connect/` dir) hasn't landed yet.
       if (isAdoptedModelName(ref.name)) return true;
+      // Synthetic models produced by `enrichModelsFromSpec` (e.g. the
+      // inline-object item type for `ConnectApplication.redirect_uris`)
+      // are added to the models list passed into this generation pass —
+      // and hence into `shared.modelToService` — but won't yet exist on
+      // disk or in `apiSurface`. Accept them so their parent field
+      // survives field-projection.
+      if (shared.modelToService.has(ref.name)) return true;
       const relPath = `src/${shared.resolveDir(shared.modelToService.get(ref.name))}/interfaces/${fileName(ref.name)}.interface.ts`;
       return liveSurfaceHasManagedFile(relPath);
     }
@@ -201,12 +208,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
     }
   }
 
+  const discriminatedSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!reachableModels.has(model.name)) continue;
     if (interfaceEligibleModels && !interfaceEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model)) continue;
+    if (discriminatedSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
     if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
@@ -723,6 +732,7 @@ export function generateSerializers(
     }
   }
 
+  const discriminatedSerializerSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
   const eligibleModels: Model[] = [];
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
@@ -730,6 +740,7 @@ export function generateSerializers(
     if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model)) continue;
+    if (discriminatedSerializerSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
     if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
@@ -928,7 +939,10 @@ function buildGeneratedResourceModelUsage(
   const mountGroups = groupByMount(ctx);
   const services: Service[] =
     mountGroups.size > 0
-      ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
+      ? [...mountGroups].map(([name, group]) => ({
+          name,
+          operations: group.operations,
+        }))
       : ctx.spec.services;
 
   for (const service of services) {

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/node-overrides.ts

@@ -1,4 +1,5 @@
-import type { EmitterContext, ResolvedOperation } from '@workos/oagen';
+import type { EmitterContext, Model, ResolvedOperation } from '@workos/oagen';
+import { enrichModelsFromSpec } from '../shared/model-utils.js';
 
 type OperationOverride = {
   methodName?: string;
@@ -42,17 +43,52 @@ function operationKey(resolved: ResolvedOperation): string {
   return `${resolved.operation.httpMethod.toUpperCase()} ${resolved.operation.path}`;
 }
 
+/**
+ * Apply oneOf / allOf+oneOf enrichment (flattening variant fields onto the
+ * parent model, plus synthetic models/enums for inline shapes) so the rest
+ * of the Node emitter sees a richer `spec.models`.
+ *
+ * Without this, `ConnectApplication` (and any other `allOf [base, oneOf [...]]`
+ * schema whose first variant is itself wrapped in `allOf`) loses every
+ * non-M2M field — the IR parser's discriminator detection silently skips
+ * variants whose properties live behind another `allOf`. Mirrors what the
+ * Go / Kotlin / .NET emitters already do.
+ *
+ * Discriminated bases produced by `enrichModelsFromSpec` get their original
+ * fields restored — Node emits flat interfaces today, not TS sum types, so
+ * an empty base would otherwise drop the common fields.
+ */
+function enrichSpecModels(models: readonly Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models as Model[]);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext {
   const cached = contextCache.get(ctx);
   if (cached) return cached;
 
+  const enrichedModels = enrichSpecModels(ctx.spec.models);
+  const specChanged =
+    enrichedModels.length !== ctx.spec.models.length || enrichedModels.some((m, i) => m !== ctx.spec.models[i]);
+  const enrichedSpec = specChanged ? { ...ctx.spec, models: enrichedModels } : ctx.spec;
+
   const resolvedOperations = ctx.resolvedOperations;
   if (!resolvedOperations?.length) {
-    contextCache.set(ctx, ctx);
-    return ctx;
+    const next = specChanged ? { ...ctx, spec: enrichedSpec } : ctx;
+    contextCache.set(ctx, next);
+    return next;
   }
 
-  let changed = false;
+  let opsChanged = false;
   const nextResolved = resolvedOperations.map((resolved) => {
     const override = OPERATION_OVERRIDES[operationKey(resolved)];
     if (!override) return resolved;
@@ -63,7 +99,7 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
       return resolved;
     }
 
-    changed = true;
+    opsChanged = true;
     return {
       ...resolved,
       methodName,
@@ -71,7 +107,14 @@ export function withNodeOperationOverrides(ctx: EmitterContext): EmitterContext
     };
   });
 
-  const next = changed ? { ...ctx, resolvedOperations: nextResolved } : ctx;
+  const next =
+    opsChanged || specChanged
+      ? {
+          ...ctx,
+          ...(opsChanged ? { resolvedOperations: nextResolved } : {}),
+          ...(specChanged ? { spec: enrichedSpec } : {}),
+        }
+      : ctx;
   contextCache.set(ctx, next);
   return next;
 }

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/index.ts

@@ -18,6 +18,7 @@ import { generateClient } from './client.js';
 import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { initializeEnumDedup } from './naming.js';
+import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 
 /** Initialize enum deduplication from spec data. */
 function ensureNamingInitialized(ctx: EmitterContext): void {
@@ -34,17 +35,39 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
   return files;
 }
 
+/**
+ * Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+ * in synthetic models / enums for inline variant shapes. PHP emits flat
+ * classes (no sum types), so a discriminated base whose IR fields the
+ * parser stripped (post-allOf-aware detection) gets its original fields
+ * restored to avoid silently dropping variant data.
+ */
+function enrichModelsForPhp(models: Model[]): Model[] {
+  const enriched = enrichModelsFromSpec(models);
+  const originalByName = new Map(models.map((m) => [m.name, m]));
+  return enriched.map((m) => {
+    if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
+      const original = originalByName.get(m.name);
+      if (original && original.fields.length > 0) {
+        return { ...m, fields: original.fields };
+      }
+    }
+    return m;
+  });
+}
+
 export const phpEmitter: Emitter = {
   language: 'php',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateModels(models, ctx));
+    return ensureTrailingNewlines(generateModels(enrichModelsForPhp(models), ctx));
   },
 
   generateEnums(enums: Enum[], ctx: EmitterContext): GeneratedFile[] {
     ensureNamingInitialized(ctx);
-    return ensureTrailingNewlines(generateEnums(enums, ctx));
+    const syntheticEnums = getSyntheticEnums();
+    return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
   },
 
   generateResources(services: Service[], ctx: EmitterContext): GeneratedFile[] {

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[] = [];