@workos/oagen-emitters 0.14.0 → 0.14.2

package/dist/plugin.mjs

@@ -1,2 +1,2 @@
-import { t as workosEmittersPlugin } from "./plugin-BxVeu2v9.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.0",
+  "version": "0.14.2",
   "description": "WorkOS' oagen emitters",
   "license": "MIT",
   "author": "WorkOS",

package/src/dotnet/models.ts

@@ -20,7 +20,11 @@ import {
 } from './naming.js';
 
 // Import and re-export shared model detection utilities
-import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import {
+  isListWrapperModel,
+  isListMetadataModel,
+  collectNonPaginatedResponseModelNames,
+} from '../shared/model-utils.js';
 export { isListWrapperModel, isListMetadataModel };
 
 /**
@@ -74,6 +78,11 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
   // (see workos-dotnet#248 with `CreateUserApiKey` /
   // `UserManagementCreateApiKeyOptions`). Skip emission for those.
   const requestBodyOnlyNames = collectRequestBodyOnlyModelNames(ctx.spec.services, models);
+  // 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);
 
   // 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.
@@ -81,9 +90,12 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
   if (discCtx) {
     for (const model of models) {
       if (discCtx.discriminatorBases.has(model.name)) {
+        const baseClassName = modelClassName(model.name);
         const fieldMap = new Map<string, string>();
         for (const field of model.fields) {
-          fieldMap.set(fieldName(field.name), mapTypeRef(field.type));
+          let csName = fieldName(field.name);
+          if (csName === baseClassName) csName = `${csName}Value`;
+          fieldMap.set(csName, mapTypeRef(field.type));
         }
         baseFieldLookup.set(model.name, fieldMap);
       }
@@ -91,7 +103,7 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
   }
 
   for (const model of models) {
-    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
     if (requestBodyOnlyNames.has(model.name)) continue;
 
     const csClassName = modelClassName(model.name);
@@ -104,7 +116,11 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
     const fieldTypes = model.fields.map((f) => mapTypeRef(f.type));
     const needsCollections = fieldTypes.some((t) => t.startsWith('List<') || t.startsWith('Dictionary<'));
     const needsSystem = fieldTypes.some((t) => t.includes('DateTimeOffset'));
-    const needsJsonAttrs = model.fields.some((f) => f.required && isEnumRef(f.type));
+    // 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));
 
     lines.push(`namespace ${ctx.namespacePascal}`);
     lines.push('{');
@@ -154,7 +170,14 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
     // Deduplicate fields by C# property name
     const seenFieldNames = new Set<string>();
     for (const field of model.fields) {
-      const csFieldName = fieldName(field.name);
+      // CS0542: a property can't share its enclosing class's name. Spec schemas
+      // like `Error.error` PascalCase into `Error.Error`, so suffix with `Value`
+      // 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);
+      const collidesWithClassName = csFieldName === csClassName;
+      if (collidesWithClassName) csFieldName = `${csFieldName}Value`;
       if (seenFieldNames.has(csFieldName)) continue;
       seenFieldNames.add(csFieldName);
 
@@ -234,7 +257,9 @@ export function generateModels(models: Model[], ctx: EmitterContext, discCtx?: D
       }
 
       const isRequiredEnum = field.required && isEnumRef(field.type) && constInit === null;
-      lines.push(...emitJsonPropertyAttributes(field.name, { isRequiredEnum }));
+      lines.push(
+        ...emitJsonPropertyAttributes(field.name, { isRequiredEnum, explicitWireName: collidesWithClassName }),
+      );
       // 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

package/src/dotnet/type-map.ts

@@ -156,7 +156,24 @@ export function isEnumRef(ref: TypeRef): boolean {
  * omission so the API returns a clear `missing required field` error instead
  * of a confusing 422.
  */
