@workos/oagen-emitters 0.7.5 → 0.8.1

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -54,6 +54,6 @@
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.16.0"
+    "@workos/oagen": "^0.17.0"
   }
 }

package/src/dotnet/index.ts

@@ -20,7 +20,7 @@ import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { generateWrapperOptionsClasses } from './wrappers.js';
 import { groupByMount } from '../shared/resolved-ops.js';
-import { discriminatedUnions } from './type-map.js';
+import { discriminatedUnions, resolveModelName } from './type-map.js';
 import { modelClassName } from './naming.js';
 
 /**
@@ -133,8 +133,11 @@ export const dotnetEmitter: Emitter = {
         lines.push('    {');
         lines.push('        public override bool CanConvert(Type objectType) => objectType == typeof(object);');
         lines.push('');
+        // Override returns `object?` to match Newtonsoft.Json 13+'s nullable
+        // signature; `JToken.ToObject<T>` is itself `T?`, so a non-nullable
+        // override would trigger CS8603 under <Nullable>enable</Nullable>.
         lines.push(
-          '        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object? existingValue, Newtonsoft.Json.JsonSerializer serializer)',
+          '        public override object? ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object? existingValue, Newtonsoft.Json.JsonSerializer serializer)',
         );
         lines.push('        {');
         lines.push('            var jObject = JObject.Load(reader);');
@@ -142,7 +145,7 @@ export const dotnetEmitter: Emitter = {
         lines.push('            switch (discriminatorValue)');
         lines.push('            {');
         for (const [value, modelName] of Object.entries(disc.mapping)) {
-          const csName = modelClassName(modelName);
+          const csName = modelClassName(resolveModelName(modelName));
           lines.push(`                case "${value}": return jObject.ToObject<${csName}>(serializer);`);
         }
         lines.push('                default: return jObject.ToObject<object>(serializer);');
@@ -194,8 +197,9 @@ export const dotnetEmitter: Emitter = {
         `        public override bool CanConvert(Type objectType) => typeof(${baseClass}).IsAssignableFrom(objectType);`,
       );
       lines.push('');
+      // See first converter — `object?` matches Newtonsoft 13+ to avoid CS8603.
       lines.push(
-        '        public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object? existingValue, Newtonsoft.Json.JsonSerializer serializer)',
+        '        public override object? ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object? existingValue, Newtonsoft.Json.JsonSerializer serializer)',
       );
       lines.push('        {');
       lines.push('            var jObject = JObject.Load(reader);');

package/src/dotnet/models.ts

@@ -1,4 +1,5 @@
-import type { Model, EmitterContext, GeneratedFile, TypeRef } from '@workos/oagen';
+import type { Model, EmitterContext, GeneratedFile, TypeRef, Service } from '@workos/oagen';
+import { walkTypeRef } from '@workos/oagen';
 import {
   mapTypeRef,
   isValueTypeRef,
@@ -6,6 +7,7 @@ import {
   emitJsonPropertyAttributes,
   setModelAliases,
   isModelAlias,
+  resolveModelName,
 } from './type-map.js';
 import {
   articleFor,
@@ -56,8 +58,23 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
   const files: GeneratedFile[] = [];
 
   // Compute and publish model aliases so mapTypeRef rewrites references.
+  // Must run BEFORE collectRequestBodyOnlyModelNames so the body/non-body
+  // tally collapses aliased pairs onto their canonical name — otherwise a
+  // model that's only a request body in name (e.g. `AddRolePermissionDto`)
+  // but is the canonical for a field-referenced alias (e.g. `SlimRole`)
+  // would be wrongly classified as body-only and skipped from emission,
+  // leaving every alias-rewritten field reference dangling.
   primeModelAliases(models);
 
+  // Models that are referenced ONLY as an operation request body (not by any
+  // response, field, or other operation type) are dead surface in .NET because
+  // the wrapper generator emits a per-operation `*Options` class containing
+  // the same fields. The method signature consumes the Options class — the
+  // named entity is never instantiated by callers and just clutters the SDK
+  // (see workos-dotnet#248 with `CreateUserApiKey` /
+  // `UserManagementCreateApiKeyOptions`). Skip emission for those.
+  const requestBodyOnlyNames = collectRequestBodyOnlyModelNames(ctx.spec.services, models);
+
   // Build a lookup of base model field C# names → C# types for inheritance.
   // Variant models skip inherited fields and use `new` for type-divergent ones.
   const baseFieldLookup = new Map<string, Map<string, string>>();
@@ -75,6 +92,7 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
 
   for (const model of models) {
     if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (requestBodyOnlyNames.has(model.name)) continue;
 
     const csClassName = modelClassName(model.name);
 
@@ -217,6 +235,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
 
       const isRequiredEnum = field.required && isEnumRef(field.type) && constInit === null;
       lines.push(...emitJsonPropertyAttributes(field.name, { isRequiredEnum }));
+      // Discriminated-union-typed field: attach the variant-dispatching converter
+      // so Newtonsoft picks the right subtype on deserialization. The converter
+      // name is keyed off the first IR variant model name (matches how
+      // `joinUnionVariants` registered it in `discriminatedUnions`).
+      const discriminatedUnionConverter = discriminatedUnionConverterName(field.type);
+      if (discriminatedUnionConverter) {
+        lines.push(`        [Newtonsoft.Json.JsonConverter(typeof(${discriminatedUnionConverter}))]`);
+      }
       const newMod = useNewModifier ? 'new ' : '';
       lines.push(`        public ${newMod}${csType} ${csFieldName} { get; ${setterModifier}set; }${initializer}`);
 
@@ -289,6 +315,24 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
   return files;
 }
 
+/**
+ * Compute the name of the discriminator converter class for a field whose
+ * type is a discriminated union, mirroring the keying used in
+ * `joinUnionVariants` (first IR model variant name + "DiscriminatorConverter").
+ * Returns null when the type isn't a discriminated union with a populated
+ * mapping. Also walks through `nullable` so an optional discriminated field
+ * still gets the converter applied.
+ */
+function discriminatedUnionConverterName(ref: TypeRef): string | null {
+  const inner = ref.kind === 'nullable' ? ref.inner : ref;
+  if (inner.kind !== 'union') return null;
+  if (!inner.discriminator || !inner.discriminator.mapping) return null;
+  if (Object.keys(inner.discriminator.mapping).length === 0) return null;
+  const firstModel = inner.variants.find((v) => v.kind === 'model');
+  if (!firstModel || firstModel.kind !== 'model') return null;
+  return `${modelClassName(firstModel.name)}DiscriminatorConverter`;
+}
+
 /**
  * Whether the emitted C# type is `Dictionary<string, object>` or its
  * nullable variant — the usual shape of metadata / additional-properties
@@ -403,3 +447,59 @@ function structuralHash(model: Model, aliasOf: Map<string, string> = new Map()):
     .sort()
     .join('|');
 }
+
+/**
+ * Names of models referenced **only** as a named operation request body —
+ * i.e. never appearing in a response, an error, a paginated item type, or as
+ * a field type on another model. The .NET wrapper generator emits a
+ * per-operation `*Options` class containing the same fields, so the named
+ * entity is never instantiated by callers and just clutters the SDK
+ * (workos-dotnet#248: `CreateUserApiKey` vs `UserManagementCreateApiKeyOptions`).
+ */
+function collectRequestBodyOnlyModelNames(services: Service[], models: Model[]): Set<string> {
+  const requestBodyNames = new Set<string>();
+  const otherReferences = new Set<string>();
+
+  // Resolve every reference through the alias map so structurally-identical
+  // models share a body/non-body classification. Without this, an alias being
+  // used as a field would only mark the alias name as non-body — leaving its
+  // canonical (which carries the same shape and gets emitted) wrongly tagged
+  // as body-only and skipped.
+  const collect = (ref: TypeRef | undefined, into: Set<string>): void => {
+    if (!ref) return;
+    walkTypeRef(ref, {
+      model: (r) => into.add(resolveModelName(r.name)),
+    });
+  };
+
+  for (const service of services) {
+    for (const op of service.operations) {
+      if (op.requestBody?.kind === 'model') {
+        requestBodyNames.add(resolveModelName(op.requestBody.name));
+      }
+      collect(op.response, otherReferences);
+      if (op.pagination) collect(op.pagination.itemType, otherReferences);
+      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
+        collect(p.type, otherReferences);
+      }
+      if (op.successResponses) {
+        for (const sr of op.successResponses) collect(sr.type, otherReferences);
+      }
+      for (const err of op.errors) {
+        if (err.type) collect(err.type, otherReferences);
+      }
+    }
+  }
+
+  for (const model of models) {
+    for (const field of model.fields) {
+      collect(field.type, otherReferences);
+    }
+  }
+
+  const result = new Set<string>();
+  for (const name of requestBodyNames) {
+    if (!otherReferences.has(name)) result.add(name);
+  }
+  return result;
+}

