@workos/oagen-emitters 0.14.0 → 0.14.2

package/dist/{plugin-BxVeu2v9.mjs → plugin-BbSmT2kj.mjs}

@@ -2286,6 +2286,24 @@ dumper.dump;
 //#endregion
 //#region src/shared/model-utils.ts
 /**
+* 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.
+*/
+function collectNonPaginatedResponseModelNames(services) {
+	const names = /* @__PURE__ */ new Set();
+	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'`.
 *
@@ -2316,6 +2334,35 @@ function isListMetadataModel(model) {
 	if (!before || !after) return false;
 	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.
+*/
+function collectReferencedListMetadataModels(models, nonPaginatedRefs) {
+	const listMetadataNames = /* @__PURE__ */ new Set();
+	for (const m of models) if (isListMetadataModel(m)) listMetadataNames.add(m.name);
+	if (listMetadataNames.size === 0) return /* @__PURE__ */ new Set();
+	const referenced = /* @__PURE__ */ new Set();
+	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) {
 	if (field.type.kind === "primitive" && field.type.type === "string") return true;
@@ -2636,7 +2683,7 @@ function detectDiscriminators(models) {
 * Returns a new array of enriched models (original models are not mutated).
 * Synthetic enums are stored internally; retrieve them via `getSyntheticEnums()`.
 */
-function enrichModelsFromSpec(models) {
+function enrichModelsFromSpec(models, enums = []) {
 	if (!loadRawSpec()) {
 		_lastSyntheticEnums = [];
 		return models;
@@ -2646,6 +2693,10 @@ function enrichModelsFromSpec(models) {
 		collector.usedNames.add(m.name);
 		collector.usedNames.add(toSnakeCase(m.name));
 	}
+	for (const e of enums) {
+		collector.usedNames.add(e.name);
+		collector.usedNames.add(toSnakeCase(e.name));
+	}
 	const enriched2 = models.map((model) => {
 		const rawSchema = lookupRawSchema(model.name);
 		if (!rawSchema) return model;
@@ -2804,6 +2855,22 @@ function isAdoptedModelName(name) {
 	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 = /* @__PURE__ */ new Set();
+function setStructurallyRenamedDomainNames(names) {
+	structurallyRenamedDomainNames = names;
+}
+/**
 * Wire/response interface name.
 *
 * Resolution order:
@@ -2826,7 +2893,7 @@ function wireInterfaceName(domainName) {
 	if (domainName.endsWith("Response")) {
 		const wireForm = `${domainName}Wire`;
 		if (baselineInterfaceNames.has(wireForm)) return wireForm;
-		if (baselineInterfaceNames.has(domainName)) return domainName;
+		if (structurallyRenamedDomainNames.has(domainName) && baselineInterfaceNames.has(domainName)) return domainName;
 		return wireForm;
 	}
 	return `${domainName}Response`;
@@ -4870,8 +4937,11 @@ function generateResourceClass(service, ctx) {
 		importedTypeNames.add(resolved);
 		const modelServiceDir = resolveDir(modelToService.get(name));
 		const relPath = modelServiceDir === serviceDir ? `./interfaces/${fileName$3(name)}.interface` : `../${modelServiceDir}/interfaces/${fileName$3(name)}.interface`;
-		if (usedWireTypes.has(resolved)) lines.push(`import type { ${resolved}, ${wireInterfaceName(resolved)} } from '${relPath}';`);
-		else lines.push(`import type { ${resolved} } from '${relPath}';`);
+		if (usedWireTypes.has(resolved)) {
+			const wireName = wireInterfaceName(resolved);
+			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}';`);
 	}
 	for (const name of requestModels) {
 		if (allModels.has(name)) continue;
@@ -5799,11 +5869,13 @@ function generateFixtures$5(spec, ctx) {
 			walk(field.type);
 		}
 	}
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+	const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
 	const seenFixturePaths = /* @__PURE__ */ new Set();
 	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 fixturePath = `src/${resolveDir(modelToService.get(model.name))}/fixtures/${fileName$3(model.name)}.json`;
 		if (seenFixturePaths.has(fixturePath)) continue;
 		seenFixturePaths.add(fixturePath);
@@ -5991,12 +6063,14 @@ function generateModels$7(models, ctx, shared) {
 		}
 	}
 	const discriminatedSkip = ctx._discriminatedModelNames;
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	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);
@@ -6185,25 +6259,27 @@ function generateModels$7(models, ctx, shared) {
 			lines.push("}");
 		}
 		lines.push("");
-		const seenWireFields = /* @__PURE__ */ new Set();
-		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;
-					const opt = baselineField?.optional === true || !field.required || isNewFieldOnExistingModel ? "?" : "";
-					lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+		if (responseName !== domainName) {
+			const seenWireFields = /* @__PURE__ */ new Set();
+			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;
+						const opt = baselineField?.optional === true || !field.required || isNewFieldOnExistingModel ? "?" : "";
+						lines.push(`  ${wireField}${opt}: ${mapWireTypeRef(field.type, modelWireTypeRefOpts)};`);
+					}
 				}
+				lines.push("}");
 			}
-			lines.push("}");
 		}
 		const filePath = `src/${dirName}/interfaces/${fileName$3(model.name)}.interface.ts`;
 		if (ctx.apiSurface && ctx.targetDir) {
@@ -6330,13 +6406,15 @@ function generateSerializers(models, ctx, shared) {
 		}
 	}
 	const discriminatedSerializerSkip = ctx._discriminatedModelNames;
+	const serializerNonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const serializerListMetadataNeeded = collectReferencedListMetadataModels(models, serializerNonPaginatedRefs);
 	const eligibleModels = [];
 	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;
 		if (!isNodeOwnedService(ctx, modelToService.get(model.name)) && !modelHasNewFields(model, ctx) && !forceGenerateSerializer.has(model.name)) continue;
 		eligibleModels.push(model);
@@ -7391,7 +7469,11 @@ function buildFieldAssertions(model, accessor, modelMap) {
 		const domainField = fieldName$6(field.name);
 		const fieldAccessor = isDateTimeFieldType(field.type) ? `${accessor}.${domainField}.toISOString()` : `${accessor}.${domainField}`;
 		if (field.example !== void 0) {
-			if (typeof field.example === "object" && field.example !== null) assertions.push(`expect(${accessor}.${domainField}).toEqual(${JSON.stringify(field.example)});`);
+			if (field.example === null) {
+				assertions.push(`expect(${accessor}.${domainField}).toBeNull();`);
+				continue;
+			}
+			if (typeof field.example === "object") assertions.push(`expect(${accessor}.${domainField}).toEqual(${JSON.stringify(field.example)});`);
 			else {
 				const exampleLiteral = typeof field.example === "string" ? `'${field.example}'` : String(field.example);
 				assertions.push(`expect(${fieldAccessor}).toBe(${exampleLiteral});`);
@@ -8183,6 +8265,22 @@ function withNodeOperationOverrides(ctx) {
 * one oagen run, so we walk the target SDK once and reuse it.
 */
 const surfaceCache = /* @__PURE__ */ new WeakMap();
+/**
+* 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 = /* @__PURE__ */ new WeakMap();
+function getEmittedPaths(ctx) {
+	let set = emittedPathsCache.get(ctx);
+	if (!set) {
+		set = /* @__PURE__ */ new Set();
+		emittedPathsCache.set(ctx, set);
+	}
+	return set;
+}
 function getSurface(ctx) {
 	let surface = surfaceCache.get(ctx);
 	if (surface) return surface;
@@ -8205,6 +8303,12 @@ function getSurface(ctx) {
 	setBaselineInterfaceNames(allInterfaces);
 	setInlineEnumUnions(/* @__PURE__ */ new Map());
 	setAdoptedModelNames(computeAdoptedModelNames(ctx, surface));
+	const renamed = /* @__PURE__ */ new Set();
+	for (const model of ctx.spec.models) {
+		const resolved = resolveInterfaceName(model.name, ctx);
+		if (resolved !== model.name) renamed.add(resolved);
+	}
+	setStructurallyRenamedDomainNames(renamed);
 	return surface;
 }
 /**
@@ -8229,8 +8333,10 @@ function getSurface(ctx) {
 * `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
@@ -8380,6 +8486,52 @@ function applyLiveSurface(files, ctx, surface) {
 		if (f.content && !f.content.endsWith("\n")) f.content += "\n";
 		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, surface) {
+	const priorPaths = ctx.priorTargetManifestPaths;
+	if (!priorPaths || priorPaths.size === 0) return [];
+	const emitted = getEmittedPaths(ctx);
+	const out = [];
+	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;
 }
 /**
@@ -8446,9 +8598,8 @@ const nodeEmitter = {
 	},
 	generateTests(spec, ctx) {
 		const nodeCtx = withNodeOperationOverrides(ctx);
-		if (!nodeOptions(nodeCtx).regenerateOwnedTests) return [];
 		const surface = getSurface(nodeCtx);
-		return applyLiveSurface(generateTests$7(spec, nodeCtx), nodeCtx, surface);
+		return [...nodeOptions(nodeCtx).regenerateOwnedTests ? applyLiveSurface(generateTests$7(spec, nodeCtx), nodeCtx, surface) : [], ...carryForwardManagedFiles(nodeCtx, surface)];
 	},
 	buildOperationsMap() {
 		return {};
@@ -9225,9 +9376,11 @@ function generateModels$6(models, ctx) {
 	const symbolToFile = /* @__PURE__ */ new Map();
 	const symbolToOriginalService = /* @__PURE__ */ new Map();
 	const emittedFilePaths = /* @__PURE__ */ new Set();
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
 	for (const model of models) {
-		if (isListWrapperModel(model)) continue;
-		if (isListMetadataModel(model)) continue;
+		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
+		if (isListMetadataModel(model) && !listMetadataNeeded.has(model.name)) continue;
 		const dirName = resolveDir(modelToService.get(model.name));
 		const modelClassName = className$5(model.name);
 		const modelFilePath = `src/${ctx.namespace}/${dirName}/models/${fileName$2(model.name)}.py`;
@@ -10640,7 +10793,9 @@ function generateResources$6(services, ctx) {
 		}
 		for (const op of allOperations) {
 			const plan = planOperation(op);
-			if (plan.responseModelName && !listWrapperNames.has(plan.responseModelName)) modelImports.add(plan.responseModelName);
+			if (plan.responseModelName) {
+				if (!listWrapperNames.has(plan.responseModelName) || !plan.isPaginated) modelImports.add(plan.responseModelName);
+			}
 			if (op.requestBody?.kind === "model") {
 				const requestBodyRef = op.requestBody;
 				modelImports.add(requestBodyRef.name);
@@ -11248,9 +11403,11 @@ function generateFixtures$4(spec) {
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
 	const files = [];
+	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;
 		if (model.fields.length === 0) continue;
 		const fixture = generateModelFixture$4(model, modelMap, enumMap);
 		files.push({
@@ -12328,7 +12485,9 @@ function generateModelRoundTripTests(spec, ctx) {
 		}
 	}
 	for (const name of responseModelNames) requestOnlyModelNames.delete(name);
-	const models = spec.models.filter((m) => !isListWrapperModel(m) && !isListMetadataModel(m) && !requestOnlyModelNames.has(m.name));
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(spec.services);
+	const listMetadataNeeded = collectReferencedListMetadataModels(spec.models, nonPaginatedRefs);
+	const models = spec.models.filter((m) => !(isListWrapperModel(m) && !nonPaginatedRefs.has(m.name)) && !(isListMetadataModel(m) && !listMetadataNeeded.has(m.name)) && !requestOnlyModelNames.has(m.name));
 	if (models.length === 0) return null;
 	const modelToService = computeSchemaPlacement(spec, ctx).originalModelToService;
 	const roundTripDirMap = buildMountDirMap$1(ctx);
@@ -12769,9 +12928,10 @@ function generateModels$5(models, ctx) {
 		].join("\n"),
 		overwriteExisting: true
 	});
+	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$4(model.name);
 		const lines = [];
 		lines.push(`namespace ${ctx.namespacePascal}\\Resource;`);
@@ -14671,10 +14831,14 @@ function generateModels$4(models, ctx) {
 	lines.push(`package ${ctx.namespace}`);
 	lines.push("");
 	const requestBodyOnly = collectRequestBodyOnlyModelNames$1(ctx.spec.services, models);
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const skipAsListWrapper = (m) => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
+	const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+	const skipAsListMetadata = (m) => isListMetadataModel(m) && !listMetadataNeeded.has(m.name);
 	const modelHashMap = /* @__PURE__ */ new Map();
 	const hashGroups = /* @__PURE__ */ new Map();
 	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$2(model);
 		modelHashMap.set(model.name, hash);
@@ -14691,7 +14855,7 @@ function generateModels$4(models, ctx) {
 	}
 	const batchedAliases = /* @__PURE__ */ new Set();
 	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$3(model.name);
 		const canonicalName = aliasOf.get(model.name);
@@ -16233,9 +16397,11 @@ function generateFixtures$2(spec) {
 	const modelMap = new Map(spec.models.map((m) => [m.name, m]));
 	const enumMap = new Map(spec.enums.map((e) => [e.name, e]));
 	const files = [];
+	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$2(model, modelMap, enumMap);
 		files.push({
 			path: `testdata/${fileName$1(model.name)}.json`,
@@ -17324,7 +17490,15 @@ function isEnumRef(ref) {
 * omission so the API returns a clear `missing required field` error instead
 * of a confusing 422.
 */
-function emitJsonPropertyAttributes(_wireName, options = {}) {
+function emitJsonPropertyAttributes(wireName, options = {}) {
+	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)]`, `        [STJS.JsonIgnore(Condition = STJS.JsonIgnoreCondition.WhenWritingDefault)]`];
 	return [];
 }
@@ -17377,16 +17551,23 @@ function generateModels$3(models, ctx, discCtx) {
 	const files = [];
 	primeModelAliases(models);
 	const requestBodyOnlyNames = collectRequestBodyOnlyModelNames(ctx.spec.services, models);
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const skipAsListWrapper = (m) => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
 	const baseFieldLookup = /* @__PURE__ */ new Map();
 	if (discCtx) {
 		for (const model of models) if (discCtx.discriminatorBases.has(model.name)) {
+			const baseClassName = modelClassName(model.name);
 			const fieldMap = /* @__PURE__ */ new Map();
-			for (const field of model.fields) fieldMap.set(fieldName$2(field.name), mapTypeRef$3(field.type));
+			for (const field of model.fields) {
+				let csName = fieldName$2(field.name);
+				if (csName === baseClassName) csName = `${csName}Value`;
+				fieldMap.set(csName, mapTypeRef$3(field.type));
+			}
 			baseFieldLookup.set(model.name, fieldMap);
 		}
 	}
 	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);
 		if (isModelAlias(model.name)) continue;
@@ -17394,7 +17575,7 @@ function generateModels$3(models, ctx, discCtx) {
 		const fieldTypes = model.fields.map((f) => mapTypeRef$3(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));
+		const needsJsonAttrs = model.fields.some((f) => fieldName$2(f.name) === csClassName) || model.fields.some((f) => f.required && isEnumRef(f.type));
 		lines.push(`namespace ${ctx.namespacePascal}`);
 		lines.push("{");
 		if (needsSystem) lines.push("    using System;");
@@ -17420,7 +17601,9 @@ function generateModels$3(models, ctx, discCtx) {
 		const dictObjectFields = [];
 		const seenFieldNames = /* @__PURE__ */ new Set();
 		for (const field of model.fields) {
-			const csFieldName = fieldName$2(field.name);
+			let csFieldName = fieldName$2(field.name);
+			const collidesWithClassName = csFieldName === csClassName;
+			if (collidesWithClassName) csFieldName = `${csFieldName}Value`;
 			if (seenFieldNames.has(csFieldName)) continue;
 			seenFieldNames.add(csFieldName);
 			let useNewModifier = false;
@@ -17465,7 +17648,10 @@ function generateModels$3(models, ctx, discCtx) {
 				lines.push(`        [System.Obsolete("${msg}")]`);
 			}
 			const isRequiredEnum = field.required && isEnumRef(field.type) && constInit === null;
-			lines.push(...emitJsonPropertyAttributes(field.name, { isRequiredEnum }));
+			lines.push(...emitJsonPropertyAttributes(field.name, {
+				isRequiredEnum,
+				explicitWireName: collidesWithClassName
+			}));
 			const discriminatedUnionConverter = discriminatedUnionConverterName(field.type);
 			if (discriminatedUnionConverter) lines.push(`        [Newtonsoft.Json.JsonConverter(typeof(${discriminatedUnionConverter}))]`);
 			const newMod = useNewModifier ? "new " : "";
@@ -20050,14 +20236,18 @@ function promoteFieldType$1(f) {
 * List wrappers (`{ data, list_metadata }`) and the shared `ListMetadata`
 * model are skipped — the hand-maintained runtime provides [Page]/[ListMetadata].
 */
-function generateModels$2(models, _ctx) {
+function generateModels$2(models, ctx) {
 	if (models.length === 0) return [];
 	for (const model of models) for (const field of model.fields) mapTypeRef$2(field.type);
 	const files = [];
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const skipAsListWrapper = (m) => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
+	const listMetadataNeeded = collectReferencedListMetadataModels(models, nonPaginatedRefs);
+	const skipAsListMetadata = (m) => isListMetadataModel(m) && !listMetadataNeeded.has(m.name);
 	modelAliasMap = null;
 	const hashGroupsPass1 = /* @__PURE__ */ new Map();
 	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$1(model.name))) continue;
 		const hash = structuralHash(model);
 		if (!hashGroupsPass1.has(hash)) hashGroupsPass1.set(hash, []);
@@ -20076,7 +20266,7 @@ function generateModels$2(models, _ctx) {
 	modelAliasMap = aliasOf;
 	const hashGroupsPass2 = /* @__PURE__ */ new Map();
 	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$1(model.name))) continue;
 		if (aliasOf.has(model.name)) continue;
 		const hash = structuralHash(model);
@@ -20094,7 +20284,7 @@ function generateModels$2(models, _ctx) {
 		}
 	}
 	for (const model of models) {
-		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+		if (skipAsListWrapper(model) || skipAsListMetadata(model)) continue;
 		const typeName = className$1(model.name);
 		if (model.fields.length === 0 && discriminatedUnions.has(typeName)) {
 			files.push(emitSealedUnion(typeName, discriminatedUnions.get(typeName)));
@@ -20122,7 +20312,7 @@ function generateModels$2(models, _ctx) {
 	}
 	const eventMapping = [];
 	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");
@@ -21433,6 +21623,8 @@ function resolveBodyModel$2(op, ctx) {
 function registerTypeImports(ref, imports, ctx) {
 	const mapped = mapTypeRef$2(ref);
 	for (const imp of implicitImportsFor(mapped)) imports.add(imp);
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const listMetadataNeeded = collectReferencedListMetadataModels(ctx.spec.models, nonPaginatedRefs);
 	walk(ref, (r) => {
 		if (r.kind === "enum") {
 			const canonicalName = enumCanonicalMap.get(r.name) ?? r.name;
@@ -21440,7 +21632,11 @@ function registerTypeImports(ref, imports, ctx) {
 		}
 		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$1(r.name)}`);
 		}
 	});
@@ -22839,10 +23035,12 @@ function generateModels$1(models, ctx) {
 		return mountDirMap.get(service) ?? classifyUnassignedModel(modelName);
 	};
 	const files = [];
+	const nonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
+	const skipAsListWrapper = (m) => isListWrapperModel(m) && !nonPaginatedRefs.has(m.name);
 	const recursiveHashes = buildRecursiveHashMap(models, enumNames);
 	const hashGroups = /* @__PURE__ */ new Map();
 	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);
@@ -22855,7 +23053,7 @@ function generateModels$1(models, ctx) {
 		for (let i = 1; i < sorted.length; i++) aliasOf.set(sorted[i], canonical);
 	}
 	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);
 		const canonical = aliasOf.get(model.name);
@@ -23328,7 +23526,10 @@ function mapSorbetType$1(ref) {
 		case "array": return `T::Array[${mapSorbetType$1(ref.items)}]`;
 		case "model": return `WorkOS::${className(ref.name)}`;
 		case "enum": return "String";
-		case "nullable": return `T.nilable(${mapSorbetType$1(ref.inner)})`;
+		case "nullable": {
+			const inner = mapSorbetType$1(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";
@@ -24932,6 +25133,7 @@ function generateRbiFiles(spec, ctx) {
 }
 /** Unwrap T.nilable(...) if already wrapped, to avoid double-wrapping. */
 function unwrapNilable(type) {
+	if (type === "T.untyped") return type;
 	const match = type.match(/^T\.nilable\((.+)\)$/);
 	return match ? match[1] : type;
 }
@@ -24986,8 +25188,8 @@ function ensureTrailingNewlines$1(files) {
 * has its original fields restored — otherwise `ConnectApplication`-style
 * bases would silently lose every variant field they had previously.
 */
-function enrichModelsForRuby(models) {
-	const enriched = enrichModelsFromSpec(models);
+function enrichModelsForRuby(models, enums) {
+	const enriched = enrichModelsFromSpec(models, enums);
 	const originalByName = new Map(models.map((m) => [m.name, m]));
 	return enriched.map((m) => {
 		if (m.discriminator && m.fields.length === 0) {
@@ -25003,7 +25205,7 @@ function enrichModelsForRuby(models) {
 const rubyEmitter = {
 	language: "ruby",
 	generateModels(models, ctx) {
-		return ensureTrailingNewlines$1(generateModels$1(enrichModelsForRuby(models), ctx));
+		return ensureTrailingNewlines$1(generateModels$1(enrichModelsForRuby(models, ctx.spec.enums), ctx));
 	},
 	generateEnums(enums, ctx) {
 		const syntheticEnums = getSyntheticEnums();
@@ -25469,7 +25671,7 @@ function renderField(field, rustField, modelName, registry) {
 function renderModelsBarrel(modules) {
 	const sorted = [...new Set(modules)].sort();
 	const lines = [];
-	for (const m of sorted) lines.push(`pub mod ${m};`);
+	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";
@@ -26552,7 +26754,7 @@ function renderResourcesBarrel(exports) {
 	}
 	unique.sort((a, b) => a.module.localeCompare(b.module));
 	const lines = [];
-	for (const { module } of unique) lines.push(`pub mod ${module};`);
+	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";
@@ -27402,4 +27604,4 @@ const workosEmittersPlugin = {
 //#endregion
 export { pythonEmitter as _, rustExtractor as a, pythonExtractor as c, rustEmitter as d, rubyEmitter as f, phpEmitter as g, goEmitter as h, kotlinExtractor as i, rubyExtractor as l, dotnetEmitter as m, elixirExtractor as n, goExtractor as o, kotlinEmitter as p, dotnetExtractor as r, phpExtractor as s, workosEmittersPlugin as t, nodeExtractor as u, nodeEmitter as v };
 
-//# sourceMappingURL=plugin-BxVeu2v9.mjs.map
+//# sourceMappingURL=plugin-BbSmT2kj.mjs.map