@workos/oagen-emitters 0.14.1 → 0.14.2

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",

package/src/go/fixtures.ts

@@ -1,6 +1,7 @@
 import type { Model, TypeRef, Enum } from '@workos/oagen';
 import { fileName, fieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
+import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 
 /**
  * Prefix mapping for generating realistic ID fixture values.
@@ -34,9 +35,12 @@ export function generateFixtures(spec: { models: Model[]; enums: Enum[]; service
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
   const files: { path: string; content: string }[] = [];
 
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+  const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
+
   for (const model of spec.models) {
-    if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 
     const fixture = model.fields.length === 0 ? {} : generateModelFixture(model, modelMap, enumMap);
 

package/src/go/models.ts

@@ -9,6 +9,7 @@ import {
   isListWrapperModel,
   isListMetadataModel,
   collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
 } from '../shared/model-utils.js';
 export { isListWrapperModel, isListMetadataModel };
 
@@ -92,12 +93,17 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   // code references them by name and the pagination iterator doesn't unwrap them.
   const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
   const skipAsListWrapper = (m: Model): boolean => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
+  // A `ListMetadata`-shape model referenced by a surviving non-paginated
+  // wrapper (e.g. vault's `VersionListResponse`) must still be emitted —
+  // otherwise the wrapper's struct references a type that was never declared.
+  const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+  const skipAsListMetadata = (m: Model): boolean => isListMetadataModel(m) && !listMetadataNeeded.has(m.name);
 
   // Build structural hash for deduplication
   const modelHashMap = new Map<string, string>();
   const hashGroups = new Map<string, string[]>();
   for (const model of models) {
-    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     if (requestBodyOnly.has(model.name)) continue;
     const hash = structuralHash(model);
     modelHashMap.set(model.name, hash);
@@ -121,7 +127,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
   const batchedAliases = new Set<string>();
   for (const model of models) {
-    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     if (requestBodyOnly.has(model.name)) continue;
 
     const structName = className(model.name);

package/src/kotlin/models.ts

@@ -6,6 +6,7 @@ import {
   isListWrapperModel,
   isListMetadataModel,
   collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
 } from '../shared/model-utils.js';
 
 const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
@@ -67,13 +68,18 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   // code references them by name and pagination iterators don't unwrap them.
   const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
   const skipAsListWrapper = (m: Model): boolean => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
+  // A `ListMetadata`-shape model referenced by a surviving non-paginated
+  // wrapper (e.g. vault's `VersionListResponse`) must still emit a data class
+  // — otherwise the wrapper's class references a type that was never declared.
+  const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+  const skipAsListMetadata = (m: Model): boolean => isListMetadataModel(m) && !listMetadataNeeded.has(m.name);
 
   // Deduplication: identical structures become typealiases.
   // Pass 1: hash without nested-alias resolution.
   modelAliasMap = null;
   const hashGroupsPass1 = new Map<string, string[]>();
   for (const model of models) {
-    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     if (model.fields.length === 0 && discriminatedUnions.has(className(model.name))) continue;
     const hash = structuralHash(model);
     if (!hashGroupsPass1.has(hash)) hashGroupsPass1.set(hash, []);
@@ -96,7 +102,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   modelAliasMap = aliasOf;
   const hashGroupsPass2 = new Map<string, string[]>();
   for (const model of models) {
-    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     if (model.fields.length === 0 && discriminatedUnions.has(className(model.name))) continue;
     if (aliasOf.has(model.name)) continue; // already aliased in pass 1
     const hash = structuralHash(model);
@@ -115,7 +121,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   }
 
   for (const model of models) {
-    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     const typeName = className(model.name);
 
     // Parent of a discriminated union: emit a sealed class.
@@ -152,7 +158,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   // mapping so Jackson can deserialize directly to the correct concrete type.
   const eventMapping: Array<{ wireValue: string; modelName: string }> = [];
   for (const model of models) {
-    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     if (aliasOf.has(model.name)) continue;
     if (!isEventEnvelopeModel(model)) continue;
     const eventField = model.fields.find((f) => f.name === 'event');

package/src/kotlin/resources.ts

@@ -11,7 +11,12 @@ import type {
 } from '@workos/oagen';
 import { planOperation } from '@workos/oagen';
 import { mapTypeRef, mapTypeRefOptional, implicitImportsFor } from './type-map.js';
-import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import {
+  isListWrapperModel,
+  isListMetadataModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
+} from '../shared/model-utils.js';
 import { enumCanonicalMap } from './enums.js';
 import {
   className,
@@ -1124,6 +1129,12 @@ function registerTypeImports(ref: TypeRef, imports: Set<string>, ctx: EmitterCon
   const mapped = mapTypeRef(ref);
   for (const imp of implicitImportsFor(mapped)) imports.add(imp);
 
+  // Match the model-emission gate: a `ListMetadata`-shape model that survives
+  // emission (because a non-paginated wrapper still references it) needs its
+  // import here too.
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+  const listMetadataNeeded = collectReferencedListMetadataModels(ctx.spec.models, nonPaginatedRefs);
+
   walk(ref, (r) => {
     if (r.kind === 'enum') {
       // When an enum is aliased, import the canonical class instead of the alias.
@@ -1132,7 +1143,11 @@ function registerTypeImports(ref: TypeRef, imports: Set<string>, ctx: EmitterCon
     }
     if (r.kind === 'model') {
       const referenced = ctx.spec.models.find((m) => m.name === r.name);
-      if (referenced && (isListWrapperModel(referenced) || isListMetadataModel(referenced))) return;
+      if (referenced) {
+        const skipWrapper = isListWrapperModel(referenced) && !nonPaginatedRefs.has(referenced.name);
+        const skipMetadata = isListMetadataModel(referenced) && !listMetadataNeeded.has(referenced.name);
+        if (skipWrapper || skipMetadata) return;
+      }
       imports.add(`com.workos.models.${className(r.name)}`);
     }
   });

package/src/node/fixtures.ts

@@ -1,7 +1,14 @@
 import type { Model, TypeRef, Enum, EmitterContext } from '@workos/oagen';
 import { wireFieldName, fileName, resolveServiceDir } from './naming.js';
 import { resolveResourceClassName, resolveResourceDir } from './resources.js';
-import { createServiceDirResolver, assignModelsToServices, isListMetadataModel, isListWrapperModel } from './utils.js';
+import {
+  createServiceDirResolver,
+  assignModelsToServices,
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
+} from './utils.js';
 
 export const ID_PREFIXES: Record<string, string> = {
   Connection: 'conn_',
@@ -75,11 +82,14 @@ export function generateFixtures(
     }
   }
 
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+  const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
+
   const seenFixturePaths = new Set<string>();
   for (const model of spec.models) {
     if (!fixtureReachable.has(model.name)) continue;
-    if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);

package/src/node/index.ts

@@ -23,6 +23,7 @@ import {
   setBaselineSerializedNames,
   setBaselineInterfaceNames,
   setAdoptedModelNames,
+  setStructurallyRenamedDomainNames,
   resolveInterfaceName,
 } from './naming.js';
 import { withNodeOperationOverrides } from './node-overrides.js';
@@ -108,6 +109,19 @@ function getSurface(ctx: EmitterContext): LiveSurface {
   // Pass an empty map; type-map will fall back to emitting the symbol name.
   setInlineEnumUnions(new Map());
   setAdoptedModelNames(computeAdoptedModelNames(ctx, surface));
+
+  // Pre-compute which domain names the resolver reaches via structural
+  // rename so `wireInterfaceName` can tell `AuditLogSchemaJson` →
+  // `AuditLogSchemaResponse` (real single-form case) apart from
+  // `CreateDataKeyResponse` → `CreateDataKeyResponse` (fresh IR model whose
+  // own name already ends in `Response`).
+  const renamed = new Set<string>();
+  for (const model of ctx.spec.models) {
+    const resolved = resolveInterfaceName(model.name, ctx);
+    if (resolved !== model.name) renamed.add(resolved);
+  }
+  setStructurallyRenamedDomainNames(renamed);
+
   return surface;
 }
 

package/src/node/models.ts

@@ -24,6 +24,7 @@ import {
   isListMetadataModel,
   isListWrapperModel,
   collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
   buildDeduplicationMap,
   relativeImport,
   modelHasNewFields,
@@ -214,11 +215,19 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
   // for `GET /vault/v1/kv/{id}/versions`) must still be emitted — the resource
   // code references them by name and pagination iterators don't unwrap them.
   const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+
+  // ListMetadata-shape models are usually subsumed by the SDK's shared
+  // pagination wrapper, so we blanket-skip them. But a non-paginated
+  // wrapper like vault's `VersionListResponse` keeps the reference live
+  // (`list_metadata: ListMetadata`), and skipping the emission leaves the
+  // wrapper's interface importing from a file that was never written.
+  const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+
   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 (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
     if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     if (discriminatedSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
@@ -517,36 +526,43 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
     }
     lines.push('');
 
-    // Wire/response interface
-    const seenWireFields = new Set<string>();
-    if (model.fields.length === 0) {
-      lines.push(`export type ${responseName}${typeParams} = object;`);
-    } else {
-      lines.push(`export interface ${responseName}${typeParams} {`);
-      for (const field of model.fields) {
-        const wireField = wireFieldName(field.name);
-        if (seenWireFields.has(wireField)) continue;
-        seenWireFields.add(wireField);
-        const baselineField = baselineResponse?.fields?.[wireField];
-        if (
-          baselineField &&
-          baselineTypeResolvable(baselineField.type, importableNames) &&
-          baselineFieldCompatible(baselineField, field)
-        ) {
-          const opt = baselineField.optional ? '?' : '';
-          lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
-        } else {
-          const isNewFieldOnExistingModel = baselineResponse && !baselineField;
-          // Same baseline-optional preservation as the domain side. The
-          // wire interface's optional flag drives test-fixture shape, so
-          // flipping it on regen breaks every fixture that omitted the
-          // field assuming it was optional.
-          const baselineSaysOptional = baselineField?.optional === true;
-          const opt = baselineSaysOptional || !field.required || isNewFieldOnExistingModel ? '?' : '';
-          lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+    // Wire/response interface — skip when the wire name collapsed onto the
+    // domain name (single-form structural-rename case, e.g. IR `Object` →
+    // `ReadObjectResponse`). Emitting the second declaration would either
+    // produce a literal duplicate `export interface ReadObjectResponse`
+    // pair or, after TypeScript's silent declaration merge, leave the
+    // call site with `import type { ReadObjectResponse, ReadObjectResponse }`.
+    if (responseName !== domainName) {
+      const seenWireFields = new Set<string>();
+      if (model.fields.length === 0) {
+        lines.push(`export type ${responseName}${typeParams} = object;`);
+      } else {
+        lines.push(`export interface ${responseName}${typeParams} {`);
+        for (const field of model.fields) {
+          const wireField = wireFieldName(field.name);
+          if (seenWireFields.has(wireField)) continue;
+          seenWireFields.add(wireField);
+          const baselineField = baselineResponse?.fields?.[wireField];
+          if (
+            baselineField &&
+            baselineTypeResolvable(baselineField.type, importableNames) &&
+            baselineFieldCompatible(baselineField, field)
+          ) {
+            const opt = baselineField.optional ? '?' : '';
+            lines.push(`  ${wireField}${opt}: ${baselineField.type};`);
+          } else {
+            const isNewFieldOnExistingModel = baselineResponse && !baselineField;
+            // Same baseline-optional preservation as the domain side. The
+            // wire interface's optional flag drives test-fixture shape, so
+            // flipping it on regen breaks every fixture that omitted the
+            // field assuming it was optional.
+            const baselineSaysOptional = baselineField?.optional === true;
+            const opt = baselineSaysOptional || !field.required || isNewFieldOnExistingModel ? '?' : '';
+            lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+          }
         }
+        lines.push('}');
       }
-      lines.push('}');
     }
 
     // Preserve inline types from existing file
@@ -739,12 +755,16 @@ export function generateSerializers(
 
   const discriminatedSerializerSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
   const serializerNonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+
+  // Mirror the interface-emission gate (see `generateModels`).
+  const serializerListMetadataNeeded = collectReferencedListMetadataModels(models, serializerNonPaginatedRefs);
+
   const eligibleModels: Model[] = [];
   for (const originalModel of models) {
     const model = projectedByName.get(originalModel.name) ?? originalModel;
     if (!serializerReachable.has(model.name)) continue;
     if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
-    if (isListMetadataModel(model)) continue;
+    if (isListMetadataModel(model) && !serializerListMetadataNeeded.has(model.name)) continue;
     if (isListWrapperModel(model) && !serializerNonPaginatedRefs.has(model.name)) continue;
     if (discriminatedSerializerSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);

package/src/node/naming.ts

@@ -73,6 +73,23 @@ export function isAdoptedModelName(name: string): boolean {
   return adoptedModelNames.has(name);
 }
 
+/**
+ * Domain names that `resolveInterfaceName` reached via a structural rename
+ * — the resolved name differs from the IR model's own name. `wireInterfaceName`
+ * consults this set to decide whether to fire the "single-form wire" case:
+ * that case is *only* meant for structurally-renamed models, where the
+ * baseline owns a `*Response` interface representing the wire shape with no
+ * separate `*Wire` companion. Without this signal, a freshly-emitted model
+ * whose IR name already ends in `Response` (e.g. `CreateDataKeyResponse`)
+ * would land in the same case as soon as a prior buggy regen wrote the
+ * baseline — producing two `export interface CreateDataKeyResponse { ... }`
+ * declarations in the same file.
+ */
+let structurallyRenamedDomainNames: Set<string> = new Set();
+export function setStructurallyRenamedDomainNames(names: Set<string>): void {
+  structurallyRenamedDomainNames = names;
+}
+
 /**
  * Wire/response interface name.
  *
@@ -97,7 +114,14 @@ export function wireInterfaceName(domainName: string): string {
   if (domainName.endsWith('Response')) {
     const wireForm = `${domainName}Wire`;
     if (baselineInterfaceNames.has(wireForm)) return wireForm;
-    if (baselineInterfaceNames.has(domainName)) return domainName;
+    // Single-form case (#3 in the docstring): only fire when the resolver
+    // structurally renamed an IR model to this baseline name. Otherwise a
+    // fresh `CreateDataKeyResponse`-style IR model would collapse onto its
+    // own name as soon as one buggy regen wrote `CreateDataKeyResponse` to
+    // the baseline, perpetuating the duplicate-interface emission.
+    if (structurallyRenamedDomainNames.has(domainName) && baselineInterfaceNames.has(domainName)) {
+      return domainName;
+    }
     return wireForm;
   }
   return `${domainName}Response`;

package/src/node/resources.ts

@@ -698,7 +698,15 @@ function generateResourceClass(service: Service, ctx: EmitterContext): Generated
         ? `./interfaces/${fileName(name)}.interface`
         : `../${modelServiceDir}/interfaces/${fileName(name)}.interface`;
     if (usedWireTypes.has(resolved)) {
-      lines.push(`import type { ${resolved}, ${wireInterfaceName(resolved)} } from '${relPath}';`);
+      const wireName = wireInterfaceName(resolved);
+      // When the wire name collapsed onto the domain name (single-form
+      // structural-rename emission), import once — otherwise we ship
+      // `import type { ReadObjectResponse, ReadObjectResponse }`.
+      if (wireName === resolved) {
+        lines.push(`import type { ${resolved} } from '${relPath}';`);
+      } else {
+        lines.push(`import type { ${resolved}, ${wireName} } from '${relPath}';`);
+      }
     } else {
       lines.push(`import type { ${resolved} } from '${relPath}';`);
     }

package/src/node/tests.ts

@@ -682,7 +682,14 @@ function buildFieldAssertions(model: Model, accessor: string, modelMap?: Map<str
     const fieldAccessor = isDateTime ? `${accessor}.${domainField}.toISOString()` : `${accessor}.${domainField}`;
     // When a field has an example value, use it as the expected assertion value
     if (field.example !== undefined) {
-      if (typeof field.example === 'object' && field.example !== null) {
+      // A null example on a nullable field must assert `toBeNull()` on the
+      // raw value — calling `.toISOString()` on null throws at runtime, and
+      // `.toBe(null)` against any non-null value never matches.
+      if (field.example === null) {
+        assertions.push(`expect(${accessor}.${domainField}).toBeNull();`);
+        continue;
+      }
+      if (typeof field.example === 'object') {
         // Objects and arrays need toEqual with JSON serialization
         assertions.push(`expect(${accessor}.${domainField}).toEqual(${JSON.stringify(field.example)});`);
       } else {

package/src/node/utils.ts

@@ -281,6 +281,7 @@ export {
   isListMetadataModel,
   isListWrapperModel,
   collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
 } from '../shared/model-utils.js';
 
 function modelFingerprint(model: Model): string {

package/src/python/fixtures.ts

@@ -2,6 +2,7 @@ import type { Model, TypeRef, Enum } from '@workos/oagen';
 
 import { fileName, fieldName } from './naming.js';
 import { isListMetadataModel, isListWrapperModel } from './models.js';
+import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 
 /**
  * Prefix mapping for generating realistic ID fixture values.
@@ -36,9 +37,12 @@ export function generateFixtures(spec: {
   const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
   const files: { path: string; content: string }[] = [];
 
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+  const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
+
   for (const model of spec.models) {
-    if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     // Skip models with no fields — these are typically discriminated unions
     // with hand-maintained @oagen-ignore overrides; generated empty fixtures
     // would not match the override's required fields.

package/src/python/models.ts

@@ -46,12 +46,16 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   // emitted — the resource code references them by name and SyncPage doesn't
   // wrap them.
   const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+  // ListMetadata-shape models referenced by a surviving non-paginated wrapper
+  // (e.g. vault's `VersionListResponse`) must still emit a dataclass —
+  // otherwise the wrapper's module imports a class that was never written.
+  const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
 
   for (const model of models) {
     // Skip list wrapper models (e.g., OrganizationList) — SyncPage handles envelopes
     if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     // Skip all list metadata models (e.g., ListMetadata, FooListListMetadata)
-    if (isListMetadataModel(model)) continue;
+    if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 
     const service = modelToService.get(model.name);
     const dirName = resolveDir(service);
@@ -875,5 +879,6 @@ import {
   isListMetadataModel,
   isListWrapperModel,
   collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
 } from '../shared/model-utils.js';
 export { isListMetadataModel, isListWrapperModel };

package/src/python/tests.ts

@@ -22,6 +22,7 @@ import { resolveResourceClassName, bodyParamName } from './resources.js';
 import { buildServiceAccessPaths } from './client.js';
 import { generateFixtures, generateModelFixture } from './fixtures.js';
 import { isListWrapperModel, isListMetadataModel } from './models.js';
+import { collectNonPaginatedResponseModelNames, collectReferencedListMetadataModels } from '../shared/model-utils.js';
 import {
   groupByMount,
   buildResolvedLookup,
@@ -1396,8 +1397,13 @@ function generateModelRoundTripTests(spec: ApiSpec, ctx: EmitterContext): Genera
   // A model is request-only if it's used as a request body but never as a response
   for (const name of responseModelNames) requestOnlyModelNames.delete(name);
 
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+  const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
   const models = spec.models.filter(
-    (m) => !isListWrapperModel(m) && !isListMetadataModel(m) && !requestOnlyModelNames.has(m.name),
+    (m) =>
+      !(isListWrapperModel(m) && !nonPaginatedRefs.has(m.name)) &&
+      !(isListMetadataModel(m) && !listMetadataNeeded.has(m.name)) &&
+      !requestOnlyModelNames.has(m.name),
   );
   if (models.length === 0) return null;
 

package/src/ruby/parameter-groups.ts

@@ -29,8 +29,10 @@ function mapSorbetType(ref: TypeRef): string {
       return `WorkOS::${className(ref.name)}`;
     case 'enum':
       return 'String';
-    case 'nullable':
-      return `T.nilable(${mapSorbetType(ref.inner)})`;
+    case 'nullable': {
+      const inner = mapSorbetType(ref.inner);
+      return inner === 'T.untyped' ? inner : `T.nilable(${inner})`;
+    }
     case 'literal':
       if (typeof ref.value === 'string') return 'String';
       if (ref.value === null) return 'NilClass';

package/src/ruby/rbi.ts

@@ -316,6 +316,7 @@ export function generateRbiFiles(spec: ApiSpec, ctx: EmitterContext): GeneratedF
 
 /** Unwrap T.nilable(...) if already wrapped, to avoid double-wrapping. */
 function unwrapNilable(type: string): string {
+  if (type === 'T.untyped') return type;
   const match = type.match(/^T\.nilable\((.+)\)$/);
   return match ? match[1] : type;
 }

package/src/shared/model-utils.ts

@@ -1,5 +1,5 @@
 import type { Model, Field, TypeRef, Enum, Service } from '@workos/oagen';
-import { toSnakeCase, toUpperSnakeCase, walkTypeRef } from '@workos/oagen';
+import { collectFieldDependencies, toSnakeCase, toUpperSnakeCase, walkTypeRef } from '@workos/oagen';
 import { readFileSync, existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 // @ts-ignore -- js-yaml has no type declarations in this project
@@ -72,6 +72,41 @@ export function isListMetadataModel(model: Model): boolean {
   return isNullableString(before) && isNullableString(after);
 }
 
+/**
+ * Compute the `ListMetadata`-shape model names that must still be emitted
+ * because some surviving wrapper references them.
+ *
+ * Each language emitter blanket-skips `isListMetadataModel` models on the
+ * assumption that the SDK's shared pagination wrapper subsumes them. That
+ * is correct for paginated list envelopes (the iterator unwraps the
+ * envelope and `list_metadata` is handled at runtime), but a *non-paginated*
+ * wrapper like vault's `VersionListResponse` still has a
+ * `list_metadata: ListMetadata` field — and skipping emission of
+ * `ListMetadata` leaves the wrapper's interface importing from a file that
+ * was never written.
+ *
+ * Pass the same `nonPaginatedRefs` set the emitter uses for its own
+ * wrapper-survival decision so the two answers stay in sync.
+ */
+export function collectReferencedListMetadataModels(models: Model[], nonPaginatedRefs: Set<string>): Set<string> {
+  const listMetadataNames = new Set<string>();
+  for (const m of models) {
+    if (isListMetadataModel(m)) listMetadataNames.add(m.name);
+  }
+  if (listMetadataNames.size === 0) return new Set();
+
+  const referenced = new Set<string>();
+  for (const model of models) {
+    if (isListMetadataModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
+    const deps = collectFieldDependencies(model);
+    for (const dep of deps.models) {
+      if (listMetadataNames.has(dep)) referenced.add(dep);
+    }
+  }
+  return referenced;
+}
+
 /** Check if a field type is nullable string (nullable<string> or just string). */
 function isNullableString(field: Field): boolean {
   if (field.type.kind === 'primitive' && field.type.type === 'string') return true;

package/test/node/naming.test.ts

@@ -1,7 +1,13 @@
 import { afterEach, describe, expect, it } from 'vitest';
 import type { EmitterContext } from '@workos/oagen';
 import { defaultSdkBehavior } from '@workos/oagen';
-import { resolveInterfaceName, setAdoptedModelNames } from '../../src/node/naming.js';
+import {
+  resolveInterfaceName,
+  setAdoptedModelNames,
+  setBaselineInterfaceNames,
+  setStructurallyRenamedDomainNames,
+  wireInterfaceName,
+} from '../../src/node/naming.js';
 
 const ctx: EmitterContext = {
   namespace: 'workos',
@@ -19,6 +25,8 @@ const ctx: EmitterContext = {
 
 afterEach(() => {
   setAdoptedModelNames(new Set());
+  setBaselineInterfaceNames(new Set());
+  setStructurallyRenamedDomainNames(new Set());
 });
 
 describe('resolveInterfaceName', () => {
@@ -75,3 +83,39 @@ describe('resolveInterfaceName', () => {
     expect(result).toBe('CreateM2MApplication');
   });
 });
+
+describe('wireInterfaceName', () => {
+  it('emits *Wire for a fresh `*Response`-named IR model with an empty baseline', () => {
+    expect(wireInterfaceName('CreateDataKeyResponse')).toBe('CreateDataKeyResponseWire');
+  });
+
+  it('returns *Wire even when a prior buggy regen poisoned the baseline with the bare name', () => {
+    // Reproduces the vault regression: `CreateDataKeyResponse` is its own IR
+    // name (no structural rename), so the resolver does not flag it. A prior
+    // broken emission wrote `export interface CreateDataKeyResponse { ... }`
+    // twice into the file, and the baseline now contains the bare name.
+    // Without the rename signal, `wireInterfaceName` must still pick `*Wire`
+    // — otherwise the duplicate emission perpetuates across regens.
+    setBaselineInterfaceNames(new Set(['CreateDataKeyResponse']));
+    expect(wireInterfaceName('CreateDataKeyResponse')).toBe('CreateDataKeyResponseWire');
+  });
+
+  it('uses *Wire when baseline already has a separate `*Wire` companion', () => {
+    setBaselineInterfaceNames(new Set(['DecryptResponse', 'DecryptResponseWire']));
+    expect(wireInterfaceName('DecryptResponse')).toBe('DecryptResponseWire');
+  });
+
+  it('returns the bare name when a structural rename mapped a differently-named IR model onto a baseline `*Response`', () => {
+    // The legitimate single-form case the heuristic was designed for:
+    // `AuditLogSchemaJson` → `AuditLogSchemaResponse` via structural match,
+    // and the baseline owns just the one `AuditLogSchemaResponse` interface
+    // representing the wire shape.
+    setBaselineInterfaceNames(new Set(['AuditLogSchemaResponse']));
+    setStructurallyRenamedDomainNames(new Set(['AuditLogSchemaResponse']));
+    expect(wireInterfaceName('AuditLogSchemaResponse')).toBe('AuditLogSchemaResponse');
+  });
+
+  it('falls back to `${name}Response` for non-`*Response` IR names', () => {
+    expect(wireInterfaceName('Organization')).toBe('OrganizationResponse');
+  });
+});