@workos/oagen-emitters 0.14.0 → 0.14.1

package/dist/plugin.mjs

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workos/oagen-emitters",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "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/models.ts

@@ -5,7 +5,11 @@ 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,
+} from '../shared/model-utils.js';
 export { isListWrapperModel, isListMetadataModel };
 
 /**
@@ -83,12 +87,17 @@ 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);
 
   // 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) || isListMetadataModel(model)) continue;
     if (requestBodyOnly.has(model.name)) continue;
     const hash = structuralHash(model);
     modelHashMap.set(model.name, hash);
@@ -112,7 +121,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) || isListMetadataModel(model)) continue;
     if (requestBodyOnly.has(model.name)) continue;
 
     const structName = className(model.name);

package/src/kotlin/models.ts

@@ -2,7 +2,11 @@ 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,
+} from '../shared/model-utils.js';
 
 const KOTLIN_SRC_PREFIX = 'src/main/kotlin/';
 const MODELS_PACKAGE = 'com.workos.models';
@@ -47,7 +51,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 +62,18 @@ 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);
+
   // 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) || isListMetadataModel(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 +96,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) || isListMetadataModel(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 +115,7 @@ export function generateModels(models: Model[], _ctx: EmitterContext): Generated
   }
 
   for (const model of models) {
-    if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+    if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
     const typeName = className(model.name);
 
     // Parent of a discriminated union: emit a sealed class.
@@ -142,7 +152,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) || isListMetadataModel(model)) continue;
     if (aliasOf.has(model.name)) continue;
     if (!isEventEnvelopeModel(model)) continue;
     const eventField = model.fields.find((f) => f.name === 'event');

package/src/node/index.ts

@@ -38,6 +38,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;
@@ -115,8 +133,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 +375,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 +509,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,7 @@ import {
   createServiceDirResolver,
   isListMetadataModel,
   isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
   buildDeduplicationMap,
   relativeImport,
   modelHasNewFields,
@@ -209,12 +210,16 @@ 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);
   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 (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
     if (discriminatedSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);
@@ -733,13 +738,14 @@ export function generateSerializers(
   }
 
   const discriminatedSerializerSkip = (ctx as { _discriminatedModelNames?: Set<string> })._discriminatedModelNames;
+  const serializerNonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
   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 (isListWrapperModel(model) && !serializerNonPaginatedRefs.has(model.name)) continue;
     if (discriminatedSerializerSkip?.has(model.name)) continue;
     const service = modelToService.get(model.name);
     const isOwnedModel = isNodeOwnedService(ctx, service);

package/src/node/utils.ts

@@ -277,7 +277,11 @@ export function isBaselineGeneric(fields: Record<string, unknown>, knownNames: S
   return false;
 }
 
-export { isListMetadataModel, isListWrapperModel } from '../shared/model-utils.js';
+export {
+  isListMetadataModel,
+  isListWrapperModel,
+  collectNonPaginatedResponseModelNames,
+} 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/models.ts

@@ -41,9 +41,15 @@ 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);
+
   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;
 
@@ -865,5 +871,9 @@ 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,
+} 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/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/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 { 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'`.
@@ -503,7 +524,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 +539,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/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::*;');
   });
 });