package/src/dotnet/type-map.ts

@@ -200,11 +200,18 @@ function joinUnionVariants(_ref: UnionType, variants: string[]): string {
     return variants[0] ?? 'object';
   }
   const unique = [...new Set(variants)];
-  if (unique.length === 1) return unique[0];
 
-  // Discriminated union: register for converter generation and return first variant as base
+  // Discriminated union: register for converter generation BEFORE collapsing
+  // single-unique to avoid losing the discriminator when all variants alias
+  // to the same canonical model (structural dedup). The base type used for
+  // the converter name comes from the discriminator's IR variant names so
+  // it stays stable even when the C# class names get rewritten by aliases.
   if (_ref.discriminator && _ref.discriminator.mapping) {
-    const baseName = unique[0];
+    const irVariantNames = _ref.variants
+      .filter((v) => v.kind === 'model')
+      .map((v) => (v.kind === 'model' ? v.name : ''))
+      .filter(Boolean);
+    const baseName = irVariantNames[0] ?? unique[0];
     discriminatedUnions.set(baseName, {
       property: _ref.discriminator.property,
       mapping: _ref.discriminator.mapping,
@@ -215,6 +222,8 @@ function joinUnionVariants(_ref: UnionType, variants: string[]): string {
     return 'object';
   }
 
+  if (unique.length === 1) return unique[0];
+
   if (unique.length >= 2 && unique.length <= 9) return `OneOf.OneOf<${unique.join(', ')}>`;
   // OneOf supports arity 2-9. Higher-arity unions collapse to `object`,
   // losing type information. Warn so the author knows the spec outgrew the

package/src/go/fixtures.ts

@@ -46,7 +46,12 @@ export function generateFixtures(spec: { models: Model[]; enums: Enum[]; service
     });
   }
 
-  // Generate list fixtures for paginated responses
+  // Generate list fixtures for paginated responses. Multiple operations may
+  // share the same item model (e.g. several role-assignment list endpoints all
+  // returning UserRoleAssignmentList) — emit each fixture path once so the
+  // content-dedup pass below doesn't see N copies of the same path and drop
+  // the file entirely.
+  const seenListPaths = new Set<string>();
   for (const service of spec.services) {
     for (const op of service.operations) {
       if (op.pagination) {
@@ -55,6 +60,9 @@ export function generateFixtures(spec: { models: Model[]; enums: Enum[]; service
           const unwrapped = unwrapListModel(itemModel, modelMap);
           if (unwrapped) itemModel = unwrapped;
           if (itemModel.fields.length === 0) continue;
+          const path = `testdata/list_${fileName(itemModel.name)}.json`;
+          if (seenListPaths.has(path)) continue;
+          seenListPaths.add(path);
           const fixture = generateModelFixture(itemModel, modelMap, enumMap);
           const listFixture = {
             data: [fixture],
@@ -64,7 +72,7 @@ export function generateFixtures(spec: { models: Model[]; enums: Enum[]; service
             },
           };
           files.push({
-            path: `testdata/list_${fileName(itemModel.name)}.json`,
+            path,
             content: JSON.stringify(listFixture, null, 2),
           });
         }

package/src/go/models.ts

@@ -1,4 +1,5 @@
-import type { Model, EmitterContext, GeneratedFile } from '@workos/oagen';
+import type { Model, EmitterContext, GeneratedFile, TypeRef, Service } from '@workos/oagen';
+import { walkTypeRef } from '@workos/oagen';
 import { mapTypeRef } from './type-map.js';
 import { className, fieldName } from './naming.js';
 import { lowerFirstForDoc, fieldDocComment, articleFor } from '../shared/naming-utils.js';
@@ -7,6 +8,67 @@ import { lowerFirstForDoc, fieldDocComment, articleFor } from '../shared/naming-
 import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
 export { isListWrapperModel, isListMetadataModel };
 
+/**
+ * Collect names of models that are referenced **only** as a named request body
+ * model on an operation, with no other consumers (response types, pagination
+ * item types, error types, or fields on other models).
+ *
+ * The Go emitter synthesizes a `{Service}{Method}Params` struct from those
+ * request bodies (see `resources.ts:392`), and the method signature uses the
+ * synthesized struct — never the named model. So emitting the named model in
+ * `models.go` would leave callers with a duplicate, unused struct (the bug
+ * surfaced in workos-go#544 with `CreateUserAPIKey` /
+ * `UserManagementCreateAPIKeyParams`).
+ *
+ * Models in this set are skipped during model emission. Callers parameterize
+ * the API surface through `*Params` exclusively, which is the sole consumer
+ * of the spec's named request body schema.
+ */
+function collectRequestBodyOnlyModelNames(services: Service[], models: Model[]): Set<string> {
+  const requestBodyNames = new Set<string>();
+  const otherReferences = new Set<string>();
+
+  const collect = (ref: TypeRef | undefined, into: Set<string>): void => {
+    if (!ref) return;
+    walkTypeRef(ref, {
+      model: (r) => into.add(r.name),
+    });
+  };
+
+  for (const service of services) {
+    for (const op of service.operations) {
+      if (op.requestBody?.kind === 'model') {
+        requestBodyNames.add(op.requestBody.name);
+      }
+      collect(op.response, otherReferences);
+      if (op.pagination) collect(op.pagination.itemType, otherReferences);
+      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams, ...(op.cookieParams ?? [])]) {
+        collect(p.type, otherReferences);
+      }
+      if (op.successResponses) {
+        for (const sr of op.successResponses) collect(sr.type, otherReferences);
+      }
+      for (const err of op.errors) {
+        if (err.type) collect(err.type, otherReferences);
+      }
+    }
+  }
+
+  // Field references — a request body model that's also a field type elsewhere
+  // is a reusable schema (e.g. consumed by webhook event data), so we keep it.
+  for (const model of models) {
+    for (const field of model.fields) {
+      collect(field.type, otherReferences);
+    }
+  }
+
+  const result = new Set<string>();
+  for (const name of requestBodyNames) {
+    if (!otherReferences.has(name)) result.add(name);
+  }
+  return result;
+}
+
 /**
  * Generate Go struct definitions from IR Models.
  * All models go into a single models.go file for the flat package.
@@ -20,11 +82,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   lines.push(`package ${ctx.namespace}`);
   lines.push('');
 
+  const requestBodyOnly = collectRequestBodyOnlyModelNames(ctx.spec.services, models);
+
   // Build structural hash for deduplication
   const modelHashMap = new Map<string, string>();
   const hashGroups = new Map<string, string[]>();
   for (const model of models) {
     if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (requestBodyOnly.has(model.name)) continue;
     const hash = structuralHash(model);
     modelHashMap.set(model.name, hash);
     if (!hashGroups.has(hash)) hashGroups.set(hash, []);
@@ -48,6 +113,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   const batchedAliases = new Set<string>();
   for (const model of models) {
     if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (requestBodyOnly.has(model.name)) continue;
 
     const structName = className(model.name);
 

package/src/go/resources.ts

@@ -410,9 +410,11 @@ function generateParamsStruct(
         const isOptional = !field.required;
         const goType = isOptional ? makeOptional(mapTypeRef(field.type)) : mapTypeRef(field.type);
         const jsonTag = field.required ? `json:"${field.name}"` : `json:"${field.name},omitempty"`;
-        // If this field also appears in query params, emit a url tag too
-        const isAlsoQueryParam = op.queryParams.some((qp) => !hidden.has(qp.name) && fieldName(qp.name) === goField);
-        const urlTag = isAlsoQueryParam ? ` url:"${field.name}${field.required ? '' : ',omitempty'}"` : '';
+        // Body fields are JSON-marshaled into the request body. Emit `url:"-"`
+        // so go-querystring's default field-name fallback doesn't also place
+        // them in the URL — important when the spec duplicates a field as both
+        // body and query param (e.g. /sso/token's `code`).
+        const urlTag = ' url:"-"';
         if (field.description) {
           const fdLines = field.description.split('\n').filter((l) => l.trim());
           lines.push(`\t// ${fieldDocComment(goField, fdLines[0])}`);

package/src/go/type-map.ts

@@ -82,6 +82,29 @@ function joinUnionVariants(_ref: UnionType, variants: string[]): string {
   }
   const unique = [...new Set(variants)];
   if (unique.length === 1) return unique[0];
-  // Go doesn't have union types; use interface{}
+  // Discriminated unions: Go has no sum types, so widen to the discriminator-
+  // resolver type when one is registered downstream (see resolveDiscriminatedUnionType).
+  // Fall back to interface{} for non-discriminated heterogeneous unions.
+  if (_ref.discriminator && _ref.discriminator.mapping) {
+    const resolverName = unionResolverName(_ref);
+    if (resolverName) return resolverName;
+  }
   return 'interface{}';
 }
+
+/**
+ * Pick a stable type name for a discriminated union's runtime resolver. Today
+ * we emit no resolver struct, so we treat the union's first model variant as
+ * the public type — matching the pre-discriminator behavior where Go just
+ * referenced one variant directly. The Owner field stays typed, callers
+ * can still inspect Type to detect the user variant (data loss on
+ * non-overlapping fields like organization_id is documented in the SDK
+ * compat report rather than fixed in the emitter — Go callers who need the
+ * user-only fields can json.Unmarshal the raw payload manually).
+ */
+function unionResolverName(ref: UnionType): string | null {
+  for (const v of ref.variants) {
+    if (v.kind === 'model') return `*${className(v.name)}`;
+  }
+  return null;
+}

package/src/kotlin/type-map.ts

@@ -95,10 +95,17 @@ function joinUnionVariants(ref: UnionType, variants: string[]): string {
     return variants[0] ?? 'Any';
   }
   const unique = [...new Set(variants)];
-  if (unique.length === 1) return unique[0];
 
+  // Register discriminated unions BEFORE the single-unique collapse so we
+  // don't lose the dispatcher when every variant aliases to the same canonical
+  // type. The base type used at the call site is the IR variant name, which
+  // matches how the dispatcher infrastructure looks up registered unions.
   if (ref.discriminator && ref.discriminator.mapping) {
-    const baseName = unique[0];
+    const irVariantNames = ref.variants
+      .filter((v) => v.kind === 'model')
+      .map((v) => (v.kind === 'model' ? v.name : ''))
+      .filter(Boolean);
+    const baseName = irVariantNames[0] ?? unique[0];
     discriminatedUnions.set(baseName, {
       property: ref.discriminator.property,
       mapping: ref.discriminator.mapping,
@@ -108,6 +115,8 @@ function joinUnionVariants(ref: UnionType, variants: string[]): string {
     return baseName;
   }
 
+  if (unique.length === 1) return unique[0];
+
   // Non-discriminated unions fall back to the Kotlin top type. A generic
   // AnyOf<> is planned for a future phase if emitter tests prove it necessary.
   return 'Any';

package/src/php/models.ts

@@ -220,6 +220,18 @@ function generateFromArrayValue(ref: TypeRef, accessor: string): string {
     case 'nullable':
       return generateFromArrayValue(ref.inner, accessor);
     case 'union': {
+      // Discriminated union: dispatch via match() on the discriminator
+      // property to call the matching variant's fromArray. Unknown values
+      // pass through as raw arrays so callers can introspect.
+      if (ref.discriminator && ref.discriminator.mapping) {
+        const entries = Object.entries(ref.discriminator.mapping);
+        if (entries.length > 0) {
+          const arms = entries
+            .map(([value, modelName]) => `'${value}' => ${className(modelName)}::fromArray(${accessor})`)
+            .join(', ');
+          return `match (${accessor}['${ref.discriminator.property}'] ?? null) { ${arms}, default => ${accessor} }`;
+        }
+      }
       const resolved = resolveDegenerateUnion(ref);
       if (resolved) return generateFromArrayValue(resolved, accessor);
       return accessor;

package/src/python/client.ts

@@ -286,12 +286,10 @@ function generateServiceInits(spec: ApiSpec, ctx: EmitterContext): GeneratedFile
       overwriteExisting: true,
     });
 
-    // Ensure models/__init__.py exists even if no models are assigned to this service
-    files.push({
-      path: `src/${ctx.namespace}/${dirName}/models/__init__.py`,
-      content: '',
-      skipIfExists: true,
-    });
+    // models/__init__.py is emitted unconditionally by `models.ts` — including
+    // an empty barrel for services with no models — so we don't need a safety
+    // net here. (A `skipIfExists` safety net previously caused stale imports
+    // to survive when the underlying module was pruned.)
   }
 
   return files;

package/src/python/models.ts

@@ -447,6 +447,24 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     serviceDirModelPaths.add(`src/${ctx.namespace}/${dirName}/models`);
   }
 
+  // Emit an empty barrel for every service-models dir that has no symbols of
+  // its own (e.g. a service whose models live in another package via
+  // cross-domain aliases). Otherwise the live SDK can keep a stale
+  // `__init__.py` from a previous spec revision — when the underlying module
+  // gets pruned the dangling re-export survives and breaks pyright. Done here
+  // (not in client.ts) so a subsequent emission for the same path with real
+  // content always wins last-write-wins.
+  for (const dirPath of serviceDirModelPaths) {
+    if (!symbolsByDir.has(dirPath)) {
+      files.push({
+        path: `${dirPath}/__init__.py`,
+        content: '',
+        integrateTarget: true,
+        overwriteExisting: true,
+      });
+    }
+  }
+
   for (const [dirPath, names] of symbolsByDir) {
     // Use `import X as X` syntax for explicit re-exports (required by pyright strict)
     const uniqueNames = [...new Set(names)].sort();
@@ -709,7 +727,27 @@ function deserializeField(ref: any, accessor: string, isRequired: boolean, walru
       return deserializeField(ref.inner, accessor, false, walrusVar);
     case 'union': {
       const modelVariants = (ref.variants ?? []).filter((v: any) => v.kind === 'model');
-      const uniqueModels = [...new Set(modelVariants.map((v: any) => v.name))];
+      const uniqueModels = [...new Set(modelVariants.map((v: any) => v.name))] as string[];
+      // Discriminated union: dispatch on the discriminator property to call
+      // the matching variant's from_dict. Unknown discriminator values fall
+      // back to the raw payload so callers can introspect.
+      if (ref.discriminator && ref.discriminator.mapping) {
+        const entries = Object.entries(ref.discriminator.mapping as Record<string, string>);
+        if (entries.length > 0) {
+          const dispatchMap = entries.map(([value, modelName]) => `"${value}": ${className(modelName)}`).join(', ');
+          const dataExpr = isRequired ? accessor : walrusVar;
+          const dataCast = `cast(Dict[str, Any], ${dataExpr})`;
+          // The dispatch dict has `str` keys, so pyright (strict) rejects the
+          // raw `Any | None` returned by `.get(prop)` even though `dict.get`
+          // accepts any hashable. Cast through `str` to satisfy the parameter
+          // type — runtime semantics are unchanged because a missing/`None`
+          // discriminator simply misses the dispatch and falls through.
+          const lookupExpr = `{${dispatchMap}}.get(cast(str, ${dataCast}.get("${ref.discriminator.property}")))`;
+          const branch = `(_disc.from_dict(${dataCast}) if (_disc := ${lookupExpr}) is not None else ${dataExpr})`;
+          if (isRequired) return branch;
+          return `(${branch}) if (${walrusVar} := ${accessor}) is not None else None`;
+        }
+      }
       if (uniqueModels.length === 1) {
         return deserializeField({ kind: 'model', name: uniqueModels[0] }, accessor, isRequired, walrusVar);
       }
@@ -745,6 +783,12 @@ function serializeField(ref: any, accessor: string): string {
       if (uniqueModels.length === 1) {
         return `${accessor}.to_dict()`;
       }
+      // Discriminated union: deserialize produced a dataclass instance for
+      // known discriminator values and the raw dict for unknowns. Round-trip
+      // both — call `.to_dict()` if it exists, otherwise pass through.
+      if (ref.discriminator && ref.discriminator.mapping && modelVariants.length > 0) {
+        return `${accessor}.to_dict() if hasattr(${accessor}, "to_dict") else ${accessor}`;
+      }
       return accessor;
     }
     default:

package/src/ruby/models.ts

@@ -269,11 +269,30 @@ function deserializeExpression(
   }
 
   if (ref.kind === 'union') {
-    // Unions: if all variants are models, try each; otherwise return raw value.
-    const modelVariants = ref.variants.filter((v) => v.kind === 'model' && modelNames.has(v.name));
-    if (modelVariants.length > 0 && modelVariants.length === ref.variants.length) {
-      // Multiple model variants — default to first successful parse or raw value.
-      return accessor; // simplification: return raw, let user inspect
+    // Discriminated union: dispatch on the discriminator property to construct
+    // the matching variant. Unknown values fall back to the raw hash so callers
+    // can still introspect (rather than crashing on an unmapped discriminator).
+    if (ref.discriminator && ref.discriminator.mapping) {
+      const entries = Object.entries(ref.discriminator.mapping).filter(([, name]) => modelNames.has(name));
+      if (entries.length > 0) {
+        const propAccess = rubyHashAccessor(accessor, ref.discriminator.property);
+        const branches = entries
+          .map(([value, modelName]) => {
+            const cls = `WorkOS::${className(modelName)}`;
+            return `when ${JSON.stringify(value)} then ${cls}.new(${accessor})`;
+          })
+          .join(' ');
+        const dispatcher = `(case ${propAccess} ${branches} else ${accessor} end)`;
+        return `${accessor} ? ${dispatcher} : nil`;
+      }
+    }
+    // Non-discriminated union of models: pick the first variant as a best-
+    // effort typed wrapper. Preserves the pre-discriminator behavior of
+    // wrapping inline-variant unions whose owner used to be a single model.
+    const firstModelVariant = ref.variants.find((v) => v.kind === 'model' && modelNames.has(v.name));
+    if (firstModelVariant && firstModelVariant.kind === 'model') {
+      const cls = `WorkOS::${className(firstModelVariant.name)}`;
+      return `${accessor} ? ${cls}.new(${accessor}) : nil`;
     }
     return accessor;
   }

package/test/go/resources.test.ts

@@ -220,11 +220,47 @@ describe('go/resources', () => {
     const files = generateResources(services, makeCtx(spec));
     const content = files[0].content;
     expect(content).toContain('type UsersCreateParams struct {');
-    expect(content).toContain('Email string `json:"email"`');
+    expect(content).toContain('Email string `json:"email" url:"-"`');
     expect(content).toContain('Notify *bool `url:"notify,omitempty" json:"-"`');
     expect(content).toContain('request(ctx, "POST", "/users", params, params, &result, opts)');
   });
 
+  it('does not emit url tag for body fields shadowed by a same-named query param', () => {
+    // Spec quirk: an operation lists the same field name in both `parameters`
+    // (in: query) and `requestBody`. The body field must not also leak into
+    // the URL query string (e.g. /sso/token's `code` carries an auth code).
+    const services: Service[] = [
+      {
+        name: 'Sso',
+        operations: [
+          makeOp({
+            name: 'getProfileAndToken',
+            httpMethod: 'post',
+            path: '/sso/token',
+            requestBody: { kind: 'model', name: 'TokenQueryDto' },
+            queryParams: [
+              {
+                name: 'code',
+                type: { kind: 'primitive', type: 'string' },
+                required: true,
+              },
+            ],
+          }),
+        ],
+      },
+    ];
+    const spec = makeSpec(services, [
+      {
+        name: 'TokenQueryDto',
+        fields: [{ name: 'code', type: { kind: 'primitive', type: 'string' }, required: true }],
+      },
+    ]);
+    const files = generateResources(services, makeCtx(spec));
+    const content = files[0].content;
+    expect(content).toContain('Code string `json:"code" url:"-"`');
+    expect(content).not.toContain('json:"code" url:"code"');
+  });
+
   it('emits Deprecated comment for deprecated body field in params struct', () => {
     const services: Service[] = [
       {