-export function emitJsonPropertyAttributes(_wireName: string, options: { isRequiredEnum?: boolean } = {}): string[] {
+export function emitJsonPropertyAttributes(
+  wireName: string,
+  options: { isRequiredEnum?: boolean; explicitWireName?: boolean } = {},
+): string[] {
+  // When the C# property name doesn't naturally map back to the wire name via
+  // the SnakeCaseLower naming policy (e.g. we suffixed the property to avoid a
+  // CS0542 class/member collision like `Error.Error` → `Error.ErrorValue`), the
+  // caller pins the wire name explicitly so JSON round-trip still works.
+  if (options.explicitWireName) {
+    if (options.isRequiredEnum) {
+      return [
+        `        [JsonProperty("${wireName}", DefaultValueHandling = DefaultValueHandling.Ignore)]`,
+        `        [STJS.JsonIgnore(Condition = STJS.JsonIgnoreCondition.WhenWritingDefault)]`,
+        `        [STJS.JsonPropertyName("${wireName}")]`,
+      ];
+    }
+    return [`        [JsonProperty("${wireName}")]`, `        [STJS.JsonPropertyName("${wireName}")]`];
+  }
   if (options.isRequiredEnum) {
     return [
       `        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]`,

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

@@ -5,7 +5,12 @@ import { className, fieldName } from './naming.js';
 import { lowerFirstForDoc, fieldDocComment, articleFor } from '../shared/naming-utils.js';
 
 // Import and re-export shared model detection utilities
-import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import {
+  isListWrapperModel,
+  isListMetadataModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
+} from '../shared/model-utils.js';
 export { isListWrapperModel, isListMetadataModel };
 
 /**
@@ -83,12 +88,22 @@ export function generateModels(models: Model[], ctx: EmitterContext): GeneratedF
   lines.push('');
 
   const requestBodyOnly = collectRequestBodyOnlyModelNames(ctx.spec.services, models);
+  // 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);
+  // 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 (isListWrapperModel(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);
@@ -112,7 +127,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 (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     if (requestBodyOnly.has(model.name)) continue;
 
     const structName = className(model.name);

package/src/kotlin/models.ts

@@ -2,7 +2,12 @@ import type { Model, EmitterContext, GeneratedFile, TypeRef, Field } from '@work
 import { mapTypeRef, discriminatedUnions } from './type-map.js';
 import { className, propertyName, ktStringLiteral, humanize } from './naming.js';
 import { enumCanonicalMap } from './enums.js';
-import { isListWrapperModel, isListMetadataModel } from '../shared/model-utils.js';
+import {
+  isListWrapperModel,
+  isListMetadataModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
+} from '../shared/model-utils.js';
 
 const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
 const MODELS_PACKAGE = 'com.workos.models';
@@ -47,7 +52,7 @@ function promoteFieldType(f: Field): Field {
  * List wrappers (`{ data, list_metadata }`) and the shared `ListMetadata`
  * model are skipped — the hand-maintained runtime provides [Page]/[ListMetadata].
  */
-export function generateModels(models: Model[], _ctx: EmitterContext): GeneratedFile[] {
+export function generateModels(models: Model[], ctx: EmitterContext): GeneratedFile[] {
   if (models.length === 0) return [];
 
   // First pass: call mapTypeRef on every model field so discriminator info is
@@ -58,12 +63,23 @@ export function generateModels(models: Model[], _ctx: EmitterContext): Generated
 
   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 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 (isListWrapperModel(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, []);
@@ -86,7 +102,7 @@ export function generateModels(models: Model[], _ctx: EmitterContext): Generated
   modelAliasMap = aliasOf;
   const hashGroupsPass2 = new Map<string, string[]>();
   for (const model of models) {
-    if (isListWrapperModel(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);
@@ -105,7 +121,7 @@ export function generateModels(models: Model[], _ctx: EmitterContext): Generated
   }
 
   for (const model of models) {
-    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
     const typeName = className(model.name);
 
     // Parent of a discriminated union: emit a sealed class.
@@ -142,7 +158,7 @@ export function generateModels(models: Model[], _ctx: EmitterContext): Generated
   // mapping so Jackson can deserialize directly to the correct concrete type.
   const eventMapping: Array<{ wireValue: string; modelName: string }> = [];
   for (const model of models) {
-    if (isListWrapperModel(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';
@@ -38,6 +39,24 @@ import { fileName } from './naming.js';
  */
 const surfaceCache = new WeakMap<EmitterContext, LiveSurface>();
 
+/**
+ * Paths the node emitter has produced so far in this ctx, accumulated across
+ * `applyLiveSurface` calls. Drives `carryForwardManagedFiles` so files in the
+ * prior manifest that we did not re-emit this run still land in the new
+ * manifest as "still managed" — without that, the orchestrator's prune diff
+ * treats every untouched autogen file as stale.
+ */
+const emittedPathsCache = new WeakMap<EmitterContext, Set<string>>();
+
+function getEmittedPaths(ctx: EmitterContext): Set<string> {
+  let set = emittedPathsCache.get(ctx);
+  if (!set) {
+    set = new Set();
+    emittedPathsCache.set(ctx, set);
+  }
+  return set;
+}
+
 function getSurface(ctx: EmitterContext): LiveSurface {
   let surface = surfaceCache.get(ctx);
   if (surface) return surface;
@@ -90,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;
 }
 
@@ -115,8 +147,10 @@ function getSurface(ctx: EmitterContext): LiveSurface {
  * `integrateTarget: false` files (smoke-manifest.json etc.) are also dropped:
  * with no `--target` step they would otherwise land as untracked cruft.
  *
- * Note: pairing this with `--no-prune` is required for stable behavior — see
- * `scripts/sdk-generate.sh` in the spec repo, which enables it for `--lang node`.
+ * Note: the carry-forward step in `generateTests` re-declares prior-manifest
+ * paths we didn't touch this run, so the orchestrator's prune diff stays
+ * accurate without needing `--no-prune` at the call site. See
+ * `carryForwardManagedFiles` below.
  */
 /**
  * `*.spec.ts`, `*.test.ts`, and JSON fixtures under `fixtures/` are owned by
@@ -355,6 +389,55 @@ function applyLiveSurface(files: GeneratedFile[], ctx: EmitterContext, surface:
     }
     out.push(f);
   }
+  const emitted = getEmittedPaths(ctx);
+  for (const f of out) emitted.add(f.path);
+  return out;
+}
+
+/**
+ * Re-declare prior-manifest paths that we did not emit this run so manifest
+ * pruning can tell "intentionally removed" from "untouched but still managed."
+ *
+ * The node emitter only outputs files it actually wants to write each run —
+ * untouched-but-up-to-date autogen files don't come back through any
+ * `generateXxx` method. Without this carry-forward, the orchestrator's
+ * `prevManifest.files − currentEmission` diff treats every such file as stale
+ * and prunes the whole tree on a regen. That's why `scripts/sdk-generate.sh`
+ * historically paired the node emitter with `--no-prune` — at the cost of
+ * never pruning legitimately-removed files (e.g. an enum file orphaned by a
+ * `schemaNameTransform` rename like `RadarAction` → `RadarListAction`).
+ *
+ * The carry-forward entry uses `skipIfExists: true`, so writer.ts skips the
+ * write and only ensures the header is present (no-op for files that already
+ * have it). The path still lands in `outputEmittedPaths` and therefore in the
+ * new manifest, which restores correct prune semantics.
+ *
+ * Files dropped from the carry-forward set:
+ *  - Not on disk anymore (file was hand-deleted — let prune confirm absence).
+ *  - `@oagen-ignore-file` protected (user has explicitly taken ownership).
+ *  - `.ts` files that no longer carry the auto-gen header (user has taken
+ *    ownership in-place; the next prune cycle will clear the manifest entry).
+ */
+function carryForwardManagedFiles(ctx: EmitterContext, surface: LiveSurface): GeneratedFile[] {
+  const priorPaths = ctx.priorTargetManifestPaths;
+  if (!priorPaths || priorPaths.size === 0) return [];
+
+  const emitted = getEmittedPaths(ctx);
+  const out: GeneratedFile[] = [];
+  for (const relPath of priorPaths) {
+    if (emitted.has(relPath)) continue;
+    if (!surface.files.has(relPath)) continue;
+    if (surface.protectedFiles.has(relPath)) continue;
+    if (relPath.endsWith('.ts') && !surface.autogenFiles.has(relPath)) continue;
+
+    out.push({
+      path: relPath,
+      content: '',
+      skipIfExists: true,
+      headerPlacement: 'skip',
+    });
+    emitted.add(relPath);
+  }
   return out;
 }
 
@@ -440,11 +523,16 @@ export const nodeEmitter: Emitter = {
 
   // Test specs and fixtures are hand-maintained except for explicitly-owned
   // service directories.
+  //
+  // This is also the last `generateXxx` hook in `generateAllFiles`, so it's
+  // where we tack on the carry-forward set — see `carryForwardManagedFiles`.
   generateTests(spec: ApiSpec, ctx: EmitterContext): GeneratedFile[] {
     const nodeCtx = withNodeOperationOverrides(ctx);
-    if (!nodeOptions(nodeCtx).regenerateOwnedTests) return [];
     const surface = getSurface(nodeCtx);
-    return applyLiveSurface(generateTestFiles(spec, nodeCtx), nodeCtx, surface);
+    const testFiles = nodeOptions(nodeCtx).regenerateOwnedTests
+      ? applyLiveSurface(generateTestFiles(spec, nodeCtx), nodeCtx, surface)
+      : [];
+    return [...testFiles, ...carryForwardManagedFiles(nodeCtx, surface)];
   },
 
   // No operations map needed — the manifest belongs to the staging+target flow,

package/src/node/models.ts

@@ -23,6 +23,8 @@ import {
   createServiceDirResolver,
   isListMetadataModel,
   isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+  collectReferencedListMetadataModels,
   buildDeduplicationMap,
   relativeImport,
   modelHasNewFields,
@@ -209,12 +211,24 @@ export function generateModels(models: Model[], ctx: EmitterContext, shared?: Sh
   }
 
   const discriminatedSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
+  // 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 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 (isListWrapperModel(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);
     const isOwnedModel = isNodeOwnedService(ctx, service);
@@ -512,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
@@ -733,13 +754,18 @@ 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 (isListWrapperModel(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);
     const isOwnedModel = isNodeOwnedService(ctx, service);