@workos/oagen-emitters 0.3.0 → 0.5.0

package/src/node/tests.ts

@@ -9,6 +9,7 @@ import {
   servicePropertyName,
   resolveMethodName,
   resolveInterfaceName,
+  wireInterfaceName,
 } from './naming.js';
 import { generateFixtures } from './fixtures.js';
 import { resolveResourceClassName } from './resources.js';
@@ -19,6 +20,8 @@ import {
   relativeImport,
   isListMetadataModel,
   isListWrapperModel,
+  modelHasNewFields,
+  computeNonEventReachable,
 } from './utils.js';
 import { groupByMount } from '../shared/resolved-ops.js';
 
@@ -28,7 +31,7 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
   // Generate fixture JSON files
   const fixtures = generateFixtures(spec, ctx);
   for (const f of fixtures) {
-    files.push({ path: f.path, content: f.content, headerPlacement: 'skip', integrateTarget: false });
+    files.push({ path: f.path, content: f.content, headerPlacement: 'skip', skipIfExists: true });
   }
 
   // Build model lookup for response field assertions
@@ -53,11 +56,33 @@ export function generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
       ? [...mountGroups].map(([name, group]) => ({ name, operations: group.operations }))
       : spec.services.map((s) => ({ name: resolveResourceClassName(s, ctx), operations: s.operations }));
 
+  // When integrating into an existing SDK, only generate tests for services
+  // that have a registered property on the WorkOS class.  The WorkOS client
+  // file uses skipIfExists, so new service properties aren't added — tests
+  // referencing workos.<service> would fail at compile time.
+  const baselineWorkOSProps = new Set<string>();
+  if (ctx.apiSurface?.classes?.['WorkOS']?.methods) {
+    // The extractor stores property accessors as methods
+    for (const name of Object.keys(ctx.apiSurface.classes['WorkOS'].methods)) {
+      baselineWorkOSProps.add(name);
+    }
+  }
+  if (ctx.apiSurface?.classes?.['WorkOS']?.properties) {
+    for (const name of Object.keys(ctx.apiSurface.classes['WorkOS'].properties)) {
+      baselineWorkOSProps.add(name);
+    }
+  }
+
   for (const { name: mountName, operations } of testEntries) {
     if (operations.length === 0) continue;
     const mergedService: Service = { name: mountName, operations };
     const ops = uncoveredOperations(mergedService, ctx);
     if (ops.length === 0) continue;
+
+    // Skip tests for services without a WorkOS property in the baseline
+    const propName = mountAccessors.get(mountName) ?? servicePropertyName(mountName);
+    if (ctx.apiSurface && baselineWorkOSProps.size > 0 && !baselineWorkOSProps.has(propName)) continue;
+
     const testService = ops.length < operations.length ? { ...mergedService, operations: ops } : mergedService;
     files.push(generateServiceTest(testService, spec, ctx, modelMap, mountAccessors));
   }
