@workos/oagen-emitters 0.18.3 → 0.18.4

package/dist/plugin.mjs

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

package/docs/sdk-architecture/rust.md

@@ -316,8 +316,8 @@ surface that the `rust` extractor reads.
 Every generated file begins with:
 
 ```rust
-// Code generated by oagen. DO NOT EDIT.
+// This file is auto-generated by oagen. Do not edit.
 ```
 
-`Cargo.toml` uses the TOML-style equivalent (`# Code generated by oagen. DO NOT EDIT.`)
+`Cargo.toml` uses the TOML-style equivalent (`# This file is auto-generated by oagen. Do not edit.`)
 and JSON fixtures skip the header (`headerPlacement: 'skip'`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.18.3",
+  "version": "0.18.4",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@commitlint/cli": "^21.0.2",
     "@commitlint/config-conventional": "^21.0.2",
-    "@types/node": "^25.9.3",
+    "@types/node": "^26.0.0",
     "husky": "^9.1.7",
     "oxfmt": "^0.55.0",
     "oxlint": "^1.70.0",
@@ -54,6 +54,6 @@
     "node": ">=24.10.0"
   },
   "dependencies": {
-    "@workos/oagen": "^0.22.6"
+    "@workos/oagen": "^0.22.7"
   }
 }

package/src/dotnet/fixtures.ts

@@ -1,5 +1,5 @@
 import type { Model, TypeRef, Enum } from '@workos/oagen';
