@workos/oagen-emitters 0.14.0 → 0.14.2

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

@@ -277,7 +277,12 @@ export function isBaselineGeneric(fields: Record<string, unknown>, knownNames: S
   return false;
 }
 
-export { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+export {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
+} from '../shared/model-utils.js';
 
 function modelFingerprint(model: Model): string {
   const fields = model.fields.map((f) => `${f.name}:${JSON.stringify(f.type)}:${f.required}`).sort();

package/src/php/models.ts

@@ -4,7 +4,11 @@ import { className, enumClassName, fieldName } from './naming.js';
 import { phpDocComment } from './utils.js';
 
 // Import and re-export shared model detection utilities
-import { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+import {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 export { isListMetadataModel, isListWrapperModel };
 
 /**
@@ -32,9 +36,14 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
     overwriteExisting: true,
   });
 
+  // Wrappers referenced as a non-paginated response (e.g. `VersionListResponse`
+  // for `GET /vault/v1/kv/{id}/versions`) must still be emitted — the resource
+  // code references them by name and the pagination iterator doesn't unwrap them.
+  const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+
   for (const model of models) {
     if (isListMetadataModel(model)) continue;
-    if (isListWrapperModel(model)) continue;
+    if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     const name = className(model.name);
     const lines: 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

@@ -41,11 +41,21 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   // oneOf enrichment collide with existing IR models in snake_case.
   const emittedFilePaths = new Set<string>();
 
+  // Wrappers referenced as a non-paginated operation response (e.g.
+  // `VersionListResponse` for `GET /vault/v1/kv/{id}/versions`) must still be
+  // 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)) continue;
+    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);
@@ -865,5 +875,10 @@ function serializeField(ref: any, accessor: string): string {
 }
 
 // Import and re-export shared model detection utilities
-import { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+import {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
+} from '../shared/model-utils.js';
 export { isListMetadataModel, isListWrapperModel };

package/src/python/resources.ts

@@ -1053,8 +1053,14 @@ export function generateResources(services: Service[], ctx: EmitterContext): Gen
 
     for (const op of allOperations) {
       const plan = planOperation(op);
-      if (plan.responseModelName && !listWrapperNames.has(plan.responseModelName)) {
-        modelImports.add(plan.responseModelName);
+      if (plan.responseModelName) {
+        // List-wrapper responses are normally replaced by SyncPage on paginated
+        // ops, so the wrapper itself is never referenced. On non-paginated ops
+        // (e.g. `GET /vault/v1/kv/{id}/versions` → `VersionListResponse`) the
+        // resource method still returns the wrapper by name and must import it.
+        if (!listWrapperNames.has(plan.responseModelName) || !plan.isPaginated) {
+          modelImports.add(plan.responseModelName);
+        }
       }
       if (op.requestBody?.kind === 'model') {
         const requestBodyRef = op.requestBody;

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

@@ -36,8 +36,8 @@ function ensureTrailingNewlines(files: GeneratedFile[]): GeneratedFile[] {
  * has its original fields restored — otherwise `ConnectApplication`-style
  * bases would silently lose every variant field they had previously.
  */
-function enrichModelsForRuby(models: Model[]): Model[] {
-  const enriched = enrichModelsFromSpec(models);
+function enrichModelsForRuby(models: Model[], enums: Enum[]): Model[] {
+  const enriched = enrichModelsFromSpec(models, enums);
   const originalByName = new Map(models.map((m) => [m.name, m]));
   return enriched.map((m) => {
     if ((m as { discriminator?: unknown }).discriminator && m.fields.length === 0) {
@@ -54,7 +54,7 @@ export const rubyEmitter: Emitter = {
   language: 'ruby',
 
   generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
-    const modelFiles = generateModels(enrichModelsForRuby(models), ctx);
+    const modelFiles = generateModels(enrichModelsForRuby(models, ctx.spec.enums), ctx);
     return ensureTrailingNewlines(modelFiles);
   },
 

package/src/ruby/models.ts

@@ -1,7 +1,11 @@
 import type { Model, EmitterContext, GeneratedFile, TypeRef, Field } from '@workos/oagen';
 import { walkTypeRef, assignModelsToServices } from '@workos/oagen';
 import { className, fieldName, fileName, buildMountDirMap } from './naming.js';
-import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import {
+  isListWrapperModel,
+  isListMetadataModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 
 /** Folder under lib/workos/ for models not owned by any service. */
 export const SHARED_MODEL_DIR = 'shared';
@@ -77,11 +81,17 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
 
   const files: GeneratedFile[] = [];
 
+  // Wrappers referenced as a non-paginated response (e.g. `VersionListResponse`
+  // for `GET /vault/v1/kv/{id}/versions`) must still be emitted — the resource
+  // 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);
+
   // Dedup identical models (by recursive structural hash).
   const recursiveHashes = buildRecursiveHashMap(models, enumNames);
   const hashGroups = new Map<string, string[]>();
   for (const m of models) {
-    if (isListWrapperModel(m) || isListMetadataModel(m)) continue;
+    if (skipAsListWrapper(m) || isListMetadataModel(m)) continue;
     const h = recursiveHashes.get(m.name) ?? '';
     if (!hashGroups.has(h)) hashGroups.set(h, []);
     hashGroups.get(h)!.push(m.name);
@@ -95,7 +105,7 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   }
 
   for (const model of models) {
-    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
 
     const cls = className(model.name);
     const file = fileName(model.name);

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/rust/models.ts

@@ -140,7 +140,11 @@ function renderField(field: Field, rustField: string, modelName: string, registr
 function renderModelsBarrel(modules: string[]): string {
   const sorted = [...new Set(modules)].sort();
   const lines: string[] = [];
-  for (const m of sorted) lines.push(`pub mod ${m};`);
+  // Declare the modules privately so `pub use crate::models::*` in lib.rs only
+  // re-exports the struct names, not the module names themselves. Otherwise a
+  // module like `models::organization_membership` collides with the same-named
+  // `resources::organization_membership` when both barrels are glob-re-exported.
+  for (const m of sorted) lines.push(`mod ${m};`);
   lines.push('');
   for (const m of sorted) lines.push(`pub use ${m}::*;`);
   return lines.join('\n') + '\n';

package/src/rust/resources.ts

@@ -1317,7 +1317,10 @@ function renderResourcesBarrel(exports: { module: string; struct: string }[]): s
   unique.sort((a, b) => a.module.localeCompare(b.module));
 
   const lines: string[] = [];
-  for (const { module } of unique) lines.push(`pub mod ${module};`);
+  // Declare modules privately — see the matching comment in `models.ts`.
+  // `pub mod resources::organization_membership` would collide with the
+  // same-named module re-exported via `pub use models::*` in lib.rs.
+  for (const { module } of unique) lines.push(`mod ${module};`);
   lines.push('');
   for (const { module, struct } of unique) lines.push(`pub use ${module}::${struct};`);
   return lines.join('\n') + '\n';

package/src/shared/model-utils.ts

@@ -1,10 +1,31 @@
-import type { Model, Field, TypeRef, Enum } from '@workos/oagen';
-import { toSnakeCase, toUpperSnakeCase } from '@workos/oagen';
+import type { Model, Field, TypeRef, Enum, Service } 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
 import { load as yamlLoad } from 'js-yaml';
 
+/**
+ * Collect model names referenced as the return type of any non-paginated
+ * operation. The list-wrapper skip rule below assumes a wrapper is always
+ * replaced by the SDK's pagination machinery — but a few endpoints
+ * (e.g. `GET /vault/v1/kv/{id}/versions`) have a list-envelope response
+ * shape with no pagination params, so the parser leaves them as a plain
+ * model reference. We must still emit those wrappers as regular models;
+ * otherwise the generated resource code references an undefined name.
+ */
+export function collectNonPaginatedResponseModelNames(services: Service[]): Set<string> {
+  const names = new Set<string>();
+  for (const service of services) {
+    for (const op of service.operations) {
+      if (op.pagination) continue;
+      walkTypeRef(op.response, { model: (r) => names.add(r.name) });
+      for (const sr of op.successResponses ?? []) walkTypeRef(sr.type, { model: (r) => names.add(r.name) });
+    }
+  }
+  return names;
+}
+
 /**
  * Detect whether a model is a list wrapper -- the standard paginated
  * list envelope with `data` (array), `list_metadata`, and optionally `object: 'list'`.
@@ -51,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;
@@ -503,7 +559,7 @@ export function detectDiscriminators(models: Model[]): Model[] {
  * Returns a new array of enriched models (original models are not mutated).
  * Synthetic enums are stored internally; retrieve them via `getSyntheticEnums()`.
  */
-export function enrichModelsFromSpec(models: Model[]): Model[] {
+export function enrichModelsFromSpec(models: Model[], enums: Enum[] = []): Model[] {
   const spec = loadRawSpec();
   if (!spec) {
     _lastSyntheticEnums = [];
@@ -518,6 +574,17 @@ export function enrichModelsFromSpec(models: Model[]): Model[] {
     collector.usedNames.add(m.name);
     collector.usedNames.add(toSnakeCase(m.name));
   }
+  // Seed existing IR enum names too. The parser already emits inline enums
+  // like `DataIntegrationAccessTokenResponseError` (PascalCase); without this
+  // seed, the synthetic path would emit a sibling enum named
+  // `DataIntegrationAccessTokenResponse_error`, and language emitters that
+  // PascalCase-normalize identifiers (Ruby, Go, PHP, Python) would collapse
+  // both onto the same class/file path — the second overwrites the first
+  // with a `X = X` self-alias.
+  for (const e of enums) {
+    collector.usedNames.add(e.name);
+    collector.usedNames.add(toSnakeCase(e.name));
+  }
 
   const enriched = models.map((model) => {
     const rawSchema = lookupRawSchema(model.name);

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');
+  });
+});

package/test/node/tests.test.ts

@@ -268,4 +268,73 @@ describe('node test generation ownership', () => {
       fs.rmSync(tmpRoot, { recursive: true, force: true });
     }
   });
+
+  it('asserts toBeNull() for nullable fields whose example is null', () => {
+    // When the spec gives `example: null` on a nullable field — common for
+    // optional date-times like `last_used_at` — the previous emitter would
+    // emit `expect(x.toISOString()).toBe(null)`, which both blows up at
+    // runtime on a null `x` and never matches when `x` is a Date.
+    const secretModel: Model = {
+      name: 'Secret',
+      fields: [
+        { name: 'id', type: { kind: 'primitive', type: 'string' }, required: true, example: 'sec_1' },
+        {
+          name: 'last_used_at',
+          type: {
+            kind: 'nullable',
+            inner: { kind: 'primitive', type: 'string', format: 'date-time' },
+          },
+          required: true,
+          example: null,
+        },
+        {
+          name: 'created_at',
+          type: { kind: 'primitive', type: 'string', format: 'date-time' },
+          required: true,
+          example: '2026-01-15T12:00:00.000Z',
+        },
+      ],
+    };
+
+    const showOp = {
+      name: 'showSecret',
+      httpMethod: 'get' as const,
+      path: '/secrets/{id}',
+      pathParams: [{ name: 'id', type: { kind: 'primitive' as const, type: 'string' as const }, required: true }],
+      queryParams: [],
+      headerParams: [],
+      response: { kind: 'model' as const, name: 'Secret' },
+      errors: [],
+      injectIdempotencyKey: false,
+    };
+    const secretService: Service = { name: 'Secrets', operations: [showOp] };
+    const secretSpec: ApiSpec = {
+      ...spec,
+      models: [secretModel],
+      services: [secretService],
+    };
+    const tmpRoot = createTrackedSdkRoot();
+    try {
+      fs.mkdirSync(path.join(tmpRoot, 'src', 'secrets', 'fixtures'), { recursive: true });
+      execFileSync('git', ['add', 'src'], { cwd: tmpRoot, stdio: 'ignore' });
+
+      const result = nodeEmitter.generateTests!(secretSpec, {
+        ...ctx,
+        spec: secretSpec,
+        outputDir: tmpRoot,
+        emitterOptions: { ownedServices: ['Secrets'], regenerateOwnedTests: true },
+      } as EmitterContext);
+
+      const testFile = result.find((f) => f.path === 'src/secrets/secrets.spec.ts');
+      expect(testFile).toBeDefined();
+      const content = testFile!.content;
+      // Null example on a nullable date-time → toBeNull(), not `.toISOString().toBe(null)`.
+      expect(content).toContain('expect(result.lastUsedAt).toBeNull();');
+      expect(content).not.toContain('lastUsedAt.toISOString()).toBe(null)');
+      // Non-null date-time examples still go through `.toISOString()`.
+      expect(content).toContain("expect(result.createdAt.toISOString()).toBe('2026-01-15T12:00:00.000Z');");
+    } finally {
+      fs.rmSync(tmpRoot, { recursive: true, force: true });
+    }
+  });
 });

package/test/rust/models.test.ts

@@ -110,7 +110,7 @@ describe('rust/models', () => {
     const event = files.find((f) => f.path === 'src/models/event.rs')!;
     expect(event.content).toContain('pub payload: EventPayloadOneOf,');
     const barrel = files.find((f) => f.path === 'src/models/mod.rs')!;
-    expect(barrel.content).toContain('pub mod _unions;');
+    expect(barrel.content).toContain('mod _unions;');
     // The _unions.rs file is rendered by generateClient (the final structural
     // pass) so resource-side body unions can join the same registry.
     const clientFiles = generateClient(emptySpec, ctx, registry);
@@ -170,8 +170,8 @@ describe('rust/models', () => {
     ];
     const files = generateModels(models, ctx, new UnionRegistry());
     const barrel = files.find((f) => f.path === 'src/models/mod.rs')!;
-    expect(barrel.content).toContain('pub mod alpha;');
-    expect(barrel.content).toContain('pub mod beta;');
+    expect(barrel.content).toContain('mod alpha;');
+    expect(barrel.content).toContain('mod beta;');
     expect(barrel.content).toContain('pub use alpha::*;');
   });
 });