@workos/oagen-emitters 0.13.0 → 0.14.0

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

@@ -2692,6 +2692,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 +2986,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 +3003,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 +3040,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 +4628,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 +4645,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 +5943,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 +5990,14 @@ function generateModels$7(models, ctx, shared) {
 			if ((ctx.apiSurface?.interfaces?.[depName])?.sourceFile === parentPath) forceGenerate.add(dep);
 		}
 	}
+	const discriminatedSkip = ctx._discriminatedModelNames;
 	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 (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,6 +6329,7 @@ function generateSerializers(models, ctx, shared) {
 			if ((ctx.apiSurface?.interfaces?.[depName])?.sourceFile === parentPath) forceGenerateSerializer.add(dep);
 		}
 	}
+	const discriminatedSerializerSkip = ctx._discriminatedModelNames;
 	const eligibleModels = [];
 	for (const originalModel of models) {
 		const model = projectedByName.get(originalModel.name) ?? originalModel;
@@ -6332,6 +6337,7 @@ function generateSerializers(models, ctx, shared) {
 		if (serializerEligibleModels && !serializerEligibleModels.has(model.name)) continue;
 		if (isListMetadataModel(model)) continue;
 		if (isListWrapperModel(model)) 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 +7649,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 +8107,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;
@@ -7897,17 +8382,51 @@ function applyLiveSurface(files, ctx, surface) {
 	}
 	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 +8436,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 [];
@@ -13845,15 +14364,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);
@@ -24436,13 +24977,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) {
+	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 rubyEmitter = {
 	language: "ruby",
 	generateModels(models, ctx) {
-		return ensureTrailingNewlines$1(generateModels$1(models, ctx));
+		return ensureTrailingNewlines$1(generateModels$1(enrichModelsForRuby(models), 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));
@@ -26731,14 +27296,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 +27402,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-BxVeu2v9.mjs.map