-import { fixtureFileName, fieldName } from './naming.js';
+import { fixtureFileName, domainFieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
 import { collectNonPaginatedResponseModelNames } from '../shared/model-utils.js';
 
@@ -155,7 +155,10 @@ export function generateModelFixture(
 
   const seenFieldNames = new Set<string>();
   const deduplicatedFields = model.fields.filter((f) => {
-    const csName = fieldName(f.name);
+    // Dedup on the DOMAIN identifier (the C# property name, honoring a
+    // `domainName` override) to mirror the dedup in models.ts. The fixture
+    // payload below still keys on the wire name (`field.name`).
+    const csName = domainFieldName(f);
     if (seenFieldNames.has(csName)) return false;
     seenFieldNames.add(csName);
     return true;

package/src/dotnet/index.ts

@@ -20,6 +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 { AUTOGEN_NOTICE } from '../shared/file-header.js';
 import { discriminatedUnions, resolveModelName } from './type-map.js';
 import { modelClassName } from './naming.js';
 
@@ -315,7 +316,7 @@ export const dotnetEmitter: Emitter = {
   },
 
   fileHeader(): string {
-    return '// This file is auto-generated by oagen. Do not edit.';
+    return `// ${AUTOGEN_NOTICE}`;
   },
 
   formatCommand(targetDir: string): FormatCommand | null {

package/src/dotnet/models.ts

@@ -12,6 +12,7 @@ import {
 import {
   articleFor,
   fieldName,
+  domainFieldName,
   humanize,
   emitXmlDoc,
   deprecationMessage,
@@ -93,7 +94,10 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
         const baseClassName = modelClassName(model.name);
         const fieldMap = new Map<string, string>();
         for (const field of model.fields) {
-          let csName = fieldName(field.name);
+          // DOMAIN identifier: the C# property name used for inheritance
+          // comparison (honors a `domainName` override). Must match the
+          // property name emitted below so variant fields dedup correctly.
+          let csName = domainFieldName(field);
           if (csName === baseClassName) csName = `${csName}Value`;
           fieldMap.set(csName, mapTypeRef(field.type));
         }
@@ -119,8 +123,16 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
     // Required enums need JsonProperty / STJS; a field whose PascalCase name
     // collides with the enclosing class needs the same imports for the wire-
     // name override emitted below.
-    const hasClassNameCollision = model.fields.some((f) => fieldName(f.name) === csClassName);
-    const needsJsonAttrs = hasClassNameCollision || model.fields.some((f) => f.required && isEnumRef(f.type));
+    // DOMAIN identifier: the emitted C# property name (honors `domainName`)
+    // is what can collide with the enclosing class name.
+    const hasClassNameCollision = model.fields.some((f) => domainFieldName(f) === csClassName);
+    // A `domainName` override renames the C# property away from the wire key
+    // (e.g. wire `connection_type` surfaced as domain `Type`). The
+    // SnakeCaseLower naming policy would otherwise serialize the domain name,
+    // so these fields need an explicit pinned wire name (and thus the imports).
+    const hasDomainRename = model.fields.some((f) => domainFieldName(f) !== fieldName(f.name));
+    const needsJsonAttrs =
+      hasClassNameCollision || hasDomainRename || model.fields.some((f) => f.required && isEnumRef(f.type));
 
     lines.push(`namespace ${ctx.namespacePascal}`);
     lines.push('{');
@@ -175,9 +187,16 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
       // when that happens. Track the rename so we emit an explicit
       // `[JsonProperty]` attribute below — the SnakeCaseLower naming policy
       // would otherwise serialize `ErrorValue` as `error_value`, not `error`.
-      let csFieldName = fieldName(field.name);
+      // DOMAIN identifier: the C# property name, honoring a `domainName`
+      // override (e.g. wire `connection_type` → domain `Type`). The wire key
+      // passed to `emitJsonPropertyAttributes` below still derives from
+      // `field.name`.
+      let csFieldName = domainFieldName(field);
       const collidesWithClassName = csFieldName === csClassName;
       if (collidesWithClassName) csFieldName = `${csFieldName}Value`;
+      // When the domain rename diverges from the wire key, the SnakeCaseLower
+      // naming policy can't recover the wire name from the property — pin it.
+      const hasDomainOverride = domainFieldName(field) !== fieldName(field.name);
       if (seenFieldNames.has(csFieldName)) continue;
       seenFieldNames.add(csFieldName);
 
@@ -257,8 +276,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
       }
 
       const isRequiredEnum = field.required && isEnumRef(field.type) && constInit === null;
+      // WIRE key: always derives from `field.name`. Pin it explicitly when the
+      // C# property name (collision suffix or `domainName` override) no longer
+      // round-trips to the wire name via the SnakeCaseLower naming policy.
       lines.push(
-        ...emitJsonPropertyAttributes(field.name, { isRequiredEnum, explicitWireName: collidesWithClassName }),
+        ...emitJsonPropertyAttributes(field.name, {
+          isRequiredEnum,
+          explicitWireName: collidesWithClassName || hasDomainOverride,
+        }),
       );
       // Discriminated-union-typed field: attach the variant-dispatching converter
       // so Newtonsoft picks the right subtype on deserialization. The converter

package/src/dotnet/naming.ts

@@ -39,6 +39,16 @@ export function fieldName(name: string): string {
   return toPascalCase(name);
 }
 
+/**
+ * PascalCase domain property name for a model field, honoring a `domainName`
+ * override (set via the `fieldHints` config) so a wire field can surface under
+ * a friendlier C# property name. The wire/serialization key (the
+ * `[JsonPropertyName("...")]` value) still derives from `field.name`.
+ */
+export function domainFieldName(field: { name: string; domainName?: string }): string {
+  return toPascalCase(field.domainName ?? field.name);
+}
+
 /** PascalCase directory name for service modules. */
 export function moduleName(name: string): string {
   return toPascalCase(name);

package/src/dotnet/tests.ts

@@ -3,6 +3,7 @@ import { planOperation } from '@workos/oagen';
 import {
   fixtureFileName,
   fieldName as csFieldName,
+  domainFieldName as csDomainFieldName,
   methodName as csMethodName,
   appendAsyncSuffix,
   modelClassName,
@@ -694,7 +695,10 @@ function buildFixtureAssertions(model: import('@workos/oagen').Model, spec: ApiS
     if (field.type.kind !== 'primitive' || field.type.type !== 'string') continue;
     if (field.type.format === 'date-time' || field.type.format === 'date') continue;
     if (field.type.format === 'binary') continue;
-    const csField = csFieldName(field.name);
+    // DOMAIN identifier: the C# property accessed on the deserialized model
+    // (honors a `domainName` override). The fixture lookup below uses the wire
+    // key (`field.name`).
+    const csField = csDomainFieldName(field);
     const val = fixture[field.name];
     if (typeof val === 'string' && val.length > 0) {
       assertions.push(`Assert.Equal(${csStringLiteral(val)}, result.${csField});`);

package/src/go/fixtures.ts

@@ -1,5 +1,5 @@
 import type { Model, TypeRef, Enum } from '@workos/oagen';
-import { fileName, fieldName } from './naming.js';
+import { fileName, domainFieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
 import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 
@@ -131,7 +131,9 @@ export function generateModelFixture(
 
   const seenFieldNames = new Set<string>();
   const deduplicatedFields = model.fields.filter((f) => {
-    const goName = fieldName(f.name);
+    // Dedup by the domain Go field name to mirror the struct in models.ts; the
+    // fixture key itself (wireName below) still derives from field.name.
+    const goName = domainFieldName(f);
     if (seenFieldNames.has(goName)) return false;
     seenFieldNames.add(goName);
     return true;

package/src/go/index.ts

@@ -88,6 +88,10 @@ export const goEmitter: Emitter = {
   },
 
   fileHeader(): string {
+    // Go-specific: this exact form matches the standard generated-file regex
+    // (`^// Code generated .* DO NOT EDIT\.$`) that gofmt, gopls, golangci-lint,
+    // and other Go tooling use to classify a file as generated. It intentionally
+    // does NOT use the shared AUTOGEN_NOTICE, which would break that detection.
     return '// Code generated by oagen. DO NOT EDIT.';
   },
 

package/src/go/models.ts

@@ -1,7 +1,7 @@
 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 { className, domainFieldName } from './naming.js';
 import { lowerFirstForDoc, fieldDocComment, articleFor } from '../shared/naming-utils.js';
 
 // Import and re-export shared model detection utilities
@@ -185,7 +185,9 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     // Deduplicate fields by Go field name
     const seenFieldNames = new Set<string>();
     for (const field of model.fields) {
-      const goFieldName = fieldName(field.name);
+      // Domain identifier honors a `fieldHints` override (e.g. connection_type
+      // → type); the json struct tag below still derives from `field.name`.
+      const goFieldName = domainFieldName(field);
       if (seenFieldNames.has(goFieldName)) continue;
       seenFieldNames.add(goFieldName);
 

package/src/go/naming.ts

@@ -61,6 +61,16 @@ export function fieldName(name: string): string {
   return applyAcronyms(toPascalCase(name));
 }
 
+/**
+ * PascalCase domain field name for a model field, honoring a `domainName`
+ * override (set via the `fieldHints` config) so a wire field can surface under
+ * a friendlier name. The wire name (the `json:"..."` struct tag) still derives
+ * from `field.name`.
+ */
+export function domainFieldName(field: { name: string; domainName?: string }): string {
+  return applyAcronyms(toPascalCase(field.domainName ?? field.name));
+}
+
 /** snake_case module/directory name. */
 export function moduleName(name: string): string {
   return toSnakeCase(name);

package/src/go/resources.ts

@@ -9,7 +9,15 @@ import type {
 import { planOperation, toSnakeCase } from '@workos/oagen';
 import { isListWrapperModel } from './models.js';
 import { mapTypeRef, mapTypeRefValue } from './type-map.js';
-import { className, fieldName, methodName, resolveClassName, resolveMethodName, unexportedName } from './naming.js';
+import {
+  className,
+  domainFieldName,
+  fieldName,
+  methodName,
+  resolveClassName,
+  resolveMethodName,
+  unexportedName,
+} from './naming.js';
 import {
   buildResolvedLookup,
   lookupResolved,
@@ -404,7 +412,8 @@ function generateParamsStruct(
       for (const field of bodyModel.fields) {
         if (hidden.has(field.name)) continue;
         if (groupedParams.has(field.name)) continue;
-        const goField = fieldName(field.name);
+        // Domain struct field; the json tag below keeps deriving from field.name.
+        const goField = domainFieldName(field);
         if (emittedFields.has(goField)) continue;
         emittedFields.add(goField);
         const isOptional = !field.required;
@@ -942,7 +951,8 @@ function emitHiddenParamsBodyStruct(
       if (hidden.has(field.name)) continue;
       if (groupedParamNames.has(field.name)) continue;
       if (!field.required) continue;
-      const goField = fieldName(field.name);
+      // Domain struct field; the json tag below keeps deriving from field.name.
+      const goField = domainFieldName(field);
       const goType = mapTypeRef(field.type);
       lines.push(`\t${goField} ${goType} \`json:"${field.name}"\``);
     }
@@ -960,7 +970,8 @@ function emitHiddenParamsBodyStruct(
       if (hidden.has(field.name)) continue;
       if (groupedParamNames.has(field.name)) continue;
       if (field.required) continue;
-      const goField = fieldName(field.name);
+      // Domain struct field; the json tag below keeps deriving from field.name.
+      const goField = domainFieldName(field);
       const goType = makeOptional(mapTypeRef(field.type));
       lines.push(`\t${goField} ${goType} \`json:"${field.name},omitempty"\``);
     }
@@ -1007,7 +1018,8 @@ function emitBodyWithHiddenParams(
     for (const field of bodyModel.fields) {
       if (hidden.has(field.name)) continue;
       if (!field.required) continue;
-      const goField = fieldName(field.name);
+      // Domain struct field on both the body literal and the params struct.
+      const goField = domainFieldName(field);
       lines.push(`\t\t${goField}: params.${goField},`);
     }
   }
@@ -1025,7 +1037,8 @@ function emitBodyWithHiddenParams(
     for (const field of bodyModel.fields) {
       if (hidden.has(field.name)) continue;
       if (field.required) continue;
-      const goField = fieldName(field.name);
+      // Domain struct field on both the body struct and the params struct.
+      const goField = domainFieldName(field);
       lines.push(`\tbody.${goField} = params.${goField}`);
     }
   }

package/src/kotlin/index.ts

@@ -19,6 +19,7 @@ import { generateTests } from './tests.js';
 import { buildOperationsMap } from './manifest.js';
 import { enrichModelsFromSpec, getSyntheticEnums } from '../shared/model-utils.js';
 import { flattenDiscriminatedUnionFields } from '../shared/union-flatten.js';
+import { AUTOGEN_NOTICE } from '../shared/file-header.js';
 
 /** Ensure every generated file ends with a trailing newline. */
 function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
@@ -95,7 +96,7 @@ export const kotlinEmitter: Emitter = {
   },
 
   fileHeader(): string {
-    return '// This file is auto-generated by oagen. Do not edit.';
+    return `// ${AUTOGEN_NOTICE}`;
   },
 
   formatCommand(targetDir: string): FormatCommand | null {

package/src/kotlin/models.ts

@@ -1,6 +1,6 @@
 import type { Model, EmitterContext, GeneratedFile, TypeRef, Field } from '@workos/oagen';
 import { mapTypeRef, discriminatedUnions } from './type-map.js';
-import { className, propertyName, ktStringLiteral, humanize } from './naming.js';
+import { className, domainPropertyName, ktStringLiteral, humanize } from './naming.js';
 import { enumCanonicalMap } from './enums.js';
 import {
   isListWrapperModel,
@@ -374,7 +374,10 @@ function renderFields(fields: Field[], overrideFields: Set<string> = new Set()):
 
   for (const rawField of fields) {
     const field = promoteFieldType(rawField);
-    const kotlinName = propertyName(field.name);
+    // DOMAIN identifier: the data class property name. Honors a `domainName`
+    // override (e.g. connection_type -> type); the `@JsonProperty(...)` wire
+    // key below still derives from `field.name`.
+    const kotlinName = domainPropertyName(field);
     if (seen.has(kotlinName)) continue;
     seen.add(kotlinName);
 

package/src/kotlin/naming.ts

@@ -57,6 +57,17 @@ export function propertyName(name: string): string {
   return escapeReserved(camel);
 }
 
+/**
+ * camelCase domain property name for a MODEL field, honoring a `domainName`
+ * override (set via the `fieldHints` config) so a wire field can surface under
+ * a friendlier name. The wire key (the `@JsonProperty("...")` argument) still
+ * derives from `field.name`. No-op when `domainName` is unset, so it is also
+ * safe on params. Only apply to model fields.
+ */
+export function domainPropertyName(field: { name: string; domainName?: string }): string {
+  return propertyName(field.domainName ?? field.name);
+}
+
 /** camelCase alias (kept for parity with other emitters). */
 export const fieldName = propertyName;
 export const localName = propertyName;

package/src/kotlin/tests.ts

@@ -17,6 +17,7 @@ import {
   ktStringLiteral,
   className,
   propertyName,
+  domainPropertyName,
   buildExportedClassNameSet,
 } from './naming.js';
 import { mapTypeRef } from './type-map.js';
@@ -713,7 +714,10 @@ function buildResponseAssertions(
   for (const field of model.fields) {
     if (!field.required) continue;
     if (assertions.length >= MAX_RESPONSE_ASSERTIONS) break;
-    const ktProp = propertyName(field.name);
+    // DOMAIN identifier: the property accessor on the deserialized model.
+    // Honors a `domainName` override; the synthesized JSON above keys off
+    // `field.name` (the wire key).
+    const ktProp = domainPropertyName(field);
     const type = field.type;
     if (type.kind === 'primitive') {
       if (type.format === 'date-time') continue;

package/src/node/field-plan.ts

@@ -388,7 +388,7 @@ export function serializerHasBaselineIncompatibility(
   const irDomainFields = new Set<string>();
   for (const field of model.fields) {
     irWireFields.add(wireFieldName(field.name));
-    irDomainFields.add(fieldName(field.name));
+    irDomainFields.add(fieldName(field.domainName ?? field.name));
   }
 
   for (const [wireField2, fieldDef] of Object.entries(baselineResponse.fields)) {
@@ -463,7 +463,7 @@ export function planDeserializeField(
   skipFormatFields: Set<string>,
   ctx: EmitterContext,
 ): { line: string; skip: boolean } {
-  const domain = fieldName(field.name);
+  const domain = fieldName(field.domainName ?? field.name);
   const wire = wireFieldName(field.name);
   const wireAccess = `response.${wire}`;
   const skip = skipFormatFields.has(field.name);
@@ -543,7 +543,7 @@ export function planSerializeField(
   ctx: EmitterContext,
 ): { line: string; skip: boolean } {
   const wire = wireFieldName(field.name);
-  const domain = fieldName(field.name);
+  const domain = fieldName(field.domainName ?? field.name);
   const domainAccess = `model.${domain}`;
   const skip = skipFormatFields.has(field.name);
 

package/src/node/index.ts

@@ -40,6 +40,7 @@ import { withNodeOperationOverrides } from './node-overrides.js';
 import { isNodeOwnedService, nodeOptions } from './options.js';
 import { setInlineEnumUnions, setDomainNameResolver } from './type-map.js';
 import { groupByMount } from '../shared/resolved-ops.js';
+import { AUTOGEN_NOTICE } from '../shared/file-header.js';
 import { assignModelsToServices, createServiceDirResolver, relativeImport } from './utils.js';
 import { fileName } from './naming.js';
 
@@ -869,7 +870,7 @@ export const nodeEmitter: Emitter = {
   },
 
   fileHeader(): string {
-    return '// This file is auto-generated by oagen. Do not edit.';
+    return `// ${AUTOGEN_NOTICE}`;
   },
 
   formatCommand(targetDir: string): FormatCommand | null {

package/src/node/models.ts

@@ -527,7 +527,9 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
     } else {
       lines.push(`export interface ${domainName}${typeParams} {`);
       for (const field of model.fields) {
-        const domainFieldName = fieldName(field.name);
+        // Domain identifier honors a `fieldHints` override (e.g. connection_type
+        // → type); the wire name below still derives from `field.name`.
+        const domainFieldName = fieldName(field.domainName ?? field.name);
         if (seenDomainFields.has(domainFieldName)) continue;
         seenDomainFields.add(domainFieldName);
         if (field.description || field.deprecated || field.readOnly || field.writeOnly || field.default !== undefined) {
@@ -546,6 +548,19 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
           baselineField && !baselineField.optional && responseBaselineField && responseBaselineField.optional;
         const readonlyPrefix = field.readOnly ? 'readonly ' : '';
         if (
+          genericDefaults.has(model.name) &&
+          baselineField &&
+          typeReferencesUnresolvable(baselineField.type, unresolvableNames)
+        ) {
+          // Baseline typed this field with the model's generic param (e.g.
+          // `customAttributes?: CustomAttributesType`). The emitted interface
+          // renames the param to `GenericType`; remap the field so the param is
+          // actually used — otherwise it trips TS6133 (declared, never read).
+          const opt = baselineField.optional ? '?' : '';
+          lines.push(
+            `  ${readonlyPrefix}${domainFieldName}${opt}: ${substituteGenericParam(baselineField.type, unresolvableNames)};`,
+          );
+        } else if (
           baselineField &&
           !domainResponseOptionalMismatch &&
           !hasDateTimeConversion(field.type) &&
@@ -597,6 +612,15 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
           seenWireFields.add(wireField);
           const baselineField = baselineResponse?.fields?.[wireField];
           if (
+            genericDefaults.has(model.name) &&
+            baselineField &&
+            typeReferencesUnresolvable(baselineField.type, unresolvableNames)
+          ) {
+            // Mirror the domain side: keep the generic param wired on the
+            // response interface so `GenericType` is used, not orphaned.
+            const opt = baselineField.optional ? '?' : '';
+            lines.push(`  ${wireField}${opt}: ${substituteGenericParam(baselineField.type, unresolvableNames)};`);
+          } else if (
             baselineField &&
             baselineTypeResolvable(baselineField.type, importableNames) &&
             baselineFieldCompatible(baselineField, field)
@@ -1301,6 +1325,21 @@ function hasSpecificIRType(ref: TypeRef): boolean {
   }
 }
 
+/** True when a baseline field type references one of the model's generic
+ *  param identifiers (collected as `unresolvableNames` — bare type names that
+ *  resolve to nothing importable, which for a generic model are its params). */
+function typeReferencesUnresolvable(type: string, unresolvable: Set<string>): boolean {
+  if (unresolvable.size === 0) return false;
+  const names = type.match(/\b[A-Z][a-zA-Z0-9]*\b/g);
+  return !!names && names.some((n) => unresolvable.has(n));
+}
+
+/** Rewrite a baseline field type so references to the model's (renamed)
+ *  generic param resolve to the emitted `GenericType` param. */
+function substituteGenericParam(type: string, unresolvable: Set<string>): string {
+  return type.replace(/\b[A-Z][a-zA-Z0-9]*\b/g, (name) => (unresolvable.has(name) ? 'GenericType' : name));
+}
+
 function renderTypeParams(model: Model, genericDefaults?: Map<string, string>): string {
   if (!model.typeParams?.length) {
     if (genericDefaults?.has(model.name)) {

package/src/node/naming.ts

@@ -32,6 +32,16 @@ export function fieldName(name: string): string {
   return toCamelCase(name);
 }
 
+/**
+ * camelCase domain field name for a model field, honoring a `domainName`
+ * override (set via the `fieldHints` config) so a wire field can surface under
+ * a friendlier name. The wire name (see {@link wireFieldName}) still derives
+ * from `field.name`.
+ */
+export function domainFieldName(field: { name: string; domainName?: string }): string {
+  return toCamelCase(field.domainName ?? field.name);
+}
+
 /** snake_case field name for wire/response interfaces. */
 export function wireFieldName(name: string): string {
   return toSnakeCase(name);

package/src/node/options.ts

@@ -1,14 +1,35 @@
-import type { EmitterContext } from '@workos/oagen';
+import type { EmitterContext, Operation, OperationPlan } from '@workos/oagen';
+import { planOperation } from '@workos/oagen';
 
 export interface OperationOverride {
   methodName?: string;
   mountOn?: string;
   optionsType?: string;
   bodyFieldMap?: Record<string, string>;
+  /**
+   * Rename spec path parameters to the SDK options-object field they should be
+   * exposed as. Keys are the camelCase identifier the param resolves to via
+   * `fieldName(param.name)` — NOT the raw (possibly snake_case) spec key — since
+   * the lookup is keyed on that camelCase form (e.g. `{ resourceId: 'targetId' }`,
+   * even for a `resource_id` spec param). Applied to the destructure, the URL
+   * template binding, and generated tests so a published SDK field name can
+   * diverge from the spec path-param name without a global spec rewrite (which
+   * would ripple across every language).
+   */
+  pathFieldMap?: Record<string, string>;
   returnType?: string;
   returnDataProperty?: string;
   returnTypeImports?: string[];
   returnExpression?: string;
+  /**
+   * Override the response model the operation deserializes, by model name.
+   * Replaces the spec-derived response model so the resource (and its test)
+   * reference a different wire type / deserializer — e.g. mapping
+   * Authorization's role responses to the full `OrganizationRole` instead of
+   * the slim `Role`/`RoleResponse` shape shared with SSO and UserManagement.
+   * Node-only; never affects the global spec or other SDKs.
+   */
+  responseModel?: string;
 }
 
 export interface NodeEmitterOptions {
@@ -90,3 +111,26 @@ export function isHandOwnedType(ctx: EmitterContext, name: string | undefined):
   if (!configured || configured.length === 0) return false;
   return configured.includes(name);
 }
+
+/**
+ * Resolve the Node operation override for an operation, keyed by "METHOD /path".
+ */
+export function operationOverrideFor(ctx: EmitterContext, op: Operation): OperationOverride | undefined {
+  return nodeOptions(ctx).operationOverrides?.[`${op.httpMethod.toUpperCase()} ${op.path}`];
+}
+
+/**
+ * `planOperation` plus the Node `responseModel` override. When an operation
+ * override supplies `responseModel`, the resolved response model name is
+ * replaced so the resource and its generated test reference the desired wire
+ * type and deserializer. Use this everywhere the Node emitter would otherwise
+ * call `planOperation(op)` directly so resource and test stay in lockstep.
+ */
+export function planOperationFor(op: Operation, ctx: EmitterContext): OperationPlan {
+  const plan = planOperation(op);
+  const responseModel = operationOverrideFor(ctx, op)?.responseModel;
+  if (responseModel && responseModel !== plan.responseModelName) {
+    return { ...plan, responseModelName: responseModel, isModelResponse: true };
+  }
+  return plan;
+}