@workos/oagen-emitters 0.13.0 → 0.14.1

package/dist/{plugin-B9F2jmwy.mjs → plugin-DRGwxN88.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'`.
 *
@@ -2636,7 +2654,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 +2664,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;
@@ -2692,6 +2714,7 @@ function enrichModelsFromSpec(models) {
 	_lastSyntheticEnums = collector.enums.map((e) => ({
 		name: e.name,
 		values: e.values.map((v) => ({
+			name: toUpperSnakeCase(String(v.value)),
 			value: v.value,
 			description: v.description
 		}))
@@ -2985,7 +3008,7 @@ function mapTypeRef$7(ref, opts) {
 	const genericDefaults = opts?.genericDefaults;
 	return mapTypeRef(ref, {
 		primitive: mapPrimitive$6,
-		array: (_r, items) => `${parenthesizeUnion(items)}[]`,
+		array: (_r, items) => `${parenthesizeUnion$1(items)}[]`,
 		model: (r) => resolveDomainName(r.name) + (genericDefaults?.get(r.name) ?? ""),
 		enum: (r) => inlineEnumUnions.get(r.name) ?? r.name,
 		union: (r, variants) => joinUnionVariants$5(r, variants),
@@ -3002,7 +3025,7 @@ function mapWireTypeRef(ref, opts) {
 	const genericDefaults = opts?.genericDefaults;
 	return mapTypeRef(ref, {
 		primitive: mapWirePrimitive,
-		array: (_r, items) => `${parenthesizeUnion(items)}[]`,
+		array: (_r, items) => `${parenthesizeUnion$1(items)}[]`,
 		model: (r) => wireInterfaceName(resolveDomainName(r.name)) + (genericDefaults?.get(r.name) ?? ""),
 		enum: (r) => inlineEnumUnions.get(r.name) ?? r.name,
 		union: (r, variants) => joinUnionVariants$5(r, variants),
@@ -3039,7 +3062,7 @@ function joinUnionVariants$5(ref, variants) {
 	if (unique.length === 1) return unique[0];
 	return unique.join(" | ");
 }
-function parenthesizeUnion(type) {
+function parenthesizeUnion$1(type) {
 	return type.includes(" | ") || type.includes(" & ") ? `(${type})` : type;
 }
 //#endregion
@@ -4627,7 +4650,7 @@ function splitCamelWords(name) {
 	return parts;
 }
 /** Naive singularize: strip trailing 's' unless it ends in 'ss'. */
-function singularize$3(word) {
+function singularize$4(word) {
 	return word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word;
 }
 /**
@@ -4644,11 +4667,11 @@ function deduplicateMethodNames(plans, _ctx) {
 		if (count <= 1) continue;
 		const dupes = plans.filter((p) => p.method === name);
 		if (new Set(dupes.map((d) => d.op.path.replace(/\/\{[^}]+\}$/, ""))).size <= 1) continue;
-		const nameWords = new Set(splitCamelWords(name).map(singularize$3));
+		const nameWords = new Set(splitCamelWords(name).map(singularize$4));
 		const scored = dupes.map((d) => {
 			return {
 				plan: d,
-				score: d.op.path.split("/").filter((s) => s && !s.startsWith("{")).flatMap((s) => s.split("_")).map(singularize$3).filter((w) => nameWords.has(w)).length
+				score: d.op.path.split("/").filter((s) => s && !s.startsWith("{")).flatMap((s) => s.split("_")).map(singularize$4).filter((w) => nameWords.has(w)).length
 			};
 		});
 		scored.sort((a, b) => b.score - a.score);
@@ -5942,6 +5965,7 @@ function isSupportedFieldType(ref, ownerModelName, shared, ctx) {
 			const resolvedName = resolveInterfaceName(ref.name, ctx);
 			if (ctx.apiSurface?.interfaces?.[resolvedName] || ctx.apiSurface?.typeAliases?.[resolvedName]) return true;
 			if (isAdoptedModelName(ref.name)) return true;
+			if (shared.modelToService.has(ref.name)) return true;
 			return liveSurfaceHasManagedFile(`src/${shared.resolveDir(shared.modelToService.get(ref.name))}/interfaces/${fileName$3(ref.name)}.interface.ts`);
 		}
 		case "enum": {
@@ -5988,12 +6012,15 @@ function generateModels$7(models, ctx, shared) {
 			if ((ctx.apiSurface?.interfaces?.[depName])?.sourceFile === parentPath) forceGenerate.add(dep);
 		}
 	}
+	const discriminatedSkip = ctx._discriminatedModelNames;
+	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);
 		if (!isOwnedModel && !modelHasNewFields(model, ctx) && !forceGenerate.has(model.name)) continue;
@@ -6325,13 +6352,16 @@ function generateSerializers(models, ctx, shared) {
 			if ((ctx.apiSurface?.interfaces?.[depName])?.sourceFile === parentPath) forceGenerateSerializer.add(dep);
 		}
 	}
+	const discriminatedSerializerSkip = ctx._discriminatedModelNames;
+	const serializerNonPaginatedRefs = collectNonPaginatedResponseModelNames(ctx.spec.services);
 	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 (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);
 	}
@@ -7643,6 +7673,445 @@ function generateSerializerTests(spec, ctx) {
 	return files;
 }
 //#endregion
+//#region src/node/discriminated-models.ts
+function detectDiscriminatedShape(modelName, rawSchemas) {
+	const schema = rawSchemas[modelName];
+	if (!schema?.allOf) return null;
+	let baseObject = null;
+	let oneOfVariants = null;
+	for (const member of schema.allOf) {
+		const resolved = resolveRef(member, rawSchemas);
+		if (resolved.oneOf) {
+			if (oneOfVariants) return null;
+			oneOfVariants = resolved.oneOf;
+		} else if (resolved.properties) baseObject = mergeBase(baseObject, resolved);
+		else if (resolved.allOf) {
+			const nestedBase = flattenObjectAllOf(resolved, rawSchemas);
+			baseObject = mergeBase(baseObject, nestedBase);
+		}
+	}
+	if (!oneOfVariants || oneOfVariants.length < 2) return null;
+	const flattenedVariants = oneOfVariants.map((v) => flattenVariant(v, rawSchemas));
+	const discProp = findSharedDiscriminator(flattenedVariants);
+	if (!discProp) return null;
+	const variants = flattenedVariants.map((fv) => {
+		const discValue = readConstString(fv.alwaysProperties.get(discProp));
+		if (!discValue) return null;
+		return {
+			nameSuffix: variantNameSuffix(discValue),
+			discriminatorValue: discValue,
+			fields: variantFields(fv, discProp, modelName, rawSchemas)
+		};
+	}).filter((v) => v !== null);
+	if (variants.length !== flattenedVariants.length) return null;
+	return {
+		modelName,
+		baseFields: baseObject ? collectObjectFields(baseObject, modelName, rawSchemas) : [],
+		discriminatorProperty: discProp,
+		discriminatorPropertyDomain: toCamelCase(discProp),
+		variants
+	};
+}
+function mergeBase(prev, next) {
+	if (!prev) return next;
+	return {
+		type: "object",
+		properties: {
+			...prev.properties ?? {},
+			...next.properties ?? {}
+		},
+		required: [...new Set([...prev.required ?? [], ...next.required ?? []])]
+	};
+}
+function flattenObjectAllOf(schema, rawSchemas) {
+	let merged = {
+		type: "object",
+		properties: {},
+		required: []
+	};
+	for (const sub of schema.allOf ?? []) {
+		const resolved = resolveRef(sub, rawSchemas);
+		if (resolved.properties) merged = mergeBase(merged, resolved);
+		else if (resolved.allOf) merged = mergeBase(merged, flattenObjectAllOf(resolved, rawSchemas));
+	}
+	return merged;
+}
+function flattenVariant(variant, rawSchemas) {
+	const resolved = resolveRef(variant, rawSchemas);
+	if (resolved.properties && !resolved.allOf && !resolved.oneOf) {
+		const props = /* @__PURE__ */ new Map();
+		for (const [k, v] of Object.entries(resolved.properties)) props.set(k, v);
+		return {
+			alwaysProperties: props,
+			optionalProperties: /* @__PURE__ */ new Map(),
+			required: new Set(resolved.required ?? [])
+		};
+	}
+	if (resolved.allOf) {
+		let agg = {
+			alwaysProperties: /* @__PURE__ */ new Map(),
+			optionalProperties: /* @__PURE__ */ new Map(),
+			required: /* @__PURE__ */ new Set()
+		};
+		let initialized = false;
+		for (const member of resolved.allOf) {
+			const memberView = flattenVariant(member, rawSchemas);
+			if (!initialized) {
+				agg = {
+					alwaysProperties: new Map(memberView.alwaysProperties),
+					optionalProperties: new Map(memberView.optionalProperties),
+					required: new Set(memberView.required)
+				};
+				initialized = true;
+				continue;
+			}
+			for (const [k, v] of memberView.alwaysProperties) if (!agg.alwaysProperties.has(k) && !agg.optionalProperties.has(k)) agg.alwaysProperties.set(k, v);
+			for (const [k, v] of memberView.optionalProperties) if (!agg.alwaysProperties.has(k) && !agg.optionalProperties.has(k)) agg.optionalProperties.set(k, v);
+			for (const r of memberView.required) agg.required.add(r);
+		}
+		return agg;
+	}
+	if (resolved.oneOf) {
+		const memberViews = resolved.oneOf.map((m) => flattenVariant(m, rawSchemas));
+		const allKeys = /* @__PURE__ */ new Set();
+		for (const view of memberViews) {
+			for (const k of view.alwaysProperties.keys()) allKeys.add(k);
+			for (const k of view.optionalProperties.keys()) allKeys.add(k);
+		}
+		const always = /* @__PURE__ */ new Map();
+		const optional = /* @__PURE__ */ new Map();
+		const requiredEverywhere = /* @__PURE__ */ new Set();
+		for (const key of allKeys) {
+			const inAll = memberViews.every((v) => v.alwaysProperties.has(key) || v.optionalProperties.has(key));
+			const merged = mergeFieldSchemas(memberViews.map((v) => v.alwaysProperties.get(key) ?? v.optionalProperties.get(key)).filter((s) => Boolean(s)));
+			if (inAll) always.set(key, merged);
+			else optional.set(key, merged);
+			if (inAll && memberViews.every((v) => v.required.has(key))) requiredEverywhere.add(key);
+		}
+		return {
+			alwaysProperties: always,
+			optionalProperties: optional,
+			required: requiredEverywhere
+		};
+	}
+	return {
+		alwaysProperties: /* @__PURE__ */ new Map(),
+		optionalProperties: /* @__PURE__ */ new Map(),
+		required: /* @__PURE__ */ new Set()
+	};
+}
+function mergeFieldSchemas(schemas) {
+	if (schemas.length === 0) return {};
+	if (schemas.length === 1) return schemas[0];
+	if (schemas.every((s) => s.type === "boolean" && typeof s.const === "boolean")) return {
+		type: "boolean",
+		description: schemas[0].description
+	};
+	if (schemas.every((s) => s.type === "string" && typeof s.const === "string")) {
+		const values = schemas.map((s) => s.const);
+		if (new Set(values).size === 1) return schemas[0];
+		return {
+			type: "string",
+			description: schemas[0].description
+		};
+	}
+	return schemas[0];
+}
+function findSharedDiscriminator(variants) {
+	if (variants.length < 2) return null;
+	const firstAlways = variants[0].alwaysProperties;
+	for (const propName of firstAlways.keys()) {
+		let allConst = true;
+		const values = [];
+		for (const v of variants) {
+			const val = readConstString(v.alwaysProperties.get(propName));
+			if (val === null) {
+				allConst = false;
+				break;
+			}
+			values.push(val);
+		}
+		if (allConst && new Set(values).size === values.length) return propName;
+	}
+	return null;
+}
+function readConstString(schema) {
+	if (!schema) return null;
+	if (typeof schema.const === "string") return schema.const;
+	if (Array.isArray(schema.enum) && schema.enum.length === 1 && typeof schema.enum[0] === "string") return schema.enum[0];
+	return null;
+}
+function variantNameSuffix(constValue) {
+	return toPascalCase(constValue);
+}
+function collectObjectFields(schema, parentName, rawSchemas) {
+	const props = schema.properties ?? {};
+	const required = new Set(schema.required ?? []);
+	const fields = [];
+	for (const [name, propSchema] of Object.entries(props)) fields.push(buildField(name, propSchema, required.has(name), parentName, rawSchemas));
+	return fields;
+}
+function variantFields(fv, discriminatorProperty, parentName, rawSchemas) {
+	const fields = [];
+	for (const [name, propSchema] of fv.alwaysProperties) {
+		if (name === discriminatorProperty) continue;
+		fields.push(buildField(name, propSchema, fv.required.has(name), parentName, rawSchemas));
+	}
+	for (const [name, propSchema] of fv.optionalProperties) {
+		if (name === discriminatorProperty) continue;
+		fields.push(buildField(name, propSchema, false, parentName, rawSchemas));
+	}
+	return fields;
+}
+function buildField(rawName, schema, required, parentName, rawSchemas) {
+	const modelDeps = /* @__PURE__ */ new Set();
+	const domainType = rawSchemaToTS(schema, parentName, rawName, false, modelDeps, rawSchemas);
+	const wireType = rawSchemaToTS(schema, parentName, rawName, true, modelDeps, rawSchemas);
+	return {
+		name: rawName,
+		description: schema.description,
+		required,
+		domainType,
+		wireType,
+		modelDeps,
+		hasDateTime: schemaHasDateTime(schema)
+	};
+}
+function schemaHasDateTime(schema) {
+	if (schema.format === "date-time" && typeOf(schema) === "string") return true;
+	if (schema.items && schemaHasDateTime(schema.items)) return true;
+	return false;
+}
+function typeOf(schema) {
+	if (Array.isArray(schema.type)) return schema.type.find((t) => t !== "null");
+	return schema.type;
+}
+function isNullable(schema) {
+	return Array.isArray(schema.type) && schema.type.includes("null");
+}
+function rawSchemaToTS(schema, parentName, fieldName, isWire, modelDeps, rawSchemas) {
+	if (schema.$ref) {
+		const refName = schema.$ref.split("/").pop();
+		modelDeps.add(refName);
+		const domain = toPascalCase(refName);
+		return isWire ? wireInterfaceName(domain) : domain;
+	}
+	if (typeof schema.const === "string") return `'${schema.const}'`;
+	if (typeof schema.const === "boolean") return String(schema.const);
+	const baseType = typeOf(schema);
+	const nullable = isNullable(schema);
+	let core;
+	if (baseType === "string") core = !isWire && schema.format === "date-time" ? "Date" : "string";
+	else if (baseType === "integer" || baseType === "number") core = "number";
+	else if (baseType === "boolean") core = "boolean";
+	else if (baseType === "array" && schema.items) core = `${parenthesizeUnion(rawSchemaToTS(schema.items, parentName, singularize$3(fieldName), isWire, modelDeps, rawSchemas))}[]`;
+	else if (baseType === "object" && schema.properties) {
+		const synthName = `${parentName}_${singularize$3(fieldName)}`;
+		modelDeps.add(synthName);
+		const domain = toPascalCase(synthName);
+		return isWire ? wireInterfaceName(domain) : domain;
+	} else core = "unknown";
+	return nullable ? `${core} | null` : core;
+}
+function parenthesizeUnion(t) {
+	return /\s\|\s/.test(t) ? `(${t})` : t;
+}
+function singularize$3(name) {
+	if (name.endsWith("ies") && name.length > 3) return `${name.slice(0, -3)}y`;
+	if (name.endsWith("s") && !name.endsWith("ss")) return name.slice(0, -1);
+	return name;
+}
+function resolveRef(schema, rawSchemas) {
+	if (!schema.$ref) return schema;
+	const segments = schema.$ref.split("/");
+	return rawSchemas[segments[segments.length - 1]] ?? schema;
+}
+function planDiscriminatedModels(models, ctx) {
+	const plans = /* @__PURE__ */ new Map();
+	const spec = loadRawSpec();
+	if (!spec?.components?.schemas) return plans;
+	const rawSchemas = spec.components.schemas;
+	const { modelToService, resolveDir } = createServiceDirResolver(models, ctx.spec.services, ctx);
+	for (const model of models) {
+		const shape = detectDiscriminatedShape(model.name, rawSchemas);
+		if (!shape) continue;
+		const modelDir = resolveDir(modelToService.get(model.name));
+		plans.set(model.name, {
+			shape,
+			modelDir
+		});
+	}
+	return plans;
+}
+function generateDiscriminatedFiles(plans, ctx) {
+	const files = [];
+	for (const plan of plans.values()) {
+		files.push(buildInterfaceFile(plan, ctx));
+		files.push(buildSerializerFile(plan, ctx));
+	}
+	return files;
+}
+function buildInterfaceFile(plan, _ctx) {
+	const { shape, modelDir } = plan;
+	const domain = toPascalCase(shape.modelName);
+	const wire = wireInterfaceName(domain);
+	const lines = [];
+	const imports = collectImports$2(plan);
+	if (imports.length > 0) {
+		for (const imp of imports) lines.push(`import type { ${imp.symbols.join(", ")} } from '${imp.path}';`);
+		lines.push("");
+	}
+	for (const variant of shape.variants) {
+		const variantDomain = `${domain}${variant.nameSuffix}`;
+		const variantWire = `${variantDomain}Response`;
+		lines.push(...buildInterfaceBody(variantDomain, shape, variant, false));
+		lines.push("");
+		lines.push(...buildInterfaceBody(variantWire, shape, variant, true));
+		lines.push("");
+	}
+	const variantNames = shape.variants.map((v) => `${domain}${v.nameSuffix}`);
+	lines.push(`export type ${domain} = ${variantNames.join(" | ")};`);
+	lines.push("");
+	const wireVariantNames = shape.variants.map((v) => `${domain}${v.nameSuffix}Response`);
+	lines.push(`export type ${wire} = ${wireVariantNames.join(" | ")};`);
+	return {
+		path: `src/${modelDir}/interfaces/${fileName$3(shape.modelName)}.interface.ts`,
+		content: lines.join("\n") + "\n",
+		overwriteExisting: true
+	};
+}
+function buildInterfaceBody(name, shape, variant, isWire) {
+	const lines = [];
+	lines.push(`export interface ${name} {`);
+	for (const field of shape.baseFields) pushFieldLine(lines, field, isWire);
+	const discKey = isWire ? shape.discriminatorProperty : shape.discriminatorPropertyDomain;
+	lines.push(`  ${discKey}: '${variant.discriminatorValue}';`);
+	for (const field of variant.fields) pushFieldLine(lines, field, isWire);
+	lines.push("}");
+	return lines;
+}
+function pushFieldLine(lines, field, isWire) {
+	const key = isWire ? field.name : toCamelCase(field.name);
+	const opt = field.required ? "" : "?";
+	const type = isWire ? field.wireType : field.domainType;
+	if (field.description) lines.push(`  /** ${field.description} */`);
+	lines.push(`  ${key}${opt}: ${type};`);
+}
+function collectImports$2(plan) {
+	const deps = /* @__PURE__ */ new Set();
+	for (const field of plan.shape.baseFields) for (const d of field.modelDeps) deps.add(d);
+	for (const variant of plan.shape.variants) for (const field of variant.fields) for (const d of field.modelDeps) deps.add(d);
+	const symbols = [];
+	for (const dep of [...deps].sort()) {
+		const domain = toPascalCase(dep);
+		symbols.push(domain);
+		const wire = wireInterfaceName(domain);
+		if (wire !== domain) symbols.push(wire);
+	}
+	if (symbols.length === 0) return [];
+	return symbols.map((sym) => {
+		return {
+			path: `./${fileName$3(toSnakeFromPascal(sym.replace(/Response$/, "")))}.interface`,
+			symbols: [sym]
+		};
+	}).reduce((acc, cur) => {
+		const existing = acc.find((a) => a.path === cur.path);
+		if (existing) existing.symbols.push(...cur.symbols);
+		else acc.push(cur);
+		return acc;
+	}, []);
+}
+function toSnakeFromPascal(s) {
+	return s.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function buildSerializerFile(plan, _ctx) {
+	const { shape, modelDir } = plan;
+	const domain = toPascalCase(shape.modelName);
+	const wire = wireInterfaceName(domain);
+	const lines = [];
+	const interfaceImportPath = `../interfaces/${fileName$3(shape.modelName)}.interface`;
+	lines.push(`import type { ${domain}, ${wire} } from '${interfaceImportPath}';`);
+	const allDeps = /* @__PURE__ */ new Set();
+	for (const field of shape.baseFields) for (const d of field.modelDeps) allDeps.add(d);
+	for (const variant of shape.variants) for (const field of variant.fields) for (const d of field.modelDeps) allDeps.add(d);
+	for (const dep of [...allDeps].sort()) {
+		const depDomain = toPascalCase(dep);
+		const depFile = fileName$3(toSnakeFromPascal(depDomain));
+		lines.push(`import { deserialize${depDomain}, serialize${depDomain} } from './${depFile}.serializer';`);
+	}
+	lines.push("");
+	lines.push(`export const deserialize${domain} = (response: ${wire}): ${domain} => {`);
+	lines.push(`  switch (response.${shape.discriminatorProperty}) {`);
+	for (const variant of shape.variants) {
+		lines.push(`    case '${variant.discriminatorValue}':`);
+		lines.push(`      return {`);
+		for (const field of shape.baseFields) lines.push(`        ${assignmentLine(field, false, allDeps)},`);
+		lines.push(`        ${shape.discriminatorPropertyDomain}: '${variant.discriminatorValue}',`);
+		for (const field of variant.fields) lines.push(`        ${assignmentLine(field, false, allDeps)},`);
+		lines.push(`      };`);
+	}
+	lines.push(`    default:`);
+	lines.push(`      throw new Error(\`Unknown ${shape.discriminatorProperty}: \${(response as { ${shape.discriminatorProperty}: string }).${shape.discriminatorProperty}}\`);`);
+	lines.push(`  }`);
+	lines.push(`};`);
+	lines.push("");
+	lines.push(`export const serialize${domain} = (model: ${domain}): ${wire} => {`);
+	lines.push(`  switch (model.${shape.discriminatorPropertyDomain}) {`);
+	for (const variant of shape.variants) {
+		lines.push(`    case '${variant.discriminatorValue}':`);
+		lines.push(`      return {`);
+		for (const field of shape.baseFields) lines.push(`        ${assignmentLine(field, true, allDeps)},`);
+		lines.push(`        ${shape.discriminatorProperty}: '${variant.discriminatorValue}',`);
+		for (const field of variant.fields) lines.push(`        ${assignmentLine(field, true, allDeps)},`);
+		lines.push(`      };`);
+	}
+	lines.push(`  }`);
+	lines.push(`};`);
+	return {
+		path: `src/${modelDir}/serializers/${fileName$3(shape.modelName)}.serializer.ts`,
+		content: lines.join("\n") + "\n",
+		overwriteExisting: true
+	};
+}
+function assignmentLine(field, serialize, _allDeps) {
+	const camel = toCamelCase(field.name);
+	const snake = field.name;
+	const lhs = serialize ? snake : camel;
+	const rhsKey = serialize ? camel : snake;
+	const source = serialize ? `model.${rhsKey}` : `response.${rhsKey}`;
+	if (field.hasDateTime) {
+		if (serialize) {
+			if (field.required) return `${lhs}: ${source}.toISOString()`;
+			return `${lhs}: ${source} != null ? ${source}.toISOString() : undefined`;
+		}
+		if (field.required) return `${lhs}: new Date(${source})`;
+		return `${lhs}: ${source} != null ? new Date(${source}) : undefined`;
+	}
+	const arrayDep = arrayItemModelDep(field);
+	if (arrayDep) {
+		const fn = serialize ? `serialize${arrayDep}` : `deserialize${arrayDep}`;
+		if (field.required) return `${lhs}: ${source}.map(${fn})`;
+		return `${lhs}: ${source} != null ? ${source}.map(${fn}) : undefined`;
+	}
+	const scalarDep = scalarModelDepName(field);
+	if (scalarDep) {
+		const fn = serialize ? `serialize${scalarDep}` : `deserialize${scalarDep}`;
+		if (field.required) return `${lhs}: ${fn}(${source})`;
+		return `${lhs}: ${source} != null ? ${fn}(${source}) : undefined`;
+	}
+	return `${lhs}: ${source}`;
+}
+function arrayItemModelDep(field) {
+	const m = field.domainType.match(/^([A-Z]\w*)\[\]$/);
+	if (m && field.modelDeps.size > 0) return m[1];
+	return null;
+}
+function scalarModelDepName(field) {
+	const stripped = field.domainType.replace(/\s*\|\s*null$/, "");
+	if (/^[A-Z]\w*$/.test(stripped) && field.modelDeps.size === 1) return toPascalCase([...field.modelDeps][0]);
+	return null;
+}
+//#endregion
 //#region src/node/node-overrides.ts
 const OPERATION_OVERRIDES = {
 	"POST /organizations/{organizationId}/groups": { methodName: "create_group" },
@@ -7662,31 +8131,71 @@ const contextCache = /* @__PURE__ */ new WeakMap();
 function operationKey(resolved) {
 	return `${resolved.operation.httpMethod.toUpperCase()} ${resolved.operation.path}`;
 }
+/**
+* Apply oneOf / allOf+oneOf enrichment (flattening variant fields onto the
+* parent model, plus synthetic models/enums for inline shapes) so the rest
+* of the Node emitter sees a richer `spec.models`.
+*
+* Without this, `ConnectApplication` (and any other `allOf [base, oneOf [...]]`
+* schema whose first variant is itself wrapped in `allOf`) loses every
+* non-M2M field — the IR parser's discriminator detection silently skips
+* variants whose properties live behind another `allOf`. Mirrors what the
+* Go / Kotlin / .NET emitters already do.
+*
+* Discriminated bases produced by `enrichModelsFromSpec` get their original
+* fields restored — Node emits flat interfaces today, not TS sum types, so
+* an empty base would otherwise drop the common fields.
+*/
+function enrichSpecModels(models) {
+	const enriched = enrichModelsFromSpec(models);
+	const originalByName = new Map(models.map((m) => [m.name, m]));
+	return enriched.map((m) => {
+		if (m.discriminator && m.fields.length === 0) {
+			const original = originalByName.get(m.name);
+			if (original && original.fields.length > 0) return {
+				...m,
+				fields: original.fields
+			};
+		}
+		return m;
+	});
+}
 function withNodeOperationOverrides(ctx) {
 	const cached = contextCache.get(ctx);
 	if (cached) return cached;
+	const enrichedModels = enrichSpecModels(ctx.spec.models);
+	const specChanged = enrichedModels.length !== ctx.spec.models.length || enrichedModels.some((m, i) => m !== ctx.spec.models[i]);
+	const enrichedSpec = specChanged ? {
+		...ctx.spec,
+		models: enrichedModels
+	} : ctx.spec;
 	const resolvedOperations = ctx.resolvedOperations;
 	if (!resolvedOperations?.length) {
-		contextCache.set(ctx, ctx);
-		return ctx;
+		const next = specChanged ? {
+			...ctx,
+			spec: enrichedSpec
+		} : ctx;
+		contextCache.set(ctx, next);
+		return next;
 	}
-	let changed = false;
+	let opsChanged = false;
 	const nextResolved = resolvedOperations.map((resolved) => {
 		const override = OPERATION_OVERRIDES[operationKey(resolved)];
 		if (!override) return resolved;
 		const methodName = override.methodName ?? resolved.methodName;
 		const mountOn = override.mountOn ?? resolved.mountOn;
 		if (methodName === resolved.methodName && mountOn === resolved.mountOn) return resolved;
-		changed = true;
+		opsChanged = true;
 		return {
 			...resolved,
 			methodName,
 			mountOn
 		};
 	});
-	const next = changed ? {
+	const next = opsChanged || specChanged ? {
 		...ctx,
-		resolvedOperations: nextResolved
+		...opsChanged ? { resolvedOperations: nextResolved } : {},
+		...specChanged ? { spec: enrichedSpec } : {}
 	} : ctx;
 	contextCache.set(ctx, next);
 	return next;
@@ -7698,6 +8207,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;
@@ -7744,8 +8269,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
@@ -7895,19 +8422,99 @@ 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;
 }
+/**
+* Flatten oneOf / allOf+oneOf variant fields from the raw spec onto each
+* model. `enrichModelsFromSpec` produces (a) extra optional fields on models
+* whose schema is `allOf [base, oneOf [...]]`, and (b) synthetic models /
+* enums for inline objects encountered inside variants (e.g. the inline
+* `redirect_uris` item shape on `ConnectApplication`).
+*
+* Node, like Go / Kotlin / .NET, emits flat interfaces rather than a sum
+* type, so on `enrichModelsFromSpec`-marked discriminated bases we restore
+* the original IR fields — otherwise the base interface would be empty.
+* A future change can emit a real TS discriminated union; for now the goal
+* is parity with the other flat-emit languages so every variant field is
+* at least reachable.
+*/
+function enrichModelsForNode(models) {
+	const enriched = enrichModelsFromSpec(models);
+	const originalByName = new Map(models.map((m) => [m.name, m]));
+	return enriched.map((m) => {
+		if (m.discriminator && m.fields.length === 0) {
+			const original = originalByName.get(m.name);
+			if (original && original.fields.length > 0) return {
+				...m,
+				fields: original.fields
+			};
+		}
+		return m;
+	});
+}
 const nodeEmitter = {
 	language: "node",
 	generateModels(models, ctx) {
 		const nodeCtx = withNodeOperationOverrides(ctx);
 		const surface = getSurface(nodeCtx);
-		return applyLiveSurface(generateModelsAndSerializers(models, nodeCtx), nodeCtx, surface);
+		const enriched = enrichModelsForNode(models);
+		const discPlans = planDiscriminatedModels(enriched, nodeCtx);
+		nodeCtx._discriminatedModelNames = new Set(discPlans.keys());
+		const standardFiles = generateModelsAndSerializers(enriched, nodeCtx);
+		const discFiles = generateDiscriminatedFiles(discPlans, nodeCtx);
+		return applyLiveSurface([...standardFiles, ...discFiles], nodeCtx, surface);
 	},
 	generateEnums(enums, ctx) {
 		const nodeCtx = withNodeOperationOverrides(ctx);
 		const surface = getSurface(nodeCtx);
-		return applyLiveSurface(generateEnums$7(enums, nodeCtx), nodeCtx, surface);
+		const syntheticEnums = getSyntheticEnums();
+		return applyLiveSurface(generateEnums$7([...enums, ...syntheticEnums], nodeCtx), nodeCtx, surface);
 	},
 	generateResources(services, ctx) {
 		const nodeCtx = withNodeOperationOverrides(ctx);
@@ -7917,7 +8524,7 @@ const nodeEmitter = {
 	generateClient(spec, ctx) {
 		const nodeCtx = withNodeOperationOverrides(ctx);
 		const surface = getSurface(nodeCtx);
-		return applyLiveSurface(generateClient$7(spec, nodeCtx), nodeCtx, surface);
+		return applyLiveSurface(generateClient$7(nodeCtx.spec, nodeCtx), nodeCtx, surface);
 	},
 	generateErrors(_ctx) {
 		return [];
@@ -7927,9 +8534,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 {};
@@ -8706,8 +9312,9 @@ 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);
 	for (const model of models) {
-		if (isListWrapperModel(model)) continue;
+		if (isListWrapperModel(model) && !nonPaginatedRefs.has(model.name)) continue;
 		if (isListMetadataModel(model)) continue;
 		const dirName = resolveDir(modelToService.get(model.name));
 		const modelClassName = className$5(model.name);
@@ -10121,7 +10728,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);
@@ -12250,9 +12859,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;`);
@@ -13845,15 +14455,37 @@ function ensureTrailingNewlines$5(files) {
 	for (const f of files) if (f.content && !f.content.endsWith("\n")) f.content += "\n";
 	return files;
 }
+/**
+* Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+* in synthetic models / enums for inline variant shapes. PHP emits flat
+* classes (no sum types), so a discriminated base whose IR fields the
+* parser stripped (post-allOf-aware detection) gets its original fields
+* restored to avoid silently dropping variant data.
+*/
+function enrichModelsForPhp(models) {
+	const enriched = enrichModelsFromSpec(models);
+	const originalByName = new Map(models.map((m) => [m.name, m]));
+	return enriched.map((m) => {
+		if (m.discriminator && m.fields.length === 0) {
+			const original = originalByName.get(m.name);
+			if (original && original.fields.length > 0) return {
+				...m,
+				fields: original.fields
+			};
+		}
+		return m;
+	});
+}
 const phpEmitter = {
 	language: "php",
 	generateModels(models, ctx) {
 		ensureNamingInitialized(ctx);
-		return ensureTrailingNewlines$5(generateModels$5(models, ctx));
+		return ensureTrailingNewlines$5(generateModels$5(enrichModelsForPhp(models), ctx));
 	},
 	generateEnums(enums, ctx) {
 		ensureNamingInitialized(ctx);
-		return ensureTrailingNewlines$5(generateEnums$5(enums, ctx));
+		const syntheticEnums = getSyntheticEnums();
+		return ensureTrailingNewlines$5(generateEnums$5([...enums, ...syntheticEnums], ctx));
 	},
 	generateResources(services, ctx) {
 		ensureNamingInitialized(ctx);
@@ -14130,10 +14762,12 @@ 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 modelHashMap = /* @__PURE__ */ new Map();
 	const hashGroups = /* @__PURE__ */ new Map();
 	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$2(model);
 		modelHashMap.set(model.name, hash);
@@ -14150,7 +14784,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) || isListMetadataModel(model)) continue;
 		if (requestBodyOnly.has(model.name)) continue;
 		const structName = className$3(model.name);
 		const canonicalName = aliasOf.get(model.name);
@@ -16783,7 +17417,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 [];
 }
@@ -16836,16 +17478,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;
@@ -16853,7 +17502,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;");
@@ -16879,7 +17528,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;
@@ -16924,7 +17575,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 " : "";
@@ -19509,14 +20163,16 @@ 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);
 	modelAliasMap = null;
 	const hashGroupsPass1 = /* @__PURE__ */ new Map();
 	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$1(model.name))) continue;
 		const hash = structuralHash(model);
 		if (!hashGroupsPass1.has(hash)) hashGroupsPass1.set(hash, []);
@@ -19535,7 +20191,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) || isListMetadataModel(model)) continue;
 		if (model.fields.length === 0 && discriminatedUnions.has(className$1(model.name))) continue;
 		if (aliasOf.has(model.name)) continue;
 		const hash = structuralHash(model);
@@ -19553,7 +20209,7 @@ function generateModels$2(models, _ctx) {
 		}
 	}
 	for (const model of models) {
-		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+		if (skipAsListWrapper(model) || isListMetadataModel(model)) continue;
 		const typeName = className$1(model.name);
 		if (model.fields.length === 0 && discriminatedUnions.has(typeName)) {
 			files.push(emitSealedUnion(typeName, discriminatedUnions.get(typeName)));
@@ -19581,7 +20237,7 @@ function generateModels$2(models, _ctx) {
 	}
 	const eventMapping = [];
 	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");
@@ -22298,10 +22954,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);
@@ -22314,7 +22972,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);
@@ -24436,13 +25094,37 @@ function ensureTrailingNewlines$1(files) {
 	for (const f of files) if (f.content && !f.content.endsWith("\n")) f.content += "\n";
 	return files;
 }
+/**
+* Flatten oneOf / allOf+oneOf variant fields onto each base model and pick
+* up the synthetic models / enums `enrichModelsFromSpec` produces for inline
+* variant shapes. Ruby emits flat hash-backed models, not sum types, so a
+* discriminated base whose IR fields were stripped (the new EventSchema-
+* style behaviour after the parser learned to walk allOf-wrapped variants)
+* has its original fields restored — otherwise `ConnectApplication`-style
+* bases would silently lose every variant field they had previously.
+*/
+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) {
+			const original = originalByName.get(m.name);
+			if (original && original.fields.length > 0) return {
+				...m,
+				fields: original.fields
+			};
+		}
+		return m;
+	});
+}
 const rubyEmitter = {
 	language: "ruby",
 	generateModels(models, ctx) {
-		return ensureTrailingNewlines$1(generateModels$1(models, ctx));
+		return ensureTrailingNewlines$1(generateModels$1(enrichModelsForRuby(models, ctx.spec.enums), ctx));
 	},
 	generateEnums(enums, ctx) {
-		return ensureTrailingNewlines$1(generateEnums$1(enums, ctx));
+		const syntheticEnums = getSyntheticEnums();
+		return ensureTrailingNewlines$1(generateEnums$1([...enums, ...syntheticEnums], ctx));
 	},
 	generateResources(services, ctx) {
 		return ensureTrailingNewlines$1(generateResources$1(services, ctx));
@@ -24904,7 +25586,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";
@@ -25987,7 +26669,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";
@@ -26731,14 +27413,37 @@ function ensureTrailingNewlines(files) {
 	for (const f of files) if (f.content && !f.content.endsWith("\n")) f.content += "\n";
 	return files;
 }
+/**
+* Flatten oneOf / allOf+oneOf variant fields onto each base model and pull
+* in synthetic models / enums for inline variant shapes. Rust emits flat
+* structs (a synthesised enum-union from `UnionRegistry` exists, but the
+* field-on-base pattern is what matches `ConnectApplication` today). A
+* discriminated base whose IR fields the parser stripped gets its original
+* fields restored to avoid losing variant data.
+*/
+function enrichModelsForRust(models) {
+	const enriched = enrichModelsFromSpec(models);
+	const originalByName = new Map(models.map((m) => [m.name, m]));
+	return enriched.map((m) => {
+		if (m.discriminator && m.fields.length === 0) {
+			const original = originalByName.get(m.name);
+			if (original && original.fields.length > 0) return {
+				...m,
+				fields: original.fields
+			};
+		}
+		return m;
+	});
+}
 const rustEmitter = {
 	language: "rust",
 	generateModels(models, ctx) {
 		unionRegistry.reset();
-		return ensureTrailingNewlines(generateModels(models, ctx, unionRegistry));
+		return ensureTrailingNewlines(generateModels(enrichModelsForRust(models), ctx, unionRegistry));
 	},
 	generateEnums(enums, ctx) {
-		return ensureTrailingNewlines(generateEnums(enums, ctx));
+		const syntheticEnums = getSyntheticEnums();
+		return ensureTrailingNewlines(generateEnums([...enums, ...syntheticEnums], ctx));
 	},
 	generateResources(services, ctx) {
 		return ensureTrailingNewlines(generateResources(services, ctx, unionRegistry));
@@ -26814,4 +27519,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-B9F2jmwy.mjs.map
+//# sourceMappingURL=plugin-DRGwxN88.mjs.map