@@ -154,7 +179,7 @@ function generateServiceTest(
         // List fixtures are always generated in the current service's directory
         // (the service owning the list operation), not in the model's home service.
         // Always use a local import path.
-        const fixturePath = `./fixtures/list-${fileName(itemModelName)}.fixture.json`;
+        const fixturePath = `./fixtures/list-${fileName(itemModelName)}.json`;
         fixtureImports.add(`import list${itemModelName}Fixture from '${fixturePath}';`);
       }
     } else if (plan.responseModelName) {
@@ -162,8 +187,8 @@ function generateServiceTest(
       const respDir = resolveDir(respService);
       const fixturePath =
         respDir === serviceDir
-          ? `./fixtures/${fileName(plan.responseModelName)}.fixture.json`
-          : `../${respDir}/fixtures/${fileName(plan.responseModelName)}.fixture.json`;
+          ? `./fixtures/${fileName(plan.responseModelName)}.json`
+          : `../${respDir}/fixtures/${fileName(plan.responseModelName)}.json`;
       fixtureImports.add(`import ${toCamelCase(plan.responseModelName)}Fixture from '${fixturePath}';`);
     }
     // NOTE: Request body fixtures are not imported for body tests because
@@ -215,7 +240,7 @@ function generateServiceTest(
 
   lines.push('});');
 
-  return { path: testPath, content: lines.join('\n'), skipIfExists: true };
+  return { path: testPath, content: lines.join('\n'), overwriteExisting: true };
 }
 
 /** Compute the test value for a single path parameter.
@@ -751,9 +776,21 @@ function buildTestPayload(
   op: Operation,
   modelMap: Map<string, Model>,
 ): { camelCaseObj: string; snakeCaseObj: string } | null {
-  if (!op.requestBody || op.requestBody.kind !== 'model') return null;
-
-  const model = modelMap.get(op.requestBody.name);
+  if (!op.requestBody) return null;
+
+  // For discriminated unions, build a payload from the first variant so the
+  // generated test produces a value that satisfies the union type.  Without
+  // this, emitted tests pass `{} as any` for union bodies — fine for older
+  // permissive runtimes, but the dispatch switch now throws on unknown
+  // discriminator values, so the tests would fail before hitting fetch.
+  let model: Model | undefined;
+  if (op.requestBody.kind === 'union') {
+    const firstVariant = op.requestBody.variants.find((v) => v.kind === 'model');
+    if (!firstVariant || firstVariant.kind !== 'model') return null;
+    model = modelMap.get(firstVariant.name);
+  } else if (op.requestBody.kind === 'model') {
+    model = modelMap.get(op.requestBody.name);
+  }
   if (!model) return null;
 
   const fields = model.fields.filter((f) => f.required);
@@ -789,8 +826,14 @@ function buildTestPayload(
  * fall back to `{} as any` to bypass type checking for complex required fields.
  */
 function fallbackBodyArg(op: Operation, modelMap: Map<string, Model>): string {
-  if (!op.requestBody || op.requestBody.kind !== 'model') return '{} as any';
-  const model = modelMap.get(op.requestBody.name);
+  if (!op.requestBody) return '{} as any';
+  let model: Model | undefined;
+  if (op.requestBody.kind === 'union') {
+    const firstVariant = op.requestBody.variants.find((v) => v.kind === 'model');
+    if (firstVariant && firstVariant.kind === 'model') model = modelMap.get(firstVariant.name);
+  } else if (op.requestBody.kind === 'model') {
+    model = modelMap.get(op.requestBody.name);
+  }
   if (!model) return '{} as any';
   const hasRequiredFields = model.fields.some((f) => f.required);
   return hasRequiredFields ? '{} as any' : '{}';
@@ -821,12 +864,24 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
 
   // Only generate round-trip tests for models with fields that have serializers generated.
   // Skip list metadata and list wrapper models since their serializers are not emitted.
+  // Skip models unchanged from baseline (no new fields) since their serializers are not regenerated.
+  // Skip models unreachable from non-event services (no model/serializer files generated).
+  const nonEventReachable = computeNonEventReachable(spec.services, spec.models);
   const eligibleModels = spec.models.filter(
-    (m) => modelNeedsRoundTripTest(m) && !isListMetadataModel(m) && !isListWrapperModel(m),
+    (m) =>
+      nonEventReachable.has(m.name) &&
+      modelNeedsRoundTripTest(m) &&
+      !isListMetadataModel(m) &&
+      !isListWrapperModel(m) &&
+      modelHasNewFields(m, ctx),
   );
 
   if (eligibleModels.length === 0) return files;
 
+  // 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>();
+
   // Group eligible models by service directory for one test file per service
   const modelsByDir = new Map<string, Model[]>();
   for (const model of eligibleModels) {
@@ -844,6 +899,7 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
 
     // Collect imports
     const serializerImports: string[] = [];
+    const interfaceImports: string[] = [];
     const fixtureImports: string[] = [];
 
     for (const model of models) {
@@ -851,18 +907,30 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
       const service = modelToService.get(model.name);
       const modelDir = resolveDir(service);
       const serializerPath = `src/${modelDir}/serializers/${fileName(model.name)}.serializer.ts`;
-      const fixturePath = `src/${modelDir}/fixtures/${fileName(model.name)}.fixture.json`;
+      const interfacePath = `src/${modelDir}/interfaces/${fileName(model.name)}.interface.ts`;
+      const fixturePath = `src/${modelDir}/fixtures/${fileName(model.name)}.json`;
 
-      serializerImports.push(
-        `import { deserialize${domainName}, serialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`,
-      );
-      const camelName = domainName.charAt(0).toLowerCase() + domainName.slice(1);
+      if (serializeSkipped.has(model.name)) {
+        serializerImports.push(
+          `import { deserialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`,
+        );
+      } else {
+        serializerImports.push(
+          `import { deserialize${domainName}, serialize${domainName} } from '${relativeImport(testPath, serializerPath)}';`,
+        );
+      }
+      const wireName = wireInterfaceName(domainName);
+      interfaceImports.push(`import type { ${wireName} } from '${relativeImport(testPath, interfacePath)}';`);
+      const camelName = toCamelCase(domainName);
       fixtureImports.push(`import ${camelName}Fixture from '${relativeImport(testPath, fixturePath)}';`);
     }
 
     for (const imp of serializerImports) {
       lines.push(imp);
     }
+    for (const imp of interfaceImports) {
+      lines.push(imp);
+    }
     for (const imp of fixtureImports) {
       lines.push(imp);
     }
@@ -870,25 +938,36 @@ function generateSerializerTests(spec: ApiSpec, ctx: EmitterContext): GeneratedF
 
     for (const model of models) {
       const domainName = resolveInterfaceName(model.name, ctx);
-      const camelDomain = domainName.charAt(0).toLowerCase() + domainName.slice(1);
-      const fixtureName = `${camelDomain}Fixture`;
-
-      lines.push(`describe('${domainName}Serializer', () => {`);
-      lines.push("  it('round-trips through serialize/deserialize', () => {");
-      lines.push(`    const fixture = ${fixtureName};`);
-      lines.push(`    const deserialized = deserialize${domainName}(fixture);`);
-      lines.push(`    const reserialized = serialize${domainName}(deserialized);`);
-      lines.push('    expect(reserialized).toEqual(expect.objectContaining(fixture));');
-      lines.push('  });');
-      lines.push('});');
+      const fixtureName = `${toCamelCase(domainName)}Fixture`;
+      const wireName = wireInterfaceName(domainName);
+
+      if (serializeSkipped.has(model.name)) {
+        // Deserialize-only test (no serialize function available)
+        lines.push(`describe('${domainName}Serializer', () => {`);
+        lines.push("  it('deserializes correctly', () => {");
+        lines.push(`    const fixture = ${fixtureName} as ${wireName};`);
+        lines.push(`    const deserialized = deserialize${domainName}(fixture);`);
+        lines.push('    expect(deserialized).toBeDefined();');
+        lines.push('  });');
+        lines.push('});');
+      } else {
+        // Round-trip test
+        lines.push(`describe('${domainName}Serializer', () => {`);
+        lines.push("  it('round-trips through serialize/deserialize', () => {");
+        lines.push(`    const fixture = ${fixtureName} as ${wireName};`);
+        lines.push(`    const deserialized = deserialize${domainName}(fixture);`);
+        lines.push(`    const reserialized = serialize${domainName}(deserialized);`);
+        lines.push('    expect(reserialized).toEqual(expect.objectContaining(fixture));');
+        lines.push('  });');
+        lines.push('});');
+      }
       lines.push('');
     }
 
     files.push({
       path: testPath,
       content: lines.join('\n'),
-      skipIfExists: true,
-      integrateTarget: false,
+      overwriteExisting: true,
     });
   }
 

package/src/node/type-map.ts

@@ -3,7 +3,6 @@ import { mapTypeRef as irMapTypeRef } from '@workos/oagen';
 import { wireInterfaceName } from './naming.js';
 
 export interface MapTypeRefOpts {
-  stringDates?: boolean;
   /** Map from model name → default type args (e.g., `'<Record<string, unknown>>'`).
    *  When present, model refs for generic models get their defaults appended. */
   genericDefaults?: Map<string, string>;
@@ -13,16 +12,12 @@ export interface MapTypeRefOpts {
  * Map an IR TypeRef to a TypeScript domain type string.
  * Domain types use PascalCase model names (e.g., `Organization`).
  *
- * @param opts.stringDates - When true, map `date-time` to `string` instead of `Date`.
- *   Use this when integrating into an existing SDK that represents timestamps as
- *   ISO 8601 strings rather than Date objects.
  * @param opts.genericDefaults - When present, appends default type args to generic model refs.
  */
 export function mapTypeRef(ref: TypeRef, opts?: MapTypeRefOpts): string {
-  const primMapper = opts?.stringDates ? mapPrimitiveStringDates : mapPrimitive;
   const genericDefaults = opts?.genericDefaults;
   return irMapTypeRef<string>(ref, {
-    primitive: primMapper,
+    primitive: mapPrimitive,
     array: (_r, items) => `${parenthesizeUnion(items)}[]`,
     model: (r) => r.name + (genericDefaults?.get(r.name) ?? ''),
     enum: (r) => r.name,
@@ -74,31 +69,6 @@ function mapPrimitive(ref: PrimitiveType): string {
   }
 }
 
-/**
- * Map a primitive type using string representation for dates.
- * Used when the existing SDK represents timestamps as ISO 8601 strings.
- */
-function mapPrimitiveStringDates(ref: PrimitiveType): string {
-  if (ref.format) {
-    switch (ref.format) {
-      case 'int64':
-        return 'bigint';
-      // date-time intentionally falls through to the string case
-    }
-  }
-  switch (ref.type) {
-    case 'string':
-      return 'string';
-    case 'integer':
-    case 'number':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'unknown':
-      return 'any';
-  }
-}
-
 /**
  * Map an IR PrimitiveType to a TypeScript wire/JSON type string.
  * Wire types match JSON encoding: date-time stays string, int64 stays string/number.

package/src/node/utils.ts

@@ -1,4 +1,4 @@
-import type { Model, EmitterContext, Service, Operation } from '@workos/oagen';
+import type { Model, EmitterContext, Service, Operation, TypeRef } from '@workos/oagen';
 import { toPascalCase } from '@workos/oagen';
 export {
   collectModelRefs,
@@ -269,17 +269,31 @@ function modelFingerprint(model: Model): string {
  *
  * Returns a Map from duplicate model name → canonical model name.
  */
-export function buildDeduplicationMap(models: Model[], ctx?: EmitterContext): Map<string, string> {
+export function buildDeduplicationMap(
+  models: Model[],
+  ctx?: EmitterContext,
+  reachable?: Set<string>,
+): Map<string, string> {
   const dedup = new Map<string, string>();
 
   // Pass 1: structural fingerprint dedup (exact match)
+  // When a reachability set is provided, prefer reachable models as canonicals
+  // so that aliases always point to models that will actually be generated.
   const fingerprints = new Map<string, string>();
   for (const model of models) {
     if (model.fields.length === 0) continue;
     const fp = modelFingerprint(model);
     const existing = fingerprints.get(fp);
     if (existing) {
-      dedup.set(model.name, existing);
+      // If the existing canonical is unreachable but this model is reachable,
+      // swap: make this model the canonical and demote the old one to alias.
+      if (reachable && !reachable.has(existing) && reachable.has(model.name)) {
+        dedup.delete(existing); // remove stale alias if present
+        dedup.set(existing, model.name);
+        fingerprints.set(fp, model.name);
+      } else {
+        dedup.set(model.name, existing);
+      }
     } else {
       fingerprints.set(fp, model.name);
     }
@@ -287,7 +301,8 @@ export function buildDeduplicationMap(models: Model[], ctx?: EmitterContext): Ma
 
   // Pass 2: name-based dedup for models that resolve to the same interface
   // name across services.  Only applies when context with name resolution is
-  // available.  Picks the model with the most fields as canonical.
+  // available.  Picks the model with the most fields as canonical, preferring
+  // reachable models when a reachability set is provided.
   if (ctx) {
     const byDomainName = new Map<string, Model[]>();
     for (const model of models) {
@@ -303,8 +318,15 @@ export function buildDeduplicationMap(models: Model[], ctx?: EmitterContext): Ma
     }
     for (const [, group] of byDomainName) {
       if (group.length < 2) continue;
-      // Choose canonical: most fields, then alphabetically by name
-      group.sort((a, b) => b.fields.length - a.fields.length || a.name.localeCompare(b.name));
+      // Choose canonical: prefer reachable, then most fields, then alphabetically
+      group.sort((a, b) => {
+        if (reachable) {
+          const aReach = reachable.has(a.name) ? 0 : 1;
+          const bReach = reachable.has(b.name) ? 0 : 1;
+          if (aReach !== bReach) return aReach - bReach;
+        }
+        return b.fields.length - a.fields.length || a.name.localeCompare(b.name);
+      });
       const canonical = group[0];
       for (let i = 1; i < group.length; i++) {
         dedup.set(group[i].name, canonical.name);
@@ -397,6 +419,26 @@ export function hasMethodsAbsentFromBaseline(service: Service, ctx: EmitterConte
   return false;
 }
 
+/**
+ * Check whether an IR model has fields not present in the baseline interface.
+ * Returns true if the model has new fields that need generation.
+ * Returns true if no baseline exists (new model entirely).
+ */
+export function modelHasNewFields(model: Model, ctx: EmitterContext): boolean {
+  if (!ctx.apiSurface?.interfaces) return true; // No surface = generate everything
+
+  const domainName = resolveInterfaceName(model.name, ctx);
+  const baseline = ctx.apiSurface.interfaces[domainName];
+  if (!baseline?.fields) return true; // No baseline for this model = new model
+
+  for (const field of model.fields) {
+    const camelName = fieldName(field.name);
+    if (!baseline.fields[camelName]) return true; // New field found
+  }
+
+  return false; // All fields exist in baseline
+}
+
 /**
  * Return operations in a service that are NOT covered by existing hand-written
  * service classes. For fully uncovered services, returns all operations.
@@ -417,3 +459,51 @@ export function uncoveredOperations(service: Service, ctx: EmitterContext): Oper
     return !existingClassNames.has(match.className); // Class doesn't exist → uncovered
   });
 }
+
+/**
+ * Compute the set of model names reachable from non-event service operations.
+ * The Events service pulls in hundreds of webhook payload models that the
+ * existing SDK handles via hand-written event types, so those models are
+ * excluded from generation.
+ *
+ * Shared between model generation, barrel generation, dedup, and tests to
+ * ensure consistency: every module agrees on which models will be generated.
+ */
+export function computeNonEventReachable(services: Service[], models: Model[]): Set<string> {
+  const seeds = new Set<string>();
+  for (const svc of services) {
+    if (svc.name.toLowerCase() === 'events') continue;
+    for (const op of svc.operations) {
+      const collectFromRef = (t: TypeRef | undefined): void => {
+        if (!t) return;
+        if (t.kind === 'model') seeds.add(t.name);
+        if (t.kind === 'array') collectFromRef(t.items);
+        if (t.kind === 'nullable') collectFromRef(t.inner);
+        if (t.kind === 'union') t.variants.forEach(collectFromRef);
+      };
+      collectFromRef(op.response);
+      collectFromRef(op.requestBody);
+      if (op.pagination?.itemType) collectFromRef(op.pagination.itemType);
+    }
+  }
+  const modelMap = new Map(models.map((m) => [m.name, m]));
+  const reachable = new Set<string>();
+  const queue = [...seeds];
+  while (queue.length > 0) {
+    const name = queue.pop()!;
+    if (reachable.has(name)) continue;
+    reachable.add(name);
+    const m = modelMap.get(name);
+    if (!m) continue;
+    for (const field of m.fields) {
+      const walk = (t: TypeRef): void => {
+        if (t.kind === 'model' && !reachable.has(t.name)) queue.push(t.name);
+        if (t.kind === 'array') walk(t.items);
+        if (t.kind === 'nullable') walk(t.inner);
+        if (t.kind === 'union') t.variants.forEach(walk);
+      };
+      walk(field.type);
+    }
+  }
+  return reachable;
+}

package/src/node/wrappers.ts

@@ -77,7 +77,37 @@ function emitWrapperMethod(
   const returnType = responseTypeName ?? 'void';
 
   // JSDoc
-  lines.push(`  /** ${formatWrapperDescription(wrapper.name)}. */`);
+  const docParts: string[] = [];
+  docParts.push(formatWrapperDescription(wrapper.name) + '.');
+
+  for (const p of op.pathParams) {
+    if (p.description) {
+      docParts.push(`@param ${fieldName(p.name)} - ${p.description}`);
+    }
+  }
+
+  for (const { paramName, field } of wrapperParams) {
+    const tsName = fieldName(paramName);
+    if (field?.description) {
+      docParts.push(`@param ${tsName} - ${field.description}`);
+    }
+  }
+
+  if (responseTypeName) {
+    docParts.push(`@returns {Promise<${returnType}>}`);
+  }
+
+  if (docParts.length === 1) {
+    lines.push(`  /** ${docParts[0]} */`);
+  } else {
+    lines.push('  /**');
+    for (const part of docParts) {
+      for (const line of part.split('\n')) {
+        lines.push(line === '' ? '   *' : `   * ${line}`);
+      }
+    }
+    lines.push('   */');
+  }
 
   // Method signature
   lines.push(`  async ${method}(${paramParts.join(', ')}): Promise<${returnType}> {`);

package/src/php/client.ts

@@ -127,10 +127,13 @@ function generateMainClient(
   for (const svc of services) {
     lines.push(`    private ?Service\\${svc.name} $${svc.propName} = null;`);
   }
-  // Non-spec service properties (hand-maintained modules)
+  // Non-spec service properties — wrapped in ignore markers so the target
+  // SDK can hand-maintain the list. The emitter provides a positional anchor.
+  lines.push('    // @oagen-ignore-start — non-spec service properties (hand-maintained)');
   for (const a of nonSpecAccessors) {
     lines.push(`    private ?${a.className} $${a.propName} = null;`);
   }
+  lines.push('    // @oagen-ignore-end');
 
   lines.push('');
   lines.push('    public function __construct(');
@@ -140,11 +143,12 @@ function generateMainClient(
   lines.push('        int $timeout = 60,');
   lines.push('        int $maxRetries = 3,');
   lines.push('        ?\\GuzzleHttp\\HandlerStack $handler = null,');
+  lines.push('        ?string $userAgent = null,');
   lines.push('    ) {');
   lines.push("        $apiKey ??= getenv('WORKOS_API_KEY') ?: self::$apiKey ?? '';");
   lines.push("        $clientId ??= getenv('WORKOS_CLIENT_ID') ?: self::$clientId;");
   lines.push(
-    '        $this->httpClient = new HttpClient($apiKey, $clientId, $baseUrl, $timeout, $maxRetries, $handler);',
+    '        $this->httpClient = new HttpClient($apiKey, $clientId, $baseUrl, $timeout, $maxRetries, $handler, $userAgent);',
   );
   lines.push('    }');
 
@@ -157,7 +161,10 @@ function generateMainClient(
     lines.push('    }');
   }
 
-  // Non-spec service accessors (hand-maintained modules)
+  // Non-spec service accessors — wrapped in ignore markers so the target
+  // SDK can hand-maintain these. The emitter provides a positional anchor.
+  lines.push('');
+  lines.push('    // @oagen-ignore-start — non-spec service accessors (hand-maintained)');
   for (const a of nonSpecAccessors) {
     lines.push('');
     lines.push(`    public function ${a.propName}(): ${a.className}`);
@@ -165,6 +172,7 @@ function generateMainClient(
     lines.push(`        return $this->${a.propName} ??= new ${a.className}($this->httpClient);`);
     lines.push('    }');
   }
+  lines.push('    // @oagen-ignore-end');
 
   lines.push('}');
   return lines.join('\n');

package/src/php/models.ts

@@ -13,30 +13,6 @@ export { isListMetadataModel, isListWrapperModel };
 export function generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
   if (models.length === 0) return [];
 
-  // Build structural hash for deduplication
-  const modelHashMap = new Map<string, string>();
-  const hashGroups = new Map<string, string[]>();
-  for (const model of models) {
-    if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
-    const hash = structuralHash(model);
-    modelHashMap.set(model.name, hash);
-    if (!hashGroups.has(hash)) hashGroups.set(hash, []);
-    hashGroups.get(hash)!.push(model.name);
-  }
-
-  // Pick canonical for each duplicate group (shortest class name wins)
-  const aliasOf = new Map<string, string>();
-  for (const [hash, names] of hashGroups) {
-    if (names.length <= 1) continue;
-    if (hash === '') continue;
-    const sorted = [...names].sort((a, b) => className(a).length - className(b).length);
-    const canonical = sorted[0];
-    for (let i = 1; i < sorted.length; i++) {
-      aliasOf.set(sorted[i], canonical);
-    }
-  }
-
   const files: GeneratedFile[] = [];
 
   // Emit shared JsonSerializableTrait once
@@ -59,8 +35,6 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   for (const model of models) {
     if (isListMetadataModel(model)) continue;
     if (isListWrapperModel(model)) continue;
-    if (aliasOf.has(model.name)) continue; // skip structural duplicates
-
     const name = className(model.name);
     const lines: string[] = [];
 
@@ -301,10 +275,3 @@ function needsVarAnnotation(ref: TypeRef): boolean {
       return false;
   }
 }
-
-function structuralHash(model: Model): string {
-  return model.fields
-    .map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`)
-    .sort()
-    .join('|');
-}

package/src/php/naming.ts

@@ -1,7 +1,7 @@
 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 } from '../shared/naming-utils.js';
+import { stripUrnPrefix, applyAcronymFixes } from '../shared/naming-utils.js';
 
 /** Namespace grouping result (shared with client.ts). */
 export interface NamespaceGroup {
@@ -16,22 +16,6 @@ export interface NamespaceGrouping {
   namespaces: NamespaceGroup[];
 }
 
-/**
- * Map of lowercase acronym forms to their correct casing.
- */
-const ACRONYM_FIXES: [RegExp, string][] = [
-  [/Workos/g, 'WorkOS'],
-  [/Sso/g, 'SSO'],
-  [/Mfa/g, 'MFA'],
-  [/Jwt/g, 'JWT'],
-  [/Cors/g, 'CORS'],
-  [/Saml/g, 'SAML'],
-  [/Scim/g, 'SCIM'],
-  [/Rbac/g, 'RBAC'],
-  [/Oauth/g, 'OAuth'],
-  [/Oidc/g, 'OIDC'],
-];
-
 /**
  * PHP reserved class names that would collide with builtins.
  */
@@ -99,10 +83,7 @@ export function enumClassName(name: string): string {
 
 /** PascalCase class name with acronym preservation. */
 export function className(name: string): string {
-  let result = toPascalCase(stripUrnPrefix(name));
-  for (const [pattern, replacement] of ACRONYM_FIXES) {
-    result = result.replace(pattern, replacement);
-  }
+  let result = applyAcronymFixes(toPascalCase(stripUrnPrefix(name)));
   if (PHP_RESERVED_CLASS_NAMES.has(result)) {
     result += 'Model';
   }