@workos/oagen-emitters 0.12.5 → 0.14.0

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

@@ -291,806 +291,533 @@ function lowerFirstForDoc(s) {
 	return s.charAt(0).toLowerCase() + s.slice(1);
 }
 //#endregion
-//#region src/node/naming.ts
-/** Strip spec-noise suffixes (e.g., "Dto") from an IR name. */
-function stripNoiseSuffixes(name) {
-	return name.replace(/Dto$/i, "");
+//#region node_modules/js-yaml/dist/js-yaml.mjs
+/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
+function isNothing(subject) {
+	return typeof subject === "undefined" || subject === null;
 }
-/** kebab-case file name (without extension). */
-function fileName$3(name) {
-	return toKebabCase(stripUrnPrefix(name));
+function isObject(subject) {
+	return typeof subject === "object" && subject !== null;
 }
-/** camelCase field name for domain interfaces. */
-function fieldName$6(name) {
-	return toCamelCase(name);
+function toArray(sequence) {
+	if (Array.isArray(sequence)) return sequence;
+	else if (isNothing(sequence)) return [];
+	return [sequence];
 }
-/** snake_case field name for wire/response interfaces. */
-function wireFieldName(name) {
-	return toSnakeCase(name);
+function extend(target, source) {
+	var index, length, key, sourceKeys;
+	if (source) {
+		sourceKeys = Object.keys(source);
+		for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+			key = sourceKeys[index];
+			target[key] = source[key];
+		}
+	}
+	return target;
 }
-/**
-* Active set of `Serialized${Name}` interfaces in the live SDK, harvested
-* from `ctx.apiSurface` once per generation run. When non-empty, the
-* legacy wire-naming scheme wins so existing hand-written serializer files
-* continue to compile.
-*
-* Set by `index.ts` immediately after `getSurface(ctx)` runs.
-*/
-let baselineSerializedNames = /* @__PURE__ */ new Set();
-function setBaselineSerializedNames(names) {
-	baselineSerializedNames = names;
+function repeat(string, count) {
+	var result = "", cycle;
+	for (cycle = 0; cycle < count; cycle += 1) result += string;
+	return result;
 }
-/**
-* Set of every interface name present in the baseline live SDK, regardless
-* of naming convention. Used to detect single-form baselines (where one
-* `*Response`-suffixed interface stands for both the domain and wire shape)
-* so we don't synthesize a non-existent `*Wire` variant.
-*/
-let baselineInterfaceNames = /* @__PURE__ */ new Set();
-function setBaselineInterfaceNames(names) {
-	baselineInterfaceNames = names;
+function isNegativeZero(number) {
+	return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
 }
-/**
-* IR models that belong to newly-adopted services should not be renamed by
-* structural baseline matches from unrelated hand-written services.
-*/
-let adoptedModelNames = /* @__PURE__ */ new Set();
-function setAdoptedModelNames(names) {
-	adoptedModelNames = names;
+var common = {
+	isNothing,
+	isObject,
+	toArray,
+	repeat,
+	isNegativeZero,
+	extend
+};
+function formatError(exception, compact) {
+	var where = "", message = exception.reason || "(unknown reason)";
+	if (!exception.mark) return message;
+	if (exception.mark.name) where += "in \"" + exception.mark.name + "\" ";
+	where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
+	if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet;
+	return message + " " + where;
 }
-function isAdoptedModelName(name) {
-	return adoptedModelNames.has(name);
+function YAMLException$1(reason, mark) {
+	Error.call(this);
+	this.name = "YAMLException";
+	this.reason = reason;
+	this.mark = mark;
+	this.message = formatError(this, false);
+	if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+	else this.stack = (/* @__PURE__ */ new Error()).stack || "";
 }
-/**
-* Wire/response interface name.
-*
-* Resolution order:
-*  1. `Serialized${domainName}` if it exists in the baseline (legacy
-*     workos-node convention; lets hand-written serializer files keep
-*     compiling).
-*  2. `${domainName}Wire` when the domain ends in `Response` AND the
-*     baseline actually has a `*Wire` interface (avoids
-*     `FooResponseResponse` stutter).
-*  3. The bare `domainName` itself when it already ends in `Response` and
-*     no `*Wire` variant exists — this happens when the structural matcher
-*     maps an IR model to a baseline-wire-shaped interface
-*     (`AuditLogSchemaJson` → `AuditLogSchemaResponse`) and the baseline
-*     has no separate domain/wire split.
-*  4. `${domainName}Response` for the standard fresh-emit case.
-*/
-function wireInterfaceName(domainName) {
-	const serialized = `Serialized${domainName}`;
-	if (baselineSerializedNames.has(serialized)) return serialized;
-	if (domainName.endsWith("Response")) {
-		const wireForm = `${domainName}Wire`;
-		if (baselineInterfaceNames.has(wireForm)) return wireForm;
-		if (baselineInterfaceNames.has(domainName)) return domainName;
-		return wireForm;
+YAMLException$1.prototype = Object.create(Error.prototype);
+YAMLException$1.prototype.constructor = YAMLException$1;
+YAMLException$1.prototype.toString = function toString(compact) {
+	return this.name + ": " + formatError(this, compact);
+};
+var exception = YAMLException$1;
+function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+	var head = "";
+	var tail = "";
+	var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
+	if (position - lineStart > maxHalfLength) {
+		head = " ... ";
+		lineStart = position - maxHalfLength + head.length;
 	}
-	return `${domainName}Response`;
+	if (lineEnd - position > maxHalfLength) {
+		tail = " ...";
+		lineEnd = position + maxHalfLength - tail.length;
+	}
+	return {
+		str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
+		pos: position - lineStart + head.length
+	};
 }
-/** kebab-case service directory name. */
-function serviceDirName(name) {
-	return toKebabCase(name);
+function padStart(string, max) {
+	return common.repeat(" ", max - string.length) + string;
 }
-/** camelCase property name for service accessors on the client. */
-function servicePropertyName$4(name) {
-	return toCamelCase(name);
+function makeSnippet(mark, options) {
+	options = Object.create(options || null);
+	if (!mark.buffer) return null;
+	if (!options.maxLength) options.maxLength = 79;
+	if (typeof options.indent !== "number") options.indent = 1;
+	if (typeof options.linesBefore !== "number") options.linesBefore = 3;
+	if (typeof options.linesAfter !== "number") options.linesAfter = 2;
+	var re = /\r?\n|\r|\0/g;
+	var lineStarts = [0];
+	var lineEnds = [];
+	var match;
+	var foundLineNo = -1;
+	while (match = re.exec(mark.buffer)) {
+		lineEnds.push(match.index);
+		lineStarts.push(match.index + match[0].length);
+		if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
+	}
+	if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+	var result = "", i, line;
+	var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+	var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+	for (i = 1; i <= options.linesBefore; i++) {
+		if (foundLineNo - i < 0) break;
+		line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
+		result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
+	}
+	line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+	result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+	result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
+	for (i = 1; i <= options.linesAfter; i++) {
+		if (foundLineNo + i >= lineEnds.length) break;
+		line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
+		result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+	}
+	return result.replace(/\n$/, "");
 }
-/**
-* Resolve the effective service name, using the overlay-resolved class name
-* when available.
-*/
-function resolveServiceName(service, ctx) {
-	return resolveClassName$5(service, ctx);
+var snippet = makeSnippet;
+var TYPE_CONSTRUCTOR_OPTIONS = [
+	"kind",
+	"multi",
+	"resolve",
+	"construct",
+	"instanceOf",
+	"predicate",
+	"represent",
+	"representName",
+	"defaultStyle",
+	"styleAliases"
+];
+var YAML_NODE_KINDS = [
+	"scalar",
+	"sequence",
+	"mapping"
+];
+function compileStyleAliases(map) {
+	var result = {};
+	if (map !== null) Object.keys(map).forEach(function(style) {
+		map[style].forEach(function(alias) {
+			result[String(alias)] = style;
+		});
+	});
+	return result;
 }
-/**
-* Build a map from IR service name -> resolved service name.
-*/
-function buildServiceNameMap(services, ctx) {
-	const map = /* @__PURE__ */ new Map();
-	for (const service of services) map.set(service.name, resolveServiceName(service, ctx));
-	return map;
+function Type$1(tag, options) {
+	options = options || {};
+	Object.keys(options).forEach(function(name) {
+		if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new exception("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type.");
+	});
+	this.options = options;
+	this.tag = tag;
+	this.kind = options["kind"] || null;
+	this.resolve = options["resolve"] || function() {
+		return true;
+	};
+	this.construct = options["construct"] || function(data) {
+		return data;
+	};
+	this.instanceOf = options["instanceOf"] || null;
+	this.predicate = options["predicate"] || null;
+	this.represent = options["represent"] || null;
+	this.representName = options["representName"] || null;
+	this.defaultStyle = options["defaultStyle"] || null;
+	this.multi = options["multi"] || false;
+	this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
+	if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new exception("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
 }
-/** Resolve the output directory for a service. */
-function resolveServiceDir$1(resolvedServiceName) {
-	return serviceDirName(resolvedServiceName);
+var type = Type$1;
+function compileList(schema, name) {
+	var result = [];
+	schema[name].forEach(function(currentType) {
+		var newIndex = result.length;
+		result.forEach(function(previousType, previousIndex) {
+			if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex;
+		});
+		result[newIndex] = currentType;
+	});
+	return result;
 }
-/** Resolve the SDK method name for an operation, using resolved operations first. */
-function resolveMethodName$6(op, _service, ctx) {
-	const resolved = lookupMethodName(op, buildResolvedLookup(ctx));
-	if (resolved) return toCamelCase(resolved);
-	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-	const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
-	if (existing) return existing.methodName;
-	return toCamelCase(op.name);
-}
-/** Resolve the SDK class name for a service, using resolved ops mountOn as canonical. */
-function resolveClassName$5(service, ctx) {
-	for (const r of ctx.resolvedOperations ?? []) if (r.service.name === service.name) return r.mountOn;
-	if (ctx.overlayLookup?.methodByOperation) for (const op of service.operations) {
-		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
-		const existing = ctx.overlayLookup.methodByOperation.get(httpKey);
-		if (existing) return existing.className;
+function compileMap() {
+	var result = {
+		scalar: {},
+		sequence: {},
+		mapping: {},
+		fallback: {},
+		multi: {
+			scalar: [],
+			sequence: [],
+			mapping: [],
+			fallback: []
+		}
+	}, index, length;
+	function collectType(type) {
+		if (type.multi) {
+			result.multi[type.kind].push(type);
+			result.multi["fallback"].push(type);
+		} else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
 	}
-	return toPascalCase(service.name);
+	for (index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
+	return result;
 }
-/**
-* Resolve the interface name for a model, checking overlay first.
-*
-* Lookup order:
-*  1. `overlayLookup.interfaceByName` — exact-name overrides from the live SDK.
-*  2. `overlayLookup.modelNameByIR` — structurally-inferred matches (e.g., IR
-*     `ValidateApiKey` with one field `value: string` → live SDK interface
-*     `ValidateApiKeyOptions`).
-*  3. Type-alias resolution (when an alias points to an interface).
-*  4. Suffix-fallback heuristic for the workos-node `*Options` convention:
-*     when the IR name `X` has no baseline match but `XOptions` does, use
-*     `XOptions`. The convention is widely used for request-body interfaces
-*     in workos-node (CreateOrganizationOptions, ListUsersOptions, etc.).
-*  5. Default — clean and PascalCase the IR name.
-*/
-function resolveInterfaceName(name, ctx, opts) {
-	const existing = ctx.overlayLookup?.interfaceByName?.get(name);
-	if (existing) return existing;
-	let inferred = adoptedModelNames.has(name) ? void 0 : ctx.overlayLookup?.modelNameByIR?.get(name);
-	if (inferred) {
-		if (inferred.startsWith("Serialized")) {
-			const stripped = inferred.slice(10);
-			if (stripped && ctx.apiSurface?.interfaces?.[stripped]) inferred = stripped;
+function Schema$1(definition) {
+	return this.extend(definition);
+}
+Schema$1.prototype.extend = function extend(definition) {
+	var implicit = [];
+	var explicit = [];
+	if (definition instanceof type) explicit.push(definition);
+	else if (Array.isArray(definition)) explicit = explicit.concat(definition);
+	else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+		if (definition.implicit) implicit = implicit.concat(definition.implicit);
+		if (definition.explicit) explicit = explicit.concat(definition.explicit);
+	} else throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+	implicit.forEach(function(type$1) {
+		if (!(type$1 instanceof type)) throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+		if (type$1.loadKind && type$1.loadKind !== "scalar") throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
+		if (type$1.multi) throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+	});
+	explicit.forEach(function(type$1) {
+		if (!(type$1 instanceof type)) throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+	});
+	var result = Object.create(Schema$1.prototype);
+	result.implicit = (this.implicit || []).concat(implicit);
+	result.explicit = (this.explicit || []).concat(explicit);
+	result.compiledImplicit = compileList(result, "implicit");
+	result.compiledExplicit = compileList(result, "explicit");
+	result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
+	return result;
+};
+var failsafe = new Schema$1({ explicit: [
+	new type("tag:yaml.org,2002:str", {
+		kind: "scalar",
+		construct: function(data) {
+			return data !== null ? data : "";
 		}
-		if (inferred.endsWith("Response") && ctx.apiSurface?.interfaces) {
-			const stripped = inferred.slice(0, -8);
-			if (stripped && ctx.apiSurface.interfaces[stripped]) inferred = stripped;
+	}),
+	new type("tag:yaml.org,2002:seq", {
+		kind: "sequence",
+		construct: function(data) {
+			return data !== null ? data : [];
 		}
-		return inferred;
-	}
-	if (!opts?.skipTypeAlias && ctx.apiSurface?.typeAliases) {
-		const alias = ctx.apiSurface.typeAliases[name];
-		if (alias?.value && ctx.apiSurface.interfaces?.[alias.value]) return alias.value;
-	}
-	if (ctx.apiSurface?.interfaces) {
-		const ifaces = ctx.apiSurface.interfaces;
-		if (!ifaces[name]) {
-			const optionsCandidate = `${name}Options`;
-			const optionsInfo = ifaces[optionsCandidate];
-			if (optionsInfo?.sourceFile) {
-				const expectedStem = toKebabCase(stripUrnPrefix(name));
-				if (optionsInfo.sourceFile.endsWith(`/${expectedStem}.interface.ts`)) return optionsCandidate;
-			}
+	}),
+	new type("tag:yaml.org,2002:map", {
+		kind: "mapping",
+		construct: function(data) {
+			return data !== null ? data : {};
 		}
-	}
-	return toPascalCase(stripUrnPrefix(ctx.apiSurface ? name : stripNoiseSuffixes(name)));
+	})
+] });
+function resolveYamlNull(data) {
+	if (data === null) return true;
+	var max = data.length;
+	return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
 }
-//#endregion
-//#region src/node/type-map.ts
-/**
-* Map of enum name → inlined string-union TS source.
-*
-* Set by `index.ts` once per generation run, sourced from `spec.enums` for
-* enums that have no baseline definition in the live SDK. When populated,
-* `mapTypeRef`/`mapWireTypeRef` substitute the union directly at the
-* reference site instead of emitting a separate import — this collapses
-* ~100 single-line enum files into inline literal types.
-*/
-let inlineEnumUnions = /* @__PURE__ */ new Map();
-function setInlineEnumUnions(map) {
-	inlineEnumUnions = map;
+function constructYamlNull() {
+	return null;
 }
-function isInlineEnum(name) {
-	return inlineEnumUnions.has(name);
+function isNull(object) {
+	return object === null;
 }
-/**
-* Optional callback that resolves an IR model name to its live-SDK interface
-* name. Set by `index.ts` once per run. When present, `mapTypeRef` and
-* `mapWireTypeRef` use it instead of the raw IR name in their `model:` cases
-* — keeping field-type references in sync with import statements that the
-* caller emits via the same resolver. Without this, a structural match like
-* IR `AuditLogSchemaJson` → live `AuditLogSchemaResponse` would produce
-* `schema: AuditLogSchemaJson` in the body but
-* `import type { AuditLogSchemaResponse }` in the imports, leaving
-* `AuditLogSchemaJson` unbound.
-*/
-let domainNameResolver = null;
-function setDomainNameResolver(fn) {
-	domainNameResolver = fn;
+var _null = new type("tag:yaml.org,2002:null", {
+	kind: "scalar",
+	resolve: resolveYamlNull,
+	construct: constructYamlNull,
+	predicate: isNull,
+	represent: {
+		canonical: function() {
+			return "~";
+		},
+		lowercase: function() {
+			return "null";
+		},
+		uppercase: function() {
+			return "NULL";
+		},
+		camelcase: function() {
+			return "Null";
+		},
+		empty: function() {
+			return "";
+		}
+	},
+	defaultStyle: "lowercase"
+});
+function resolveYamlBoolean(data) {
+	if (data === null) return false;
+	var max = data.length;
+	return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
 }
-function resolveDomainName(irName) {
-	return domainNameResolver ? domainNameResolver(irName) : irName;
+function constructYamlBoolean(data) {
+	return data === "true" || data === "True" || data === "TRUE";
 }
-/**
-* Map an IR TypeRef to a TypeScript domain type string.
-* Domain types use PascalCase model names (e.g., `Organization`).
-*/
-function mapTypeRef$7(ref, opts) {
-	const genericDefaults = opts?.genericDefaults;
-	return mapTypeRef(ref, {
-		primitive: mapPrimitive$6,
-		array: (_r, items) => `${parenthesizeUnion(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),
-		nullable: (_r, inner) => `${inner} | null`,
-		literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
-		map: (_r, value) => `Record<string, ${value}>`
-	});
+function isBoolean(object) {
+	return Object.prototype.toString.call(object) === "[object Boolean]";
 }
-/**
-* Map an IR TypeRef to a TypeScript wire/response type string.
-* Model references get the `Response` suffix (e.g., `OrganizationResponse`).
-*/
-function mapWireTypeRef(ref, opts) {
-	const genericDefaults = opts?.genericDefaults;
-	return mapTypeRef(ref, {
-		primitive: mapWirePrimitive,
-		array: (_r, items) => `${parenthesizeUnion(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),
-		nullable: (_r, inner) => `${inner} | null`,
-		literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
-		map: (_r, value) => `Record<string, ${value}>`
-	});
+var bool = new type("tag:yaml.org,2002:bool", {
+	kind: "scalar",
+	resolve: resolveYamlBoolean,
+	construct: constructYamlBoolean,
+	predicate: isBoolean,
+	represent: {
+		lowercase: function(object) {
+			return object ? "true" : "false";
+		},
+		uppercase: function(object) {
+			return object ? "TRUE" : "FALSE";
+		},
+		camelcase: function(object) {
+			return object ? "True" : "False";
+		}
+	},
+	defaultStyle: "lowercase"
+});
+function isHexCode(c) {
+	return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
 }
-function mapPrimitive$6(ref) {
-	if (ref.format) switch (ref.format) {
-		case "date-time": return "Date";
-		case "int64": return "bigint";
-	}
-	switch (ref.type) {
-		case "string": return "string";
-		case "integer":
-		case "number": return "number";
-		case "boolean": return "boolean";
-		case "unknown": return "any";
-	}
-}
-function mapWirePrimitive(ref) {
-	switch (ref.type) {
-		case "string": return "string";
-		case "integer":
-		case "number": return "number";
-		case "boolean": return "boolean";
-		case "unknown": return "any";
-	}
-}
-function joinUnionVariants$5(ref, variants) {
-	const unique = [...new Set(variants)];
-	if (ref.compositionKind === "allOf") return unique.join(" & ");
-	if (unique.length === 1) return unique[0];
-	return unique.join(" | ");
-}
-function parenthesizeUnion(type) {
-	return type.includes(" | ") || type.includes(" & ") ? `(${type})` : type;
-}
-//#endregion
-//#region node_modules/js-yaml/dist/js-yaml.mjs
-/*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
-function isNothing(subject) {
-	return typeof subject === "undefined" || subject === null;
-}
-function isObject(subject) {
-	return typeof subject === "object" && subject !== null;
+function isOctCode(c) {
+	return 48 <= c && c <= 55;
 }
-function toArray(sequence) {
-	if (Array.isArray(sequence)) return sequence;
-	else if (isNothing(sequence)) return [];
-	return [sequence];
+function isDecCode(c) {
+	return 48 <= c && c <= 57;
 }
-function extend(target, source) {
-	var index, length, key, sourceKeys;
-	if (source) {
-		sourceKeys = Object.keys(source);
-		for (index = 0, length = sourceKeys.length; index < length; index += 1) {
-			key = sourceKeys[index];
-			target[key] = source[key];
+function resolveYamlInteger(data) {
+	if (data === null) return false;
+	var max = data.length, index = 0, hasDigits = false, ch;
+	if (!max) return false;
+	ch = data[index];
+	if (ch === "-" || ch === "+") ch = data[++index];
+	if (ch === "0") {
+		if (index + 1 === max) return true;
+		ch = data[++index];
+		if (ch === "b") {
+			index++;
+			for (; index < max; index++) {
+				ch = data[index];
+				if (ch === "_") continue;
+				if (ch !== "0" && ch !== "1") return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
+		}
+		if (ch === "x") {
+			index++;
+			for (; index < max; index++) {
+				ch = data[index];
+				if (ch === "_") continue;
+				if (!isHexCode(data.charCodeAt(index))) return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
+		}
+		if (ch === "o") {
+			index++;
+			for (; index < max; index++) {
+				ch = data[index];
+				if (ch === "_") continue;
+				if (!isOctCode(data.charCodeAt(index))) return false;
+				hasDigits = true;
+			}
+			return hasDigits && ch !== "_";
 		}
 	}
-	return target;
-}
-function repeat(string, count) {
-	var result = "", cycle;
-	for (cycle = 0; cycle < count; cycle += 1) result += string;
-	return result;
-}
-function isNegativeZero(number) {
-	return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+	if (ch === "_") return false;
+	for (; index < max; index++) {
+		ch = data[index];
+		if (ch === "_") continue;
+		if (!isDecCode(data.charCodeAt(index))) return false;
+		hasDigits = true;
+	}
+	if (!hasDigits || ch === "_") return false;
+	return true;
 }
-var common = {
-	isNothing,
-	isObject,
-	toArray,
-	repeat,
-	isNegativeZero,
-	extend
-};
-function formatError(exception, compact) {
-	var where = "", message = exception.reason || "(unknown reason)";
-	if (!exception.mark) return message;
-	if (exception.mark.name) where += "in \"" + exception.mark.name + "\" ";
-	where += "(" + (exception.mark.line + 1) + ":" + (exception.mark.column + 1) + ")";
-	if (!compact && exception.mark.snippet) where += "\n\n" + exception.mark.snippet;
-	return message + " " + where;
+function constructYamlInteger(data) {
+	var value = data, sign = 1, ch;
+	if (value.indexOf("_") !== -1) value = value.replace(/_/g, "");
+	ch = value[0];
+	if (ch === "-" || ch === "+") {
+		if (ch === "-") sign = -1;
+		value = value.slice(1);
+		ch = value[0];
+	}
+	if (value === "0") return 0;
+	if (ch === "0") {
+		if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
+		if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
+		if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
+	}
+	return sign * parseInt(value, 10);
 }
-function YAMLException$1(reason, mark) {
-	Error.call(this);
-	this.name = "YAMLException";
-	this.reason = reason;
-	this.mark = mark;
-	this.message = formatError(this, false);
-	if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-	else this.stack = (/* @__PURE__ */ new Error()).stack || "";
+function isInteger(object) {
+	return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
 }
-YAMLException$1.prototype = Object.create(Error.prototype);
-YAMLException$1.prototype.constructor = YAMLException$1;
-YAMLException$1.prototype.toString = function toString(compact) {
-	return this.name + ": " + formatError(this, compact);
-};
-var exception = YAMLException$1;
-function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
-	var head = "";
-	var tail = "";
-	var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
-	if (position - lineStart > maxHalfLength) {
-		head = " ... ";
-		lineStart = position - maxHalfLength + head.length;
-	}
-	if (lineEnd - position > maxHalfLength) {
-		tail = " ...";
-		lineEnd = position + maxHalfLength - tail.length;
+var int = new type("tag:yaml.org,2002:int", {
+	kind: "scalar",
+	resolve: resolveYamlInteger,
+	construct: constructYamlInteger,
+	predicate: isInteger,
+	represent: {
+		binary: function(obj) {
+			return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
+		},
+		octal: function(obj) {
+			return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+		},
+		decimal: function(obj) {
+			return obj.toString(10);
+		},
+		hexadecimal: function(obj) {
+			return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+		}
+	},
+	defaultStyle: "decimal",
+	styleAliases: {
+		binary: [2, "bin"],
+		octal: [8, "oct"],
+		decimal: [10, "dec"],
+		hexadecimal: [16, "hex"]
 	}
-	return {
-		str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "→") + tail,
-		pos: position - lineStart + head.length
-	};
+});
+var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat(data) {
+	if (data === null) return false;
+	if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") return false;
+	return true;
 }
-function padStart(string, max) {
-	return common.repeat(" ", max - string.length) + string;
+function constructYamlFloat(data) {
+	var value = data.replace(/_/g, "").toLowerCase(), sign = value[0] === "-" ? -1 : 1;
+	if ("+-".indexOf(value[0]) >= 0) value = value.slice(1);
+	if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+	else if (value === ".nan") return NaN;
+	return sign * parseFloat(value, 10);
 }
-function makeSnippet(mark, options) {
-	options = Object.create(options || null);
-	if (!mark.buffer) return null;
-	if (!options.maxLength) options.maxLength = 79;
-	if (typeof options.indent !== "number") options.indent = 1;
-	if (typeof options.linesBefore !== "number") options.linesBefore = 3;
-	if (typeof options.linesAfter !== "number") options.linesAfter = 2;
-	var re = /\r?\n|\r|\0/g;
-	var lineStarts = [0];
-	var lineEnds = [];
-	var match;
-	var foundLineNo = -1;
-	while (match = re.exec(mark.buffer)) {
-		lineEnds.push(match.index);
-		lineStarts.push(match.index + match[0].length);
-		if (mark.position <= match.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+function representYamlFloat(object, style) {
+	var res;
+	if (isNaN(object)) switch (style) {
+		case "lowercase": return ".nan";
+		case "uppercase": return ".NAN";
+		case "camelcase": return ".NaN";
 	}
-	if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-	var result = "", i, line;
-	var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
-	var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
-	for (i = 1; i <= options.linesBefore; i++) {
-		if (foundLineNo - i < 0) break;
-		line = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
-		result = common.repeat(" ", options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + " | " + line.str + "\n" + result;
+	else if (Number.POSITIVE_INFINITY === object) switch (style) {
+		case "lowercase": return ".inf";
+		case "uppercase": return ".INF";
+		case "camelcase": return ".Inf";
 	}
-	line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
-	result += common.repeat(" ", options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + " | " + line.str + "\n";
-	result += common.repeat("-", options.indent + lineNoLength + 3 + line.pos) + "^\n";
-	for (i = 1; i <= options.linesAfter; i++) {
-		if (foundLineNo + i >= lineEnds.length) break;
-		line = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
-		result += common.repeat(" ", options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + " | " + line.str + "\n";
+	else if (Number.NEGATIVE_INFINITY === object) switch (style) {
+		case "lowercase": return "-.inf";
+		case "uppercase": return "-.INF";
+		case "camelcase": return "-.Inf";
 	}
-	return result.replace(/\n$/, "");
+	else if (common.isNegativeZero(object)) return "-0.0";
+	res = object.toString(10);
+	return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
 }
-var snippet = makeSnippet;
-var TYPE_CONSTRUCTOR_OPTIONS = [
-	"kind",
-	"multi",
-	"resolve",
-	"construct",
-	"instanceOf",
-	"predicate",
-	"represent",
-	"representName",
-	"defaultStyle",
-	"styleAliases"
-];
-var YAML_NODE_KINDS = [
-	"scalar",
-	"sequence",
-	"mapping"
-];
-function compileStyleAliases(map) {
-	var result = {};
-	if (map !== null) Object.keys(map).forEach(function(style) {
-		map[style].forEach(function(alias) {
-			result[String(alias)] = style;
-		});
-	});
-	return result;
-}
-function Type$1(tag, options) {
-	options = options || {};
-	Object.keys(options).forEach(function(name) {
-		if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new exception("Unknown option \"" + name + "\" is met in definition of \"" + tag + "\" YAML type.");
-	});
-	this.options = options;
-	this.tag = tag;
-	this.kind = options["kind"] || null;
-	this.resolve = options["resolve"] || function() {
-		return true;
-	};
-	this.construct = options["construct"] || function(data) {
-		return data;
-	};
-	this.instanceOf = options["instanceOf"] || null;
-	this.predicate = options["predicate"] || null;
-	this.represent = options["represent"] || null;
-	this.representName = options["representName"] || null;
-	this.defaultStyle = options["defaultStyle"] || null;
-	this.multi = options["multi"] || false;
-	this.styleAliases = compileStyleAliases(options["styleAliases"] || null);
-	if (YAML_NODE_KINDS.indexOf(this.kind) === -1) throw new exception("Unknown kind \"" + this.kind + "\" is specified for \"" + tag + "\" YAML type.");
-}
-var type = Type$1;
-function compileList(schema, name) {
-	var result = [];
-	schema[name].forEach(function(currentType) {
-		var newIndex = result.length;
-		result.forEach(function(previousType, previousIndex) {
-			if (previousType.tag === currentType.tag && previousType.kind === currentType.kind && previousType.multi === currentType.multi) newIndex = previousIndex;
-		});
-		result[newIndex] = currentType;
-	});
-	return result;
-}
-function compileMap() {
-	var result = {
-		scalar: {},
-		sequence: {},
-		mapping: {},
-		fallback: {},
-		multi: {
-			scalar: [],
-			sequence: [],
-			mapping: [],
-			fallback: []
-		}
-	}, index, length;
-	function collectType(type) {
-		if (type.multi) {
-			result.multi[type.kind].push(type);
-			result.multi["fallback"].push(type);
-		} else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
-	}
-	for (index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
-	return result;
-}
-function Schema$1(definition) {
-	return this.extend(definition);
-}
-Schema$1.prototype.extend = function extend(definition) {
-	var implicit = [];
-	var explicit = [];
-	if (definition instanceof type) explicit.push(definition);
-	else if (Array.isArray(definition)) explicit = explicit.concat(definition);
-	else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
-		if (definition.implicit) implicit = implicit.concat(definition.implicit);
-		if (definition.explicit) explicit = explicit.concat(definition.explicit);
-	} else throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
-	implicit.forEach(function(type$1) {
-		if (!(type$1 instanceof type)) throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-		if (type$1.loadKind && type$1.loadKind !== "scalar") throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
-		if (type$1.multi) throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
-	});
-	explicit.forEach(function(type$1) {
-		if (!(type$1 instanceof type)) throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-	});
-	var result = Object.create(Schema$1.prototype);
-	result.implicit = (this.implicit || []).concat(implicit);
-	result.explicit = (this.explicit || []).concat(explicit);
-	result.compiledImplicit = compileList(result, "implicit");
-	result.compiledExplicit = compileList(result, "explicit");
-	result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit);
-	return result;
-};
-var failsafe = new Schema$1({ explicit: [
-	new type("tag:yaml.org,2002:str", {
-		kind: "scalar",
-		construct: function(data) {
-			return data !== null ? data : "";
-		}
-	}),
-	new type("tag:yaml.org,2002:seq", {
-		kind: "sequence",
-		construct: function(data) {
-			return data !== null ? data : [];
-		}
-	}),
-	new type("tag:yaml.org,2002:map", {
-		kind: "mapping",
-		construct: function(data) {
-			return data !== null ? data : {};
-		}
-	})
-] });
-function resolveYamlNull(data) {
-	if (data === null) return true;
-	var max = data.length;
-	return max === 1 && data === "~" || max === 4 && (data === "null" || data === "Null" || data === "NULL");
-}
-function constructYamlNull() {
-	return null;
-}
-function isNull(object) {
-	return object === null;
+function isFloat(object) {
+	return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
 }
-var _null = new type("tag:yaml.org,2002:null", {
+var float = new type("tag:yaml.org,2002:float", {
 	kind: "scalar",
-	resolve: resolveYamlNull,
-	construct: constructYamlNull,
-	predicate: isNull,
-	represent: {
-		canonical: function() {
-			return "~";
-		},
-		lowercase: function() {
-			return "null";
-		},
-		uppercase: function() {
-			return "NULL";
-		},
-		camelcase: function() {
-			return "Null";
-		},
-		empty: function() {
-			return "";
-		}
-	},
+	resolve: resolveYamlFloat,
+	construct: constructYamlFloat,
+	predicate: isFloat,
+	represent: representYamlFloat,
 	defaultStyle: "lowercase"
 });
-function resolveYamlBoolean(data) {
+var core = failsafe.extend({ implicit: [
+	_null,
+	bool,
+	int,
+	float
+] });
+var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(data) {
 	if (data === null) return false;
-	var max = data.length;
-	return max === 4 && (data === "true" || data === "True" || data === "TRUE") || max === 5 && (data === "false" || data === "False" || data === "FALSE");
+	if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+	if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+	return false;
 }
-function constructYamlBoolean(data) {
-	return data === "true" || data === "True" || data === "TRUE";
+function constructYamlTimestamp(data) {
+	var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
+	match = YAML_DATE_REGEXP.exec(data);
+	if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+	if (match === null) throw new Error("Date resolve error");
+	year = +match[1];
+	month = +match[2] - 1;
+	day = +match[3];
+	if (!match[4]) return new Date(Date.UTC(year, month, day));
+	hour = +match[4];
+	minute = +match[5];
+	second = +match[6];
+	if (match[7]) {
+		fraction = match[7].slice(0, 3);
+		while (fraction.length < 3) fraction += "0";
+		fraction = +fraction;
+	}
+	if (match[9]) {
+		tz_hour = +match[10];
+		tz_minute = +(match[11] || 0);
+		delta = (tz_hour * 60 + tz_minute) * 6e4;
+		if (match[9] === "-") delta = -delta;
+	}
+	date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+	if (delta) date.setTime(date.getTime() - delta);
+	return date;
 }
-function isBoolean(object) {
-	return Object.prototype.toString.call(object) === "[object Boolean]";
+function representYamlTimestamp(object) {
+	return object.toISOString();
 }
-var bool = new type("tag:yaml.org,2002:bool", {
+var timestamp = new type("tag:yaml.org,2002:timestamp", {
 	kind: "scalar",
-	resolve: resolveYamlBoolean,
-	construct: constructYamlBoolean,
-	predicate: isBoolean,
-	represent: {
-		lowercase: function(object) {
-			return object ? "true" : "false";
-		},
-		uppercase: function(object) {
-			return object ? "TRUE" : "FALSE";
-		},
-		camelcase: function(object) {
-			return object ? "True" : "False";
-		}
-	},
-	defaultStyle: "lowercase"
+	resolve: resolveYamlTimestamp,
+	construct: constructYamlTimestamp,
+	instanceOf: Date,
+	represent: representYamlTimestamp
 });
-function isHexCode(c) {
-	return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
-}
-function isOctCode(c) {
-	return 48 <= c && c <= 55;
-}
-function isDecCode(c) {
-	return 48 <= c && c <= 57;
+function resolveYamlMerge(data) {
+	return data === "<<" || data === null;
 }
-function resolveYamlInteger(data) {
-	if (data === null) return false;
-	var max = data.length, index = 0, hasDigits = false, ch;
-	if (!max) return false;
-	ch = data[index];
-	if (ch === "-" || ch === "+") ch = data[++index];
-	if (ch === "0") {
-		if (index + 1 === max) return true;
-		ch = data[++index];
-		if (ch === "b") {
-			index++;
-			for (; index < max; index++) {
-				ch = data[index];
-				if (ch === "_") continue;
-				if (ch !== "0" && ch !== "1") return false;
-				hasDigits = true;
-			}
-			return hasDigits && ch !== "_";
-		}
-		if (ch === "x") {
-			index++;
-			for (; index < max; index++) {
-				ch = data[index];
-				if (ch === "_") continue;
-				if (!isHexCode(data.charCodeAt(index))) return false;
-				hasDigits = true;
-			}
-			return hasDigits && ch !== "_";
-		}
-		if (ch === "o") {
-			index++;
-			for (; index < max; index++) {
-				ch = data[index];
-				if (ch === "_") continue;
-				if (!isOctCode(data.charCodeAt(index))) return false;
-				hasDigits = true;
-			}
-			return hasDigits && ch !== "_";
-		}
-	}
-	if (ch === "_") return false;
-	for (; index < max; index++) {
-		ch = data[index];
-		if (ch === "_") continue;
-		if (!isDecCode(data.charCodeAt(index))) return false;
-		hasDigits = true;
-	}
-	if (!hasDigits || ch === "_") return false;
-	return true;
-}
-function constructYamlInteger(data) {
-	var value = data, sign = 1, ch;
-	if (value.indexOf("_") !== -1) value = value.replace(/_/g, "");
-	ch = value[0];
-	if (ch === "-" || ch === "+") {
-		if (ch === "-") sign = -1;
-		value = value.slice(1);
-		ch = value[0];
-	}
-	if (value === "0") return 0;
-	if (ch === "0") {
-		if (value[1] === "b") return sign * parseInt(value.slice(2), 2);
-		if (value[1] === "x") return sign * parseInt(value.slice(2), 16);
-		if (value[1] === "o") return sign * parseInt(value.slice(2), 8);
-	}
-	return sign * parseInt(value, 10);
-}
-function isInteger(object) {
-	return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
-}
-var int = new type("tag:yaml.org,2002:int", {
-	kind: "scalar",
-	resolve: resolveYamlInteger,
-	construct: constructYamlInteger,
-	predicate: isInteger,
-	represent: {
-		binary: function(obj) {
-			return obj >= 0 ? "0b" + obj.toString(2) : "-0b" + obj.toString(2).slice(1);
-		},
-		octal: function(obj) {
-			return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
-		},
-		decimal: function(obj) {
-			return obj.toString(10);
-		},
-		hexadecimal: function(obj) {
-			return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
-		}
-	},
-	defaultStyle: "decimal",
-	styleAliases: {
-		binary: [2, "bin"],
-		octal: [8, "oct"],
-		decimal: [10, "dec"],
-		hexadecimal: [16, "hex"]
-	}
-});
-var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-function resolveYamlFloat(data) {
-	if (data === null) return false;
-	if (!YAML_FLOAT_PATTERN.test(data) || data[data.length - 1] === "_") return false;
-	return true;
-}
-function constructYamlFloat(data) {
-	var value = data.replace(/_/g, "").toLowerCase(), sign = value[0] === "-" ? -1 : 1;
-	if ("+-".indexOf(value[0]) >= 0) value = value.slice(1);
-	if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-	else if (value === ".nan") return NaN;
-	return sign * parseFloat(value, 10);
-}
-var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
-function representYamlFloat(object, style) {
-	var res;
-	if (isNaN(object)) switch (style) {
-		case "lowercase": return ".nan";
-		case "uppercase": return ".NAN";
-		case "camelcase": return ".NaN";
-	}
-	else if (Number.POSITIVE_INFINITY === object) switch (style) {
-		case "lowercase": return ".inf";
-		case "uppercase": return ".INF";
-		case "camelcase": return ".Inf";
-	}
-	else if (Number.NEGATIVE_INFINITY === object) switch (style) {
-		case "lowercase": return "-.inf";
-		case "uppercase": return "-.INF";
-		case "camelcase": return "-.Inf";
-	}
-	else if (common.isNegativeZero(object)) return "-0.0";
-	res = object.toString(10);
-	return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace("e", ".e") : res;
-}
-function isFloat(object) {
-	return Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || common.isNegativeZero(object));
-}
-var float = new type("tag:yaml.org,2002:float", {
-	kind: "scalar",
-	resolve: resolveYamlFloat,
-	construct: constructYamlFloat,
-	predicate: isFloat,
-	represent: representYamlFloat,
-	defaultStyle: "lowercase"
-});
-var core = failsafe.extend({ implicit: [
-	_null,
-	bool,
-	int,
-	float
-] });
-var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
-var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
-function resolveYamlTimestamp(data) {
-	if (data === null) return false;
-	if (YAML_DATE_REGEXP.exec(data) !== null) return true;
-	if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
-	return false;
-}
-function constructYamlTimestamp(data) {
-	var match, year, month, day, hour, minute, second, fraction = 0, delta = null, tz_hour, tz_minute, date;
-	match = YAML_DATE_REGEXP.exec(data);
-	if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
-	if (match === null) throw new Error("Date resolve error");
-	year = +match[1];
-	month = +match[2] - 1;
-	day = +match[3];
-	if (!match[4]) return new Date(Date.UTC(year, month, day));
-	hour = +match[4];
-	minute = +match[5];
-	second = +match[6];
-	if (match[7]) {
-		fraction = match[7].slice(0, 3);
-		while (fraction.length < 3) fraction += "0";
-		fraction = +fraction;
-	}
-	if (match[9]) {
-		tz_hour = +match[10];
-		tz_minute = +(match[11] || 0);
-		delta = (tz_hour * 60 + tz_minute) * 6e4;
-		if (match[9] === "-") delta = -delta;
-	}
-	date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
-	if (delta) date.setTime(date.getTime() - delta);
-	return date;
-}
-function representYamlTimestamp(object) {
-	return object.toISOString();
-}
-var timestamp = new type("tag:yaml.org,2002:timestamp", {
-	kind: "scalar",
-	resolve: resolveYamlTimestamp,
-	construct: constructYamlTimestamp,
-	instanceOf: Date,
-	represent: representYamlTimestamp
-});
-function resolveYamlMerge(data) {
-	return data === "<<" || data === null;
-}
-var merge = new type("tag:yaml.org,2002:merge", {
-	kind: "scalar",
-	resolve: resolveYamlMerge
-});
-var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
-function resolveYamlBinary(data) {
+var merge = new type("tag:yaml.org,2002:merge", {
+	kind: "scalar",
+	resolve: resolveYamlMerge
+});
+var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+function resolveYamlBinary(data) {
 	if (data === null) return false;
 	var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
 	for (idx = 0; idx < max; idx++) {
@@ -2426,552 +2153,895 @@ function writeFlowMapping(state, level, object) {
 	state.tag = _tag;
 	state.dump = "{" + _result + "}";
 }
-function writeBlockMapping(state, level, object, compact) {
-	var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
-	if (state.sortKeys === true) objectKeyList.sort();
-	else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
-	else if (state.sortKeys) throw new exception("sortKeys must be a boolean or a function");
-	for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-		pairBuffer = "";
-		if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
-		objectKey = objectKeyList[index];
-		objectValue = object[objectKey];
-		if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-		if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
-		explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
-		if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
-		else pairBuffer += "? ";
-		pairBuffer += state.dump;
-		if (explicitPair) pairBuffer += generateNextLine(state, level);
-		if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
-		if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
-		else pairBuffer += ": ";
-		pairBuffer += state.dump;
-		_result += pairBuffer;
+function writeBlockMapping(state, level, object, compact) {
+	var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length, objectKey, objectValue, explicitPair, pairBuffer;
+	if (state.sortKeys === true) objectKeyList.sort();
+	else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
+	else if (state.sortKeys) throw new exception("sortKeys must be a boolean or a function");
+	for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+		pairBuffer = "";
+		if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
+		objectKey = objectKeyList[index];
+		objectValue = object[objectKey];
+		if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+		if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
+		explicitPair = state.tag !== null && state.tag !== "?" || state.dump && state.dump.length > 1024;
+		if (explicitPair) if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += "?";
+		else pairBuffer += "? ";
+		pairBuffer += state.dump;
+		if (explicitPair) pairBuffer += generateNextLine(state, level);
+		if (!writeNode(state, level + 1, objectValue, true, explicitPair)) continue;
+		if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
+		else pairBuffer += ": ";
+		pairBuffer += state.dump;
+		_result += pairBuffer;
+	}
+	state.tag = _tag;
+	state.dump = _result || "{}";
+}
+function detectType(state, object, explicit) {
+	var _result, typeList = explicit ? state.explicitTypes : state.implicitTypes, index, length, type, style;
+	for (index = 0, length = typeList.length; index < length; index += 1) {
+		type = typeList[index];
+		if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
+			if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
+			else state.tag = type.tag;
+			else state.tag = "?";
+			if (type.represent) {
+				style = state.styleMap[type.tag] || type.defaultStyle;
+				if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
+				else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
+				else throw new exception("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
+				state.dump = _result;
+			}
+			return true;
+		}
+	}
+	return false;
+}
+function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+	state.tag = null;
+	state.dump = object;
+	if (!detectType(state, object, false)) detectType(state, object, true);
+	var type = _toString.call(state.dump);
+	var inblock = block;
+	var tagStr;
+	if (block) block = state.flowLevel < 0 || state.flowLevel > level;
+	var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
+	if (objectOrArray) {
+		duplicateIndex = state.duplicates.indexOf(object);
+		duplicate = duplicateIndex !== -1;
+	}
+	if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
+	if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
+	else {
+		if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
+		if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
+			writeBlockMapping(state, level, state.dump, compact);
+			if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+		} else {
+			writeFlowMapping(state, level, state.dump);
+			if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+		}
+		else if (type === "[object Array]") if (block && state.dump.length !== 0) {
+			if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
+			else writeBlockSequence(state, level, state.dump, compact);
+			if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
+		} else {
+			writeFlowSequence(state, level, state.dump);
+			if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
+		}
+		else if (type === "[object String]") {
+			if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
+		} else if (type === "[object Undefined]") return false;
+		else {
+			if (state.skipInvalid) return false;
+			throw new exception("unacceptable kind of an object to dump " + type);
+		}
+		if (state.tag !== null && state.tag !== "?") {
+			tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
+			if (state.tag[0] === "!") tagStr = "!" + tagStr;
+			else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
+			else tagStr = "!<" + tagStr + ">";
+			state.dump = tagStr + " " + state.dump;
+		}
+	}
+	return true;
+}
+function getDuplicateReferences(object, state) {
+	var objects = [], duplicatesIndexes = [], index, length;
+	inspectNode(object, objects, duplicatesIndexes);
+	for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
+	state.usedDuplicates = new Array(length);
+}
+function inspectNode(object, objects, duplicatesIndexes) {
+	var objectKeyList, index, length;
+	if (object !== null && typeof object === "object") {
+		index = objects.indexOf(object);
+		if (index !== -1) {
+			if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
+		} else {
+			objects.push(object);
+			if (Array.isArray(object)) for (index = 0, length = object.length; index < length; index += 1) inspectNode(object[index], objects, duplicatesIndexes);
+			else {
+				objectKeyList = Object.keys(object);
+				for (index = 0, length = objectKeyList.length; index < length; index += 1) inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+			}
+		}
+	}
+}
+function dump$1(input, options) {
+	options = options || {};
+	var state = new State(options);
+	if (!state.noRefs) getDuplicateReferences(input, state);
+	var value = input;
+	if (state.replacer) value = state.replacer.call({ "": value }, "", value);
+	if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+	return "";
+}
+var dumper = { dump: dump$1 };
+var load = loader.load;
+loader.loadAll;
+dumper.dump;
+//#endregion
+//#region src/shared/model-utils.ts
+/**
+* Detect whether a model is a list wrapper -- the standard paginated
+* list envelope with `data` (array), `list_metadata`, and optionally `object: 'list'`.
+*
+* These models are redundant because each language SDK already has its own
+* pagination wrapper, and the runtime handles deserialization.
+*/
+function isListWrapperModel(model) {
+	const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
+	const dataField = fieldsByName.get("data");
+	if (!dataField) return false;
+	if (dataField.type.kind !== "array") return false;
+	if (!(fieldsByName.get("list_metadata") ?? fieldsByName.get("listMetadata"))) return false;
+	const objectField = fieldsByName.get("object");
+	if (objectField) {
+		if (objectField.type.kind !== "literal" || objectField.type.value !== "list") return false;
+	}
+	return true;
+}
+/**
+* Detect whether a model is a list metadata model (e.g., ListMetadata).
+* These models typically have exactly `before` and `after` nullable string fields.
+*/
+function isListMetadataModel(model) {
+	if (model.fields.length !== 2) return false;
+	const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
+	const before = fieldsByName.get("before");
+	const after = fieldsByName.get("after");
+	if (!before || !after) return false;
+	return isNullableString(before) && isNullableString(after);
+}
+/** 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;
+	if (field.type.kind === "nullable" && field.type.inner.kind === "primitive" && field.type.inner.type === "string") return true;
+	return false;
+}
+/**
+* Discover the OpenAPI spec path from CLI args or environment.
+* Returns null if not found.
+*/
+function discoverSpecPath() {
+	const args = process.argv;
+	for (let i = 0; i < args.length; i++) {
+		if (args[i] === "--spec" && args[i + 1]) return resolve(args[i + 1]);
+		if (args[i]?.startsWith("--spec=")) return resolve(args[i].slice(7));
+	}
+	if (process.env.OPENAPI_SPEC_PATH) return resolve(process.env.OPENAPI_SPEC_PATH);
+	return null;
+}
+/** Cached raw spec to avoid re-reading on multiple calls. */
+let _rawSpecCache = null;
+let _rawSpecLoaded = false;
+function loadRawSpec() {
+	if (_rawSpecLoaded) return _rawSpecCache;
+	_rawSpecLoaded = true;
+	const specPath = discoverSpecPath();
+	if (!specPath || !existsSync(specPath)) return null;
+	try {
+		_rawSpecCache = load(readFileSync(specPath, "utf-8"));
+		return _rawSpecCache;
+	} catch {
+		return null;
+	}
+}
+/** Look up a schema by name in the raw spec's components/schemas. */
+function lookupRawSchema(name) {
+	const spec = loadRawSpec();
+	if (!spec) return null;
+	return spec?.components?.schemas?.[name] ?? null;
+}
+function createCollector() {
+	return {
+		models: [],
+		enums: [],
+		usedNames: /* @__PURE__ */ new Set()
+	};
+}
+/**
+* Singularize a snake_case name for use as an array-item model name.
+* `redirect_uris` -> `redirect_uri`, `scopes` -> `scope`.
+*/
+function singularizeSnake(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;
+}
+/**
+* Convert a raw OpenAPI type+format to an IR TypeRef.
+*
+* When `parentModelName` and `fieldName` are provided, inline objects and
+* enums generate synthetic models/enums instead of degrading to `unknown`
+* or `string`.
+*/
+function rawSchemaToTypeRef(schema, parentModelName, fName, collector) {
+	if (schema.const !== void 0) return {
+		kind: "literal",
+		value: schema.const
+	};
+	if (schema.enum && collector && parentModelName && fName) {
+		const syntheticName = `${parentModelName}_${fName}`;
+		if (!collector.usedNames.has(syntheticName) && !collector.usedNames.has(toSnakeCase(syntheticName))) {
+			collector.usedNames.add(syntheticName);
+			collector.enums.push({
+				name: syntheticName,
+				values: schema.enum.map((v) => ({
+					value: v,
+					description: void 0
+				}))
+			});
+		}
+		return {
+			kind: "enum",
+			name: syntheticName,
+			values: schema.enum
+		};
+	}
+	if (schema.enum) return {
+		kind: "primitive",
+		type: "string"
+	};
+	if (schema.$ref) return {
+		kind: "model",
+		name: schema.$ref.split("/").pop()
+	};
+	let baseType = schema.type;
+	let isNullable = false;
+	if (Array.isArray(baseType)) {
+		const nonNull = baseType.filter((t) => t !== "null");
+		isNullable = baseType.includes("null");
+		baseType = nonNull[0] ?? "string";
+	}
+	let ref;
+	if (baseType === "object" && schema.properties && collector && parentModelName && fName) {
+		const syntheticName = `${parentModelName}_${fName}`;
+		if (!collector.usedNames.has(syntheticName) && !collector.usedNames.has(toSnakeCase(syntheticName))) {
+			collector.usedNames.add(syntheticName);
+			const fields = [];
+			const requiredSet = new Set(schema.required ?? []);
+			for (const [propName, propSchema] of Object.entries(schema.properties)) fields.push({
+				name: propName,
+				type: rawSchemaToTypeRef(propSchema, syntheticName, propName, collector),
+				required: requiredSet.has(propName),
+				description: propSchema.description,
+				deprecated: propSchema.deprecated
+			});
+			collector.models.push({
+				name: syntheticName,
+				fields,
+				description: schema.description
+			});
+		}
+		ref = {
+			kind: "model",
+			name: syntheticName
+		};
+	} else if (baseType === "object" && schema.properties) ref = {
+		kind: "primitive",
+		type: "unknown"
+	};
+	else if (baseType === "array" && schema.items) {
+		const itemFieldName = fName ? singularizeSnake(fName) : void 0;
+		ref = {
+			kind: "array",
+			items: rawSchemaToTypeRef(schema.items, parentModelName, itemFieldName, collector)
+		};
+	} else if (baseType === "boolean") ref = {
+		kind: "primitive",
+		type: "boolean"
+	};
+	else if (baseType === "integer" || baseType === "number") ref = {
+		kind: "primitive",
+		type: baseType
+	};
+	else ref = {
+		kind: "primitive",
+		type: "string"
+	};
+	if (isNullable) return {
+		kind: "nullable",
+		inner: ref
+	};
+	return ref;
+}
+/**
+* Extract fields from a raw OpenAPI object schema.
+* All fields are returned as optional (not required) since they come from
+* oneOf variants where only one variant is active at a time.
+*/
+function extractFieldsFromRawSchema(schema, parentModelName, collector) {
+	const fields = [];
+	const props = schema.properties ?? {};
+	for (const [name, propSchema] of Object.entries(props)) fields.push({
+		name,
+		type: rawSchemaToTypeRef(propSchema, parentModelName, name, collector),
+		required: false,
+		description: propSchema.description,
+		deprecated: propSchema.deprecated
+	});
+	return fields;
+}
+/**
+* Recursively collect all fields from a oneOf schema, flattening nested
+* allOf+oneOf compositions. All fields are marked optional.
+*/
+function collectOneOfFields(schema, parentModelName, collector) {
+	const allFields = [];
+	const seenFieldNames = /* @__PURE__ */ new Set();
+	function walkSchema(s) {
+		if (s.properties) {
+			for (const f of extractFieldsFromRawSchema(s, parentModelName, collector)) if (!seenFieldNames.has(f.name)) {
+				seenFieldNames.add(f.name);
+				allFields.push(f);
+			}
+		}
+		if (s.allOf) for (const sub of s.allOf) walkSchema(sub);
+		if (s.oneOf) for (const variant of s.oneOf) walkSchema(variant);
+		if (s.anyOf) for (const variant of s.anyOf) walkSchema(variant);
+	}
+	walkSchema(schema);
+	return allFields;
+}
+/**
+* Check if a TypeRef is `unknown` (the degraded type for inline objects).
+*/
+function isUnknownType(ref) {
+	return ref.kind === "primitive" && ref.type === "unknown";
+}
+/**
+* If a field is an `array<unknown>` (or `nullable<array<unknown>>`) and the
+* raw spec defines inline object/enum items, replace the item type with a
+* synthetic model/enum. Returns the original field unchanged when no upgrade
+* is needed.
+*/
+function upgradeArrayItemType(field, rawSchema, parentModelName, collector) {
+	let arrayRef = null;
+	let isNullableWrapper = false;
+	if (field.type.kind === "array") arrayRef = field.type;
+	else if (field.type.kind === "nullable" && field.type.inner.kind === "array") {
+		arrayRef = field.type.inner;
+		isNullableWrapper = true;
+	}
+	if (!arrayRef || arrayRef.kind !== "array") return field;
+	if (!isUnknownType(arrayRef.items)) return field;
+	const rawProp = rawSchema.properties?.[field.name];
+	if (!rawProp) return field;
+	let rawArraySchema = rawProp;
+	if (Array.isArray(rawProp.type)) {
+		if (rawProp.type.filter((t) => t !== "null")[0] === "array") rawArraySchema = rawProp;
+	}
+	if (rawArraySchema.type !== "array" && !(Array.isArray(rawArraySchema.type) && rawArraySchema.type.includes("array"))) return field;
+	if (!rawArraySchema.items) return field;
+	const itemFieldName = singularizeSnake(field.name);
+	const newItemRef = rawSchemaToTypeRef(rawArraySchema.items, parentModelName, itemFieldName, collector);
+	if (isUnknownType(newItemRef)) return field;
+	const newArrayRef = {
+		kind: "array",
+		items: newItemRef
+	};
+	const newType = isNullableWrapper ? {
+		kind: "nullable",
+		inner: newArrayRef
+	} : newArrayRef;
+	return {
+		...field,
+		type: newType
+	};
+}
+let _lastSyntheticEnums = [];
+/**
+* Return the synthetic enums generated during the last call to
+* `enrichModelsFromSpec`. Call this after enrichment to merge them into the
+* enum generation phase.
+*/
+function getSyntheticEnums() {
+	return _lastSyntheticEnums;
+}
+/**
+* Find a property name that has a `const` value in ALL oneOf variants.
+* Returns null if no shared const property is found.
+*/
+function findSharedConstProperty(oneOfSchemas) {
+	if (oneOfSchemas.length === 0) return null;
+	const first = oneOfSchemas[0];
+	if (!first.properties) return null;
+	const candidates = Object.keys(first.properties).filter((name) => first.properties[name].const !== void 0);
+	for (const candidate of candidates) if (oneOfSchemas.every((variant) => variant.properties?.[candidate]?.const !== void 0)) return candidate;
+	return null;
+}
+/**
+* Build a discriminator mapping from const values to IR model names.
+* For each oneOf variant's const value on `discProperty`, find the IR model
+* whose field with the same name is a Literal type with that value.
+*/
+function buildDiscriminatorMapping(discProperty, oneOfSchemas, models, parentModelName) {
+	const mapping = {};
+	for (const variant of oneOfSchemas) {
+		const constValue = variant.properties?.[discProperty]?.const;
+		if (constValue === void 0) continue;
+		const variantModel = models.find((m) => m.name !== parentModelName && m.fields.some((f) => f.name === discProperty && f.type.kind === "literal" && f.type.value === constValue));
+		if (variantModel) mapping[String(constValue)] = variantModel.name;
 	}
-	state.tag = _tag;
-	state.dump = _result || "{}";
+	return mapping;
 }
-function detectType(state, object, explicit) {
-	var _result, typeList = explicit ? state.explicitTypes : state.implicitTypes, index, length, type, style;
-	for (index = 0, length = typeList.length; index < length; index += 1) {
-		type = typeList[index];
-		if ((type.instanceOf || type.predicate) && (!type.instanceOf || typeof object === "object" && object instanceof type.instanceOf) && (!type.predicate || type.predicate(object))) {
-			if (explicit) if (type.multi && type.representName) state.tag = type.representName(object);
-			else state.tag = type.tag;
-			else state.tag = "?";
-			if (type.represent) {
-				style = state.styleMap[type.tag] || type.defaultStyle;
-				if (_toString.call(type.represent) === "[object Function]") _result = type.represent(object, style);
-				else if (_hasOwnProperty.call(type.represent, style)) _result = type.represent[style](object, style);
-				else throw new exception("!<" + type.tag + "> tag resolver accepts not \"" + style + "\" style");
-				state.dump = _result;
+/**
+* Detect implicit discriminators on models without full oneOf flattening.
+* Returns a new array with discriminator annotations; models without
+* discriminators are returned as-is. Use this when you need discriminator
+* info but don't want the side-effects of full enrichment (synthetic
+* models/enums, field flattening).
+*/
+function detectDiscriminators(models) {
+	if (!loadRawSpec()) return models;
+	let changed = false;
+	const result = models.map((model) => {
+		if (model.discriminator) return model;
+		const rawSchema = lookupRawSchema(model.name);
+		if (!rawSchema) return model;
+		const oneOfContainer = rawSchema.allOf?.find((s) => s.oneOf);
+		if (!oneOfContainer?.oneOf || oneOfContainer.oneOf.length === 0) return model;
+		const discProperty = findSharedConstProperty(oneOfContainer.oneOf);
+		if (!discProperty) return model;
+		const mapping = buildDiscriminatorMapping(discProperty, oneOfContainer.oneOf, models, model.name);
+		if (Object.keys(mapping).length === 0) return model;
+		changed = true;
+		return {
+			...model,
+			fields: [],
+			discriminator: {
+				property: discProperty,
+				mapping
 			}
-			return true;
-		}
-	}
-	return false;
+		};
+	});
+	return changed ? result : models;
 }
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-	state.tag = null;
-	state.dump = object;
-	if (!detectType(state, object, false)) detectType(state, object, true);
-	var type = _toString.call(state.dump);
-	var inblock = block;
-	var tagStr;
-	if (block) block = state.flowLevel < 0 || state.flowLevel > level;
-	var objectOrArray = type === "[object Object]" || type === "[object Array]", duplicateIndex, duplicate;
-	if (objectOrArray) {
-		duplicateIndex = state.duplicates.indexOf(object);
-		duplicate = duplicateIndex !== -1;
+/**
+* Enrich IR models by flattening oneOf/allOf+oneOf variant fields from the raw spec.
+*
+* For models with 0 fields whose raw spec schema is a pure oneOf:
+*   - Collect all variant fields and add them as optional fields.
+*
+* For models whose raw spec schema has allOf containing a oneOf:
+*   - Collect the missing variant fields and add them as optional.
+*
+* Inline objects and enums in oneOf branches are promoted to synthetic
+* models/enums instead of degrading to `object` / `string`.
+*
+* Returns a new array of enriched models (original models are not mutated).
+* Synthetic enums are stored internally; retrieve them via `getSyntheticEnums()`.
+*/
+function enrichModelsFromSpec(models) {
+	if (!loadRawSpec()) {
+		_lastSyntheticEnums = [];
+		return models;
 	}
-	if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) compact = false;
-	if (duplicate && state.usedDuplicates[duplicateIndex]) state.dump = "*ref_" + duplicateIndex;
-	else {
-		if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) state.usedDuplicates[duplicateIndex] = true;
-		if (type === "[object Object]") if (block && Object.keys(state.dump).length !== 0) {
-			writeBlockMapping(state, level, state.dump, compact);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-		} else {
-			writeFlowMapping(state, level, state.dump);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-		}
-		else if (type === "[object Array]") if (block && state.dump.length !== 0) {
-			if (state.noArrayIndent && !isblockseq && level > 0) writeBlockSequence(state, level - 1, state.dump, compact);
-			else writeBlockSequence(state, level, state.dump, compact);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
-		} else {
-			writeFlowSequence(state, level, state.dump);
-			if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-		}
-		else if (type === "[object String]") {
-			if (state.tag !== "?") writeScalar(state, state.dump, level, iskey, inblock);
-		} else if (type === "[object Undefined]") return false;
-		else {
-			if (state.skipInvalid) return false;
-			throw new exception("unacceptable kind of an object to dump " + type);
-		}
-		if (state.tag !== null && state.tag !== "?") {
-			tagStr = encodeURI(state.tag[0] === "!" ? state.tag.slice(1) : state.tag).replace(/!/g, "%21");
-			if (state.tag[0] === "!") tagStr = "!" + tagStr;
-			else if (tagStr.slice(0, 18) === "tag:yaml.org,2002:") tagStr = "!!" + tagStr.slice(18);
-			else tagStr = "!<" + tagStr + ">";
-			state.dump = tagStr + " " + state.dump;
-		}
+	const collector = createCollector();
+	for (const m of models) {
+		collector.usedNames.add(m.name);
+		collector.usedNames.add(toSnakeCase(m.name));
 	}
-	return true;
-}
-function getDuplicateReferences(object, state) {
-	var objects = [], duplicatesIndexes = [], index, length;
-	inspectNode(object, objects, duplicatesIndexes);
-	for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
-	state.usedDuplicates = new Array(length);
-}
-function inspectNode(object, objects, duplicatesIndexes) {
-	var objectKeyList, index, length;
-	if (object !== null && typeof object === "object") {
-		index = objects.indexOf(object);
-		if (index !== -1) {
-			if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
-		} else {
-			objects.push(object);
-			if (Array.isArray(object)) for (index = 0, length = object.length; index < length; index += 1) inspectNode(object[index], objects, duplicatesIndexes);
-			else {
-				objectKeyList = Object.keys(object);
-				for (index = 0, length = objectKeyList.length; index < length; index += 1) inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+	const enriched2 = models.map((model) => {
+		const rawSchema = lookupRawSchema(model.name);
+		if (!rawSchema) return model;
+		if (!(rawSchema.oneOf || rawSchema.allOf?.some((s) => s.oneOf))) return model;
+		if (rawSchema.discriminator || rawSchema.oneOf?.some((v) => v.discriminator) || rawSchema.allOf?.some((s) => s.discriminator || s.oneOf?.some((v) => v.discriminator))) return model;
+		const oneOfContainer = rawSchema.allOf?.find((s) => s.oneOf);
+		if (oneOfContainer?.oneOf && oneOfContainer.oneOf.length > 0) {
+			const discProperty = findSharedConstProperty(oneOfContainer.oneOf);
+			if (discProperty) {
+				const mapping = buildDiscriminatorMapping(discProperty, oneOfContainer.oneOf, models, model.name);
+				if (Object.keys(mapping).length > 0) return {
+					...model,
+					fields: [],
+					discriminator: {
+						property: discProperty,
+						mapping
+					}
+				};
 			}
 		}
-	}
-}
-function dump$1(input, options) {
-	options = options || {};
-	var state = new State(options);
-	if (!state.noRefs) getDuplicateReferences(input, state);
-	var value = input;
-	if (state.replacer) value = state.replacer.call({ "": value }, "", value);
-	if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
-	return "";
+		const variantFields = collectOneOfFields(rawSchema, model.name, collector);
+		if (variantFields.length === 0) return model;
+		const existingNames = new Set(model.fields.map((f) => f.name));
+		const newFields = variantFields.filter((f) => !existingNames.has(f.name));
+		if (newFields.length === 0) return model;
+		return {
+			...model,
+			fields: [...model.fields, ...newFields]
+		};
+	}).map((model) => {
+		const rawSchema = lookupRawSchema(model.name);
+		if (!rawSchema?.properties) return model;
+		let modified = false;
+		const newFields = model.fields.map((field) => {
+			const upgraded = upgradeArrayItemType(field, rawSchema, model.name, collector);
+			if (upgraded !== field) modified = true;
+			return upgraded;
+		});
+		return modified ? {
+			...model,
+			fields: newFields
+		} : model;
+	});
+	_lastSyntheticEnums = collector.enums.map((e) => ({
+		name: e.name,
+		values: e.values.map((v) => ({
+			name: toUpperSnakeCase(String(v.value)),
+			value: v.value,
+			description: v.description
+		}))
+	}));
+	const existingSnakeNames = new Set(enriched2.map((m) => toSnakeCase(m.name)));
+	const filteredSynthetic = collector.models.filter((m) => !existingSnakeNames.has(toSnakeCase(m.name)));
+	return [...enriched2, ...filteredSynthetic];
 }
-var dumper = { dump: dump$1 };
-var load = loader.load;
-loader.loadAll;
-dumper.dump;
 //#endregion
-//#region src/shared/model-utils.ts
+//#region src/shared/service-name-collision.ts
 /**
-* Detect whether a model is a list wrapper -- the standard paginated
-* list envelope with `data` (array), `list_metadata`, and optionally `object: 'list'`.
+* Suffix applied to an operation-client class name when it collides with an
+* exported model/enum class name in the same SDK namespace. Standardized
+* across emitters so colliding services look the same in every language —
+* e.g. `OrganizationMembershipService` regardless of language.
 *
-* These models are redundant because each language SDK already has its own
-* pagination wrapper, and the runtime handles deserialization.
+* Languages whose operation clients already carry a unique suffix (Go's
+* `…Service`, Rust's `…Api`, .NET's `…Service`) skip this helper entirely.
 */
-function isListWrapperModel(model) {
-	const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
-	const dataField = fieldsByName.get("data");
-	if (!dataField) return false;
-	if (dataField.type.kind !== "array") return false;
-	if (!(fieldsByName.get("list_metadata") ?? fieldsByName.get("listMetadata"))) return false;
-	const objectField = fieldsByName.get("object");
-	if (objectField) {
-		if (objectField.type.kind !== "literal" || objectField.type.value !== "list") return false;
+const SERVICE_COLLISION_SUFFIX = "Service";
+/**
+* Build the set of model + enum class names that the SDK exports under its
+* top-level namespace. Each emitter passes its own `classNameFn` so the
+* comparison happens on the language-specific class-name form (e.g. Ruby's
+* `RoleList`, Python's `RoleList`).
+*
+* List-wrapper and list-metadata models are excluded — they aren't exposed
+* as user-facing types.
+*/
+function buildExportedClassNameSet$5(ctx, classNameFn) {
+	const out = /* @__PURE__ */ new Set();
+	for (const model of ctx.spec.models) {
+		if (isListWrapperModel(model) || isListMetadataModel(model)) continue;
+		out.add(classNameFn(model.name));
 	}
-	return true;
+	for (const enumDef of ctx.spec.enums) out.add(classNameFn(enumDef.name));
+	return out;
 }
 /**
-* Detect whether a model is a list metadata model (e.g., ListMetadata).
-* These models typically have exactly `before` and `after` nullable string fields.
+* Resolve the PascalCase mount-target identifier for an operation client,
+* appending `Service` when the un-suffixed class name would shadow an
+* exported model or enum.
+*
+* Operates on the PascalCase target (the mount-target string the IR carries),
+* so the returned value feeds cleanly into each language's `className` and
+* `fileName` helpers — e.g. `OrganizationMembership` → `OrganizationMembershipService`,
+* then `fileName` → `organization_membership_service` / `organization-membership-service`.
+*
+* The accessor on the client (`client.organization_membership`) is intentionally
+* NOT suffixed — callers should keep using the raw target for `servicePropertyName`
+* so the accessor reads naturally.
 */
-function isListMetadataModel(model) {
-	if (model.fields.length !== 2) return false;
-	const fieldsByName = new Map(model.fields.map((f) => [f.name, f]));
-	const before = fieldsByName.get("before");
-	const after = fieldsByName.get("after");
-	if (!before || !after) return false;
-	return isNullableString(before) && isNullableString(after);
+function resolveServiceTarget$5(target, exportedClasses, classNameFn) {
+	return exportedClasses.has(classNameFn(target)) ? `${target}${SERVICE_COLLISION_SUFFIX}` : target;
 }
-/** 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;
-	if (field.type.kind === "nullable" && field.type.inner.kind === "primitive" && field.type.inner.type === "string") return true;
-	return false;
+//#endregion
+//#region src/node/naming.ts
+/** Strip spec-noise suffixes (e.g., "Dto") from an IR name. */
+function stripNoiseSuffixes(name) {
+	return name.replace(/Dto$/i, "");
 }
-/**
-* Discover the OpenAPI spec path from CLI args or environment.
-* Returns null if not found.
-*/
-function discoverSpecPath() {
-	const args = process.argv;
-	for (let i = 0; i < args.length; i++) {
-		if (args[i] === "--spec" && args[i + 1]) return resolve(args[i + 1]);
-		if (args[i]?.startsWith("--spec=")) return resolve(args[i].slice(7));
-	}
-	if (process.env.OPENAPI_SPEC_PATH) return resolve(process.env.OPENAPI_SPEC_PATH);
-	return null;
+/** PascalCase class/interface name. */
+function className$6(name) {
+	return toPascalCase(stripUrnPrefix(name));
 }
-/** Cached raw spec to avoid re-reading on multiple calls. */
-let _rawSpecCache = null;
-let _rawSpecLoaded = false;
-function loadRawSpec() {
-	if (_rawSpecLoaded) return _rawSpecCache;
-	_rawSpecLoaded = true;
-	const specPath = discoverSpecPath();
-	if (!specPath || !existsSync(specPath)) return null;
-	try {
-		_rawSpecCache = load(readFileSync(specPath, "utf-8"));
-		return _rawSpecCache;
-	} catch {
-		return null;
-	}
+/** kebab-case file name (without extension). */
+function fileName$3(name) {
+	return toKebabCase(stripUrnPrefix(name));
 }
-/** Look up a schema by name in the raw spec's components/schemas. */
-function lookupRawSchema(name) {
-	const spec = loadRawSpec();
-	if (!spec) return null;
-	return spec?.components?.schemas?.[name] ?? null;
+/** camelCase field name for domain interfaces. */
+function fieldName$6(name) {
+	return toCamelCase(name);
 }
-function createCollector() {
-	return {
-		models: [],
-		enums: [],
-		usedNames: /* @__PURE__ */ new Set()
-	};
+/** snake_case field name for wire/response interfaces. */
+function wireFieldName(name) {
+	return toSnakeCase(name);
 }
 /**
-* Singularize a snake_case name for use as an array-item model name.
-* `redirect_uris` -> `redirect_uri`, `scopes` -> `scope`.
+* Active set of `Serialized${Name}` interfaces in the live SDK, harvested
+* from `ctx.apiSurface` once per generation run. When non-empty, the
+* legacy wire-naming scheme wins so existing hand-written serializer files
+* continue to compile.
+*
+* Set by `index.ts` immediately after `getSurface(ctx)` runs.
 */
-function singularizeSnake(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;
+let baselineSerializedNames = /* @__PURE__ */ new Set();
+function setBaselineSerializedNames(names) {
+	baselineSerializedNames = names;
 }
 /**
-* Convert a raw OpenAPI type+format to an IR TypeRef.
+* Set of every interface name present in the baseline live SDK, regardless
+* of naming convention. Used to detect single-form baselines (where one
+* `*Response`-suffixed interface stands for both the domain and wire shape)
+* so we don't synthesize a non-existent `*Wire` variant.
+*/
+let baselineInterfaceNames = /* @__PURE__ */ new Set();
+function setBaselineInterfaceNames(names) {
+	baselineInterfaceNames = names;
+}
+/**
+* IR models that belong to newly-adopted services should not be renamed by
+* structural baseline matches from unrelated hand-written services.
+*/
+let adoptedModelNames = /* @__PURE__ */ new Set();
+function setAdoptedModelNames(names) {
+	adoptedModelNames = names;
+}
+function isAdoptedModelName(name) {
+	return adoptedModelNames.has(name);
+}
+/**
+* Wire/response interface name.
 *
-* When `parentModelName` and `fieldName` are provided, inline objects and
-* enums generate synthetic models/enums instead of degrading to `unknown`
-* or `string`.
+* Resolution order:
+*  1. `Serialized${domainName}` if it exists in the baseline (legacy
+*     workos-node convention; lets hand-written serializer files keep
+*     compiling).
+*  2. `${domainName}Wire` when the domain ends in `Response` AND the
+*     baseline actually has a `*Wire` interface (avoids
+*     `FooResponseResponse` stutter).
+*  3. The bare `domainName` itself when it already ends in `Response` and
+*     no `*Wire` variant exists — this happens when the structural matcher
+*     maps an IR model to a baseline-wire-shaped interface
+*     (`AuditLogSchemaJson` → `AuditLogSchemaResponse`) and the baseline
+*     has no separate domain/wire split.
+*  4. `${domainName}Response` for the standard fresh-emit case.
 */
-function rawSchemaToTypeRef(schema, parentModelName, fName, collector) {
-	if (schema.const !== void 0) return {
-		kind: "literal",
-		value: schema.const
-	};
-	if (schema.enum && collector && parentModelName && fName) {
-		const syntheticName = `${parentModelName}_${fName}`;
-		if (!collector.usedNames.has(syntheticName) && !collector.usedNames.has(toSnakeCase(syntheticName))) {
-			collector.usedNames.add(syntheticName);
-			collector.enums.push({
-				name: syntheticName,
-				values: schema.enum.map((v) => ({
-					value: v,
-					description: void 0
-				}))
-			});
-		}
-		return {
-			kind: "enum",
-			name: syntheticName,
-			values: schema.enum
-		};
-	}
-	if (schema.enum) return {
-		kind: "primitive",
-		type: "string"
-	};
-	if (schema.$ref) return {
-		kind: "model",
-		name: schema.$ref.split("/").pop()
-	};
-	let baseType = schema.type;
-	let isNullable = false;
-	if (Array.isArray(baseType)) {
-		const nonNull = baseType.filter((t) => t !== "null");
-		isNullable = baseType.includes("null");
-		baseType = nonNull[0] ?? "string";
+function wireInterfaceName(domainName) {
+	const serialized = `Serialized${domainName}`;
+	if (baselineSerializedNames.has(serialized)) return serialized;
+	if (domainName.endsWith("Response")) {
+		const wireForm = `${domainName}Wire`;
+		if (baselineInterfaceNames.has(wireForm)) return wireForm;
+		if (baselineInterfaceNames.has(domainName)) return domainName;
+		return wireForm;
 	}
-	let ref;
-	if (baseType === "object" && schema.properties && collector && parentModelName && fName) {
-		const syntheticName = `${parentModelName}_${fName}`;
-		if (!collector.usedNames.has(syntheticName) && !collector.usedNames.has(toSnakeCase(syntheticName))) {
-			collector.usedNames.add(syntheticName);
-			const fields = [];
-			const requiredSet = new Set(schema.required ?? []);
-			for (const [propName, propSchema] of Object.entries(schema.properties)) fields.push({
-				name: propName,
-				type: rawSchemaToTypeRef(propSchema, syntheticName, propName, collector),
-				required: requiredSet.has(propName),
-				description: propSchema.description,
-				deprecated: propSchema.deprecated
-			});
-			collector.models.push({
-				name: syntheticName,
-				fields,
-				description: schema.description
-			});
-		}
-		ref = {
-			kind: "model",
-			name: syntheticName
-		};
-	} else if (baseType === "object" && schema.properties) ref = {
-		kind: "primitive",
-		type: "unknown"
-	};
-	else if (baseType === "array" && schema.items) {
-		const itemFieldName = fName ? singularizeSnake(fName) : void 0;
-		ref = {
-			kind: "array",
-			items: rawSchemaToTypeRef(schema.items, parentModelName, itemFieldName, collector)
-		};
-	} else if (baseType === "boolean") ref = {
-		kind: "primitive",
-		type: "boolean"
-	};
-	else if (baseType === "integer" || baseType === "number") ref = {
-		kind: "primitive",
-		type: baseType
-	};
-	else ref = {
-		kind: "primitive",
-		type: "string"
-	};
-	if (isNullable) return {
-		kind: "nullable",
-		inner: ref
-	};
-	return ref;
+	return `${domainName}Response`;
+}
+/** kebab-case service directory name. */
+function serviceDirName(name) {
+	return toKebabCase(name);
+}
+/** camelCase property name for service accessors on the client. */
+function servicePropertyName$4(name) {
+	return toCamelCase(name);
 }
 /**
-* Extract fields from a raw OpenAPI object schema.
-* All fields are returned as optional (not required) since they come from
-* oneOf variants where only one variant is active at a time.
+* Resolve the effective service name, using the overlay-resolved class name
+* when available.
 */
-function extractFieldsFromRawSchema(schema, parentModelName, collector) {
-	const fields = [];
-	const props = schema.properties ?? {};
-	for (const [name, propSchema] of Object.entries(props)) fields.push({
-		name,
-		type: rawSchemaToTypeRef(propSchema, parentModelName, name, collector),
-		required: false,
-		description: propSchema.description,
-		deprecated: propSchema.deprecated
-	});
-	return fields;
+function resolveServiceName(service, ctx) {
+	return resolveClassName$5(service, ctx);
+}
+/**
+* Build the set of model + enum class names exported by the SDK. Used to
+* detect collisions with operation-client class names — a colliding service
+* gets a `Service` suffix appended.
+*/
+function buildExportedClassNameSet$4(ctx) {
+	return buildExportedClassNameSet$5(ctx, className$6);
 }
 /**
-* Recursively collect all fields from a oneOf schema, flattening nested
-* allOf+oneOf compositions. All fields are marked optional.
+* Resolve a service's mount-target identifier, appending `Service` on
+* collision with an exported model/enum class. The result feeds `className`
+* and `fileName` so both the `export class` declaration and its file name
+* stay aligned (e.g. `OrganizationMembershipService` /
+* `organization-membership-service.ts`).
 */
-function collectOneOfFields(schema, parentModelName, collector) {
-	const allFields = [];
-	const seenFieldNames = /* @__PURE__ */ new Set();
-	function walkSchema(s) {
-		if (s.properties) {
-			for (const f of extractFieldsFromRawSchema(s, parentModelName, collector)) if (!seenFieldNames.has(f.name)) {
-				seenFieldNames.add(f.name);
-				allFields.push(f);
-			}
-		}
-		if (s.allOf) for (const sub of s.allOf) walkSchema(sub);
-		if (s.oneOf) for (const variant of s.oneOf) walkSchema(variant);
-		if (s.anyOf) for (const variant of s.anyOf) walkSchema(variant);
-	}
-	walkSchema(schema);
-	return allFields;
+function resolveServiceTarget$4(target, exportedClasses) {
+	return resolveServiceTarget$5(target, exportedClasses, className$6);
 }
 /**
-* Check if a TypeRef is `unknown` (the degraded type for inline objects).
+* Build a map from IR service name -> resolved service name.
 */
-function isUnknownType(ref) {
-	return ref.kind === "primitive" && ref.type === "unknown";
+function buildServiceNameMap(services, ctx) {
+	const map = /* @__PURE__ */ new Map();
+	for (const service of services) map.set(service.name, resolveServiceName(service, ctx));
+	return map;
+}
+/** Resolve the output directory for a service. */
+function resolveServiceDir$1(resolvedServiceName) {
+	return serviceDirName(resolvedServiceName);
+}
+/** Resolve the SDK method name for an operation, using resolved operations first. */
+function resolveMethodName$6(op, _service, ctx) {
+	const resolved = lookupMethodName(op, buildResolvedLookup(ctx));
+	if (resolved) return toCamelCase(resolved);
+	const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+	const existing = ctx.overlayLookup?.methodByOperation?.get(httpKey);
+	if (existing) return existing.methodName;
+	return toCamelCase(op.name);
+}
+/** Resolve the SDK class name for a service, using resolved ops mountOn as canonical. */
+function resolveClassName$5(service, ctx) {
+	for (const r of ctx.resolvedOperations ?? []) if (r.service.name === service.name) return r.mountOn;
+	if (ctx.overlayLookup?.methodByOperation) for (const op of service.operations) {
+		const httpKey = `${op.httpMethod.toUpperCase()} ${op.path}`;
+		const existing = ctx.overlayLookup.methodByOperation.get(httpKey);
+		if (existing) return existing.className;
+	}
+	return toPascalCase(service.name);
 }
 /**
-* If a field is an `array<unknown>` (or `nullable<array<unknown>>`) and the
-* raw spec defines inline object/enum items, replace the item type with a
-* synthetic model/enum. Returns the original field unchanged when no upgrade
-* is needed.
+* Resolve the interface name for a model, checking overlay first.
+*
+* Lookup order:
+*  1. `overlayLookup.interfaceByName` — exact-name overrides from the live SDK.
+*  2. `overlayLookup.modelNameByIR` — structurally-inferred matches (e.g., IR
+*     `ValidateApiKey` with one field `value: string` → live SDK interface
+*     `ValidateApiKeyOptions`).
+*  3. Type-alias resolution (when an alias points to an interface).
+*  4. Suffix-fallback heuristic for the workos-node `*Options` convention:
+*     when the IR name `X` has no baseline match but `XOptions` does, use
+*     `XOptions`. The convention is widely used for request-body interfaces
+*     in workos-node (CreateOrganizationOptions, ListUsersOptions, etc.).
+*  5. Default — clean and PascalCase the IR name.
 */
-function upgradeArrayItemType(field, rawSchema, parentModelName, collector) {
-	let arrayRef = null;
-	let isNullableWrapper = false;
-	if (field.type.kind === "array") arrayRef = field.type;
-	else if (field.type.kind === "nullable" && field.type.inner.kind === "array") {
-		arrayRef = field.type.inner;
-		isNullableWrapper = true;
+function resolveInterfaceName(name, ctx, opts) {
+	const existing = ctx.overlayLookup?.interfaceByName?.get(name);
+	if (existing) return existing;
+	let inferred = adoptedModelNames.has(name) ? void 0 : ctx.overlayLookup?.modelNameByIR?.get(name);
+	if (inferred) {
+		if (inferred.startsWith("Serialized")) {
+			const stripped = inferred.slice(10);
+			if (stripped && ctx.apiSurface?.interfaces?.[stripped]) inferred = stripped;
+		}
+		if (inferred.endsWith("Response") && ctx.apiSurface?.interfaces) {
+			const stripped = inferred.slice(0, -8);
+			if (stripped && ctx.apiSurface.interfaces[stripped]) inferred = stripped;
+		}
+		return inferred;
 	}
-	if (!arrayRef || arrayRef.kind !== "array") return field;
-	if (!isUnknownType(arrayRef.items)) return field;
-	const rawProp = rawSchema.properties?.[field.name];
-	if (!rawProp) return field;
-	let rawArraySchema = rawProp;
-	if (Array.isArray(rawProp.type)) {
-		if (rawProp.type.filter((t) => t !== "null")[0] === "array") rawArraySchema = rawProp;
+	if (!opts?.skipTypeAlias && ctx.apiSurface?.typeAliases) {
+		const alias = ctx.apiSurface.typeAliases[name];
+		if (alias?.value && ctx.apiSurface.interfaces?.[alias.value]) return alias.value;
 	}
-	if (rawArraySchema.type !== "array" && !(Array.isArray(rawArraySchema.type) && rawArraySchema.type.includes("array"))) return field;
-	if (!rawArraySchema.items) return field;
-	const itemFieldName = singularizeSnake(field.name);
-	const newItemRef = rawSchemaToTypeRef(rawArraySchema.items, parentModelName, itemFieldName, collector);
-	if (isUnknownType(newItemRef)) return field;
-	const newArrayRef = {
-		kind: "array",
-		items: newItemRef
-	};
-	const newType = isNullableWrapper ? {
-		kind: "nullable",
-		inner: newArrayRef
-	} : newArrayRef;
-	return {
-		...field,
-		type: newType
-	};
+	if (ctx.apiSurface?.interfaces) {
+		const ifaces = ctx.apiSurface.interfaces;
+		if (!ifaces[name]) {
+			const optionsCandidate = `${name}Options`;
+			const optionsInfo = ifaces[optionsCandidate];
+			if (optionsInfo?.sourceFile) {
+				const expectedStem = toKebabCase(stripUrnPrefix(name));
+				if (optionsInfo.sourceFile.endsWith(`/${expectedStem}.interface.ts`)) return optionsCandidate;
+			}
+		}
+	}
+	return toPascalCase(stripUrnPrefix(ctx.apiSurface ? name : stripNoiseSuffixes(name)));
 }
-let _lastSyntheticEnums = [];
+//#endregion
+//#region src/node/type-map.ts
 /**
-* Return the synthetic enums generated during the last call to
-* `enrichModelsFromSpec`. Call this after enrichment to merge them into the
-* enum generation phase.
+* Map of enum name → inlined string-union TS source.
+*
+* Set by `index.ts` once per generation run, sourced from `spec.enums` for
+* enums that have no baseline definition in the live SDK. When populated,
+* `mapTypeRef`/`mapWireTypeRef` substitute the union directly at the
+* reference site instead of emitting a separate import — this collapses
+* ~100 single-line enum files into inline literal types.
 */
-function getSyntheticEnums() {
-	return _lastSyntheticEnums;
+let inlineEnumUnions = /* @__PURE__ */ new Map();
+function setInlineEnumUnions(map) {
+	inlineEnumUnions = map;
 }
-/**
-* Find a property name that has a `const` value in ALL oneOf variants.
-* Returns null if no shared const property is found.
-*/
-function findSharedConstProperty(oneOfSchemas) {
-	if (oneOfSchemas.length === 0) return null;
-	const first = oneOfSchemas[0];
-	if (!first.properties) return null;
-	const candidates = Object.keys(first.properties).filter((name) => first.properties[name].const !== void 0);
-	for (const candidate of candidates) if (oneOfSchemas.every((variant) => variant.properties?.[candidate]?.const !== void 0)) return candidate;
-	return null;
+function isInlineEnum(name) {
+	return inlineEnumUnions.has(name);
 }
 /**
-* Build a discriminator mapping from const values to IR model names.
-* For each oneOf variant's const value on `discProperty`, find the IR model
-* whose field with the same name is a Literal type with that value.
+* Optional callback that resolves an IR model name to its live-SDK interface
+* name. Set by `index.ts` once per run. When present, `mapTypeRef` and
+* `mapWireTypeRef` use it instead of the raw IR name in their `model:` cases
+* — keeping field-type references in sync with import statements that the
+* caller emits via the same resolver. Without this, a structural match like
+* IR `AuditLogSchemaJson` → live `AuditLogSchemaResponse` would produce
+* `schema: AuditLogSchemaJson` in the body but
+* `import type { AuditLogSchemaResponse }` in the imports, leaving
+* `AuditLogSchemaJson` unbound.
 */
-function buildDiscriminatorMapping(discProperty, oneOfSchemas, models, parentModelName) {
-	const mapping = {};
-	for (const variant of oneOfSchemas) {
-		const constValue = variant.properties?.[discProperty]?.const;
-		if (constValue === void 0) continue;
-		const variantModel = models.find((m) => m.name !== parentModelName && m.fields.some((f) => f.name === discProperty && f.type.kind === "literal" && f.type.value === constValue));
-		if (variantModel) mapping[String(constValue)] = variantModel.name;
-	}
-	return mapping;
+let domainNameResolver = null;
+function setDomainNameResolver(fn) {
+	domainNameResolver = fn;
+}
+function resolveDomainName(irName) {
+	return domainNameResolver ? domainNameResolver(irName) : irName;
 }
 /**
-* Detect implicit discriminators on models without full oneOf flattening.
-* Returns a new array with discriminator annotations; models without
-* discriminators are returned as-is. Use this when you need discriminator
-* info but don't want the side-effects of full enrichment (synthetic
-* models/enums, field flattening).
+* Map an IR TypeRef to a TypeScript domain type string.
+* Domain types use PascalCase model names (e.g., `Organization`).
 */
-function detectDiscriminators(models) {
-	if (!loadRawSpec()) return models;
-	let changed = false;
-	const result = models.map((model) => {
-		if (model.discriminator) return model;
-		const rawSchema = lookupRawSchema(model.name);
-		if (!rawSchema) return model;
-		const oneOfContainer = rawSchema.allOf?.find((s) => s.oneOf);
-		if (!oneOfContainer?.oneOf || oneOfContainer.oneOf.length === 0) return model;
-		const discProperty = findSharedConstProperty(oneOfContainer.oneOf);
-		if (!discProperty) return model;
-		const mapping = buildDiscriminatorMapping(discProperty, oneOfContainer.oneOf, models, model.name);
-		if (Object.keys(mapping).length === 0) return model;
-		changed = true;
-		return {
-			...model,
-			fields: [],
-			discriminator: {
-				property: discProperty,
-				mapping
-			}
-		};
+function mapTypeRef$7(ref, opts) {
+	const genericDefaults = opts?.genericDefaults;
+	return mapTypeRef(ref, {
+		primitive: mapPrimitive$6,
+		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),
+		nullable: (_r, inner) => `${inner} | null`,
+		literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
+		map: (_r, value) => `Record<string, ${value}>`
 	});
-	return changed ? result : models;
 }
 /**
-* Enrich IR models by flattening oneOf/allOf+oneOf variant fields from the raw spec.
-*
-* For models with 0 fields whose raw spec schema is a pure oneOf:
-*   - Collect all variant fields and add them as optional fields.
-*
-* For models whose raw spec schema has allOf containing a oneOf:
-*   - Collect the missing variant fields and add them as optional.
-*
-* Inline objects and enums in oneOf branches are promoted to synthetic
-* models/enums instead of degrading to `object` / `string`.
-*
-* Returns a new array of enriched models (original models are not mutated).
-* Synthetic enums are stored internally; retrieve them via `getSyntheticEnums()`.
+* Map an IR TypeRef to a TypeScript wire/response type string.
+* Model references get the `Response` suffix (e.g., `OrganizationResponse`).
 */
-function enrichModelsFromSpec(models) {
-	if (!loadRawSpec()) {
-		_lastSyntheticEnums = [];
-		return models;
+function mapWireTypeRef(ref, opts) {
+	const genericDefaults = opts?.genericDefaults;
+	return mapTypeRef(ref, {
+		primitive: mapWirePrimitive,
+		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),
+		nullable: (_r, inner) => `${inner} | null`,
+		literal: (r) => typeof r.value === "string" ? `'${r.value}'` : String(r.value),
+		map: (_r, value) => `Record<string, ${value}>`
+	});
+}
+function mapPrimitive$6(ref) {
+	if (ref.format) switch (ref.format) {
+		case "date-time": return "Date";
+		case "int64": return "bigint";
 	}
-	const collector = createCollector();
-	for (const m of models) {
-		collector.usedNames.add(m.name);
-		collector.usedNames.add(toSnakeCase(m.name));
+	switch (ref.type) {
+		case "string": return "string";
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "unknown": return "any";
 	}
-	const enriched2 = models.map((model) => {
-		const rawSchema = lookupRawSchema(model.name);
-		if (!rawSchema) return model;
-		if (!(rawSchema.oneOf || rawSchema.allOf?.some((s) => s.oneOf))) return model;
-		if (rawSchema.discriminator || rawSchema.oneOf?.some((v) => v.discriminator) || rawSchema.allOf?.some((s) => s.discriminator || s.oneOf?.some((v) => v.discriminator))) return model;
-		const oneOfContainer = rawSchema.allOf?.find((s) => s.oneOf);
-		if (oneOfContainer?.oneOf && oneOfContainer.oneOf.length > 0) {
-			const discProperty = findSharedConstProperty(oneOfContainer.oneOf);
-			if (discProperty) {
-				const mapping = buildDiscriminatorMapping(discProperty, oneOfContainer.oneOf, models, model.name);
-				if (Object.keys(mapping).length > 0) return {
-					...model,
-					fields: [],
-					discriminator: {
-						property: discProperty,
-						mapping
-					}
-				};
-			}
-		}
-		const variantFields = collectOneOfFields(rawSchema, model.name, collector);
-		if (variantFields.length === 0) return model;
-		const existingNames = new Set(model.fields.map((f) => f.name));
-		const newFields = variantFields.filter((f) => !existingNames.has(f.name));
-		if (newFields.length === 0) return model;
-		return {
-			...model,
-			fields: [...model.fields, ...newFields]
-		};
-	}).map((model) => {
-		const rawSchema = lookupRawSchema(model.name);
-		if (!rawSchema?.properties) return model;
-		let modified = false;
-		const newFields = model.fields.map((field) => {
-			const upgraded = upgradeArrayItemType(field, rawSchema, model.name, collector);
-			if (upgraded !== field) modified = true;
-			return upgraded;
-		});
-		return modified ? {
-			...model,
-			fields: newFields
-		} : model;
-	});
-	_lastSyntheticEnums = collector.enums.map((e) => ({
-		name: e.name,
-		values: e.values.map((v) => ({
-			value: v.value,
-			description: v.description
-		}))
-	}));
-	const existingSnakeNames = new Set(enriched2.map((m) => toSnakeCase(m.name)));
-	const filteredSynthetic = collector.models.filter((m) => !existingSnakeNames.has(toSnakeCase(m.name)));
-	return [...enriched2, ...filteredSynthetic];
+}
+function mapWirePrimitive(ref) {
+	switch (ref.type) {
+		case "string": return "string";
+		case "integer":
+		case "number": return "number";
+		case "boolean": return "boolean";
+		case "unknown": return "any";
+	}
+}
+function joinUnionVariants$5(ref, variants) {
+	const unique = [...new Set(variants)];
+	if (ref.compositionKind === "allOf") return unique.join(" & ");
+	if (unique.length === 1) return unique[0];
+	return unique.join(" | ");
+}
+function parenthesizeUnion$1(type) {
+	return type.includes(" | ") || type.includes(" & ") ? `(${type})` : type;
 }
 //#endregion
 //#region src/node/utils.ts
@@ -4463,15 +4533,19 @@ function hasCompatibleConstructor(className, ctx) {
 */
 function resolveResourceClassName$3(service, ctx) {
 	const overlayName = resolveServiceName(service, ctx);
-	if (hasCompatibleConstructor(overlayName, ctx)) return overlayName;
-	const irName = toPascalCase(service.name);
-	if (irName === overlayName) return irName + "Endpoints";
-	return irName;
+	let base;
+	if (hasCompatibleConstructor(overlayName, ctx)) base = overlayName;
+	else {
+		const irName = toPascalCase(service.name);
+		base = irName === overlayName ? `${irName}Endpoints` : irName;
+	}
+	return resolveServiceTarget$4(base, buildExportedClassNameSet$4(ctx));
 }
 function resolveResourceDir(service, ctx) {
 	const resolvedName = resolveResourceClassName$3(service, ctx);
 	if (resolvedName === "WebhooksEndpoints") return "webhooks";
-	return resolveServiceDir$1(resolvedName);
+	const overlayName = resolveServiceName(service, ctx);
+	return resolveServiceDir$1(resolvedName === `${overlayName}Service` ? overlayName : resolvedName);
 }
 /** Standard pagination query params handled by PaginationOptions — not imported individually. */
 const PAGINATION_PARAM_NAMES = new Set([
@@ -4554,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;
 }
 /**
@@ -4571,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);
@@ -5869,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": {
@@ -5915,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;
@@ -6252,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;
@@ -6259,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);
 	}
@@ -6562,7 +6641,7 @@ function generateWorkOSClient$1(spec, ctx) {
 	for (const service of spec.services) {
 		if (coveredServices.has(service.name)) continue;
 		const resolvedName = resolveResourceClassName$3(service, ctx);
-		const propName = servicePropertyName$4(resolvedName);
+		const propName = servicePropertyName$4(resolveServiceName(service, ctx));
 		if (existingProps.has(propName)) continue;
 		const classDeprecation = ctx.apiSurface?.classes?.[resolvedName]?.deprecationMessage;
 		if (classDeprecation !== void 0) {
@@ -6988,7 +7067,7 @@ function generateServiceTest$3(service, spec, ctx, modelMap, mountAccessors) {
 	const resolvedName = resolveResourceClassName$3(service, ctx);
 	const serviceDir = resolveResourceDir(service, ctx);
 	const serviceClass = resolvedName;
-	const serviceProp = mountAccessors?.get(service.name) ?? servicePropertyName$4(resolvedName);
+	const serviceProp = mountAccessors?.get(service.name) ?? servicePropertyName$4(resolveServiceName(service, ctx));
 	const testPath = `src/${serviceDir}/${fileName$3(resolvedName)}.spec.ts`;
 	const plans = service.operations.map((op) => ({
 		op,
@@ -7570,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" },
@@ -7589,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;
@@ -7824,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);
@@ -7844,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 [];
@@ -7952,6 +8544,25 @@ function resolveMethodName$5(op, _service, ctx) {
 	if (existing) return toSnakeCase(existing.methodName);
 	return toSnakeCase(op.name);
 }
+/**
+* Build the set of model + enum class names exported by the SDK. Used to
+* detect collisions with operation-client class names — a colliding service
+* gets a `Service` suffix appended.
+*/
+function buildExportedClassNameSet$3(ctx) {
+	return buildExportedClassNameSet$5(ctx, className$5);
+}
+/**
+* Resolve a service's mount-target identifier, appending `Service` on
+* collision with an exported model/enum class. Feeds `className`/`fileName`
+* so the class declaration, file, and any qualified references stay aligned.
+*
+* Accessor names (`servicePropertyName`) intentionally use the RAW target —
+* `client.organization_membership` reads better than the suffixed form.
+*/
+function resolveServiceTarget$3(target, exportedClasses) {
+	return resolveServiceTarget$5(target, exportedClasses, className$5);
+}
 /** Resolve the SDK class name for a service, using resolved operations' mountOn. */
 function resolveClassName$4(service, ctx) {
 	for (const r of ctx.resolvedOperations ?? []) if (r.service.name === service.name) return r.mountOn;
@@ -10001,10 +10612,11 @@ function generateResources$6(services, ctx) {
 		name: resolveClassName$4(s, ctx),
 		operations: s.operations
 	}));
+	const exportedClasses = buildExportedClassNameSet$3(ctx);
 	for (const { name: mountName, operations: allOperations } of entries) {
 		if (allOperations.length === 0) continue;
 		const dirName = moduleName$2(mountName);
-		const resourceClassName = className$5(mountName);
+		const resourceClassName = className$5(resolveServiceTarget$3(mountName, exportedClasses));
 		const importPrefix = relativeImportPrefix(dirName);
 		const lines = [];
 		lines.push("from __future__ import annotations");
@@ -10450,9 +11062,10 @@ function generateWorkOSClient(spec, ctx) {
 	lines.push("    AsyncWorkOSClient as _AsyncBase,");
 	lines.push(")");
 	const serviceDirMap = buildMountDirMap$1(ctx);
+	const exportedClasses = buildExportedClassNameSet$3(ctx);
 	for (const service of topLevelServices) {
 		const resolvedName = resolveResourceClassName$2(service, ctx);
-		const clsName = className$5(resolvedName);
+		const clsName = className$5(resolveServiceTarget$3(resolvedName, exportedClasses));
 		const dirName = serviceDirMap.get(service.name) ?? resolveServiceDir(resolvedName);
 		const importLine = `from .${dirToModule(dirName)}._resource import ${clsName}, Async${clsName}`;
 		if (importLine.length > 88) {
@@ -10473,7 +11086,7 @@ function generateWorkOSClient(spec, ctx) {
 	const generatedProps = /* @__PURE__ */ new Set();
 	for (const service of topLevelServices) {
 		const resolvedName = resolveResourceClassName$2(service, ctx);
-		const clsName = className$5(resolvedName);
+		const clsName = className$5(resolveServiceTarget$3(resolvedName, exportedClasses));
 		const prop = servicePropertyName$3(resolvedName);
 		const readable = clsName.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
 		lines.push("");
@@ -10492,7 +11105,7 @@ function generateWorkOSClient(spec, ctx) {
 	const asyncGeneratedProps = /* @__PURE__ */ new Set();
 	for (const service of topLevelServices) {
 		const resolvedName = resolveResourceClassName$2(service, ctx);
-		const clsName = className$5(resolvedName);
+		const clsName = className$5(resolveServiceTarget$3(resolvedName, exportedClasses));
 		const prop = servicePropertyName$3(resolvedName);
 		const readable = clsName.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
 		lines.push("");
@@ -10531,16 +11144,18 @@ function generateServiceInits(spec, ctx) {
 	const files = [];
 	const topLevel = deduplicateByMount$4(spec.services, ctx);
 	const serviceDirMap = buildMountDirMap$1(ctx);
+	const exportedClasses = buildExportedClassNameSet$3(ctx);
 	const mountGroups = groupByMount(ctx);
 	for (const service of topLevel) {
 		const resolvedName = resolveResourceClassName$2(service, ctx);
+		const clsName = className$5(resolveServiceTarget$3(resolvedName, exportedClasses));
 		const dirName = serviceDirMap.get(service.name) ?? resolveServiceDir(resolvedName);
 		const lines = [];
 		const mountTarget = getMountTarget(service, ctx);
 		const groupClassNames = collectParameterGroupClassNames(mountGroups.get(mountTarget)?.operations ?? service.operations);
 		const aliasedImports = [
-			resolvedName,
-			`Async${resolvedName}`,
+			clsName,
+			`Async${clsName}`,
 			...groupClassNames
 		].map((n) => `${n} as ${n}`);
 		lines.push(`from ._resource import ${aliasedImports.join(", ")}`);
@@ -12010,6 +12625,22 @@ function className$4(name) {
 	if (PHP_RESERVED_CLASS_NAMES.has(result)) result += "Model";
 	return result;
 }
+/**
+* Build the set of model + enum class names exported by the SDK. Used to
+* detect collisions with operation-client class names — a colliding service
+* gets a `Service` suffix appended.
+*/
+function buildExportedClassNameSet$2(ctx) {
+	return buildExportedClassNameSet$5(ctx, className$4);
+}
+/**
+* Resolve a service's mount-target identifier, appending `Service` on
+* collision with an exported model/enum class. Used in `\Service\…` files
+* to avoid `use WorkOS\Resource\X; class X` PHP fatal errors.
+*/
+function resolveServiceTarget$2(target, exportedClasses) {
+	return resolveServiceTarget$5(target, exportedClasses, className$4);
+}
 /** Resolve the SDK method name for an operation, using resolved operations first. */
 function resolveMethodName$4(op, _service, ctx) {
 	const resolved = lookupMethodName(op, buildResolvedLookup(ctx));
@@ -12542,9 +13173,10 @@ function generateResources$5(services, ctx) {
 		name: className$4(s.name),
 		operations: s.operations
 	}));
+	const exportedClasses = buildExportedClassNameSet$2(ctx);
 	for (const { name: mountName, operations } of entries) {
 		if (operations.length === 0) continue;
-		const resourceName = className$4(mountName);
+		const resourceName = className$4(resolveServiceTarget$2(mountName, exportedClasses));
 		const mergedService = {
 			name: mountName,
 			operations
@@ -13080,10 +13712,11 @@ function buildServiceAccessPaths$2(services, ctx) {
 }
 function deduplicateByMount$3(services, ctx) {
 	const seen = /* @__PURE__ */ new Map();
+	const exportedClasses = buildExportedClassNameSet$2(ctx);
 	for (const service of services) {
 		const target = getMountTarget(service, ctx);
 		if (!seen.has(target)) seen.set(target, {
-			name: className$4(target),
+			name: className$4(resolveServiceTarget$2(target, exportedClasses)),
 			propName: servicePropertyName$2(target)
 		});
 	}
@@ -13731,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);
@@ -18965,6 +19620,33 @@ function packageSegment(name) {
 function apiClassName(name) {
 	return className$1(name);
 }
+/**
+* Resolve the Kotlin service class name with the collision suffix applied
+* when needed. Wraps `apiClassName` so callers don't need to thread the
+* exported-classes set through unrelated emission logic.
+*/
+function resolveApiClassName(name, exportedClasses) {
+	return apiClassName(resolveServiceTarget$1(name, exportedClasses));
+}
+/**
+* Build the set of model + enum class names exported by the SDK. Used to
+* detect collisions with operation-client class names — a colliding service
+* gets a `Service` suffix appended.
+*/
+function buildExportedClassNameSet$1(ctx) {
+	return buildExportedClassNameSet$5(ctx, className$1);
+}
+/**
+* Resolve a service's mount-target identifier, appending `Service` on
+* collision with an exported model/enum class. Kotlin sees the collision
+* when a service class shares a simple name with an imported model class
+* (e.g. `com.workos.models.OrganizationMembership` vs
+* `com.workos.organizationmembership.OrganizationMembership`) — the file's
+* local declaration shadows the import for unqualified references.
+*/
+function resolveServiceTarget$1(target, exportedClasses) {
+	return resolveServiceTarget$5(target, exportedClasses, className$1);
+}
 /** Accessor property exposed on the WorkOS client (camelCase). */
 function servicePropertyName$1(name) {
 	return toCamelCase(name);
@@ -20134,12 +20816,13 @@ function generateResources$2(services, ctx) {
 	if (mountGroups.size === 0) return [];
 	const files = [];
 	const resolvedLookup = buildResolvedLookup(ctx);
+	const exportedClasses = buildExportedClassNameSet$1(ctx);
 	for (const [mountName, group] of mountGroups) {
 		const classCode = generateApiClass(mountName, group.operations, ctx, resolvedLookup);
 		if (!classCode) continue;
 		const pkg = packageSegment(mountName);
 		files.push({
-			path: `${KOTLIN_SRC_PREFIX$1}com/workos/${pkg}/${apiClassName(mountName)}.kt`,
+			path: `${KOTLIN_SRC_PREFIX$1}com/workos/${pkg}/${resolveApiClassName(mountName, exportedClasses)}.kt`,
 			content: classCode,
 			overwriteExisting: true
 		});
@@ -20148,7 +20831,7 @@ function generateResources$2(services, ctx) {
 }
 function generateApiClass(mountName, operations, ctx, resolvedLookup) {
 	if (operations.length === 0) return null;
-	const apiClass = apiClassName(mountName);
+	const apiClass = resolveApiClassName(mountName, buildExportedClassNameSet$1(ctx));
 	const pkg = `com.workos.${packageSegment(mountName)}`;
 	const imports = /* @__PURE__ */ new Set();
 	imports.add("com.workos.WorkOS");
@@ -20949,8 +21632,9 @@ function generateClient$2(spec, ctx) {
 	if (targets.length === 0) return [];
 	const imports = /* @__PURE__ */ new Set();
 	const accessorLines = [];
+	const exportedClasses = buildExportedClassNameSet$1(ctx);
 	for (const mount of targets) {
-		const apiCls = apiClassName(mount);
+		const apiCls = resolveApiClassName(mount, exportedClasses);
 		const fqn = `com.workos.${packageSegment(mount)}.${apiCls}`;
 		imports.add(fqn);
 		const prop = servicePropertyName$1(mount);
@@ -21032,12 +21716,13 @@ function generateTests$2(spec, ctx) {
 	const files = [];
 	const mountGroups = groupByMount(ctx);
 	const resolvedLookup = buildResolvedLookup(ctx);
+	const exportedClasses = buildExportedClassNameSet$1(ctx);
 	for (const [mountName, group] of mountGroups) {
 		const content = generateServiceTestClass(mountName, group.operations, ctx, resolvedLookup);
 		if (!content) continue;
 		const pkg = packageSegment(mountName);
 		files.push({
-			path: `${TEST_PREFIX}com/workos/${pkg}/${apiClassName(mountName)}Test.kt`,
+			path: `${TEST_PREFIX}com/workos/${pkg}/${resolveApiClassName(mountName, exportedClasses)}Test.kt`,
 			content,
 			overwriteExisting: true
 		});
@@ -21106,7 +21791,7 @@ function generateServiceTestClass(mountName, operations, ctx, resolvedLookup) {
 	if (anyForbidden) imports.add("com.github.tomakehurst.wiremock.client.WireMock.absent");
 	if (uniqueTests.some((t) => t.canEmitHappyPath && t.responseAssertions.length > 0)) imports.add("org.junit.jupiter.api.Assertions.assertEquals");
 	const pkg = packageSegment(mountName);
-	const apiCls = apiClassName(mountName);
+	const apiCls = resolveApiClassName(mountName, buildExportedClassNameSet$1(ctx));
 	if (uniqueTests.some((t) => !t.canEmitHappyPath)) imports.add("org.junit.jupiter.api.Disabled");
 	const lines = [];
 	lines.push(`package com.workos.${pkg}`);
@@ -22022,6 +22707,30 @@ function moduleName$1(name) {
 	return toSnakeCase(name);
 }
 /**
+* Build the set of model + enum Ruby class names that the SDK exposes under
+* `WorkOS::`. Used to detect collisions with operation-client class names —
+* a colliding service gets a `Service` suffix (`OrganizationMembershipService`)
+* so it doesn't shadow the model class under Zeitwerk's collapsed namespace.
+*/
+function buildExportedClassNameSet(ctx) {
+	return buildExportedClassNameSet$5(ctx, className);
+}
+/**
+* Resolve a service's mount-target identifier, appending `Service` on
+* collision with an exported model/enum class name. The returned PascalCase
+* value feeds `className`/`fileName` to derive matching class + file names
+* (e.g. `OrganizationMembershipService` / `organization_membership_service`).
+*
+* Accessor names (`servicePropertyName`) intentionally use the RAW target —
+* `client.organization_membership` is more readable than the suffixed form.
+*
+* The directory used by `loader.collapse` (the model home) likewise uses the
+* raw target.
+*/
+function resolveServiceTarget(target, exportedClasses) {
+	return resolveServiceTarget$5(target, exportedClasses, className);
+}
+/**
 * PascalCase class name for a parameter-group variant. Mirrors the Python
 * convention: group "password" + variant "plaintext" → `PasswordPlaintext`.
 * Used as the Ruby constant under the WorkOS module.
@@ -22796,9 +23505,11 @@ function generateResources$1(services, ctx) {
 	const listWrapperModels = /* @__PURE__ */ new Map();
 	for (const m of ctx.spec.models) if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
 	const groupOwners = buildGroupOwnerMap(ctx);
+	const exportedClasses = buildExportedClassNameSet(ctx);
 	for (const [mountTarget, group] of groups) {
-		const cls = className(mountTarget);
-		const file = fileName(mountTarget);
+		const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+		const cls = className(resolvedTarget);
+		const file = fileName(resolvedTarget);
 		const operations = group.operations;
 		if (operations.length === 0) continue;
 		const requires = /* @__PURE__ */ new Set();
@@ -22826,7 +23537,8 @@ function generateResources$1(services, ctx) {
 				modelByName,
 				listWrapperModels,
 				requires,
-				groupOwners
+				groupOwners,
+				exportedClasses
 			});
 			methodBodies.push(body);
 			if (resolved?.wrappers && resolved.wrappers.length > 0) {
@@ -22872,12 +23584,12 @@ function generateResources$1(services, ctx) {
 }
 /** Build a single Ruby method from an Operation. */
 function emitMethod(args) {
-	const { op, method, defaults, inferFromClient, hiddenParams, enumNames, modelNames, modelByName, listWrapperModels, requires, groupOwners } = args;
+	const { op, method, defaults, inferFromClient, hiddenParams, enumNames, modelNames, modelByName, listWrapperModels, requires, groupOwners, exportedClasses } = args;
 	/** Fully-qualified Ruby constant for a variant (e.g. WorkOS::UserManagement::PasswordPlaintext). */
 	const variantClassRef = (group, variantName) => {
 		const owner = groupOwners.get(group.name);
 		if (!owner) throw new Error(`No owner mount target found for parameter group '${group.name}'`);
-		return scopedGroupVariantClassName(owner, group.name, variantName);
+		return scopedGroupVariantClassName(resolveServiceTarget(owner, exportedClasses), group.name, variantName);
 	};
 	planOperation(op);
 	const lines = [];
@@ -23429,8 +24141,9 @@ function rubyCamelize(basename) {
 function buildInflectionMap(spec, ctx) {
 	const inflections = /* @__PURE__ */ new Map();
 	inflections.set("workos", "WorkOS");
+	const exportedClasses = buildExportedClassNameSet(ctx);
 	for (const service of buildTopLevelServices(spec, ctx)) {
-		const target = getMountTarget(service, ctx) || resolveClassName(service, ctx);
+		const target = resolveServiceTarget(getMountTarget(service, ctx) || resolveClassName(service, ctx), exportedClasses);
 		const cls = className(target);
 		const file = fileName(target);
 		if (rubyCamelize(file) !== cls) inflections.set(file, cls);
@@ -23522,10 +24235,11 @@ function generateClientClass(spec, ctx) {
 	lines.push("module WorkOS");
 	lines.push("  class Client < BaseClient");
 	const topLevelServices = buildTopLevelServices(spec, ctx);
+	const exportedClasses = buildExportedClassNameSet(ctx);
 	for (const service of topLevelServices) {
-		const target = getMountTarget(service, ctx) || resolveClassName(service, ctx);
-		const cls = className(target);
-		const prop = servicePropertyName(target);
+		const rawTarget = getMountTarget(service, ctx) || resolveClassName(service, ctx);
+		const cls = className(resolveServiceTarget(rawTarget, exportedClasses));
+		const prop = servicePropertyName(rawTarget);
 		lines.push("");
 		lines.push(`    def ${prop}`);
 		lines.push(`      @${prop} ||= WorkOS::${cls}.new(self)`);
@@ -23571,10 +24285,12 @@ function generateTests$1(spec, ctx) {
 	for (const m of models) modelByName.set(m.name, m);
 	const lookup = buildResolvedLookup(ctx);
 	const groupOwners = buildGroupOwnerMap(ctx);
+	const exportedClasses = buildExportedClassNameSet(ctx);
 	for (const [mountTarget, group] of groups) {
-		const cls = className(mountTarget);
+		const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+		const cls = className(resolvedTarget);
 		const prop = servicePropertyName(mountTarget);
-		const file = fileName(mountTarget);
+		const file = fileName(resolvedTarget);
 		const lines = [];
 		lines.push(`require 'test_helper'`);
 		lines.push("");
@@ -23600,7 +24316,7 @@ function generateTests$1(spec, ctx) {
 			const httpMethodSym = `:${op.httpMethod.toLowerCase()}`;
 			const resolved = lookupResolved(op, lookup);
 			const hiddenParams = buildHiddenParams$1(resolved);
-			const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models);
+			const callArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, exportedClasses);
 			const bodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models);
 			authMethodManifest.push({
 				method,
@@ -23629,7 +24345,7 @@ function generateTests$1(spec, ctx) {
 			for (const group of op.parameterGroups ?? []) for (let vi = 1; vi < group.variants.length; vi++) {
 				const variant = group.variants[vi];
 				const overrides = new Map([[group.name, vi]]);
-				const variantCallArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, overrides);
+				const variantCallArgs = buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, exportedClasses, overrides);
 				const variantBodyMatcher = buildBodyMatcher(op, modelByName, hiddenParams, models, overrides);
 				const suffix = `with_${fieldName$1(group.name)}_${fieldName$1(variant.name)}`;
 				lines.push("");
@@ -23786,7 +24502,7 @@ function roundTripStub(ref, enumNames) {
 *  default to variant 0. Used to emit per-variant test cases that exercise the
 *  second/third arm of each parameter-group dispatcher.
 */
-function buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, variantOverrides = /* @__PURE__ */ new Map()) {
+function buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, exportedClasses, variantOverrides = /* @__PURE__ */ new Map()) {
 	const parts = [];
 	const seen = /* @__PURE__ */ new Set();
 	const pathParamNames = /* @__PURE__ */ new Set();
@@ -23828,7 +24544,7 @@ function buildCallArgsStub(op, modelByName, hiddenParams, groupOwners, models, v
 		if (variant) {
 			const owner = groupOwners.get(group.name);
 			if (!owner) throw new Error(`No owner mount target found for parameter group '${group.name}'`);
-			const variantClass = scopedGroupVariantClassName(owner, group.name, variant.name);
+			const variantClass = scopedGroupVariantClassName(resolveServiceTarget(owner, exportedClasses), group.name, variant.name);
 			const fieldStubs = variant.parameters.map((p) => `${fieldName$1(p.name)}: ${stubValueFor(pickVariantParamType(p.type, bodyFieldTypes.get(p.name)))}`).join(", ");
 			parts.push(`${name}: ${variantClass}.new(${fieldStubs})`);
 		}
@@ -23969,6 +24685,10 @@ function stubUrlRegex(escaped) {
 * Uses each resolved operation's actual mountOn (not the service default) so
 * operations remounted via operationHints land on the correct service prop.
 * Split operations emit one entry per wrapper (keyed by wrapper name + variant).
+*
+* The accessor (`service` field) uses the raw mountOn — accessor names stay
+* unsuffixed even when the underlying service class gets a `Service` suffix
+* on collision.
 */
 function buildOperationsMap$1(spec, ctx) {
 	const manifest = {};
@@ -24069,8 +24789,10 @@ function generateRbiFiles(spec, ctx) {
 	const listWrapperModels = /* @__PURE__ */ new Map();
 	for (const m of spec.models) if (isListWrapperModel(m)) listWrapperModels.set(m.name, m);
 	const groupOwners = buildGroupOwnerMap(ctx);
+	const exportedClasses = buildExportedClassNameSet(ctx);
 	for (const [mountTarget, group] of groups) {
-		const cls = className(mountTarget);
+		const resolvedTarget = resolveServiceTarget(mountTarget, exportedClasses);
+		const cls = className(resolvedTarget);
 		const lines = [];
 		lines.push("# typed: strong");
 		lines.push("");
@@ -24078,6 +24800,7 @@ function generateRbiFiles(spec, ctx) {
 		lines.push(`  class ${cls}`);
 		const variants = collectVariantsForMountTarget(ctx, spec.models, mountTarget);
 		for (const v of variants) {
+			v.mountTarget = resolvedTarget;
 			for (const line of emitInlineVariantRbi(v)) lines.push(line);
 			lines.push("");
 		}
@@ -24102,7 +24825,8 @@ function generateRbiFiles(spec, ctx) {
 			const groupSorbetType = (group) => {
 				const owner = groupOwners.get(group.name);
 				if (!owner) throw new Error(`No owner mount target found for parameter group '${group.name}'`);
-				const variants = group.variants.map((v) => scopedGroupVariantClassName(owner, group.name, v.name));
+				const resolvedOwner = resolveServiceTarget(owner, exportedClasses);
+				const variants = group.variants.map((v) => scopedGroupVariantClassName(resolvedOwner, group.name, v.name));
 				if (variants.length === 1) return variants[0];
 				return `T.any(${variants.join(", ")})`;
 			};
@@ -24176,7 +24900,7 @@ function generateRbiFiles(spec, ctx) {
 		lines.push("  end");
 		lines.push("end");
 		files.push({
-			path: `rbi/workos/${fileName(mountTarget)}.rbi`,
+			path: `rbi/workos/${fileName(resolvedTarget)}.rbi`,
 			content: lines.join("\n"),
 			integrateTarget: true,
 			overwriteExisting: true
@@ -24189,8 +24913,8 @@ function generateRbiFiles(spec, ctx) {
 		lines.push("module WorkOS");
 		lines.push("  class Client < BaseClient");
 		for (const [mountTarget] of groups) {
-			const cls = className(mountTarget);
-			const prop = mountTarget.replace(/-/g, "_").replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`).replace(/^_/, "");
+			const cls = className(resolveServiceTarget(mountTarget, exportedClasses));
+			const prop = servicePropertyName(mountTarget);
 			lines.push(`    sig { returns(WorkOS::${cls}) }`);
 			lines.push(`    def ${prop}; end`);
 			lines.push("");
@@ -24253,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));
@@ -26548,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));
@@ -26631,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-Ca9LUkWW.mjs.map
+//# sourceMappingURL=plugin-BxVeu2v9.mjs.map